pimcore/lib/Pimcore/Bundle/AdminBundle/Controller/Admin/AssetController.php line 1147

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\Controller\Configuration\TemplatePhp;
  18. use Pimcore\Controller\EventedControllerInterface;
  19. use Pimcore\Event\AdminEvents;
  20. use Pimcore\File;
  21. use Pimcore\Logger;
  22. use Pimcore\Model;
  23. use Pimcore\Model\Asset;
  24. use Pimcore\Model\Element;
  25. use Pimcore\Tool;
  26. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  27. use Symfony\Component\EventDispatcher\GenericEvent;
  28. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  29. use Symfony\Component\HttpFoundation\JsonResponse;
  30. use Symfony\Component\HttpFoundation\Request;
  31. use Symfony\Component\HttpFoundation\Response;
  32. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  33. use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBagInterface;
  34. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  35. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  36. use Symfony\Component\Routing\Annotation\Route;
  38. /**
  39.  * @Route("/asset")
  40.  */
  41. class AssetController extends ElementControllerBase implements EventedControllerInterface
  42. {
  43.     /**
  44.      * @var Asset\Service
  45.      */
  46.     protected $_assetService;
  48.     /**
  49.      * @Route("/get-data-by-id")
  50.      *
  51.      * @param Request $request
  52.      *
  53.      * @return JsonResponse
  54.      */
  55.     public function getDataByIdAction(Request $request, EventDispatcherInterface $eventDispatcher)
  56.     {
  58.         // check for lock
  59.         if (Element\Editlock::isLocked($request->get('id'), 'asset')) {
  60.             return $this->adminJson([
  61.                 'editlock' => Element\Editlock::getByElement($request->get('id'), 'asset')
  62.             ]);
  63.         }
  64.         Element\Editlock::lock($request->get('id'), 'asset');
  66.         $asset = Asset::getById(intval($request->get('id')));
  67.         $asset = clone $asset;
  69.         if (!$asset instanceof Asset) {
  70.             return $this->adminJson(['success' => false, 'message' => "asset doesn't exist"]);
  71.         }
  73.         $asset->setMetadata(Asset\Service::expandMetadataForEditmode($asset->getMetadata()));
  74.         $asset->setProperties(Element\Service::minimizePropertiesForEditmode($asset->getProperties()));
  75.         //$asset->getVersions();
  76.         $asset->getScheduledTasks();
  77.         $asset->idPath = Element\Service::getIdPath($asset);
  78.         $asset->userPermissions = $asset->getUserPermissions();
  79.         $asset->setLocked($asset->isLocked());
  80.         $asset->setParent(null);
  82.         if ($asset instanceof Asset\Text) {
  83.             if ($asset->getFileSize() < 2000000) {
  84.                 // it doesn't make sense to show a preview for files bigger than 2MB
  85.                 $asset->data =  \ForceUTF8\Encoding::toUTF8($asset->getData());
  86.             } else {
  87.                 $asset->data = false;
  88.             }
  89.         }
  91.         if ($asset instanceof Asset\Image) {
  92.             $imageInfo = [];
  94.             if ($asset->getWidth() && $asset->getHeight()) {
  95.                 $imageInfo['dimensions'] = [];
  96.                 $imageInfo['dimensions']['width'] = $asset->getWidth();
  97.                 $imageInfo['dimensions']['height'] = $asset->getHeight();
  98.             }
  100.             $exifData = $asset->getEXIFData();
  101.             if (!empty($exifData)) {
  102.                 $imageInfo['exif'] = $exifData;
  103.             }
  105.             $iptcData = $asset->getIPTCData();
  106.             if (!empty($iptcData)) {
  107.                 // flatten data, to be displayed in grid
  108.                 foreach ($iptcData as &$value) {
  109.                     if (is_array($value)) {
  110.                         $value = implode(', ', $value);
  111.                     }
  112.                 }
  114.                 $imageInfo['iptc'] = $iptcData;
  115.             }
  117.             $imageInfo['exiftoolAvailable'] = (bool) \Pimcore\Tool\Console::getExecutable('exiftool');
  119.             $asset->imageInfo = $imageInfo;
  120.         }
  122.         $asset->setStream(null);
  124.         //Hook for modifying return value - e.g. for changing permissions based on object data
  125.         //data need to wrapped into a container in order to pass parameter to event listeners by reference so that they can change the values
  126.         $data = object2array($asset);
  127.         $event = new GenericEvent($this, [
  128.             'data' => $data,
  129.             'asset' => $asset
  130.         ]);
  131.         $eventDispatcher->dispatch(AdminEvents::ASSET_GET_PRE_SEND_DATA, $event);
  132.         $data = $event->getArgument('data');
  134.         if ($asset->isAllowed('view')) {
  135.             return $this->adminJson($data);
  136.         }
  138.         return $this->adminJson(['success' => false, 'message' => 'missing_permission']);
  139.     }
  141.     /**
  142.      * @Route("/tree-get-childs-by-id")
  143.      *
  144.      * @param Request $request
  145.      *
  146.      * @return JsonResponse
  147.      */
  148.     public function treeGetChildsByIdAction(Request $request, EventDispatcherInterface $eventDispatcher)
  149.     {
  150.         $allParams = array_merge($request->request->all(), $request->query->all());
  152.         $assets = [];
  153.         $cv = false;
  154.         $asset = Asset::getById($allParams['node']);
  156.         $limit = intval($allParams['limit']);
  157.         if (!$allParams['limit']) {
  158.             $limit = 100000000;
  159.         }
  160.         $offset = intval($allParams['start']);
  162.         if ($asset->hasChildren()) {
  163.             if ($allParams['view']) {
  164.                 $cv = \Pimcore\Model\Element\Service::getCustomViewById($allParams['view']);
  165.             }
  167.             // get assets
  168.             $childsList = new Asset\Listing();
  169.             if ($this->getAdminUser()->isAdmin()) {
  170.                 $childsList->setCondition('parentId = ? ', $asset->getId());
  171.             } else {
  172.                 $userIds = $this->getAdminUser()->getRoles();
  173.                 $userIds[] = $this->getAdminUser()->getId();
  174.                 $childsList->setCondition('parentId = ? and
  175.                     (
  176.                     (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
  177.                     or
  178.                     (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
  179.                     )', $asset->getId());
  180.             }
  181.             $childsList->setLimit($limit);
  182.             $childsList->setOffset($offset);
  183.             $childsList->setOrderKey("FIELD(assets.type, 'folder') DESC, assets.filename ASC", false);
  185.             \Pimcore\Model\Element\Service::addTreeFilterJoins($cv, $childsList);
  187.             $beforeListLoadEvent = new GenericEvent($this, [
  188.                 'list' => $childsList,
  189.                 'context' => $allParams
  190.             ]);
  191.             $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD, $beforeListLoadEvent);
  192.             $childsList = $beforeListLoadEvent->getArgument('list');
  194.             $childs = $childsList->load();
  196.             foreach ($childs as $childAsset) {
  197.                 if ($childAsset->isAllowed('list')) {
  198.                     $assets[] = $this->getTreeNodeConfig($childAsset);
  199.                 }
  200.             }
  201.         }
  203.         if ($allParams['limit']) {
  204.             return $this->adminJson([
  205.                 'offset' => $offset,
  206.                 'limit' => $limit,
  207.                 'total' => $asset->getChildAmount($this->getAdminUser()),
  208.                 'nodes' => $assets
  209.             ]);
  210.         } else {
  211.             return $this->adminJson($assets);
  212.         }
  213.     }
  215.     /**
  216.      * @Route("/add-asset")
  217.      *
  218.      * @param Request $request
  219.      *
  220.      * @return JsonResponse
  221.      */
  222.     public function addAssetAction(Request $request)
  223.     {
  224.         $res = $this->addAsset($request);
  226.         return $this->adminJson(['success' => $res['success'], 'msg' => 'Success']);
  227.     }
  229.     /**
  230.      * @Route("/add-asset-compatibility")
  231.      *
  232.      * @param Request $request
  233.      *
  234.      * @return JsonResponse
  235.      */
  236.     public function addAssetCompatibilityAction(Request $request)
  237.     {
  238.         // this is a special action for the compatibility mode upload (without flash)
  239.         $res = $this->addAsset($request);
  241.         $response = $this->adminJson([
  242.             'success' => $res['success'],
  243.             'msg' => $res['success'] ? 'Success' : 'Error',
  244.             'id' => $res['asset'] ? $res['asset']->getId() : null,
  245.             'fullpath' => $res['asset'] ? $res['asset']->getRealFullPath() : null,
  246.             'type' => $res['asset'] ? $res['asset']->getType() : null
  247.         ]);
  248.         $response->headers->set('Content-Type', 'text/html');
  250.         return $response;
  251.     }
  253.     /**
  254.      * @param Request $request
  255.      *
  256.      * @return array
  257.      *
  258.      * @throws \Exception
  259.      */
  260.     protected function addAsset(Request $request)
  261.     {
  262.         $success = false;
  264.         if (array_key_exists('Filedata', $_FILES)) {
  265.             $filename = $_FILES['Filedata']['name'];
  266.             $sourcePath = $_FILES['Filedata']['tmp_name'];
  267.         } elseif ($request->get('type') == 'base64') {
  268.             $filename = $request->get('filename');
  269.             $sourcePath = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/upload-base64' . uniqid() . '.tmp';
  270.             $data = preg_replace('@^data:[^,]+;base64,@', '', $request->get('data'));
  271.             File::put($sourcePath, base64_decode($data));
  272.         }
  274.         $parentId = $request->get('parentId');
  276.         if ($request->get('dir') && $request->get('parentId')) {
  277.             // this is for uploading folders with Drag&Drop
  278.             // param "dir" contains the relative path of the file
  279.             $parent = Asset::getById($request->get('parentId'));
  280.             $newPath = $parent->getRealFullPath() . '/' . trim($request->get('dir'), '/ ');
  282.             // check if the path is outside of the asset directory
  283.             $newRealPath = PIMCORE_ASSET_DIRECTORY . $newPath;
  284.             $newRealPath = resolvePath($newRealPath);
  285.             if (strpos($newRealPath, PIMCORE_ASSET_DIRECTORY) !== 0) {
  286.                 throw new \Exception('not allowed');
  287.             }
  289.             $maxRetries = 5;
  290.             for ($retries=0; $retries < $maxRetries; $retries++) {
  291.                 try {
  292.                     $newParent = Asset\Service::createFolderByPath($newPath);
  293.                     break;
  294.                 } catch (\Exception $e) {
  295.                     if ($retries < ($maxRetries - 1)) {
  296.                         $waitTime = rand(100000, 900000); // microseconds
  297.                         usleep($waitTime); // wait specified time until we restart the transaction
  298.                     } else {
  299.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  300.                         throw $e;
  301.                     }
  302.                 }
  303.             }
  304.             $parentId = $newParent->getId();
  305.         } elseif (!$request->get('parentId') && $request->get('parentPath')) {
  306.             $parent = Asset::getByPath($request->get('parentPath'));
  307.             if ($parent instanceof Asset\Folder) {
  308.                 $parentId = $parent->getId();
  309.             } else {
  310.                 $parentId = 1;
  311.             }
  312.         } elseif (!$request->get('parentId')) {
  313.             // set the parent to the root folder
  314.             $parentId = 1;
  315.         }
  317.         $filename = Element\Service::getValidKey($filename, 'asset');
  318.         if (empty($filename)) {
  319.             throw new \Exception('The filename of the asset is empty');
  320.         }
  322.         $parentAsset = Asset::getById(intval($parentId));
  324.         // check for duplicate filename
  325.         $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  327.         if ($parentAsset->isAllowed('create')) {
  328.             if (is_file($sourcePath) && filesize($sourcePath) < 1) {
  329.                 throw new \Exception('File is empty!');
  330.             } elseif (!is_file($sourcePath)) {
  331.                 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);
  332.             }
  334.             $asset = Asset::create($parentId, [
  335.                 'filename' => $filename,
  336.                 'sourcePath' => $sourcePath,
  337.                 'userOwner' => $this->getAdminUser()->getId(),
  338.                 'userModification' => $this->getAdminUser()->getId()
  339.             ]);
  340.             $success = true;
  342.             @unlink($sourcePath);
  343.         } else {
  344.             Logger::debug('prevented creating asset because of missing permissions, parent asset is ' . $parentAsset->getRealFullPath());
  345.         }
  347.         return [
  348.             'success' => $success,
  349.             'asset' => $asset
  350.         ];
  351.     }
  353.     /**
  354.      * @param $targetPath
  355.      * @param $filename
  356.      *
  357.      * @return string
  358.      */
  359.     protected function getSafeFilename($targetPath, $filename)
  360.     {
  361.         $originalFilename = $filename;
  362.         $count = 1;
  364.         if ($targetPath == '/') {
  365.             $targetPath = '';
  366.         }
  368.         while (true) {
  369.             if (Asset\Service::pathExists($targetPath . '/' . $filename)) {
  370.                 $filename = str_ireplace('.' . File::getFileExtension($originalFilename), '_' . $count . '.' . File::getFileExtension($originalFilename), $originalFilename);
  371.                 $count++;
  372.             } else {
  373.                 return $filename;
  374.             }
  375.         }
  376.     }
  378.     /**
  379.      * @Route("/replace-asset")
  380.      *
  381.      * @param Request $request
  382.      *
  383.      * @return JsonResponse
  384.      *
  385.      * @throws \Exception
  386.      */
  387.     public function replaceAssetAction(Request $request)
  388.     {
  389.         $asset = Asset::getById($request->get('id'));
  391.         $newFilename = Element\Service::getValidKey($_FILES['Filedata']['name'], 'asset');
  392.         $mimetype = Tool\Mime::detect($_FILES['Filedata']['tmp_name'], $newFilename);
  393.         $newType = Asset::getTypeFromMimeMapping($mimetype, $newFilename);
  395.         if ($newType != $asset->getType()) {
  396.             $translator = $this->get('translator');
  398.             return $this->adminJson([
  399.                 'success'=>false,
  400.                 'message'=> sprintf($translator->trans('asset_type_change_not_allowed', [], 'admin'), $asset->getType(), $newType)
  401.             ]);
  402.         }
  404.         $stream = fopen($_FILES['Filedata']['tmp_name'], 'r+');
  405.         $asset->setStream($stream);
  406.         $asset->setCustomSetting('thumbnails', null);
  407.         $asset->setUserModification($this->getAdminUser()->getId());
  409.         $newFileExt = File::getFileExtension($newFilename);
  410.         $currentFileExt = File::getFileExtension($asset->getFilename());
  411.         if ($newFileExt != $currentFileExt) {
  412.             $newFilename = preg_replace('/\.' . $currentFileExt . '$/', '.'.$newFileExt, $asset->getFilename());
  413.             $newFilename = Element\Service::getSaveCopyName('asset', $newFilename, $asset->getParent());
  414.             $asset->setFilename($newFilename);
  415.         }
  417.         if ($asset->isAllowed('publish')) {
  418.             $asset->save();
  420.             $response = $this->adminJson([
  421.                 'id' => $asset->getId(),
  422.                 'path' => $asset->getRealFullPath(),
  423.                 'success' => true
  424.             ]);
  426.             // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  427.             // Ext.form.Action.Submit and mark the submission as failed
  428.             $response->headers->set('Content-Type', 'text/html');
  430.             return $response;
  431.         } else {
  432.             throw new \Exception('missing permission');
  433.         }
  434.     }
  436.     /**
  437.      * @Route("/add-folder")
  438.      *
  439.      * @param Request $request
  440.      *
  441.      * @return JsonResponse
  442.      */
  443.     public function addFolderAction(Request $request)
  444.     {
  445.         $success = false;
  446.         $parentAsset = Asset::getById(intval($request->get('parentId')));
  447.         $equalAsset = Asset::getByPath($parentAsset->getRealFullPath() . '/' . $request->get('name'));
  449.         if ($parentAsset->isAllowed('create')) {
  450.             if (!$equalAsset) {
  451.                 $asset = Asset::create($request->get('parentId'), [
  452.                     'filename' => $request->get('name'),
  453.                     'type' => 'folder',
  454.                     'userOwner' => $this->getAdminUser()->getId(),
  455.                     'userModification' => $this->getAdminUser()->getId()
  456.                 ]);
  457.                 $success = true;
  458.             }
  459.         } else {
  460.             Logger::debug('prevented creating asset because of missing permissions');
  461.         }
  463.         return $this->adminJson(['success' => $success]);
  464.     }
  466.     /**
  467.      * @Route("/delete")
  468.      *
  469.      * @param Request $request
  470.      *
  471.      * @return JsonResponse
  472.      */
  473.     public function deleteAction(Request $request)
  474.     {
  475.         if ($request->get('type') == 'childs') {
  476.             $parentAsset = Asset::getById($request->get('id'));
  478.             $list = new Asset\Listing();
  479.             $list->setCondition('path LIKE ?', [$parentAsset->getRealFullPath() . '/%']);
  480.             $list->setLimit(intval($request->get('amount')));
  481.             $list->setOrderKey('LENGTH(path)', false);
  482.             $list->setOrder('DESC');
  484.             $assets = $list->load();
  486.             $deletedItems = [];
  487.             foreach ($assets as $asset) {
  488.                 /**
  489.                  * @var $asset Asset
  490.                  */
  491.                 $deletedItems[] = $asset->getRealFullPath();
  492.                 if ($asset->isAllowed('delete')) {
  493.                     $asset->delete();
  494.                 }
  495.             }
  497.             return $this->adminJson(['success' => true, 'deleted' => $deletedItems]);
  498.         } elseif ($request->get('id')) {
  499.             $asset = Asset::getById($request->get('id'));
  501.             if ($asset->isAllowed('delete')) {
  502.                 $asset->delete();
  504.                 return $this->adminJson(['success' => true]);
  505.             }
  506.         }
  508.         return $this->adminJson(['success' => false, 'message' => 'missing_permission']);
  509.     }
  511.     /**
  512.      * @Route("/delete-info")
  513.      *
  514.      * @param Request $request
  515.      *
  516.      * @return JsonResponse
  517.      */
  518.     public function deleteInfoAction(Request $request)
  519.     {
  520.         $hasDependency = false;
  521.         $deleteJobs = [];
  522.         $recycleJobs = [];
  524.         $totalChilds = 0;
  526.         $ids = $request->get('id');
  527.         $ids = explode(',', $ids);
  529.         foreach ($ids as $id) {
  530.             try {
  531.                 $asset = Asset::getById($id);
  532.                 if (!$asset) {
  533.                     continue;
  534.                 }
  535.                 $hasDependency = $asset->getDependencies()->isRequired();
  536.             } catch (\Exception $e) {
  537.                 Logger::err('failed to access asset with id: ' . $id);
  538.                 continue;
  539.             }
  541.             // check for childs
  542.             if ($asset instanceof Asset) {
  543.                 $recycleJobs[] = [[
  544.                     'url' => '/admin/recyclebin/add',
  545.                     'params' => [
  546.                         'type' => 'asset',
  547.                         'id' => $asset->getId()
  548.                     ]
  549.                 ]];
  551.                 $hasChilds = $asset->hasChildren();
  552.                 if (!$hasDependency) {
  553.                     $hasDependency = $hasChilds;
  554.                 }
  556.                 $childs = 0;
  557.                 if ($hasChilds) {
  558.                     // get amount of childs
  559.                     $list = new Asset\Listing();
  560.                     $list->setCondition('path LIKE ?', [$asset->getRealFullPath() . '/%']);
  561.                     $childs = $list->getTotalCount();
  562.                     $totalChilds += $childs;
  564.                     if ($childs > 0) {
  565.                         $deleteObjectsPerRequest = 5;
  566.                         for ($i = 0; $i < ceil($childs / $deleteObjectsPerRequest); $i++) {
  567.                             $deleteJobs[] = [[
  568.                                 'url' => '/admin/asset/delete',
  569.                                 'params' => [
  570.                                     'step' => $i,
  571.                                     'amount' => $deleteObjectsPerRequest,
  572.                                     'type' => 'childs',
  573.                                     'id' => $asset->getId()
  574.                                 ]
  575.                             ]];
  576.                         }
  577.                     }
  578.                 }
  580.                 // the asset itself is the last one
  581.                 $deleteJobs[] = [[
  582.                     'url' => '/admin/asset/delete',
  583.                     'params' => [
  584.                         'id' => $asset->getId()
  585.                     ]
  586.                 ]];
  587.             }
  588.         }
  590.         // get the element key in case of just one
  591.         $elementKey = false;
  592.         if (count($ids) === 1) {
  593.             $elementKey = Asset::getById($id)->getKey();
  594.         }
  596.         $deleteJobs = array_merge($recycleJobs, $deleteJobs);
  598.         return $this->adminJson([
  599.             'hasDependencies' => $hasDependency,
  600.             'childs' => $totalChilds,
  601.             'deletejobs' => $deleteJobs,
  602.             'batchDelete' => count($ids) > 1,
  603.             'elementKey' => $elementKey
  604.         ]);
  605.     }
  607.     /**
  608.      * @param $element
  609.      *
  610.      * @return array
  611.      */
  612.     protected function getTreeNodeConfig($element)
  613.     {
  614.         /**
  615.          * @var $asset Asset
  616.          */
  617.         $asset = $element;
  619.         $tmpAsset = [
  620.             'id' => $asset->getId(),
  621.             'text' => $asset->getFilename(),
  622.             'type' => $asset->getType(),
  623.             'path' => $asset->getRealFullPath(),
  624.             'basePath' => $asset->getRealPath(),
  625.             'locked' => $asset->isLocked(),
  626.             'lockOwner' => $asset->getLocked() ? true : false,
  627.             'elementType' => 'asset',
  628.             'permissions' => [
  629.                 'remove' => $asset->isAllowed('delete'),
  630.                 'settings' => $asset->isAllowed('settings'),
  631.                 'rename' => $asset->isAllowed('rename'),
  632.                 'publish' => $asset->isAllowed('publish'),
  633.                 'view' => $asset->isAllowed('view')
  634.             ]
  635.         ];
  637.         // set type specific settings
  638.         if ($asset->getType() == 'folder') {
  639.             $tmpAsset['leaf'] = false;
  640.             $tmpAsset['expanded'] = $asset->hasNoChilds();
  641.             $tmpAsset['loaded'] = $asset->hasNoChilds();
  642.             $tmpAsset['iconCls'] = 'pimcore_icon_folder';
  643.             $tmpAsset['permissions']['create'] = $asset->isAllowed('create');
  645.             $folderThumbs = [];
  646.             $children = new Asset\Listing();
  647.             $children->setCondition('path LIKE ?', [$asset->getRealFullPath() . '/%']);
  648.             $children->setLimit(35);
  650.             foreach ($children as $child) {
  651.                 if ($child->isAllowed('view')) {
  652.                     if ($thumbnailUrl = $this->getThumbnailUrl($child)) {
  653.                         $folderThumbs[] = $thumbnailUrl;
  654.                     }
  655.                 }
  656.             }
  658.             if (!empty($folderThumbs)) {
  659.                 $tmpAsset['thumbnails'] = $folderThumbs;
  660.             }
  661.         } else {
  662.             $tmpAsset['leaf'] = true;
  663.             $tmpAsset['expandable'] = false;
  664.             $tmpAsset['expanded'] = false;
  666.             $tmpAsset['iconCls'] = 'pimcore_icon_asset_default';
  668.             $fileExt = File::getFileExtension($asset->getFilename());
  669.             if ($fileExt) {
  670.                 $tmpAsset['iconCls'] .= ' pimcore_icon_' . File::getFileExtension($asset->getFilename());
  671.             }
  672.         }
  674.         $tmpAsset['qtipCfg'] = [
  675.             'title' => 'ID: ' . $asset->getId()
  676.         ];
  678.         if ($asset->getType() == 'image') {
  679.             try {
  680.                 $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset);
  682.                 // this is for backward-compatibility, to calculate the dimensions if they are not there
  683.                 if (!$asset->getCustomSetting('imageDimensionsCalculated')) {
  684.                     $asset->save();
  685.                 }
  687.                 // we need the dimensions for the wysiwyg editors, so that they can resize the image immediately
  688.                 if ($asset->getCustomSetting('imageWidth') && $asset->getCustomSetting('imageHeight')) {
  689.                     $tmpAsset['imageWidth'] = $asset->getCustomSetting('imageWidth');
  690.                     $tmpAsset['imageHeight'] = $asset->getCustomSetting('imageHeight');
  691.                 }
  692.             } catch (\Exception $e) {
  693.                 Logger::debug('Cannot get dimensions of image, seems to be broken.');
  694.             }
  695.         } elseif ($asset->getType() == 'video') {
  696.             try {
  697.                 if (\Pimcore\Video::isAvailable()) {
  698.                     $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset);
  699.                 }
  700.             } catch (\Exception $e) {
  701.                 Logger::debug('Cannot get dimensions of video, seems to be broken.');
  702.             }
  703.         } elseif ($asset->getType() == 'document') {
  704.             try {
  705.                 // add the PDF check here, otherwise the preview layer in admin is shown without content
  706.                 if (\Pimcore\Document::isAvailable() && \Pimcore\Document::isFileTypeSupported($asset->getFilename())) {
  707.                     $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset);
  708.                 }
  709.             } catch (\Exception $e) {
  710.                 Logger::debug('Cannot get dimensions of video, seems to be broken.');
  711.             }
  712.         }
  714.         $tmpAsset['cls'] = '';
  715.         if ($asset->isLocked()) {
  716.             $tmpAsset['cls'] .= 'pimcore_treenode_locked ';
  717.         }
  718.         if ($asset->getLocked()) {
  719.             $tmpAsset['cls'] .= 'pimcore_treenode_lockOwner ';
  720.         }
  722.         return $tmpAsset;
  723.     }
  725.     /**
  726.      * @param Asset $asset
  727.      *
  728.      * @return null|string
  729.      */
  730.     protected function getThumbnailUrl(Asset $asset)
  731.     {
  732.         if ($asset instanceof Asset\Image) {
  733.             return '/admin/asset/get-image-thumbnail?id=' . $asset->getId() . '&treepreview=true';
  734.         } elseif ($asset instanceof Asset\Video && \Pimcore\Video::isAvailable()) {
  735.             return '/admin/asset/get-video-thumbnail?id=' . $asset->getId() . '&treepreview=true';
  736.         } elseif ($asset instanceof Asset\Document && \Pimcore\Document::isAvailable()) {
  737.             return '/admin/asset/get-document-thumbnail?id=' . $asset->getId() . '&treepreview=true';
  738.         }
  740.         return null;
  741.     }
  743.     /**
  744.      * @Route("/update")
  745.      *
  746.      * @param Request $request
  747.      *
  748.      * @return JsonResponse
  749.      *
  750.      * @throws \Exception
  751.      */
  752.     public function updateAction(Request $request)
  753.     {
  754.         $success = false;
  755.         $allowUpdate = true;
  757.         $updateData = array_merge($request->request->all(), $request->query->all());
  759.         $asset = Asset::getById($request->get('id'));
  760.         if ($asset->isAllowed('settings')) {
  761.             $asset->setUserModification($this->getAdminUser()->getId());
  763.             // if the position is changed the path must be changed || also from the childs
  764.             if ($request->get('parentId')) {
  765.                 $parentAsset = Asset::getById($request->get('parentId'));
  767.                 //check if parent is changed i.e. asset is moved
  768.                 if ($asset->getParentId() != $parentAsset->getId()) {
  769.                     if (!$parentAsset->isAllowed('create')) {
  770.                         throw new \Exception('Prevented moving asset - no create permission on new parent ');
  771.                     }
  773.                     $intendedPath = $parentAsset->getRealPath();
  774.                     $pKey = $parentAsset->getKey();
  775.                     if (!empty($pKey)) {
  776.                         $intendedPath .= $parentAsset->getKey() . '/';
  777.                     }
  779.                     $assetWithSamePath = Asset::getByPath($intendedPath . $asset->getKey());
  781.                     if ($assetWithSamePath != null) {
  782.                         $allowUpdate = false;
  783.                     }
  785.                     if ($asset->isLocked()) {
  786.                         $allowUpdate = false;
  787.                     }
  788.                 }
  789.             }
  791.             if ($allowUpdate) {
  792.                 if ($request->get('filename') != $asset->getFilename() and !$asset->isAllowed('rename')) {
  793.                     unset($updateData['filename']);
  794.                     Logger::debug('prevented renaming asset because of missing permissions ');
  795.                 }
  797.                 $asset->setValues($updateData);
  799.                 try {
  800.                     $asset->save();
  801.                     $success = true;
  802.                 } catch (\Exception $e) {
  803.                     return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  804.                 }
  805.             } else {
  806.                 $msg = 'prevented moving asset, asset with same path+key already exists at target location or the asset is locked. ID: ' . $asset->getId();
  807.                 Logger::debug($msg);
  809.                 return $this->adminJson(['success' => $success, 'message' => $msg]);
  810.             }
  811.         } elseif ($asset->isAllowed('rename') && $request->get('filename')) {
  812.             //just rename
  813.             try {
  814.                 $asset->setFilename($request->get('filename'));
  815.                 $asset->save();
  816.                 $success = true;
  817.             } catch (\Exception $e) {
  818.                 return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  819.             }
  820.         } else {
  821.             Logger::debug('prevented update asset because of missing permissions ');
  822.         }
  824.         return $this->adminJson(['success' => $success]);
  825.     }
  827.     /**
  828.      * @Route("/webdav{path}", requirements={"path"=".*"}, name="pimcore_admin_webdav")
  829.      *
  830.      * @param Request $request
  831.      */
  832.     public function webdavAction(Request $request)
  833.     {
  834.         $homeDir = Asset::getById(1);
  836.         try {
  837.             $publicDir = new Asset\WebDAV\Folder($homeDir);
  838.             $objectTree = new Asset\WebDAV\Tree($publicDir);
  839.             $server = new \Sabre\DAV\Server($objectTree);
  840.             $server->setBaseUri('/admin/asset/webdav/');
  842.             // lock plugin
  843.             $lockBackend = new \Sabre\DAV\Locks\Backend\File(PIMCORE_SYSTEM_TEMP_DIRECTORY . '/webdav-locks.dat');
  844.             $lockPlugin = new \Sabre\DAV\Locks\Plugin($lockBackend);
  845.             $server->addPlugin($lockPlugin);
  847.             // sync plugin
  848.             $server->addPlugin(new \Sabre\DAV\Sync\Plugin());
  850.             // browser plugin
  851.             $server->addPlugin(new \Sabre\DAV\Browser\Plugin());
  853.             $server->exec();
  854.         } catch (\Exception $e) {
  855.             Logger::error($e);
  856.         }
  858.         exit;
  859.     }
  861.     /**
  862.      * @Route("/save")
  863.      *
  864.      * @param Request $request
  865.      *
  866.      * @return JsonResponse
  867.      *
  868.      * @throws \Exception
  869.      */
  870.     public function saveAction(Request $request)
  871.     {
  872.         try {
  873.             $success = false;
  874.             if ($request->get('id')) {
  875.                 $asset = Asset::getById($request->get('id'));
  876.                 if ($asset->isAllowed('publish')) {
  878.                     // metadata
  879.                     if ($request->get('metadata')) {
  880.                         $metadata = $this->decodeJson($request->get('metadata'));
  881.                         $metadata = Asset\Service::minimizeMetadata($metadata);
  882.                         $asset->setMetadata($metadata);
  883.                     }
  885.                     // properties
  886.                     if ($request->get('properties')) {
  887.                         $properties = [];
  888.                         $propertiesData = $this->decodeJson($request->get('properties'));
  890.                         if (is_array($propertiesData)) {
  891.                             foreach ($propertiesData as $propertyName => $propertyData) {
  892.                                 $value = $propertyData['data'];
  894.                                 try {
  895.                                     $property = new Model\Property();
  896.                                     $property->setType($propertyData['type']);
  897.                                     $property->setName($propertyName);
  898.                                     $property->setCtype('asset');
  899.                                     $property->setDataFromEditmode($value);
  900.                                     $property->setInheritable($propertyData['inheritable']);
  902.                                     $properties[$propertyName] = $property;
  903.                                 } catch (\Exception $e) {
  904.                                     Logger::err("Can't add " . $propertyName . ' to asset ' . $asset->getRealFullPath());
  905.                                 }
  906.                             }
  908.                             $asset->setProperties($properties);
  909.                         }
  910.                     }
  912.                     // scheduled tasks
  913.                     if ($request->get('scheduler')) {
  914.                         $tasks = [];
  915.                         $tasksData = $this->decodeJson($request->get('scheduler'));
  917.                         if (!empty($tasksData)) {
  918.                             foreach ($tasksData as $taskData) {
  919.                                 $taskData['date'] = strtotime($taskData['date'] . ' ' . $taskData['time']);
  921.                                 $task = new Model\Schedule\Task($taskData);
  922.                                 $tasks[] = $task;
  923.                             }
  924.                         }
  926.                         $asset->setScheduledTasks($tasks);
  927.                     }
  929.                     if ($request->get('data')) {
  930.                         $asset->setData($request->get('data'));
  931.                     }
  933.                     $asset->setUserModification($this->getAdminUser()->getId());
  935.                     try {
  936.                         $asset->save();
  937.                         $asset->getData();
  938.                         $success = true;
  939.                     } catch (\Exception $e) {
  940.                         if ($e instanceof Element\ValidationException) {
  941.                             throw $e;
  942.                         }
  944.                         return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  945.                     }
  946.                 } else {
  947.                     Logger::debug('prevented save asset because of missing permissions ');
  948.                 }
  950.                 return $this->adminJson(['success' => $success]);
  951.             }
  953.             return $this->adminJson(false);
  954.         } catch (\Exception $e) {
  955.             Logger::log($e);
  956.             if ($e instanceof Element\ValidationException) {
  957.                 return $this->adminJson(['success' => false, 'type' => 'ValidationException', 'message' => $e->getMessage(), 'stack' => $e->getTraceAsString(), 'code' => $e->getCode()]);
  958.             }
  959.             throw $e;
  960.         }
  961.     }
  963.     /**
  964.      * @Route("/publish-version")
  965.      *
  966.      * @param Request $request
  967.      *
  968.      * @return JsonResponse
  969.      */
  970.     public function publishVersionAction(Request $request)
  971.     {
  972.         $version = Model\Version::getById($request->get('id'));
  973.         $asset = $version->loadData();
  975.         $currentAsset = Asset::getById($asset->getId());
  976.         if ($currentAsset->isAllowed('publish')) {
  977.             try {
  978.                 $asset->setUserModification($this->getAdminUser()->getId());
  979.                 $asset->save();
  981.                 return $this->adminJson(['success' => true]);
  982.             } catch (\Exception $e) {
  983.                 return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  984.             }
  985.         }
  987.         return $this->adminJson(false);
  988.     }
  990.     /**
  991.      * @Route("/show-version")
  992.      * @TemplatePhp()
  993.      *
  994.      * @param Request $request
  995.      *
  996.      * @return Response
  997.      *
  998.      * @throws \Exception
  999.      */
  1000.     public function showVersionAction(Request $request)
  1001.     {
  1002.         $id = intval($request->get('id'));
  1003.         $version = Model\Version::getById($id);
  1004.         $asset = $version->loadData();
  1006.         if ($asset->isAllowed('versions')) {
  1007.             return $this->render(
  1008.                 'PimcoreAdminBundle:Admin/Asset:showVersion' . ucfirst($asset->getType()) . '.html.php',
  1009.                 ['asset' => $asset]
  1010.             );
  1011.         } else {
  1012.             throw new \Exception('Permission denied, version id [' . $id . ']');
  1013.         }
  1014.     }
  1016.     /**
  1017.      * @Route("/download")
  1018.      *
  1019.      * @param Request $request
  1020.      *
  1021.      * @return BinaryFileResponse
  1022.      */
  1023.     public function downloadAction(Request $request)
  1024.     {
  1025.         $asset = Asset::getById($request->get('id'));
  1027.         if ($asset->isAllowed('view')) {
  1028.             $response = new BinaryFileResponse($asset->getFileSystemPath());
  1029.             $response->headers->set('Content-Type', $asset->getMimetype());
  1030.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $asset->getFilename());
  1032.             return $response;
  1033.         }
  1034.     }
  1036.     /**
  1037.      * @Route("/download-image-thumbnail")
  1038.      *
  1039.      * @param Request $request
  1040.      *
  1041.      * @return BinaryFileResponse
  1042.      */
  1043.     public function downloadImageThumbnailAction(Request $request)
  1044.     {
  1045.         $image = Asset\Image::getById($request->get('id'));
  1047.         if (!$image->isAllowed('view')) {
  1048.             throw new \Exception('not allowed to view thumbnail');
  1049.         }
  1051.         $config = null;
  1053.         if ($request->get('config')) {
  1054.             $config = $this->decodeJson($request->get('config'));
  1055.         } elseif ($request->get('type')) {
  1056.             $predefined = [
  1057.                 'web' => [
  1058.                     'resize_mode' => 'scaleByWidth',
  1059.                     'width' => 3500,
  1060.                     'dpi' => 72,
  1061.                     'format' => 'JPEG',
  1062.                     'quality' => 85
  1063.                 ],
  1064.                 'print' => [
  1065.                     'resize_mode' => 'scaleByWidth',
  1066.                     'width' => 6000,
  1067.                     'dpi' => 300,
  1068.                     'format' => 'JPEG',
  1069.                     'quality' => 95
  1070.                 ],
  1071.                 'office' => [
  1072.                     'resize_mode' => 'scaleByWidth',
  1073.                     'width' => 1190,
  1074.                     'dpi' => 144,
  1075.                     'format' => 'JPEG',
  1076.                     'quality' => 90
  1077.                 ],
  1078.             ];
  1080.             $config = $predefined[$request->get('type')];
  1081.         }
  1083.         if ($config) {
  1084.             $thumbnailConfig = new Asset\Image\Thumbnail\Config();
  1085.             $thumbnailConfig->setName('pimcore-download-' . $image->getId() . '-' . md5($request->get('config')));
  1087.             if ($config['resize_mode'] == 'scaleByWidth') {
  1088.                 $thumbnailConfig->addItem('scaleByWidth', [
  1089.                     'width' => $config['width']
  1090.                 ]);
  1091.             } elseif ($config['resize_mode'] == 'scaleByHeight') {
  1092.                 $thumbnailConfig->addItem('scaleByHeight', [
  1093.                     'height' => $config['height']
  1094.                 ]);
  1095.             } else {
  1096.                 $thumbnailConfig->addItem('resize', [
  1097.                     'width' => $config['width'],
  1098.                     'height' => $config['height']
  1099.                 ]);
  1100.             }
  1102.             $thumbnailConfig->setQuality($config['quality']);
  1103.             $thumbnailConfig->setFormat($config['format']);
  1105.             if ($thumbnailConfig->getFormat() == 'JPEG') {
  1106.                 $thumbnailConfig->setPreserveMetaData(true);
  1108.                 if (empty($config['quality'])) {
  1109.                     $thumbnailConfig->setPreserveColor(true);
  1110.                 }
  1111.             }
  1113.             $thumbnail = $image->getThumbnail($thumbnailConfig);
  1114.             $thumbnailFile = $thumbnail->getFileSystemPath();
  1116.             $exiftool = \Pimcore\Tool\Console::getExecutable('exiftool');
  1117.             if ($thumbnailConfig->getFormat() == 'JPEG' && $exiftool && isset($config['dpi']) && $config['dpi']) {
  1118.                 \Pimcore\Tool\Console::exec($exiftool . ' -overwrite_original -xresolution=' . $config['dpi'] . ' -yresolution=' . $config['dpi'] . ' -resolutionunit=inches ' . escapeshellarg($thumbnailFile));
  1119.             }
  1121.             $downloadFilename = str_replace(
  1122.                 '.' . File::getFileExtension($image->getFilename()),
  1123.                 '.' . $thumbnail->getFileExtension(),
  1124.                 $image->getFilename()
  1125.             );
  1126.             $downloadFilename = strtolower($downloadFilename);
  1128.             clearstatcache();
  1130.             $response = new BinaryFileResponse($thumbnailFile);
  1131.             $response->headers->set('Content-Type', $thumbnail->getMimeType());
  1132.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $downloadFilename);
  1133.             $this->addThumbnailCacheHeaders($response);
  1134.             $response->deleteFileAfterSend(true);
  1136.             return $response;
  1137.         }
  1138.     }
  1140.     /**
  1141.      * @Route("/get-image-thumbnail")
  1142.      *
  1143.      * @param Request $request
  1144.      *
  1145.      * @return BinaryFileResponse|JsonResponse
  1146.      */
  1147.     public function getImageThumbnailAction(Request $request)
  1148.     {
  1149.         $fileinfo = $request->get('fileinfo');
  1150.         $image = Asset\Image::getById(intval($request->get('id')));
  1152.         if (!$image->isAllowed('view')) {
  1153.             throw new \Exception('not allowed to view thumbnail');
  1154.         }
  1156.         $thumbnail = null;
  1158.         if ($request->get('thumbnail')) {
  1159.             $thumbnail = $image->getThumbnailConfig($request->get('thumbnail'));
  1160.         }
  1161.         if (!$thumbnail) {
  1162.             if ($request->get('config')) {
  1163.                 $thumbnail = $image->getThumbnailConfig($this->decodeJson($request->get('config')));
  1164.             } else {
  1165.                 $thumbnail = $image->getThumbnailConfig(array_merge($request->request->all(), $request->query->all()));
  1166.             }
  1167.         } else {
  1168.             // no high-res images in admin mode (editmode)
  1169.             // this is mostly because of the document's image editable, which doesn't know anything about the thumbnail
  1170.             // configuration, so the dimensions would be incorrect (double the size)
  1171.             $thumbnail->setHighResolution(1);
  1172.         }
  1174.         $format = strtolower($thumbnail->getFormat());
  1175.         if ($format == 'source' || $format == 'print') {
  1176.             $thumbnail->setFormat('PNG');
  1177.         }
  1179.         if ($request->get('treepreview')) {
  1180.             $thumbnail = Asset\Image\Thumbnail\Config::getPreviewConfig();
  1181.         }
  1183.         if ($request->get('cropPercent')) {
  1184.             $thumbnail->addItemAt(0, 'cropPercent', [
  1185.                 'width' => $request->get('cropWidth'),
  1186.                 'height' => $request->get('cropHeight'),
  1187.                 'y' => $request->get('cropTop'),
  1188.                 'x' => $request->get('cropLeft')
  1189.             ]);
  1191.             $hash = md5(Tool\Serialize::serialize(array_merge($request->request->all(), $request->query->all())));
  1192.             $thumbnail->setName($thumbnail->getName() . '_auto_' . $hash);
  1193.         }
  1195.         $thumbnail = $image->getThumbnail($thumbnail);
  1197.         if ($fileinfo) {
  1198.             return $this->adminJson([
  1199.                 'width' => $thumbnail->getWidth(),
  1200.                 'height' => $thumbnail->getHeight()]);
  1201.         }
  1203.         $thumbnailFile = $thumbnail->getFileSystemPath();
  1205.         $response = new BinaryFileResponse($thumbnailFile);
  1206.         $response->headers->set('Content-Type', $thumbnail->getMimeType());
  1207.         $response->headers->set('Access-Control-Allow-Origin', '*');
  1209.         $this->addThumbnailCacheHeaders($response);
  1211.         return $response;
  1212.     }
  1214.     /**
  1215.      * @Route("/get-video-thumbnail")
  1216.      *
  1217.      * @param Request $request
  1218.      *
  1219.      * @return BinaryFileResponse
  1220.      */
  1221.     public function getVideoThumbnailAction(Request $request)
  1222.     {
  1223.         if ($request->get('id')) {
  1224.             $video = Asset::getById(intval($request->get('id')));
  1225.         } elseif ($request->get('path')) {
  1226.             $video = Asset::getByPath($request->get('path'));
  1227.         }
  1229.         if (!$video->isAllowed('view')) {
  1230.             throw new \Exception('not allowed to view thumbnail');
  1231.         }
  1233.         $thumbnail = array_merge($request->request->all(), $request->query->all());
  1235.         if ($request->get('treepreview')) {
  1236.             $thumbnail = Asset\Image\Thumbnail\Config::getPreviewConfig();
  1237.         }
  1239.         $time = null;
  1240.         if ($request->get('time')) {
  1241.             $time = intval($request->get('time'));
  1242.         }
  1244.         if ($request->get('settime')) {
  1245.             $video->removeCustomSetting('image_thumbnail_asset');
  1246.             $video->setCustomSetting('image_thumbnail_time', $time);
  1247.             $video->save();
  1248.         }
  1250.         $image = null;
  1251.         if ($request->get('image')) {
  1252.             $image = Asset::getById(intval($request->get('image')));
  1253.         }
  1255.         if ($request->get('setimage') && $image) {
  1256.             $video->removeCustomSetting('image_thumbnail_time');
  1257.             $video->setCustomSetting('image_thumbnail_asset', $image->getId());
  1258.             $video->save();
  1259.         }
  1261.         $thumb = $video->getImageThumbnail($thumbnail, $time, $image);
  1262.         $thumbnailFile = $thumb->getFileSystemPath();
  1264.         $response = new BinaryFileResponse($thumbnailFile);
  1265.         $response->headers->set('Content-type', 'image/' . File::getFileExtension($thumbnailFile));
  1267.         $this->addThumbnailCacheHeaders($response);
  1269.         return $response;
  1270.     }
  1272.     /**
  1273.      * @Route("/get-document-thumbnail")
  1274.      *
  1275.      * @param Request $request
  1276.      *
  1277.      * @return BinaryFileResponse
  1278.      */
  1279.     public function getDocumentThumbnailAction(Request $request)
  1280.     {
  1281.         $document = Asset::getById(intval($request->get('id')));
  1283.         if (!$document->isAllowed('view')) {
  1284.             throw new \Exception('not allowed to view thumbnail');
  1285.         }
  1287.         $thumbnail = Asset\Image\Thumbnail\Config::getByAutoDetect(array_merge($request->request->all(), $request->query->all()));
  1289.         $format = strtolower($thumbnail->getFormat());
  1290.         if ($format == 'source') {
  1291.             $thumbnail->setFormat('jpeg'); // default format for documents is JPEG not PNG (=too big)
  1292.         }
  1294.         if ($request->get('treepreview')) {
  1295.             $thumbnail = Asset\Image\Thumbnail\Config::getPreviewConfig();
  1296.         }
  1298.         $page = 1;
  1299.         if (is_numeric($request->get('page'))) {
  1300.             $page = (int)$request->get('page');
  1301.         }
  1303.         $thumb = $document->getImageThumbnail($thumbnail, $page);
  1304.         $thumbnailFile = $thumb->getFileSystemPath();
  1306.         $format = 'png';
  1308.         $response = new BinaryFileResponse($thumbnailFile);
  1309.         $response->headers->set('Content-type', 'image/' . $format);
  1310.         $this->addThumbnailCacheHeaders($response);
  1312.         return $response;
  1313.     }
  1315.     /**
  1316.      * @param Response $response
  1317.      */
  1318.     protected function addThumbnailCacheHeaders(Response $response)
  1319.     {
  1320.         $lifetime = 300;
  1321.         $date = new \DateTime('now');
  1322.         $date->add(new \DateInterval('PT' . $lifetime . 'S'));
  1324.         $response->setMaxAge($lifetime);
  1325.         $response->setPublic();
  1326.         $response->setExpires($date);
  1327.         $response->headers->set('Pragma', '');
  1328.     }
  1330.     /**
  1331.      * @Route("/get-preview-document")
  1332.      * @TemplatePhp()
  1333.      *
  1334.      * @param Request $request
  1335.      *
  1336.      * @return array
  1337.      */
  1338.     public function getPreviewDocumentAction(Request $request)
  1339.     {
  1340.         $asset = Asset::getById($request->get('id'));
  1342.         if (!$asset->isAllowed('view')) {
  1343.             throw new \Exception('not allowed to preview');
  1344.         }
  1346.         return ['asset' => $asset];
  1347.     }
  1349.     /**
  1350.      * @Route("/get-preview-video")
  1351.      * @TemplatePhp()
  1352.      *
  1353.      * @param Request $request
  1354.      *
  1355.      * @return Response
  1356.      */
  1357.     public function getPreviewVideoAction(Request $request)
  1358.     {
  1359.         $asset = Asset::getById($request->get('id'));
  1361.         if (!$asset->isAllowed('view')) {
  1362.             throw new \Exception('not allowed to preview');
  1363.         }
  1365.         $previewData = ['asset' => $asset];
  1367.         $config = Asset\Video\Thumbnail\Config::getPreviewConfig();
  1369.         $thumbnail = $asset->getThumbnail($config, ['mp4']);
  1371.         if ($thumbnail) {
  1372.             $previewData['asset'] = $asset;
  1373.             $previewData['thumbnail'] = $thumbnail;
  1375.             if ($thumbnail['status'] == 'finished') {
  1376.                 return $this->render(
  1377.                     'PimcoreAdminBundle:Admin/Asset:getPreviewVideoDisplay.html.php',
  1378.                     $previewData
  1379.                 );
  1380.             } else {
  1381.                 return $this->render(
  1382.                     'PimcoreAdminBundle:Admin/Asset:getPreviewVideoError.html.php',
  1383.                     $previewData
  1384.                 );
  1385.             }
  1386.         } else {
  1387.             return $this->render(
  1388.                 'PimcoreAdminBundle:Admin/Asset:getPreviewVideoError.html.php',
  1389.                 $previewData
  1390.             );
  1391.         }
  1392.     }
  1394.     /**
  1395.      * @Route("/image-editor")
  1396.      *
  1397.      * @param Request $request
  1398.      * @TemplatePhp()
  1399.      *
  1400.      * @return array
  1401.      */
  1402.     public function imageEditorAction(Request $request)
  1403.     {
  1404.         $asset = Asset::getById($request->get('id'));
  1406.         if (!$asset->isAllowed('view')) {
  1407.             throw new \Exception('not allowed to preview');
  1408.         }
  1410.         return ['asset' => $asset];
  1411.     }
  1413.     /**
  1414.      * @Route("/image-editor-save")
  1415.      *
  1416.      * @param Request $request
  1417.      *
  1418.      * @return JsonResponse
  1419.      */
  1420.     public function imageEditorSaveAction(Request $request)
  1421.     {
  1422.         $asset = Asset::getById($request->get('id'));
  1424.         if (!$asset->isAllowed('publish')) {
  1425.             throw new \Exception('not allowed to publish');
  1426.         }
  1428.         $data = $request->get('dataUri');
  1429.         $data = substr($data, strpos($data, ','));
  1430.         $data = base64_decode($data);
  1431.         $asset->setData($data);
  1432.         $asset->setUserModification($this->getAdminUser()->getId());
  1433.         $asset->save();
  1435.         return $this->adminJson(['success' => true]);
  1436.     }
  1438.     /**
  1439.      * @Route("/get-folder-content-preview")
  1440.      *
  1441.      * @param Request $request
  1442.      *
  1443.      * @return JsonResponse
  1444.      */
  1445.     public function getFolderContentPreviewAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1446.     {
  1447.         $allParams = array_merge($request->request->all(), $request->query->all());
  1449.         $filterPrepareEvent = new GenericEvent($this, [
  1450.             'requestParams' => $allParams
  1451.         ]);
  1452.         $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_FILTER_PREPARE, $filterPrepareEvent);
  1454.         $allParams = $filterPrepareEvent->getArgument('requestParams');
  1456.         $folder = Asset::getById($allParams['id']);
  1458.         $start = 0;
  1459.         $limit = 10;
  1461.         if ($allParams['limit']) {
  1462.             $limit = $allParams['limit'];
  1463.         }
  1464.         if ($allParams['start']) {
  1465.             $start = $allParams['start'];
  1466.         }
  1468.         $conditionFilters = [];
  1469.         $list = new Asset\Listing();
  1470.         $conditionFilters[] = 'path LIKE ' . ($folder->getRealFullPath() == '/' ? "'/%'" : $list->quote($folder->getRealFullPath() . '/%')) ." AND type != 'folder'";
  1472.         if (!$this->getAdminUser()->isAdmin()) {
  1473.             $userIds = $this->getAdminUser()->getRoles();
  1474.             $userIds[] = $this->getAdminUser()->getId();
  1475.             $conditionFilters[] .= ' (
  1476.                                                     (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
  1477.                                                     OR
  1478.                                                     (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
  1479.                                                  )';
  1480.         }
  1482.         $condition = implode(' AND ', $conditionFilters);
  1484.         $list->setCondition($condition);
  1485.         $list->setLimit($limit);
  1486.         $list->setOffset($start);
  1487.         $list->setOrderKey('filename');
  1488.         $list->setOrder('asc');
  1490.         $beforeListLoadEvent = new GenericEvent($this, [
  1491.             'list' => $list,
  1492.             'context' => $allParams
  1493.         ]);
  1494.         $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD, $beforeListLoadEvent);
  1495.         $list = $beforeListLoadEvent->getArgument('list');
  1497.         $list->load();
  1499.         $assets = [];
  1501.         foreach ($list as $asset) {
  1502.             $thumbnailMethod = '';
  1503.             if ($asset instanceof Asset\Image) {
  1504.                 $thumbnailMethod = 'getThumbnail';
  1505.             } elseif ($asset instanceof Asset\Video && \Pimcore\Video::isAvailable()) {
  1506.                 $thumbnailMethod = 'getImageThumbnail';
  1507.             } elseif ($asset instanceof Asset\Document && \Pimcore\Document::isAvailable()) {
  1508.                 $thumbnailMethod = 'getImageThumbnail';
  1509.             }
  1511.             if (!empty($thumbnailMethod)) {
  1512.                 $filenameDisplay = $asset->getFilename();
  1513.                 if (strlen($filenameDisplay) > 32) {
  1514.                     $filenameDisplay = substr($filenameDisplay, 0, 25) . '...' . \Pimcore\File::getFileExtension($filenameDisplay);
  1515.                 }
  1517.                 // 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
  1518.                 if ($asset->isAllowed('list')) {
  1519.                     $assets[] = [
  1520.                         'id' => $asset->getId(),
  1521.                         'type' => $asset->getType(),
  1522.                         'filename' => $asset->getFilename(),
  1523.                         'filenameDisplay' => $filenameDisplay,
  1524.                         'url' => '/admin/asset/get-' . $asset->getType() . '-thumbnail?id=' . $asset->getId() . '&treepreview=true',
  1525.                         'idPath' => $data['idPath'] = Element\Service::getIdPath($asset)
  1526.                     ];
  1527.                 }
  1528.             }
  1529.         }
  1531.         // We need to temporary use data key to be compatible with the ASSET_LIST_AFTER_LIST_LOAD global event
  1532.         $result = ['data' => $assets, 'success' => true, 'total' => $list->getTotalCount()];
  1534.         $afterListLoadEvent = new GenericEvent($this, [
  1535.             'list' => $result,
  1536.             'context' => $allParams
  1537.         ]);
  1538.         $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_AFTER_LIST_LOAD, $afterListLoadEvent);
  1539.         $result = $afterListLoadEvent->getArgument('list');
  1541.         // Here we revert to assets key
  1542.         return $this->adminJson(['assets' => $result['data'], 'success' => $result['success'], 'total' => $result['total']]);
  1543.     }
  1545.     /**
  1546.      * @Route("/copy-info")
  1547.      *
  1548.      * @param Request $request
  1549.      *
  1550.      * @return JsonResponse
  1551.      */
  1552.     public function copyInfoAction(Request $request)
  1553.     {
  1554.         $transactionId = time();
  1555.         $pasteJobs = [];
  1557.         Tool\Session::useSession(function (AttributeBagInterface $session) use ($transactionId) {
  1558.             $session->set($transactionId, []);
  1559.         }, 'pimcore_copy');
  1561.         if ($request->get('type') == 'recursive') {
  1562.             $asset = Asset::getById($request->get('sourceId'));
  1564.             // first of all the new parent
  1565.             $pasteJobs[] = [[
  1566.                 'url' => '/admin/asset/copy',
  1567.                 'params' => [
  1568.                     'sourceId' => $request->get('sourceId'),
  1569.                     'targetId' => $request->get('targetId'),
  1570.                     'type' => 'child',
  1571.                     'transactionId' => $transactionId,
  1572.                     'saveParentId' => true
  1573.                 ]
  1574.             ]];
  1576.             if ($asset->hasChildren()) {
  1577.                 // get amount of children
  1578.                 $list = new Asset\Listing();
  1579.                 $list->setCondition('path LIKE ?', [$asset->getRealFullPath() . '/%']);
  1580.                 $list->setOrderKey('LENGTH(path)', false);
  1581.                 $list->setOrder('ASC');
  1582.                 $childIds = $list->loadIdList();
  1584.                 if (count($childIds) > 0) {
  1585.                     foreach ($childIds as $id) {
  1586.                         $pasteJobs[] = [[
  1587.                             'url' => '/admin/asset/copy',
  1588.                             'params' => [
  1589.                                 'sourceId' => $id,
  1590.                                 'targetParentId' => $request->get('targetId'),
  1591.                                 'sourceParentId' => $request->get('sourceId'),
  1592.                                 'type' => 'child',
  1593.                                 'transactionId' => $transactionId
  1594.                             ]
  1595.                         ]];
  1596.                     }
  1597.                 }
  1598.             }
  1599.         } elseif ($request->get('type') == 'child' || $request->get('type') == 'replace') {
  1600.             // the object itself is the last one
  1601.             $pasteJobs[] = [[
  1602.                 'url' => '/admin/asset/copy',
  1603.                 'params' => [
  1604.                     'sourceId' => $request->get('sourceId'),
  1605.                     'targetId' => $request->get('targetId'),
  1606.                     'type' => $request->get('type'),
  1607.                     'transactionId' => $transactionId
  1608.                 ]
  1609.             ]];
  1610.         }
  1612.         return $this->adminJson([
  1613.             'pastejobs' => $pasteJobs
  1614.         ]);
  1615.     }
  1617.     /**
  1618.      * @Route("/copy")
  1619.      *
  1620.      * @param Request $request
  1621.      *
  1622.      * @return JsonResponse
  1623.      */
  1624.     public function copyAction(Request $request)
  1625.     {
  1626.         $success = false;
  1627.         $sourceId = intval($request->get('sourceId'));
  1628.         $source = Asset::getById($sourceId);
  1630.         $session = Tool\Session::get('pimcore_copy');
  1631.         $sessionBag = $session->get($request->get('transactionId'));
  1633.         $targetId = intval($request->get('targetId'));
  1634.         if ($request->get('targetParentId')) {
  1635.             $sourceParent = Asset::getById($request->get('sourceParentId'));
  1637.             // this is because the key can get the prefix "_copy" if the target does already exists
  1638.             if ($sessionBag['parentId']) {
  1639.                 $targetParent = Asset::getById($sessionBag['parentId']);
  1640.             } else {
  1641.                 $targetParent = Asset::getById($request->get('targetParentId'));
  1642.             }
  1644.             $targetPath = preg_replace('@^' . $sourceParent->getRealFullPath() . '@', $targetParent . '/', $source->getRealPath());
  1645.             $target = Asset::getByPath($targetPath);
  1646.         } else {
  1647.             $target = Asset::getById($targetId);
  1648.         }
  1650.         if ($target->isAllowed('create')) {
  1651.             $source = Asset::getById($sourceId);
  1652.             if ($source != null) {
  1653.                 if ($request->get('type') == 'child') {
  1654.                     $newAsset = $this->_assetService->copyAsChild($target, $source);
  1656.                     // this is because the key can get the prefix "_copy" if the target does already exists
  1657.                     if ($request->get('saveParentId')) {
  1658.                         $sessionBag['parentId'] = $newAsset->getId();
  1659.                     }
  1660.                 } elseif ($request->get('type') == 'replace') {
  1661.                     $this->_assetService->copyContents($target, $source);
  1662.                 }
  1664.                 $session->set($request->get('transactionId'), $sessionBag);
  1665.                 Tool\Session::writeClose();
  1667.                 $success = true;
  1668.             } else {
  1669.                 Logger::debug('prevended copy/paste because asset with same path+key already exists in this location');
  1670.             }
  1671.         } else {
  1672.             Logger::error('could not execute copy/paste because of missing permissions on target [ ' . $targetId . ' ]');
  1674.             return $this->adminJson(['error' => false, 'message' => 'missing_permission']);
  1675.         }
  1677.         Tool\Session::writeClose();
  1679.         return $this->adminJson(['success' => $success]);
  1680.     }
  1682.     /**
  1683.      * @Route("/download-as-zip-jobs")
  1684.      *
  1685.      * @param Request $request
  1686.      *
  1687.      * @return JsonResponse
  1688.      */
  1689.     public function downloadAsZipJobsAction(Request $request)
  1690.     {
  1691.         $jobId = uniqid();
  1692.         $filesPerJob = 5;
  1693.         $jobs = [];
  1694.         $asset = Asset::getById($request->get('id'));
  1696.         if ($asset->isAllowed('view')) {
  1697.             $parentPath = $asset->getRealFullPath();
  1698.             if ($asset->getId() == 1) {
  1699.                 $parentPath = '';
  1700.             }
  1702.             $db = \Pimcore\Db::get();
  1703.             $conditionFilters = [];
  1704.             $conditionFilters[] .= 'path LIKE ' . $db->quote($parentPath . '/%') .' AND type != ' . $db->quote('folder');
  1705.             if (!$this->getAdminUser()->isAdmin()) {
  1706.                 $userIds = $this->getAdminUser()->getRoles();
  1707.                 $userIds[] = $this->getAdminUser()->getId();
  1708.                 $conditionFilters[] .= ' (
  1709.                                                     (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
  1710.                                                     OR
  1711.                                                     (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
  1712.                                                  )';
  1713.             }
  1715.             $condition = implode(' AND ', $conditionFilters);
  1717.             $assetList = new Asset\Listing();
  1718.             $assetList->setCondition($condition);
  1719.             $assetList->setOrderKey('LENGTH(path)', false);
  1720.             $assetList->setOrder('ASC');
  1722.             for ($i = 0; $i < ceil($assetList->getTotalCount() / $filesPerJob); $i++) {
  1723.                 $jobs[] = [[
  1724.                     'url' => '/admin/asset/download-as-zip-add-files',
  1725.                     'params' => [
  1726.                         'id' => $asset->getId(),
  1727.                         'offset' => $i * $filesPerJob,
  1728.                         'limit' => $filesPerJob,
  1729.                         'jobId' => $jobId
  1730.                     ]
  1731.                 ]];
  1732.             }
  1733.         }
  1735.         return $this->adminJson([
  1736.             'success' => true,
  1737.             'jobs' => $jobs,
  1738.             'jobId' => $jobId
  1739.         ]);
  1740.     }
  1742.     /**
  1743.      * @Route("/download-as-zip-add-files")
  1744.      *
  1745.      * @param Request $request
  1746.      *
  1747.      * @return JsonResponse
  1748.      */
  1749.     public function downloadAsZipAddFilesAction(Request $request)
  1750.     {
  1751.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/download-zip-' . $request->get('jobId') . '.zip';
  1752.         $asset = Asset::getById($request->get('id'));
  1753.         $success = false;
  1755.         if ($asset->isAllowed('view')) {
  1756.             $zip = new \ZipArchive();
  1757.             if (!is_file($zipFile)) {
  1758.                 $zipState = $zip->open($zipFile, \ZipArchive::CREATE);
  1759.             } else {
  1760.                 $zipState = $zip->open($zipFile);
  1761.             }
  1763.             if ($zipState === true) {
  1764.                 $parentPath = $asset->getRealFullPath();
  1765.                 if ($asset->getId() == 1) {
  1766.                     $parentPath = '';
  1767.                 }
  1769.                 $db = \Pimcore\Db::get();
  1770.                 $conditionFilters = [];
  1771.                 $conditionFilters[] .= "type != 'folder' AND path LIKE " . $db->quote($parentPath . '/%');
  1772.                 if (!$this->getAdminUser()->isAdmin()) {
  1773.                     $userIds = $this->getAdminUser()->getRoles();
  1774.                     $userIds[] = $this->getAdminUser()->getId();
  1775.                     $conditionFilters[] .= ' (
  1776.                                                     (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
  1777.                                                     OR
  1778.                                                     (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
  1779.                                                  )';
  1780.                 }
  1782.                 $condition = implode(' AND ', $conditionFilters);
  1784.                 $assetList = new Asset\Listing();
  1785.                 $assetList->setCondition($condition);
  1786.                 $assetList->setOrderKey('LENGTH(path) ASC, id ASC', false);
  1787.                 $assetList->setOffset((int)$request->get('offset'));
  1788.                 $assetList->setLimit((int)$request->get('limit'));
  1790.                 foreach ($assetList->load() as $a) {
  1791.                     if ($a->isAllowed('view')) {
  1792.                         if (!$a instanceof Asset\Folder) {
  1793.                             // add the file with the relative path to the parent directory
  1794.                             $zip->addFile($a->getFileSystemPath(), preg_replace('@^' . preg_quote($asset->getRealPath(), '@') . '@i', '', $a->getRealFullPath()));
  1795.                         }
  1796.                     }
  1797.                 }
  1799.                 $zip->close();
  1800.                 $success = true;
  1801.             }
  1802.         }
  1804.         return $this->adminJson([
  1805.             'success' => $success
  1806.         ]);
  1807.     }
  1809.     /**
  1810.      * @Route("/download-as-zip")
  1811.      *
  1812.      * @param Request $request
  1813.      *
  1814.      * @return BinaryFileResponse
  1815.      * Download all assets contained in the folder with parameter id as ZIP file.
  1816.      * The suggested filename is either [folder name].zip or assets.zip for the root folder.
  1817.      */
  1818.     public function downloadAsZipAction(Request $request)
  1819.     {
  1820.         $asset = Asset::getById($request->get('id'));
  1821.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/download-zip-' . $request->get('jobId') . '.zip';
  1822.         $suggestedFilename = $asset->getFilename();
  1823.         if (empty($suggestedFilename)) {
  1824.             $suggestedFilename = 'assets';
  1825.         }
  1827.         $response = new BinaryFileResponse($zipFile);
  1828.         $response->headers->set('Content-Type', 'application/zip');
  1829.         $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $suggestedFilename . '.zip');
  1830.         $response->deleteFileAfterSend(true);
  1832.         return $response;
  1833.     }
  1835.     /**
  1836.      * @Route("/import-zip")
  1837.      *
  1838.      * @param Request $request
  1839.      *
  1840.      * @return Response
  1841.      */
  1842.     public function importZipAction(Request $request)
  1843.     {
  1844.         $jobId = uniqid();
  1845.         $filesPerJob = 5;
  1846.         $jobs = [];
  1847.         $asset = Asset::getById($request->get('parentId'));
  1849.         if (!$asset->isAllowed('create')) {
  1850.             throw new \Exception('not allowed to create');
  1851.         }
  1853.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/' . $jobId . '.zip';
  1855.         copy($_FILES['Filedata']['tmp_name'], $zipFile);
  1857.         $zip = new \ZipArchive;
  1858.         if ($zip->open($zipFile) === true) {
  1859.             $jobAmount = ceil($zip->numFiles / $filesPerJob);
  1860.             for ($i = 0; $i < $jobAmount; $i++) {
  1861.                 $jobs[] = [[
  1862.                     'url' => '/admin/asset/import-zip-files',
  1863.                     'params' => [
  1864.                         'parentId' => $asset->getId(),
  1865.                         'offset' => $i * $filesPerJob,
  1866.                         'limit' => $filesPerJob,
  1867.                         'jobId' => $jobId,
  1868.                         'last' => (($i + 1) >= $jobAmount) ? 'true' : ''
  1869.                     ]
  1870.                 ]];
  1871.             }
  1872.             $zip->close();
  1873.         }
  1875.         // here we have to use this method and not the JSON action helper ($this->_helper->json()) because this will add
  1876.         // Content-Type: application/json which fires a download window in most browsers, because this is a normal POST
  1877.         // request and not XHR where the content-type doesn't matter
  1878.         $responseJson = $this->encodeJson([
  1879.             'success' => true,
  1880.             'jobs' => $jobs,
  1881.             'jobId' => $jobId
  1882.         ]);
  1884.         return new Response($responseJson);
  1885.     }
  1887.     /**
  1888.      * @Route("/import-zip-files")
  1889.      *
  1890.      * @param Request $request
  1891.      *
  1892.      * @return JsonResponse
  1893.      */
  1894.     public function importZipFilesAction(Request $request)
  1895.     {
  1896.         $jobId = $request->get('jobId');
  1897.         $limit = (int)$request->get('limit');
  1898.         $offset = (int)$request->get('offset');
  1899.         $importAsset = Asset::getById($request->get('parentId'));
  1900.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/' . $jobId . '.zip';
  1901.         $tmpDir = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/zip-import';
  1903.         if (!is_dir($tmpDir)) {
  1904.             File::mkdir($tmpDir, 0777, true);
  1905.         }
  1907.         $zip = new \ZipArchive;
  1908.         if ($zip->open($zipFile) === true) {
  1909.             for ($i = $offset; $i < ($offset + $limit); $i++) {
  1910.                 $path = $zip->getNameIndex($i);
  1912.                 if ($path !== false) {
  1913.                     if ($zip->extractTo($tmpDir . '/', $path)) {
  1914.                         $tmpFile = $tmpDir . '/' . preg_replace('@^/@', '', $path);
  1916.                         $filename = Element\Service::getValidKey(basename($path), 'asset');
  1918.                         $relativePath = '';
  1919.                         if (dirname($path) != '.') {
  1920.                             $relativePath = dirname($path);
  1921.                         }
  1923.                         $parentPath = $importAsset->getRealFullPath() . '/' . preg_replace('@^/@', '', $relativePath);
  1924.                         $parent = Asset\Service::createFolderByPath($parentPath);
  1926.                         // check for duplicate filename
  1927.                         $filename = $this->getSafeFilename($parent->getRealFullPath(), $filename);
  1929.                         if ($parent->isAllowed('create')) {
  1930.                             $asset = Asset::create($parent->getId(), [
  1931.                                 'filename' => $filename,
  1932.                                 'sourcePath' => $tmpFile,
  1933.                                 'userOwner' => $this->getAdminUser()->getId(),
  1934.                                 'userModification' => $this->getAdminUser()->getId()
  1935.                             ]);
  1937.                             @unlink($tmpFile);
  1938.                         } else {
  1939.                             Logger::debug('prevented creating asset because of missing permissions');
  1940.                         }
  1941.                     }
  1942.                 }
  1943.             }
  1944.             $zip->close();
  1945.         }
  1947.         if ($request->get('last')) {
  1948.             unlink($zipFile);
  1949.         }
  1951.         return $this->adminJson([
  1952.             'success' => true
  1953.         ]);
  1954.     }
  1956.     /**
  1957.      * @Route("/import-server")
  1958.      *
  1959.      * @param Request $request
  1960.      *
  1961.      * @return JsonResponse
  1962.      */
  1963.     public function importServerAction(Request $request)
  1964.     {
  1965.         $success = true;
  1966.         $filesPerJob = 5;
  1967.         $jobs = [];
  1968.         $importDirectory = str_replace('/fileexplorer', PIMCORE_PROJECT_ROOT, $request->get('serverPath'));
  1969.         if (is_dir($importDirectory)) {
  1970.             $files = rscandir($importDirectory . '/');
  1971.             $count = count($files);
  1972.             $jobFiles = [];
  1974.             for ($i = 0; $i < $count; $i++) {
  1975.                 if (is_dir($files[$i])) {
  1976.                     continue;
  1977.                 }
  1979.                 $jobFiles[] = preg_replace('@^' . preg_quote($importDirectory, '@') . '@', '', $files[$i]);
  1981.                 if (count($jobFiles) >= $filesPerJob || $i >= ($count - 1)) {
  1982.                     $jobs[] = [[
  1983.                         'url' => '/admin/asset/import-server-files',
  1984.                         'params' => [
  1985.                             'parentId' => $request->get('parentId'),
  1986.                             'serverPath' => $importDirectory,
  1987.                             'files' => implode('::', $jobFiles)
  1988.                         ]
  1989.                     ]];
  1990.                     $jobFiles = [];
  1991.                 }
  1992.             }
  1993.         }
  1995.         return $this->adminJson([
  1996.             'success' => $success,
  1997.             'jobs' => $jobs
  1998.         ]);
  1999.     }
  2001.     /**
  2002.      * @Route("/import-server-files")
  2003.      *
  2004.      * @param Request $request
  2005.      *
  2006.      * @return JsonResponse
  2007.      */
  2008.     public function importServerFilesAction(Request $request)
  2009.     {
  2010.         $assetFolder = Asset::getById($request->get('parentId'));
  2011.         $serverPath = $request->get('serverPath');
  2012.         $files = explode('::', $request->get('files'));
  2014.         foreach ($files as $file) {
  2015.             $absolutePath = $serverPath . $file;
  2016.             if (is_file($absolutePath)) {
  2017.                 $relFolderPath = str_replace('\\', '/', dirname($file));
  2018.                 $folder = Asset\Service::createFolderByPath($assetFolder->getRealFullPath() . $relFolderPath);
  2019.                 $filename = basename($file);
  2021.                 // check for duplicate filename
  2022.                 $filename = Element\Service::getValidKey($filename, 'asset');
  2023.                 $filename = $this->getSafeFilename($folder->getRealFullPath(), $filename);
  2025.                 if ($assetFolder->isAllowed('create')) {
  2026.                     $asset = Asset::create($folder->getId(), [
  2027.                         'filename' => $filename,
  2028.                         'sourcePath' => $absolutePath,
  2029.                         'userOwner' => $this->getAdminUser()->getId(),
  2030.                         'userModification' => $this->getAdminUser()->getId()
  2031.                     ]);
  2032.                 } else {
  2033.                     Logger::debug('prevented creating asset because of missing permissions ');
  2034.                 }
  2035.             }
  2036.         }
  2038.         return $this->adminJson([
  2039.             'success' => true
  2040.         ]);
  2041.     }
  2043.     /**
  2044.      * @Route("/import-url")
  2045.      *
  2046.      * @param Request $request
  2047.      *
  2048.      * @return JsonResponse
  2049.      *
  2050.      * @throws \Exception
  2051.      */
  2052.     public function importUrlAction(Request $request)
  2053.     {
  2054.         $success = true;
  2056.         $data = Tool::getHttpData($request->get('url'));
  2057.         $filename = basename($request->get('url'));
  2058.         $parentId = $request->get('id');
  2059.         $parentAsset = Asset::getById(intval($parentId));
  2061.         $filename = Element\Service::getValidKey($filename, 'asset');
  2062.         $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  2064.         if (empty($filename)) {
  2065.             throw new \Exception('The filename of the asset is empty');
  2066.         }
  2068.         // check for duplicate filename
  2069.         $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  2071.         if ($parentAsset->isAllowed('create')) {
  2072.             $asset = Asset::create($parentId, [
  2073.                 'filename' => $filename,
  2074.                 'data' => $data,
  2075.                 'userOwner' => $this->getAdminUser()->getId(),
  2076.                 'userModification' => $this->getAdminUser()->getId()
  2077.             ]);
  2078.             $success = true;
  2079.         } else {
  2080.             Logger::debug('prevented creating asset because of missing permissions');
  2081.         }
  2083.         return $this->adminJson(['success' => $success]);
  2084.     }
  2086.     /**
  2087.      * @Route("/clear-thumbnail")
  2088.      *
  2089.      * @param Request $request
  2090.      *
  2091.      * @return JsonResponse
  2092.      */
  2093.     public function clearThumbnailAction(Request $request)
  2094.     {
  2095.         $success = false;
  2097.         if ($asset = Asset::getById($request->get('id'))) {
  2098.             if (method_exists($asset, 'clearThumbnails')) {
  2099.                 if (!$asset->isAllowed('publish')) {
  2100.                     throw new \Exception('not allowed to publish');
  2101.                 }
  2103.                 $asset->clearThumbnails(true); // force clear
  2104.                 $asset->save();
  2106.                 $success = true;
  2107.             }
  2108.         }
  2110.         return $this->adminJson(['success' => $success]);
  2111.     }
  2113.     /**
  2114.      * @Route("/grid-proxy")
  2115.      *
  2116.      * @param Request $request
  2117.      *
  2118.      * @return JsonResponse
  2119.      */
  2120.     public function gridProxyAction(Request $request, EventDispatcherInterface $eventDispatcher)
  2121.     {
  2122.         $allParams = array_merge($request->request->all(), $request->query->all());
  2124.         $filterPrepareEvent = new GenericEvent($this, [
  2125.             'requestParams' => $allParams
  2126.         ]);
  2127.         $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_FILTER_PREPARE, $filterPrepareEvent);
  2129.         $allParams = $filterPrepareEvent->getArgument('requestParams');
  2131.         if ($allParams['data']) {
  2132.             if ($allParams['xaction'] == 'update') {
  2133.                 //TODO probably not needed
  2134.             }
  2135.         } else {
  2136.             $db = \Pimcore\Db::get();
  2137.             // get list of objects
  2138.             $folder = Asset::getById($allParams['folderId']);
  2140.             $start = 0;
  2141.             $limit = 20;
  2142.             $orderKey = 'id';
  2143.             $order = 'ASC';
  2145.             if ($allParams['limit']) {
  2146.                 $limit = $allParams['limit'];
  2147.             }
  2148.             if ($allParams['start']) {
  2149.                 $start = $allParams['start'];
  2150.             }
  2152.             $sortingSettings = \Pimcore\Bundle\AdminBundle\Helper\QueryParams::extractSortingSettings($allParams);
  2153.             if ($sortingSettings['orderKey']) {
  2154.                 $orderKey = $sortingSettings['orderKey'];
  2155.                 if ($orderKey == 'fullpath') {
  2156.                     $orderKey = ['path', 'filename'];
  2157.                 }
  2159.                 $order = $sortingSettings['order'];
  2160.             }
  2162.             $list = new Asset\Listing();
  2164.             $conditionFilters = [];
  2165.             if ($allParams['only_direct_children'] == 'true') {
  2166.                 $conditionFilters[] = 'parentId = ' . $folder->getId();
  2167.             } else {
  2168.                 $conditionFilters[] = 'path LIKE ' . ($folder->getRealFullPath() == '/' ? "'/%'" : $list->quote($folder->getRealFullPath() . '/%'));
  2169.             }
  2171.             $conditionFilters[] = "type != 'folder'";
  2172.             $filterJson = $allParams['filter'];
  2173.             if ($filterJson) {
  2174.                 $filters = $this->decodeJson($filterJson);
  2175.                 foreach ($filters as $filter) {
  2176.                     $operator = '=';
  2178.                     $filterField = $filter['property'];
  2179.                     $filterOperator = $filter['operator'];
  2180.                     $filterType = $filter['type'];
  2182.                     if ($filterType == 'string') {
  2183.                         $operator = 'LIKE';
  2184.                     } elseif ($filterType == 'numeric') {
  2185.                         if ($filterOperator == 'lt') {
  2186.                             $operator = '<';
  2187.                         } elseif ($filterOperator == 'gt') {
  2188.                             $operator = '>';
  2189.                         } elseif ($filterOperator == 'eq') {
  2190.                             $operator = '=';
  2191.                         }
  2192.                     } elseif ($filterType == 'date') {
  2193.                         if ($filterOperator == 'lt') {
  2194.                             $operator = '<';
  2195.                         } elseif ($filterOperator == 'gt') {
  2196.                             $operator = '>';
  2197.                         } elseif ($filterOperator == 'eq') {
  2198.                             $operator = '=';
  2199.                         }
  2200.                         $filter['value'] = strtotime($filter['value']);
  2201.                     } elseif ($filterType == 'list') {
  2202.                         $operator = '=';
  2203.                     } elseif ($filterType == 'boolean') {
  2204.                         $operator = '=';
  2205.                         $filter['value'] = (int) $filter['value'];
  2206.                     }
  2207.                     // system field
  2208.                     $value = $filter['value'];
  2209.                     if ($operator == 'LIKE') {
  2210.                         $value = '%' . $value . '%';
  2211.                     }
  2213.                     $field = '`' . $filterField . '` ';
  2214.                     if ($filterField == 'fullpath') {
  2215.                         $field = 'CONCAT(path,filename)';
  2216.                     }
  2218.                     $conditionFilters[] =  $field . $operator . ' ' . $db->quote($value);
  2219.                 }
  2220.             }
  2222.             if (!$this->getAdminUser()->isAdmin()) {
  2223.                 $userIds = $this->getAdminUser()->getRoles();
  2224.                 $userIds[] = $this->getAdminUser()->getId();
  2225.                 $conditionFilters[] .= ' (
  2226.                                                     (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
  2227.                                                     OR
  2228.                                                     (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
  2229.                                                  )';
  2230.             }
  2232.             $condition = implode(' AND ', $conditionFilters);
  2233.             $list->setCondition($condition);
  2234.             $list->setLimit($limit);
  2235.             $list->setOffset($start);
  2236.             $list->setOrder($order);
  2237.             $list->setOrderKey($orderKey);
  2239.             $beforeListLoadEvent = new GenericEvent($this, [
  2240.                 'list' => $list,
  2241.                 'context' => $allParams
  2242.             ]);
  2243.             $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD, $beforeListLoadEvent);
  2244.             $list = $beforeListLoadEvent->getArgument('list');
  2246.             $list->load();
  2248.             $assets = [];
  2249.             foreach ($list->getAssets() as $asset) {
  2251.                 /** @var $asset Asset */
  2252.                 $filename = PIMCORE_ASSET_DIRECTORY . '/' . $asset->getRealFullPath();
  2253.                 $size = @filesize($filename);
  2255.                 // 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
  2256.                 if ($asset->isAllowed('list')) {
  2257.                     $assets[] = [
  2258.                         'id' => $asset->getid(),
  2259.                         'type' => $asset->getType(),
  2260.                         'fullpath' => $asset->getRealFullPath(),
  2261.                         'creationDate' => $asset->getCreationDate(),
  2262.                         'modificationDate' => $asset->getModificationDate(),
  2263.                         'size' => formatBytes($size),
  2264.                         'idPath' => $data['idPath'] = Element\Service::getIdPath($asset)
  2265.                     ];
  2266.                 }
  2267.             }
  2269.             $result = ['data' => $assets, 'success' => true, 'total' => $list->getTotalCount()];
  2271.             $afterListLoadEvent = new GenericEvent($this, [
  2272.                 'list' => $result,
  2273.                 'context' => $allParams
  2274.             ]);
  2275.             $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_AFTER_LIST_LOAD, $afterListLoadEvent);
  2276.             $result = $afterListLoadEvent->getArgument('list');
  2278.             return $this->adminJson($result);
  2279.         }
  2280.     }
  2282.     /**
  2283.      * @Route("/get-text")
  2284.      *
  2285.      * @param Request $request
  2286.      *
  2287.      * @return JsonResponse
  2288.      */
  2289.     public function getTextAction(Request $request)
  2290.     {
  2291.         $asset = Asset::getById($request->get('id'));
  2293.         if (!$asset->isAllowed('view')) {
  2294.             throw new \Exception('not allowed to view');
  2295.         }
  2297.         $page = $request->get('page');
  2298.         if ($asset instanceof Asset\Document) {
  2299.             $text = $asset->getText($page);
  2300.         }
  2302.         return $this->adminJson(['success' => 'true', 'text' => $text]);
  2303.     }
  2305.     /**
  2306.      * @param FilterControllerEvent $event
  2307.      */
  2308.     public function onKernelController(FilterControllerEvent $event)
  2309.     {
  2310.         $isMasterRequest = $event->isMasterRequest();
  2311.         if (!$isMasterRequest) {
  2312.             return;
  2313.         }
  2315.         $this->checkActionPermission($event, 'assets', [
  2316.             'getImageThumbnailAction', 'getVideoThumbnailAction', 'getDocumentThumbnailAction'
  2317.         ]);
  2319.         $this->_assetService = new Asset\Service($this->getAdminUser());
  2320.     }
  2322.     /**
  2323.      * @param FilterResponseEvent $event
  2324.      */
  2325.     public function onKernelResponse(FilterResponseEvent $event)
  2326.     {
  2327.         // nothing to do
  2328.     }
  2329. }