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

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