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

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.      * Returns the element data denoted by the given type and ID or path.
  71.      *
  72.      * @Route("/element/get-subtype", name="pimcore_admin_element_getsubtype", methods={"GET"})
  73.      *
  74.      * @param Request $request
  75.      *
  76.      * @return JsonResponse
  77.      */
  78.     public function getSubtypeAction(Request $request)
  79.     {
  80.         $idOrPath = trim($request->get('id'));
  81.         $type = $request->get('type');
  83.         $event = new ResolveElementEvent($type, $idOrPath);
  84.         \Pimcore::getEventDispatcher()->dispatch($event, AdminEvents::RESOLVE_ELEMENT);
  85.         $idOrPath = $event->getId();
  86.         $type = $event->getType();
  88.         if (is_numeric($idOrPath)) {
  89.             $el = Element\Service::getElementById($type, (int) $idOrPath);
  90.         } else {
  91.             if ($type == 'document') {
  92.                 $el = Document\Service::getByUrl($idOrPath);
  93.             } else {
  94.                 $el = Element\Service::getElementByPath($type, $idOrPath);
  95.             }
  96.         }
  98.         if ($el) {
  99.             $subtype = null;
  100.             if ($el instanceof Asset || $el instanceof Document) {
  101.                 $subtype = $el->getType();
  102.             } elseif ($el instanceof DataObject\Concrete) {
  103.                 $subtype = $el->getClassName();
  104.             } elseif ($el instanceof DataObject\Folder) {
  105.                 $subtype = 'folder';
  106.             }
  108.             return $this->adminJson([
  109.                 'subtype' => $subtype,
  110.                 'id' => $el->getId(),
  111.                 'type' => $type,
  112.                 'success' => true,
  113.             ]);
  114.         } else {
  115.             return $this->adminJson([
  116.                 'success' => false,
  117.             ]);
  118.         }
  119.     }
  121.     /**
  122.      * @param string $parameterName
  123.      *
  124.      * @return \Pimcore\Bundle\AdminBundle\HttpFoundation\JsonResponse
  125.      */
  126.     protected function processNoteTypesFromParameters(string $parameterName)
  127.     {
  128.         $config = $this->getParameter($parameterName);
  129.         $result = [];
  130.         foreach ($config as $configEntry) {
  131.             $result[] = [
  132.                 'name' => $configEntry,
  133.             ];
  134.         }
  136.         return $this->adminJson(['noteTypes' => $result]);
  137.     }
  139.     /**
  140.      * @Route("/element/note-types", name="pimcore_admin_element_notetypes", methods={"GET"})
  141.      *
  142.      * @param Request $request
  143.      *
  144.      * @return JsonResponse
  145.      */
  146.     public function noteTypes(Request $request)
  147.     {
  148.         switch ($request->get('ctype')) {
  149.             case 'document':
  150.                 return $this->processNoteTypesFromParameters(PimcoreAdminExtension::PARAM_DOCUMENTS_NOTES_EVENTS_TYPES);
  151.             case 'asset':
  152.                 return $this->processNoteTypesFromParameters(PimcoreAdminExtension::PARAM_ASSETS_NOTES_EVENTS_TYPES);
  153.             case 'object':
  154.                 return $this->processNoteTypesFromParameters(PimcoreAdminExtension::PARAM_DATAOBJECTS_NOTES_EVENTS_TYPES);
  155.             default:
  156.                 return $this->adminJson(['noteTypes' => []]);
  158.         }
  159.     }
  161.     /**
  162.      * @Route("/element/note-list", name="pimcore_admin_element_notelist", methods={"POST"})
  163.      *
  164.      * @param Request $request
  165.      *
  166.      * @return JsonResponse
  167.      */
  168.     public function noteListAction(Request $request)
  169.     {
  170.         $this->checkPermission('notes_events');
  172.         $list = new Element\Note\Listing();
  174.         $list->setLimit($request->get('limit'));
  175.         $list->setOffset($request->get('start'));
  177.         $sortingSettings = \Pimcore\Bundle\AdminBundle\Helper\QueryParams::extractSortingSettings(array_merge($request->request->all(), $request->query->all()));
  178.         if ($sortingSettings['orderKey'] && $sortingSettings['order']) {
  179.             $list->setOrderKey($sortingSettings['orderKey']);
  180.             $list->setOrder($sortingSettings['order']);
  181.         } else {
  182.             $list->setOrderKey(['date', 'id']);
  183.             $list->setOrder(['DESC', 'DESC']);
  184.         }
  186.         $conditions = [];
  187.         $filterText = $request->get('filterText');
  189.         if ($filterText) {
  190.             $conditions[] = '('
  191.                 . '`title` LIKE ' . $list->quote('%'. $filterText .'%')
  192.                 . ' OR `description` LIKE ' . $list->quote('%'.$filterText.'%')
  193.                 . ' OR `type` LIKE ' . $list->quote('%'.$filterText.'%')
  194.                 . ' OR `user` IN (SELECT `id` FROM `users` WHERE `name` LIKE ' . $list->quote('%'.$filterText.'%') . ')'
  195.                 . " OR DATE_FORMAT(FROM_UNIXTIME(`date`), '%Y-%m-%d') LIKE " . $list->quote('%'.$filterText.'%')
  196.                 . ')';
  197.         }
  199.         $filterJson = $request->get('filter');
  200.         if ($filterJson) {
  201.             $db = Db::get();
  202.             $filters = $this->decodeJson($filterJson);
  203.             $propertyKey = 'property';
  204.             $comparisonKey = 'operator';
  206.             foreach ($filters as $filter) {
  207.                 $operator = '=';
  209.                 if ($filter['type'] == 'string') {
  210.                     $operator = 'LIKE';
  211.                 } elseif ($filter['type'] == 'numeric') {
  212.                     if ($filter[$comparisonKey] == 'lt') {
  213.                         $operator = '<';
  214.                     } elseif ($filter[$comparisonKey] == 'gt') {
  215.                         $operator = '>';
  216.                     } elseif ($filter[$comparisonKey] == 'eq') {
  217.                         $operator = '=';
  218.                     }
  219.                 } elseif ($filter['type'] == 'date') {
  220.                     if ($filter[$comparisonKey] == 'lt') {
  221.                         $operator = '<';
  222.                     } elseif ($filter[$comparisonKey] == 'gt') {
  223.                         $operator = '>';
  224.                     } elseif ($filter[$comparisonKey] == 'eq') {
  225.                         $operator = '=';
  226.                     }
  227.                     $filter['value'] = strtotime($filter['value']);
  228.                 } elseif ($filter[$comparisonKey] == 'list') {
  229.                     $operator = '=';
  230.                 } elseif ($filter[$comparisonKey] == 'boolean') {
  231.                     $operator = '=';
  232.                     $filter['value'] = (int) $filter['value'];
  233.                 }
  234.                 // system field
  235.                 $value = $filter['value'];
  236.                 if ($operator == 'LIKE') {
  237.                     $value = '%' . $value . '%';
  238.                 }
  240.                 if ($filter[$propertyKey] == 'user') {
  241.                     $conditions[] = '`user` IN (SELECT `id` FROM `users` WHERE `name` LIKE ' . $list->quote('%'.$filter['value'].'%') . ')';
  242.                 } else {
  243.                     if ($filter['type'] == 'date' && $filter[$comparisonKey] == 'eq') {
  244.                         $maxTime = $filter['value'] + (86400 - 1); //specifies the top point of the range used in the condition
  245.                         $dateCondition = '`' . $filter[$propertyKey] . '` ' . ' BETWEEN ' . $db->quote($filter['value']) . ' AND ' . $db->quote($maxTime);
  246.                         $conditions[] = $dateCondition;
  247.                     } else {
  248.                         $field = '`'.$filter[$propertyKey].'` ';
  249.                         $conditions[] = $field.$operator.' '.$db->quote($value);
  250.                     }
  251.                 }
  252.             }
  253.         }
  255.         if ($request->get('cid') && $request->get('ctype')) {
  256.             $conditions[] = '(cid = ' . $list->quote($request->get('cid')) . ' AND ctype = ' . $list->quote($request->get('ctype')) . ')';
  257.         }
  259.         if (!empty($conditions)) {
  260.             $condition = implode(' AND ', $conditions);
  261.             $list->setCondition($condition);
  262.         }
  264.         $list->load();
  266.         $notes = [];
  268.         foreach ($list->getNotes() as $note) {
  269.             $e = Element\Service::getNoteData($note);
  270.             $notes[] = $e;
  271.         }
  273.         return $this->adminJson([
  274.             'data' => $notes,
  275.             'success' => true,
  276.             'total' => $list->getTotalCount(),
  277.         ]);
  278.     }
  280.     /**
  281.      * @Route("/element/note-add", name="pimcore_admin_element_noteadd", methods={"POST"})
  282.      *
  283.      * @param Request $request
  284.      *
  285.      * @return JsonResponse
  286.      */
  287.     public function noteAddAction(Request $request)
  288.     {
  289.         $this->checkPermission('notes_events');
  291.         $note = new Element\Note();
  292.         $note->setCid((int) $request->get('cid'));
  293.         $note->setCtype($request->get('ctype'));
  294.         $note->setDate(time());
  295.         $note->setTitle($request->get('title'));
  296.         $note->setDescription($request->get('description'));
  297.         $note->setType($request->get('type'));
  298.         $note->save();
  300.         return $this->adminJson([
  301.             'success' => true,
  302.         ]);
  303.     }
  305.     /**
  306.      * @Route("/element/find-usages", name="pimcore_admin_element_findusages", methods={"GET"})
  307.      *
  308.      * @param Request $request
  309.      *
  310.      * @return JsonResponse
  311.      */
  312.     public function findUsagesAction(Request $request)
  313.     {
  314.         $element = null;
  315.         if ($request->get('id')) {
  316.             $element = Element\Service::getElementById($request->get('type'), $request->get('id'));
  317.         } elseif ($request->get('path')) {
  318.             $element = Element\Service::getElementByPath($request->get('type'), $request->get('path'));
  319.         }
  321.         $results = [];
  322.         $success = false;
  323.         $hasHidden = false;
  324.         $total = 0;
  325.         $limit = (int)$request->get('limit', 50);
  326.         $offset = (int)$request->get('start', 0);
  328.         if ($element instanceof Element\ElementInterface) {
  329.             $total = $element->getDependencies()->getRequiredByTotalCount();
  331.             if ($request->get('sort')) {
  332.                 $sort = json_decode($request->get('sort'))[0];
  333.                 $orderBy = $sort->property;
  334.                 $orderDirection = $sort->direction;
  335.             } else {
  336.                 $orderBy = null;
  337.                 $orderDirection = null;
  338.             }
  340.             $queryOffset = $offset;
  341.             $queryLimit = $limit;
  343.             while (count($results) < min($limit, $total) && $queryOffset < $total) {
  344.                 $elements = $element->getDependencies()
  345.                     ->getRequiredByWithPath($queryOffset, $queryLimit, $orderBy, $orderDirection);
  347.                 foreach ($elements as $el) {
  348.                     $item = Element\Service::getElementById($el['type'], $el['id']);
  350.                     if ($item instanceof Element\ElementInterface) {
  351.                         if ($item->isAllowed('list')) {
  352.                             $results[] = $el;
  353.                         } else {
  354.                             $hasHidden = true;
  355.                         }
  356.                     }
  357.                 }
  359.                 $queryOffset += count($elements);
  360.                 $queryLimit = $limit - count($results);
  361.             }
  363.             $success = true;
  364.         }
  366.         return $this->adminJson([
  367.             'data' => $results,
  368.             'total' => $total,
  369.             'hasHidden' => $hasHidden,
  370.             'success' => $success,
  371.         ]);
  372.     }
  374.     /**
  375.      * @Route("/element/get-replace-assignments-batch-jobs", name="pimcore_admin_element_getreplaceassignmentsbatchjobs", methods={"GET"})
  376.      *
  377.      * @param Request $request
  378.      *
  379.      * @return \Pimcore\Bundle\AdminBundle\HttpFoundation\JsonResponse
  380.      */
  381.     public function getReplaceAssignmentsBatchJobsAction(Request $request)
  382.     {
  383.         $element = null;
  385.         if ($request->get('id')) {
  386.             $element = Element\Service::getElementById($request->get('type'), $request->get('id'));
  387.         } elseif ($request->get('path')) {
  388.             $element = Element\Service::getElementByPath($request->get('type'), $request->get('path'));
  389.         }
  391.         if ($element instanceof Element\ElementInterface) {
  392.             return $this->adminJson([
  393.                 'success' => true,
  394.                 'jobs' => $element->getDependencies()->getRequiredBy(),
  395.             ]);
  396.         } else {
  397.             return $this->adminJson(['success' => false], Response::HTTP_NOT_FOUND);
  398.         }
  399.     }
  401.     /**
  402.      * @Route("/element/replace-assignments", name="pimcore_admin_element_replaceassignments", methods={"POST"})
  403.      *
  404.      * @param Request $request
  405.      *
  406.      * @return JsonResponse
  407.      */
  408.     public function replaceAssignmentsAction(Request $request)
  409.     {
  410.         $success = false;
  411.         $message = '';
  412.         $element = Element\Service::getElementById($request->get('type'), $request->get('id'));
  413.         $sourceEl = Element\Service::getElementById($request->get('sourceType'), $request->get('sourceId'));
  414.         $targetEl = Element\Service::getElementById($request->get('targetType'), $request->get('targetId'));
  416.         if ($element && $sourceEl && $targetEl
  417.             && $request->get('sourceType') == $request->get('targetType')
  418.             && $sourceEl->getType() == $targetEl->getType()
  419.             && $element->isAllowed('save')
  420.         ) {
  421.             $rewriteConfig = [
  422.                 $request->get('sourceType') => [
  423.                     $sourceEl->getId() => $targetEl->getId(),
  424.                 ],
  425.             ];
  427.             if ($element instanceof Document) {
  428.                 $element = Document\Service::rewriteIds($element, $rewriteConfig);
  429.             } elseif ($element instanceof DataObject\AbstractObject) {
  430.                 $element = DataObject\Service::rewriteIds($element, $rewriteConfig);
  431.             } elseif ($element instanceof Asset) {
  432.                 $element = Asset\Service::rewriteIds($element, $rewriteConfig);
  433.             }
  435.             $element->setUserModification($this->getAdminUser()->getId());
  436.             $element->save();
  438.             $success = true;
  439.         } else {
  440.             $message = 'source-type and target-type do not match';
  441.         }
  443.         return $this->adminJson([
  444.             'success' => $success,
  445.             'message' => $message,
  446.         ]);
  447.     }
  449.     /**
  450.      * @Route("/element/unlock-propagate", name="pimcore_admin_element_unlockpropagate", methods={"PUT"})
  451.      *
  452.      * @param Request $request
  453.      *
  454.      * @return JsonResponse
  455.      */
  456.     public function unlockPropagateAction(Request $request)
  457.     {
  458.         $success = false;
  460.         $element = Element\Service::getElementById($request->get('type'), $request->get('id'));
  461.         if ($element) {
  462.             $element->unlockPropagate();
  463.             $success = true;
  464.         }
  466.         return $this->adminJson([
  467.             'success' => $success,
  468.         ]);
  469.     }
  471.     /**
  472.      * @Route("/element/type-path", name="pimcore_admin_element_typepath", methods={"GET"})
  473.      *
  474.      * @param Request $request
  475.      *
  476.      * @return JsonResponse
  477.      */
  478.     public function typePathAction(Request $request)
  479.     {
  480.         $id = $request->get('id');
  481.         $type = $request->get('type');
  482.         $data = [];
  484.         if ($type === 'asset') {
  485.             $element = Asset::getById($id);
  486.         } elseif ($type === 'document') {
  487.             $element = Document::getById($id);
  488.         } else {
  489.             $element = DataObject::getById($id);
  490.         }
  492.         if (!$element) {
  493.             $data['success'] = false;
  495.             return $this->adminJson($data);
  496.         }
  498.         $typePath = Element\Service::getTypePath($element);
  500.         $data['success'] = true;
  501.         $data['index'] = method_exists($element, 'getIndex') ? (int) $element->getIndex() : 0;
  502.         $data['idPath'] = Element\Service::getIdPath($element);
  503.         $data['typePath'] = $typePath;
  504.         $data['fullpath'] = $element->getRealFullPath();
  506.         if ($type !== 'asset') {
  507.             $sortIndexPath = Element\Service::getSortIndexPath($element);
  508.             $data['sortIndexPath'] = $sortIndexPath;
  509.         }
  511.         return $this->adminJson($data);
  512.     }
  514.     /**
  515.      * @Route("/element/version-update", name="pimcore_admin_element_versionupdate", methods={"PUT"})
  516.      *
  517.      * @param Request $request
  518.      *
  519.      * @return JsonResponse
  520.      */
  521.     public function versionUpdateAction(Request $request)
  522.     {
  523.         $data = $this->decodeJson($request->get('data'));
  525.         $version = Version::getById($data['id']);
  527.         if ($data['public'] != $version->getPublic() || $data['note'] != $version->getNote()) {
  528.             $version->setPublic($data['public']);
  529.             $version->setNote($data['note']);
  530.             $version->save();
  531.         }
  533.         return $this->adminJson(['success' => true]);
  534.     }
  536.     /**
  537.      * @Route("/element/get-nice-path", name="pimcore_admin_element_getnicepath", methods={"POST"})
  538.      *
  539.      * @param Request $request
  540.      *
  541.      * @return JsonResponse
  542.      *
  543.      * @throws \Exception
  544.      */
  545.     public function getNicePathAction(Request $request)
  546.     {
  547.         $source = $this->decodeJson($request->get('source'));
  548.         if ($source['type'] != 'object') {
  549.             throw new \Exception('currently only objects as source elements are supported');
  550.         }
  551.         $result = [];
  552.         $id = $source['id'];
  553.         $source = DataObject\Concrete::getById($id);
  554.         if ($request->get('context')) {
  555.             $context = $this->decodeJson($request->get('context'));
  556.         } else {
  557.             $context = [];
  558.         }
  560.         $ownerType = $context['containerType'];
  561.         $fieldname = $context['fieldname'];
  563.         $fd = $this->getNicePathFormatterFieldDefinition($source, $context);
  565.         $targets = $this->decodeJson($request->get('targets'));
  567.         $result = $this->convertResultWithPathFormatter($source, $context, $result, $targets);
  569.         if ($request->get('loadEditModeData') == 'true') {
  570.             $idProperty = $request->get('idProperty', 'id');
  571.             $methodName = 'get' . ucfirst($fieldname);
  572.             if ($ownerType == 'object' && method_exists($source, $methodName)) {
  573.                 $data = $source->$methodName();
  574.                 $editModeData = $fd->getDataForEditmode($data, $source);
  575.                 // Inherited values show as an empty array
  576.                 if (is_array($editModeData) && !empty($editModeData)) {
  577.                     foreach ($editModeData as $relationObjectAttribute) {
  578.                         $relationObjectAttribute['$$nicepath'] =
  579.                             isset($relationObjectAttribute[$idProperty]) && isset($result[$relationObjectAttribute[$idProperty]]) ? $result[$relationObjectAttribute[$idProperty]] : null;
  580.                         $result[$relationObjectAttribute[$idProperty]] = $relationObjectAttribute;
  581.                     }
  582.                 } else {
  583.                     foreach ($result as $resultItemId => $resultItem) {
  584.                         $result[$resultItemId] = ['$$nicepath' => $resultItem];
  585.                     }
  586.                 }
  587.             } else {
  588.                 Logger::error('Loading edit mode data is not supported for ownertype: ' . $ownerType);
  589.             }
  590.         }
  592.         return $this->adminJson(['success' => true, 'data' => $result]);
  593.     }
  595.     /**
  596.      * @Route("/element/get-versions", name="pimcore_admin_element_getversions", methods={"GET"})
  597.      *
  598.      * @param Request $request
  599.      *
  600.      * @return JsonResponse
  601.      *
  602.      * @throws \Exception
  603.      */
  604.     public function getVersionsAction(Request $request)
  605.     {
  606.         $id = (int)$request->get('id');
  607.         $type = $request->get('elementType');
  608.         $allowedTypes = ['asset', 'document', 'object'];
  610.         if ($id && in_array($type, $allowedTypes)) {
  611.             $element = Model\Element\Service::getElementById($type, $id);
  612.             if ($element) {
  613.                 if ($element->isAllowed('versions')) {
  614.                     $schedule = $element->getScheduledTasks();
  615.                     $schedules = [];
  616.                     foreach ($schedule as $task) {
  617.                         if ($task->getActive()) {
  618.                             $schedules[$task->getVersion()] = $task->getDate();
  619.                         }
  620.                     }
  622.                     //only load auto-save versions from current user
  623.                     $list = new Version\Listing();
  624.                     $list->setLoadAutoSave(true);
  625.                     $list->setCondition('cid = ? AND ctype = ? AND (autoSave=0 OR (autoSave=1 AND userId = ?)) ', [
  626.                         $element->getId(),
  627.                         Element\Service::getType($element),
  628.                         $this->getAdminUser()->getId(),
  629.                     ])
  630.                         ->setOrderKey('date')
  631.                         ->setOrder('ASC');
  633.                     $versions = $list->load();
  635.                     $versions = Model\Element\Service::getSafeVersionInfo($versions);
  636.                     $versions = array_reverse($versions); //reverse array to sort by ID DESC
  637.                     foreach ($versions as &$version) {
  638.                         $version['scheduled'] = null;
  639.                         if (array_key_exists($version['id'], $schedules)) {
  640.                             $version['scheduled'] = $schedules[$version['id']];
  641.                         }
  642.                     }
  644.                     return $this->adminJson(['versions' => $versions]);
  645.                 } else {
  646.                     throw $this->createAccessDeniedException('Permission denied, ' . $type . ' id [' . $id . ']');
  647.                 }
  648.             } else {
  649.                 throw $this->createNotFoundException($type . ' with id [' . $id . "] doesn't exist");
  650.             }
  651.         }
  653.         throw $this->createNotFoundException('Element type not found');
  654.     }
  656.     /**
  657.      * @Route("/element/delete-draft", name="pimcore_admin_element_deletedraft", methods={"DELETE"})
  658.      *
  659.      * @param Request $request
  660.      *
  661.      * @return JsonResponse
  662.      */
  663.     public function deleteDraftAction(Request $request)
  664.     {
  665.         $version = Version::getById($request->get('id'));
  666.         if ($version) {
  667.             $version->delete();
  668.         }
  670.         return $this->adminJson(['success' => true]);
  671.     }
  673.     /**
  674.      * @Route("/element/delete-version", name="pimcore_admin_element_deleteversion", methods={"DELETE"})
  675.      *
  676.      * @param Request $request
  677.      *
  678.      * @return JsonResponse
  679.      */
  680.     public function deleteVersionAction(Request $request)
  681.     {
  682.         $version = Model\Version::getById($request->get('id'));
  683.         $version->delete();
  685.         return $this->adminJson(['success' => true]);
  686.     }
  688.     /**
  689.      * @Route("/element/delete-all-versions", name="pimcore_admin_element_deleteallversion", methods={"DELETE"})
  690.      *
  691.      * @param Request $request
  692.      *
  693.      * @return JsonResponse
  694.      */
  695.     public function deleteAllVersionAction(Request $request)
  696.     {
  697.         $elementId = $request->get('id');
  698.         $elementModificationdate = $request->get('date');
  700.         $versions = new Model\Version\Listing();
  701.         $versions->setCondition('cid = ' . $versions->quote($elementId) . ' AND date <> ' . $versions->quote($elementModificationdate));
  703.         foreach ($versions->load() as $vkey => $version) {
  704.             $version->delete();
  705.         }
  707.         return $this->adminJson(['success' => true]);
  708.     }
  710.     /**
  711.      * @Route("/element/get-requires-dependencies", name="pimcore_admin_element_getrequiresdependencies", methods={"GET"})
  712.      *
  713.      * @param Request $request
  714.      *
  715.      * @return JsonResponse
  716.      */
  717.     public function getRequiresDependenciesAction(Request $request)
  718.     {
  719.         $id = $request->get('id');
  720.         $type = $request->get('elementType');
  721.         $allowedTypes = ['asset', 'document', 'object'];
  722.         $offset = $request->get('start');
  723.         $limit = $request->get('limit');
  725.         if ($id && in_array($type, $allowedTypes)) {
  726.             $element = Model\Element\Service::getElementById($type, $id);
  727.             $dependencies = $element->getDependencies();
  729.             if ($element instanceof Model\Element\ElementInterface) {
  730.                 $dependenciesResult = Model\Element\Service::getRequiresDependenciesForFrontend($dependencies, $offset, $limit);
  732.                 $dependenciesResult['start'] = $offset;
  733.                 $dependenciesResult['limit'] = $limit;
  734.                 $dependenciesResult['total'] = $dependencies->getRequiresTotalCount();
  736.                 return $this->adminJson($dependenciesResult);
  737.             }
  738.         }
  740.         return $this->adminJson(false);
  741.     }
  743.     /**
  744.      * @Route("/element/get-required-by-dependencies", name="pimcore_admin_element_getrequiredbydependencies", methods={"GET"})
  745.      *
  746.      * @param Request $request
  747.      *
  748.      * @return JsonResponse
  749.      */
  750.     public function getRequiredByDependenciesAction(Request $request)
  751.     {
  752.         $id = $request->get('id');
  753.         $type = $request->get('elementType');
  754.         $allowedTypes = ['asset', 'document', 'object'];
  755.         $offset = $request->get('start');
  756.         $limit = $request->get('limit');
  758.         if ($id && in_array($type, $allowedTypes)) {
  759.             $element = Model\Element\Service::getElementById($type, $id);
  760.             $dependencies = $element->getDependencies();
  762.             if ($element instanceof Model\Element\ElementInterface) {
  763.                 $dependenciesResult = Model\Element\Service::getRequiredByDependenciesForFrontend($dependencies, $offset, $limit);
  765.                 $dependenciesResult['start'] = $offset;
  766.                 $dependenciesResult['limit'] = $limit;
  767.                 $dependenciesResult['total'] = $dependencies->getRequiredByTotalCount();
  769.                 return $this->adminJson($dependenciesResult);
  770.             }
  771.         }
  773.         return $this->adminJson(false);
  774.     }
  776.     /**
  777.      * @Route("/element/get-predefined-properties", name="pimcore_admin_element_getpredefinedproperties", methods={"GET"})
  778.      *
  779.      * @param Request $request
  780.      *
  781.      * @return JsonResponse
  782.      */
  783.     public function getPredefinedPropertiesAction(Request $request)
  784.     {
  785.         $properties = [];
  786.         $type = $request->get('elementType');
  787.         $allowedTypes = ['asset', 'document', 'object'];
  789.         if (in_array($type, $allowedTypes)) {
  790.             $list = new Model\Property\Predefined\Listing();
  791.             $list->setFilter(function ($row) use ($type) {
  792.                 if (is_array($row['ctype'])) {
  793.                     $row['ctype'] = implode(',', $row['ctype']);
  794.                 }
  795.                 if (strpos($row['ctype'], $type) !== false) {
  796.                     return true;
  797.                 }
  799.                 return false;
  800.             });
  802.             $list->load();
  804.             foreach ($list->getProperties() as $type) {
  805.                 $properties[] = $type->getObjectVars();
  806.             }
  807.         }
  809.         return $this->adminJson(['properties' => $properties]);
  810.     }
  812.     /**
  813.      * @Route("/element/analyze-permissions", name="pimcore_admin_element_analyzepermissions", methods={"POST"})
  814.      *
  815.      * @param Request $request
  816.      *
  817.      * @return Response
  818.      */
  819.     public function analyzePermissionsAction(Request $request)
  820.     {
  821.         $userId = $request->get('userId');
  822.         if ($userId) {
  823.             $user = Model\User::getById($userId);
  824.             $userList = [$user];
  825.         } else {
  826.             $userList = new Model\User\Listing();
  827.             $userList->setCondition('type = ?', ['user']);
  828.             $userList = $userList->load();
  829.         }
  831.         $elementType = $request->get('elementType');
  832.         $elementId = $request->get('elementId');
  834.         $element = Element\Service::getElementById($elementType, $elementId);
  836.         $result = Element\PermissionChecker::check($element, $userList);
  838.         return $this->adminJson(
  839.             [
  840.                 'data' => $result,
  841.                 'success' => true,
  842.             ]
  843.         );
  844.     }
  846.     /**
  847.      * @param DataObject\Concrete $source
  848.      * @param array $context
  849.      *
  850.      * @return bool|DataObject\ClassDefinition\Data|null
  851.      *
  852.      * @throws \Exception
  853.      */
  854.     protected function getNicePathFormatterFieldDefinition($source, $context)
  855.     {
  856.         $ownerType = $context['containerType'];
  857.         $fieldname = $context['fieldname'];
  858.         $fd = null;
  860.         if ($ownerType == 'object') {
  861.             $subContainerType = isset($context['subContainerType']) ? $context['subContainerType'] : null;
  862.             if ($subContainerType) {
  863.                 $subContainerKey = $context['subContainerKey'];
  864.                 $subContainer = $source->getClass()->getFieldDefinition($subContainerKey);
  865.                 if (method_exists($subContainer, 'getFieldDefinition')) {
  866.                     $fd = $subContainer->getFieldDefinition($fieldname);
  867.                 }
  868.             } else {
  869.                 $fd = $source->getClass()->getFieldDefinition($fieldname);
  870.             }
  871.         } elseif ($ownerType == 'localizedfield') {
  872.             $localizedfields = $source->getClass()->getFieldDefinition('localizedfields');
  873.             if ($localizedfields instanceof DataObject\ClassDefinition\Data\Localizedfields) {
  874.                 $fd = $localizedfields->getFieldDefinition($fieldname);
  875.             }
  876.         } elseif ($ownerType == 'objectbrick') {
  877.             $fdBrick = DataObject\Objectbrick\Definition::getByKey($context['containerKey']);
  878.             $fd = $fdBrick->getFieldDefinition($fieldname);
  879.         } elseif ($ownerType == 'fieldcollection') {
  880.             $containerKey = $context['containerKey'];
  881.             $fdCollection = DataObject\Fieldcollection\Definition::getByKey($containerKey);
  882.             if (($context['subContainerType'] ?? null) === 'localizedfield') {
  883.                 /** @var DataObject\ClassDefinition\Data\Localizedfields $fdLocalizedFields */
  884.                 $fdLocalizedFields = $fdCollection->getFieldDefinition('localizedfields');
  885.                 $fd = $fdLocalizedFields->getFieldDefinition($fieldname);
  886.             } else {
  887.                 $fd = $fdCollection->getFieldDefinition($fieldname);
  888.             }
  889.         }
  891.         return $fd;
  892.     }
  894.     /**
  895.      * @param DataObject\Concrete $source
  896.      * @param array $context
  897.      * @param array $result
  898.      * @param array $targets
  899.      *
  900.      * @return array
  901.      *
  902.      * @throws \Exception
  903.      */
  904.     protected function convertResultWithPathFormatter(DataObject\Concrete $source, $context, $result, $targets): array
  905.     {
  906.         $fd = $this->getNicePathFormatterFieldDefinition($source, $context);
  908.         if ($fd instanceof DataObject\ClassDefinition\PathFormatterAwareInterface) {
  909.             $formatter = $fd->getPathFormatterClass();
  911.             if (null !== $formatter) {
  912.                 $pathFormatter = DataObject\ClassDefinition\Helper\PathFormatterResolver::resolvePathFormatter(
  913.                     $fd->getPathFormatterClass()
  914.                 );
  916.                 if ($pathFormatter instanceof DataObject\ClassDefinition\PathFormatterInterface) {
  917.                     $result = $pathFormatter->formatPath($result, $source, $targets, [
  918.                         'fd' => $fd,
  919.                         'context' => $context,
  920.                     ]);
  921.                 }
  922.             }
  923.         }
  925.         return $result;
  926.     }
  927. }