vendor/pimcore/pimcore/bundles/AdminBundle/Controller/Admin/ElementController.php line 39

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore\Bundle\AdminBundle\Controller\Admin;
  18. use Pimcore\Bundle\AdminBundle\Controller\AdminController;
  19. use Pimcore\Bundle\AdminBundle\DependencyInjection\PimcoreAdminExtension;
  20. use Pimcore\Db;
  21. use Pimcore\Event\AdminEvents;
  22. use Pimcore\Event\Model\ResolveElementEvent;
  23. use Pimcore\Logger;
  24. use Pimcore\Model;
  25. use Pimcore\Model\Asset;
  26. use Pimcore\Model\DataObject;
  27. use Pimcore\Model\Document;
  28. use Pimcore\Model\Element;
  29. use Pimcore\Model\Version;
  30. use Symfony\Component\HttpFoundation\JsonResponse;
  31. use Symfony\Component\HttpFoundation\Request;
  32. use Symfony\Component\HttpFoundation\Response;
  33. use Symfony\Component\Routing\Annotation\Route;
  35. /**
  36.  *
  37.  * @internal
  38.  */
  39. class ElementController extends AdminController
  40. {
  41.     /**
  42.      * @Route("/element/lock-element", name="pimcore_admin_element_lockelement", methods={"PUT"})
  43.      *
  44.      * @param Request $request
  45.      *
  46.      * @return Response
  47.      */
  48.     public function lockElementAction(Request $request)
  49.     {
  50.         Element\Editlock::lock($request->get('id'), $request->get('type'));
  52.         return $this->adminJson(['success' => true]);
  53.     }
  55.     /**
  56.      * @Route("/element/unlock-element", name="pimcore_admin_element_unlockelement", methods={"PUT"})
  57.      *
  58.      * @param Request $request
  59.      *
  60.      * @return Response
  61.      */
  62.     public function unlockElementAction(Request $request)
  63.     {
  64.         Element\Editlock::unlock($request->get('id'), $request->get('type'));
  66.         return $this->adminJson(['success' => true]);
  67.     }
  69.     /**
  70.      * @Route("/element/unlock-elements", name="pimcore_admin_element_unlockelements", methods={"POST"})
  71.      *
  72.      * @param Request $request
  73.      *
  74.      * @return Response
  75.      */
  76.     public function unlockElementsAction(Request $request)
  77.     {
  78.         $request = json_decode($request->getContent(), true) ?? [];
  79.         foreach ($request['elements'] as $elementIdentifierData) {
  80.             Element\Editlock::unlock($elementIdentifierData['id'], $elementIdentifierData['type']);
  81.         }
  83.         return $this->adminJson(['success' => true]);
  84.     }
  86.     /**
  87.      * Returns the element data denoted by the given type and ID or path.
  88.      *
  89.      * @Route("/element/get-subtype", name="pimcore_admin_element_getsubtype", methods={"GET"})
  90.      *
  91.      * @param Request $request
  92.      *
  93.      * @return JsonResponse
  94.      */
  95.     public function getSubtypeAction(Request $request)
  96.     {
  97.         $idOrPath = trim($request->get('id'));
  98.         $type = $request->get('type');
  100.         $event = new ResolveElementEvent($type, $idOrPath);
  101.         \Pimcore::getEventDispatcher()->dispatch($event, AdminEvents::RESOLVE_ELEMENT);
  102.         $idOrPath = $event->getId();
  103.         $type = $event->getType();
  105.         if (is_numeric($idOrPath)) {
  106.             $el = Element\Service::getElementById($type, (int) $idOrPath);
  107.         } else {
  108.             if ($type == 'document') {
  109.                 $el = Document\Service::getByUrl($idOrPath);
  110.             } else {
  111.                 $el = Element\Service::getElementByPath($type, $idOrPath);
  112.             }
  113.         }
  115.         if ($el) {
  116.             $subtype = null;
  117.             if ($el instanceof Asset || $el instanceof Document) {
  118.                 $subtype = $el->getType();
  119.             } elseif ($el instanceof DataObject\Concrete) {
  120.                 $subtype = $el->getClassName();
  121.             } elseif ($el instanceof DataObject\Folder) {
  122.                 $subtype = 'folder';
  123.             }
  125.             return $this->adminJson([
  126.                 'subtype' => $subtype,
  127.                 'id' => $el->getId(),
  128.                 'type' => $type,
  129.                 'success' => true,
  130.             ]);
  131.         } else {
  132.             return $this->adminJson([
  133.                 'success' => false,
  134.             ]);
  135.         }
  136.     }
  138.     /**
  139.      * @param string $parameterName
  140.      *
  141.      * @return \Pimcore\Bundle\AdminBundle\HttpFoundation\JsonResponse
  142.      */
  143.     protected function processNoteTypesFromParameters(string $parameterName)
  144.     {
  145.         $config = $this->getParameter($parameterName);
  146.         $result = [];
  147.         foreach ($config as $configEntry) {
  148.             $result[] = [
  149.                 'name' => $configEntry,
  150.             ];
  151.         }
  153.         return $this->adminJson(['noteTypes' => $result]);
  154.     }
  156.     /**
  157.      * @Route("/element/note-types", name="pimcore_admin_element_notetypes", methods={"GET"})
  158.      *
  159.      * @param Request $request
  160.      *
  161.      * @return JsonResponse
  162.      */
  163.     public function noteTypes(Request $request)
  164.     {
  165.         switch ($request->get('ctype')) {
  166.             case 'document':
  167.                 return $this->processNoteTypesFromParameters(PimcoreAdminExtension::PARAM_DOCUMENTS_NOTES_EVENTS_TYPES);
  168.             case 'asset':
  169.                 return $this->processNoteTypesFromParameters(PimcoreAdminExtension::PARAM_ASSETS_NOTES_EVENTS_TYPES);
  170.             case 'object':
  171.                 return $this->processNoteTypesFromParameters(PimcoreAdminExtension::PARAM_DATAOBJECTS_NOTES_EVENTS_TYPES);
  172.             default:
  173.                 return $this->adminJson(['noteTypes' => []]);
  174.         }
  175.     }
  177.     /**
  178.      * @Route("/element/note-list", name="pimcore_admin_element_notelist", methods={"POST"})
  179.      *
  180.      * @param Request $request
  181.      *
  182.      * @return JsonResponse
  183.      */
  184.     public function noteListAction(Request $request)
  185.     {
  186.         $this->checkPermission('notes_events');
  188.         $list = new Element\Note\Listing();
  190.         $list->setLimit($request->get('limit'));
  191.         $list->setOffset($request->get('start'));
  193.         $sortingSettings = \Pimcore\Bundle\AdminBundle\Helper\QueryParams::extractSortingSettings(array_merge($request->request->all(), $request->query->all()));
  194.         if ($sortingSettings['orderKey'] && $sortingSettings['order']) {
  195.             $list->setOrderKey($sortingSettings['orderKey']);
  196.             $list->setOrder($sortingSettings['order']);
  197.         } else {
  198.             $list->setOrderKey(['date', 'id']);
  199.             $list->setOrder(['DESC', 'DESC']);
  200.         }
  202.         $conditions = [];
  203.         $filterText = $request->get('filterText');
  205.         if ($filterText) {
  206.             $conditions[] = '('
  207.                 . '`title` LIKE ' . $list->quote('%'. $filterText .'%')
  208.                 . ' OR `description` LIKE ' . $list->quote('%'.$filterText.'%')
  209.                 . ' OR `type` LIKE ' . $list->quote('%'.$filterText.'%')
  210.                 . ' OR `user` IN (SELECT `id` FROM `users` WHERE `name` LIKE ' . $list->quote('%'.$filterText.'%') . ')'
  211.                 . " OR DATE_FORMAT(FROM_UNIXTIME(`date`), '%Y-%m-%d') LIKE " . $list->quote('%'.$filterText.'%')
  212.                 . ')';
  213.         }
  215.         $filterJson = $request->get('filter');
  216.         if ($filterJson) {
  217.             $db = Db::get();
  218.             $filters = $this->decodeJson($filterJson);
  219.             $propertyKey = 'property';
  220.             $comparisonKey = 'operator';
  222.             foreach ($filters as $filter) {
  223.                 $operator = '=';
  225.                 if ($filter['type'] == 'string') {
  226.                     $operator = 'LIKE';
  227.                 } elseif ($filter['type'] == 'numeric') {
  228.                     if ($filter[$comparisonKey] == 'lt') {
  229.                         $operator = '<';
  230.                     } elseif ($filter[$comparisonKey] == 'gt') {
  231.                         $operator = '>';
  232.                     } elseif ($filter[$comparisonKey] == 'eq') {
  233.                         $operator = '=';
  234.                     }
  235.                 } elseif ($filter['type'] == 'date') {
  236.                     if ($filter[$comparisonKey] == 'lt') {
  237.                         $operator = '<';
  238.                     } elseif ($filter[$comparisonKey] == 'gt') {
  239.                         $operator = '>';
  240.                     } elseif ($filter[$comparisonKey] == 'eq') {
  241.                         $operator = '=';
  242.                     }
  243.                     $filter['value'] = strtotime($filter['value']);
  244.                 } elseif ($filter[$comparisonKey] == 'list') {
  245.                     $operator = '=';
  246.                 } elseif ($filter[$comparisonKey] == 'boolean') {
  247.                     $operator = '=';
  248.                     $filter['value'] = (int) $filter['value'];
  249.                 }
  250.                 // system field
  251.                 $value = ($filter['value']??'');
  252.                 if ($operator == 'LIKE') {
  253.                     $value = '%' . $value . '%';
  254.                 }
  256.                 if ($filter[$propertyKey] == 'user') {
  257.                     $conditions[] = '`user` IN (SELECT `id` FROM `users` WHERE `name` LIKE ' . $list->quote($value) . ')';
  258.                 } else {
  259.                     if ($filter['type'] == 'date' && $filter[$comparisonKey] == 'eq') {
  260.                         $maxTime = $value + (86400 - 1); //specifies the top point of the range used in the condition
  261.                         $dateCondition = '`' . $filter[$propertyKey] . '` ' . ' BETWEEN ' . $db->quote($value) . ' AND ' . $db->quote($maxTime);
  262.                         $conditions[] = $dateCondition;
  263.                     } else {
  264.                         $conditions[] = $db->quoteIdentifier($filter[$propertyKey]).' '.$operator.' '.$db->quote($value);
  265.                     }
  266.                 }
  267.             }
  268.         }
  270.         if ($request->get('cid') && $request->get('ctype')) {
  271.             $conditions[] = '(cid = ' . $list->quote($request->get('cid')) . ' AND ctype = ' . $list->quote($request->get('ctype')) . ')';
  272.         }
  274.         if (!empty($conditions)) {
  275.             $condition = implode(' AND ', $conditions);
  276.             $list->setCondition($condition);
  277.         }
  279.         $list->load();
  281.         $notes = [];
  283.         foreach ($list->getNotes() as $note) {
  284.             $e = Element\Service::getNoteData($note);
  285.             $notes[] = $e;
  286.         }
  288.         return $this->adminJson([
  289.             'data' => $notes,
  290.             'success' => true,
  291.             'total' => $list->getTotalCount(),
  292.         ]);
  293.     }
  295.     /**
  296.      * @Route("/element/note-add", name="pimcore_admin_element_noteadd", methods={"POST"})
  297.      *
  298.      * @param Request $request
  299.      *
  300.      * @return JsonResponse
  301.      */
  302.     public function noteAddAction(Request $request)
  303.     {
  304.         $this->checkPermission('notes_events');
  306.         $note = new Element\Note();
  307.         $note->setCid((int) $request->get('cid'));
  308.         $note->setCtype($request->get('ctype'));
  309.         $note->setDate(time());
  310.         $note->setTitle($request->get('title'));
  311.         $note->setDescription($request->get('description'));
  312.         $note->setType($request->get('type'));
  313.         $note->save();
  315.         return $this->adminJson([
  316.             'success' => true,
  317.         ]);
  318.     }
  320.     /**
  321.      * @Route("/element/find-usages", name="pimcore_admin_element_findusages", methods={"GET"})
  322.      *
  323.      * @param Request $request
  324.      *
  325.      * @return JsonResponse
  326.      */
  327.     public function findUsagesAction(Request $request)
  328.     {
  329.         $element = null;
  330.         if ($request->get('id')) {
  331.             $element = Element\Service::getElementById($request->get('type'), $request->get('id'));
  332.         } elseif ($request->get('path')) {
  333.             $element = Element\Service::getElementByPath($request->get('type'), $request->get('path'));
  334.         }
  336.         $results = [];
  337.         $success = false;
  338.         $hasHidden = false;
  339.         $total = 0;
  340.         $limit = (int)$request->get('limit', 50);
  341.         $offset = (int)$request->get('start', 0);
  343.         if ($element instanceof Element\ElementInterface) {
  344.             $total = $element->getDependencies()->getRequiredByTotalCount();
  346.             if ($request->get('sort')) {
  347.                 $sort = json_decode($request->get('sort'))[0];
  348.                 $orderBy = $sort->property;
  349.                 $orderDirection = $sort->direction;
  350.             } else {
  351.                 $orderBy = null;
  352.                 $orderDirection = null;
  353.             }
  355.             $queryOffset = $offset;
  356.             $queryLimit = $limit;
  358.             while (count($results) < min($limit, $total) && $queryOffset < $total) {
  359.                 $elements = $element->getDependencies()
  360.                     ->getRequiredByWithPath($queryOffset, $queryLimit, $orderBy, $orderDirection);
  362.                 foreach ($elements as $el) {
  363.                     $item = Element\Service::getElementById($el['type'], $el['id']);
  365.                     if ($item instanceof Element\ElementInterface) {
  366.                         if ($item->isAllowed('list')) {
  367.                             $results[] = $el;
  368.                         } else {
  369.                             $hasHidden = true;
  370.                         }
  371.                     }
  372.                 }
  374.                 $queryOffset += count($elements);
  375.                 $queryLimit = $limit - count($results);
  376.             }
  378.             $success = true;
  379.         }
  381.         return $this->adminJson([
  382.             'data' => $results,
  383.             'total' => $total,
  384.             'hasHidden' => $hasHidden,
  385.             'success' => $success,
  386.         ]);
  387.     }
  389.     /**
  390.      * @Route("/element/get-replace-assignments-batch-jobs", name="pimcore_admin_element_getreplaceassignmentsbatchjobs", methods={"GET"})
  391.      *
  392.      * @param Request $request
  393.      *
  394.      * @return \Pimcore\Bundle\AdminBundle\HttpFoundation\JsonResponse
  395.      */
  396.     public function getReplaceAssignmentsBatchJobsAction(Request $request)
  397.     {
  398.         $element = null;
  400.         if ($request->get('id')) {
  401.             $element = Element\Service::getElementById($request->get('type'), $request->get('id'));
  402.         } elseif ($request->get('path')) {
  403.             $element = Element\Service::getElementByPath($request->get('type'), $request->get('path'));
  404.         }
  406.         if ($element instanceof Element\ElementInterface) {
  407.             return $this->adminJson([
  408.                 'success' => true,
  409.                 'jobs' => $element->getDependencies()->getRequiredBy(),
  410.             ]);
  411.         } else {
  412.             return $this->adminJson(['success' => false], Response::HTTP_NOT_FOUND);
  413.         }
  414.     }
  416.     /**
  417.      * @Route("/element/replace-assignments", name="pimcore_admin_element_replaceassignments", methods={"POST"})
  418.      *
  419.      * @param Request $request
  420.      *
  421.      * @return JsonResponse
  422.      */
  423.     public function replaceAssignmentsAction(Request $request)
  424.     {
  425.         $success = false;
  426.         $message = '';
  427.         $element = Element\Service::getElementById($request->get('type'), $request->get('id'));
  428.         $sourceEl = Element\Service::getElementById($request->get('sourceType'), $request->get('sourceId'));
  429.         $targetEl = Element\Service::getElementById($request->get('targetType'), $request->get('targetId'));
  431.         if ($element && $sourceEl && $targetEl
  432.             && $request->get('sourceType') == $request->get('targetType')
  433.             && $sourceEl->getType() == $targetEl->getType()
  434.             && $element->isAllowed('save')
  435.         ) {
  436.             $rewriteConfig = [
  437.                 $request->get('sourceType') => [
  438.                     $sourceEl->getId() => $targetEl->getId(),
  439.                 ],
  440.             ];
  442.             if ($element instanceof Document) {
  443.                 $element = Document\Service::rewriteIds($element, $rewriteConfig);
  444.             } elseif ($element instanceof DataObject\AbstractObject) {
  445.                 $element = DataObject\Service::rewriteIds($element, $rewriteConfig);
  446.             } elseif ($element instanceof Asset) {
  447.                 $element = Asset\Service::rewriteIds($element, $rewriteConfig);
  448.             }
  450.             $element->setUserModification($this->getAdminUser()->getId());
  451.             $element->save();
  453.             $success = true;
  454.         } else {
  455.             $message = 'source-type and target-type do not match';
  456.         }
  458.         return $this->adminJson([
  459.             'success' => $success,
  460.             'message' => $message,
  461.         ]);
  462.     }
  464.     /**
  465.      * @Route("/element/unlock-propagate", name="pimcore_admin_element_unlockpropagate", methods={"PUT"})
  466.      *
  467.      * @param Request $request
  468.      *
  469.      * @return JsonResponse
  470.      */
  471.     public function unlockPropagateAction(Request $request)
  472.     {
  473.         $success = false;
  475.         $element = Element\Service::getElementById($request->get('type'), $request->get('id'));
  476.         if ($element) {
  477.             $element->unlockPropagate();
  478.             $success = true;
  479.         }
  481.         return $this->adminJson([
  482.             'success' => $success,
  483.         ]);
  484.     }
  486.     /**
  487.      * @Route("/element/type-path", name="pimcore_admin_element_typepath", methods={"GET"})
  488.      *
  489.      * @param Request $request
  490.      *
  491.      * @return JsonResponse
  492.      */
  493.     public function typePathAction(Request $request)
  494.     {
  495.         $id = $request->get('id');
  496.         $type = $request->get('type');
  497.         $data = [];
  499.         if ($type === 'asset') {
  500.             $element = Asset::getById($id);
  501.         } elseif ($type === 'document') {
  502.             $element = Document::getById($id);
  503.         } else {
  504.             $element = DataObject::getById($id);
  505.         }
  507.         if (!$element) {
  508.             $data['success'] = false;
  510.             return $this->adminJson($data);
  511.         }
  513.         $typePath = Element\Service::getTypePath($element);
  515.         $data['success'] = true;
  516.         $data['index'] = method_exists($element, 'getIndex') ? (int) $element->getIndex() : 0;
  517.         $data['idPath'] = Element\Service::getIdPath($element);
  518.         $data['typePath'] = $typePath;
  519.         $data['fullpath'] = $element->getRealFullPath();
  521.         if ($type !== 'asset') {
  522.             $sortIndexPath = Element\Service::getSortIndexPath($element);
  523.             $data['sortIndexPath'] = $sortIndexPath;
  524.         }
  526.         return $this->adminJson($data);
  527.     }
  529.     /**
  530.      * @Route("/element/version-update", name="pimcore_admin_element_versionupdate", methods={"PUT"})
  531.      *
  532.      * @param Request $request
  533.      *
  534.      * @return JsonResponse
  535.      */
  536.     public function versionUpdateAction(Request $request)
  537.     {
  538.         $data = $this->decodeJson($request->get('data'));
  540.         $version = Version::getById($data['id']);
  542.         if ($data['public'] != $version->getPublic() || $data['note'] != $version->getNote()) {
  543.             $version->setPublic($data['public']);
  544.             $version->setNote($data['note']);
  545.             $version->save();
  546.         }
  548.         return $this->adminJson(['success' => true]);
  549.     }
  551.     /**
  552.      * @Route("/element/get-nice-path", name="pimcore_admin_element_getnicepath", methods={"POST"})
  553.      *
  554.      * @param Request $request
  555.      *
  556.      * @return JsonResponse
  557.      *
  558.      * @throws \Exception
  559.      */
  560.     public function getNicePathAction(Request $request)
  561.     {
  562.         $source = $this->decodeJson($request->get('source'));
  563.         if ($source['type'] != 'object') {
  564.             throw new \Exception('currently only objects as source elements are supported');
  565.         }
  566.         $result = [];
  567.         $id = $source['id'];
  568.         $source = DataObject\Concrete::getById($id);
  569.         if ($request->get('context')) {
  570.             $context = $this->decodeJson($request->get('context'));
  571.         } else {
  572.             $context = [];
  573.         }
  575.         $ownerType = $context['containerType'];
  576.         $fieldname = $context['fieldname'];
  578.         $fd = $this->getNicePathFormatterFieldDefinition($source, $context);
  580.         $targets = $this->decodeJson($request->get('targets'));
  582.         $result = $this->convertResultWithPathFormatter($source, $context, $result, $targets);
  584.         if ($request->get('loadEditModeData') == 'true') {
  585.             $idProperty = $request->get('idProperty', 'id');
  586.             $methodName = 'get' . ucfirst($fieldname);
  587.             if ($ownerType == 'object' && method_exists($source, $methodName)) {
  588.                 $data = $source->$methodName();
  589.                 $editModeData = $fd->getDataForEditmode($data, $source);
  590.                 // Inherited values show as an empty array
  591.                 if (is_array($editModeData) && !empty($editModeData)) {
  592.                     foreach ($editModeData as $relationObjectAttribute) {
  593.                         $relationObjectAttribute['$$nicepath'] =
  594.                             isset($relationObjectAttribute[$idProperty]) && isset($result[$relationObjectAttribute[$idProperty]]) ? $result[$relationObjectAttribute[$idProperty]] : null;
  595.                         $result[$relationObjectAttribute[$idProperty]] = $relationObjectAttribute;
  596.                     }
  597.                 } else {
  598.                     foreach ($result as $resultItemId => $resultItem) {
  599.                         $result[$resultItemId] = ['$$nicepath' => $resultItem];
  600.                     }
  601.                 }
  602.             } else {
  603.                 Logger::error('Loading edit mode data is not supported for ownertype: ' . $ownerType);
  604.             }
  605.         }
  607.         return $this->adminJson(['success' => true, 'data' => $result]);
  608.     }
  610.     /**
  611.      * @Route("/element/get-versions", name="pimcore_admin_element_getversions", methods={"GET"})
  612.      *
  613.      * @param Request $request
  614.      *
  615.      * @return JsonResponse
  616.      *
  617.      * @throws \Exception
  618.      */
  619.     public function getVersionsAction(Request $request)
  620.     {
  621.         $id = (int)$request->get('id');
  622.         $type = $request->get('elementType');
  623.         $allowedTypes = ['asset', 'document', 'object'];
  625.         if ($id && in_array($type, $allowedTypes)) {
  626.             $element = Model\Element\Service::getElementById($type, $id);
  627.             if ($element) {
  628.                 if ($element->isAllowed('versions')) {
  629.                     $schedule = $element->getScheduledTasks();
  630.                     $schedules = [];
  631.                     foreach ($schedule as $task) {
  632.                         if ($task->getActive()) {
  633.                             $schedules[$task->getVersion()] = $task->getDate();
  634.                         }
  635.                     }
  637.                     //only load auto-save versions from current user
  638.                     $list = new Version\Listing();
  639.                     $list->setLoadAutoSave(true);
  640.                     $list->setCondition('cid = ? AND ctype = ? AND (autoSave=0 OR (autoSave=1 AND userId = ?)) ', [
  641.                         $element->getId(),
  642.                         Element\Service::getElementType($element),
  643.                         $this->getAdminUser()->getId(),
  644.                     ])
  645.                         ->setOrderKey('date')
  646.                         ->setOrder('ASC');
  648.                     $versions = $list->load();
  650.                     $versions = Model\Element\Service::getSafeVersionInfo($versions);
  651.                     $versions = array_reverse($versions); //reverse array to sort by ID DESC
  652.                     foreach ($versions as &$version) {
  653.                         $version['scheduled'] = null;
  654.                         if (array_key_exists($version['id'], $schedules)) {
  655.                             $version['scheduled'] = $schedules[$version['id']];
  656.                         }
  657.                     }
  659.                     return $this->adminJson(['versions' => $versions]);
  660.                 } else {
  661.                     throw $this->createAccessDeniedException('Permission denied, ' . $type . ' id [' . $id . ']');
  662.                 }
  663.             } else {
  664.                 throw $this->createNotFoundException($type . ' with id [' . $id . "] doesn't exist");
  665.             }
  666.         }
  668.         throw $this->createNotFoundException('Element type not found');
  669.     }
  671.     /**
  672.      * @Route("/element/delete-draft", name="pimcore_admin_element_deletedraft", methods={"DELETE"})
  673.      *
  674.      * @param Request $request
  675.      *
  676.      * @return JsonResponse
  677.      */
  678.     public function deleteDraftAction(Request $request)
  679.     {
  680.         $version = Version::getById((int) $request->get('id'));
  681.         if ($version) {
  682.             $version->delete();
  683.         }
  685.         return $this->adminJson(['success' => true]);
  686.     }
  688.     /**
  689.      * @Route("/element/delete-version", name="pimcore_admin_element_deleteversion", methods={"DELETE"})
  690.      *
  691.      * @param Request $request
  692.      *
  693.      * @return JsonResponse
  694.      */
  695.     public function deleteVersionAction(Request $request)
  696.     {
  697.         $version = Model\Version::getById((int) $request->get('id'));
  698.         $version->delete();
  700.         return $this->adminJson(['success' => true]);
  701.     }
  703.     /**
  704.      * @Route("/element/delete-all-versions", name="pimcore_admin_element_deleteallversion", methods={"DELETE"})
  705.      *
  706.      * @param Request $request
  707.      *
  708.      * @return JsonResponse
  709.      */
  710.     public function deleteAllVersionAction(Request $request)
  711.     {
  712.         $elementId = $request->get('id');
  713.         $elementModificationdate = $request->get('date');
  715.         $versions = new Model\Version\Listing();
  716.         $versions->setCondition('cid = ' . $versions->quote($elementId) . ' AND date <> ' . $versions->quote($elementModificationdate));
  718.         foreach ($versions->load() as $vkey => $version) {
  719.             $version->delete();
  720.         }
  722.         return $this->adminJson(['success' => true]);
  723.     }
  725.     /**
  726.      * @Route("/element/get-requires-dependencies", name="pimcore_admin_element_getrequiresdependencies", methods={"GET"})
  727.      *
  728.      * @param Request $request
  729.      *
  730.      * @return JsonResponse
  731.      */
  732.     public function getRequiresDependenciesAction(Request $request)
  733.     {
  734.         $id = $request->get('id');
  735.         $type = $request->get('elementType');
  736.         $allowedTypes = ['asset', 'document', 'object'];
  737.         $offset = $request->get('start');
  738.         $limit = $request->get('limit');
  740.         if ($id && in_array($type, $allowedTypes)) {
  741.             $element = Model\Element\Service::getElementById($type, $id);
  742.             $dependencies = $element->getDependencies();
  744.             if ($element instanceof Model\Element\ElementInterface) {
  745.                 $dependenciesResult = Model\Element\Service::getRequiresDependenciesForFrontend($dependencies, $offset, $limit);
  747.                 $dependenciesResult['start'] = $offset;
  748.                 $dependenciesResult['limit'] = $limit;
  749.                 $dependenciesResult['total'] = $dependencies->getRequiresTotalCount();
  751.                 return $this->adminJson($dependenciesResult);
  752.             }
  753.         }
  755.         return $this->adminJson(false);
  756.     }
  758.     /**
  759.      * @Route("/element/get-required-by-dependencies", name="pimcore_admin_element_getrequiredbydependencies", methods={"GET"})
  760.      *
  761.      * @param Request $request
  762.      *
  763.      * @return JsonResponse
  764.      */
  765.     public function getRequiredByDependenciesAction(Request $request)
  766.     {
  767.         $id = $request->get('id');
  768.         $type = $request->get('elementType');
  769.         $allowedTypes = ['asset', 'document', 'object'];
  770.         $offset = $request->get('start');
  771.         $limit = $request->get('limit');
  773.         if ($id && in_array($type, $allowedTypes)) {
  774.             $element = Model\Element\Service::getElementById($type, $id);
  775.             $dependencies = $element->getDependencies();
  777.             if ($element instanceof Model\Element\ElementInterface) {
  778.                 $dependenciesResult = Model\Element\Service::getRequiredByDependenciesForFrontend($dependencies, $offset, $limit);
  780.                 $dependenciesResult['start'] = $offset;
  781.                 $dependenciesResult['limit'] = $limit;
  782.                 $dependenciesResult['total'] = $dependencies->getRequiredByTotalCount();
  784.                 return $this->adminJson($dependenciesResult);
  785.             }
  786.         }
  788.         return $this->adminJson(false);
  789.     }
  791.     /**
  792.      * @Route("/element/get-predefined-properties", name="pimcore_admin_element_getpredefinedproperties", methods={"GET"})
  793.      *
  794.      * @param Request $request
  795.      *
  796.      * @return JsonResponse
  797.      */
  798.     public function getPredefinedPropertiesAction(Request $request)
  799.     {
  800.         $properties = [];
  801.         $type = $request->get('elementType');
  802.         $query = $request->get('query');
  803.         $allowedTypes = ['asset', 'document', 'object'];
  805.         if (in_array($type, $allowedTypes, true)) {
  806.             $list = new Model\Property\Predefined\Listing();
  807.             $list->setFilter(function (Model\Property\Predefined $predefined) use ($type, $query) {
  808.                 if (!str_contains($predefined->getCtype(), $type)) {
  809.                     return false;
  810.                 }
  811.                 if ($query && stripos($this->trans($predefined->getName()), $query) === false) {
  812.                     return false;
  813.                 }
  815.                 return true;
  816.             });
  818.             foreach ($list->getProperties() as $type) {
  819.                 $properties[] = $type->getObjectVars();
  820.             }
  821.         }
  823.         return $this->adminJson(['properties' => $properties]);
  824.     }
  826.     /**
  827.      * @Route("/element/analyze-permissions", name="pimcore_admin_element_analyzepermissions", methods={"POST"})
  828.      *
  829.      * @param Request $request
  830.      *
  831.      * @return Response
  832.      */
  833.     public function analyzePermissionsAction(Request $request)
  834.     {
  835.         $userId = $request->get('userId');
  836.         if ($userId) {
  837.             $user = Model\User::getById($userId);
  838.             $userList = [$user];
  839.         } else {
  840.             $userList = new Model\User\Listing();
  841.             $userList->setCondition('type = ?', ['user']);
  842.             $userList = $userList->load();
  843.         }
  845.         $elementType = $request->get('elementType');
  846.         $elementId = $request->get('elementId');
  848.         $element = Element\Service::getElementById($elementType, $elementId);
  850.         $result = Element\PermissionChecker::check($element, $userList);
  852.         return $this->adminJson(
  853.             [
  854.                 'data' => $result,
  855.                 'success' => true,
  856.             ]
  857.         );
  858.     }
  860.     /**
  861.      * @param DataObject\Concrete $source
  862.      * @param array $context
  863.      *
  864.      * @return bool|DataObject\ClassDefinition\Data|null
  865.      *
  866.      * @throws \Exception
  867.      */
  868.     protected function getNicePathFormatterFieldDefinition($source, $context)
  869.     {
  870.         $ownerType = $context['containerType'];
  871.         $fieldname = $context['fieldname'];
  872.         $fd = null;
  874.         if ($ownerType == 'object') {
  875.             $subContainerType = isset($context['subContainerType']) ? $context['subContainerType'] : null;
  876.             if ($subContainerType) {
  877.                 $subContainerKey = $context['subContainerKey'];
  878.                 $subContainer = $source->getClass()->getFieldDefinition($subContainerKey);
  879.                 if (method_exists($subContainer, 'getFieldDefinition')) {
  880.                     $fd = $subContainer->getFieldDefinition($fieldname);
  881.                 }
  882.             } else {
  883.                 $fd = $source->getClass()->getFieldDefinition($fieldname);
  884.             }
  885.         } elseif ($ownerType == 'localizedfield') {
  886.             $localizedfields = $source->getClass()->getFieldDefinition('localizedfields');
  887.             if ($localizedfields instanceof DataObject\ClassDefinition\Data\Localizedfields) {
  888.                 $fd = $localizedfields->getFieldDefinition($fieldname);
  889.             }
  890.         } elseif ($ownerType == 'objectbrick') {
  891.             $fdBrick = DataObject\Objectbrick\Definition::getByKey($context['containerKey']);
  892.             $fd = $fdBrick->getFieldDefinition($fieldname);
  893.         } elseif ($ownerType == 'fieldcollection') {
  894.             $containerKey = $context['containerKey'];
  895.             $fdCollection = DataObject\Fieldcollection\Definition::getByKey($containerKey);
  896.             if (($context['subContainerType'] ?? null) === 'localizedfield') {
  897.                 /** @var DataObject\ClassDefinition\Data\Localizedfields $fdLocalizedFields */
  898.                 $fdLocalizedFields = $fdCollection->getFieldDefinition('localizedfields');
  899.                 $fd = $fdLocalizedFields->getFieldDefinition($fieldname);
  900.             } else {
  901.                 $fd = $fdCollection->getFieldDefinition($fieldname);
  902.             }
  903.         }
  905.         return $fd;
  906.     }
  908.     /**
  909.      * @param DataObject\Concrete $source
  910.      * @param array $context
  911.      * @param array $result
  912.      * @param array $targets
  913.      *
  914.      * @return array
  915.      *
  916.      * @throws \Exception
  917.      */
  918.     protected function convertResultWithPathFormatter(DataObject\Concrete $source, $context, $result, $targets): array
  919.     {
  920.         $fd = $this->getNicePathFormatterFieldDefinition($source, $context);
  922.         if ($fd instanceof DataObject\ClassDefinition\PathFormatterAwareInterface) {
  923.             $formatter = $fd->getPathFormatterClass();
  925.             if (null !== $formatter) {
  926.                 $pathFormatter = DataObject\ClassDefinition\Helper\PathFormatterResolver::resolvePathFormatter(
  927.                     $fd->getPathFormatterClass()
  928.                 );
  930.                 if ($pathFormatter instanceof DataObject\ClassDefinition\PathFormatterInterface) {
  931.                     $result = $pathFormatter->formatPath($result, $source, $targets, [
  932.                         'fd' => $fd,
  933.                         'context' => $context,
  934.                     ]);
  935.                 }
  936.             }
  937.         }
  939.         return $result;
  940.     }
  941. }