vendor/pimcore/pimcore/bundles/AdminBundle/Controller/Admin/DataObject/ClassController.php line 91

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\DataObject;
  18. use Pimcore\Bundle\AdminBundle\Controller\AdminController;
  19. use Pimcore\Bundle\AdminBundle\HttpFoundation\JsonResponse;
  20. use Pimcore\Controller\KernelControllerEventInterface;
  21. use Pimcore\Db;
  22. use Pimcore\Event\AdminEvents;
  23. use Pimcore\Logger;
  24. use Pimcore\Model\Asset;
  25. use Pimcore\Model\DataObject;
  26. use Pimcore\Model\Document;
  27. use Pimcore\Model\Translation;
  28. use Pimcore\Tool\Session;
  29. use Symfony\Component\EventDispatcher\GenericEvent;
  30. use Symfony\Component\HttpFoundation\Request;
  31. use Symfony\Component\HttpFoundation\Response;
  32. use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBagInterface;
  33. use Symfony\Component\HttpKernel\Event\ControllerEvent;
  34. use Symfony\Component\Routing\Annotation\Route;
  35. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  37. /**
  38.  * @Route("/class")
  39.  *
  40.  * @internal
  41.  */
  42. class ClassController extends AdminController implements KernelControllerEventInterface
  43. {
  44.     /**
  45.      * @Route("/get-document-types", name="pimcore_admin_dataobject_class_getdocumenttypes", methods={"GET"})
  46.      *
  47.      * @param Request $request
  48.      *
  49.      * @return JsonResponse
  50.      */
  51.     public function getDocumentTypesAction(Request $request)
  52.     {
  53.         $documentTypes = Document::getTypes();
  54.         $typeItems = [];
  55.         foreach ($documentTypes as $documentType) {
  56.             $typeItems[] = [
  57.                 'text' => $documentType,
  58.             ];
  59.         }
  61.         return $this->adminJson($typeItems);
  62.     }
  64.     /**
  65.      * @Route("/get-asset-types", name="pimcore_admin_dataobject_class_getassettypes", methods={"GET"})
  66.      *
  67.      * @param Request $request
  68.      *
  69.      * @return JsonResponse
  70.      */
  71.     public function getAssetTypesAction(Request $request)
  72.     {
  73.         $assetTypes = Asset::getTypes();
  74.         $typeItems = [];
  75.         foreach ($assetTypes as $assetType) {
  76.             $typeItems[] = [
  77.                 'text' => $assetType,
  78.             ];
  79.         }
  81.         return $this->adminJson($typeItems);
  82.     }
  84.     /**
  85.      * @Route("/get-tree", name="pimcore_admin_dataobject_class_gettree", methods={"GET", "POST"})
  86.      *
  87.      * @param Request $request
  88.      *
  89.      * @return JsonResponse
  90.      */
  91.     public function getTreeAction(Request $request)
  92.     {
  93.         $defaultIcon = '/bundles/pimcoreadmin/img/flat-color-icons/class.svg';
  95.         $classesList = new DataObject\ClassDefinition\Listing();
  96.         $classesList->setOrderKey('name');
  97.         $classesList->setOrder('asc');
  98.         $classes = $classesList->load();
  100.         // filter classes
  101.         if ($request->get('createAllowed')) {
  102.             $tmpClasses = [];
  103.             foreach ($classes as $class) {
  104.                 if ($this->getAdminUser()->isAllowed($class->getId(), 'class')) {
  105.                     $tmpClasses[] = $class;
  106.                 }
  107.             }
  108.             $classes = $tmpClasses;
  109.         }
  111.         $withId = $request->get('withId');
  112.         $getClassConfig = function ($class) use ($defaultIcon, $withId) {
  113.             $text = $class->getname();
  114.             if ($withId) {
  115.                 $text .= ' (' . $class->getId() . ')';
  116.             }
  118.             $hasBrickField = false;
  119.             foreach ($class->getFieldDefinitions() as $fieldDefinition) {
  120.                 if ($fieldDefinition instanceof DataObject\ClassDefinition\Data\Objectbricks) {
  121.                     $hasBrickField = true;
  123.                     break;
  124.                 }
  125.             }
  127.             return [
  128.                 'id' => $class->getId(),
  129.                 'text' => $text,
  130.                 'leaf' => true,
  131.                 'icon' => $class->getIcon() ? htmlspecialchars($class->getIcon()) : $defaultIcon,
  132.                 'cls' => 'pimcore_class_icon',
  133.                 'propertyVisibility' => $class->getPropertyVisibility(),
  134.                 'enableGridLocking' => $class->isEnableGridLocking(),
  135.                 'hasBrickField' => $hasBrickField,
  136.             ];
  137.         };
  139.         // build groups
  140.         $groups = [];
  141.         foreach ($classes as $class) {
  142.             $groupName = null;
  144.             if ($class->getGroup()) {
  145.                 $type = 'manual';
  146.                 $groupName = $class->getGroup();
  147.             } else {
  148.                 $type = 'auto';
  149.                 if (preg_match('@^([A-Za-z])([^A-Z]+)@', $class->getName(), $matches)) {
  150.                     $groupName = $matches[0];
  151.                 }
  153.                 if (!$groupName) {
  154.                     // this is eg. the case when class name uses only capital letters
  155.                     $groupName = $class->getName();
  156.                 }
  157.             }
  159.             $groupName = Translation::getByKeyLocalized($groupName, Translation::DOMAIN_ADMIN, true, true);
  161.             if (!isset($groups[$groupName])) {
  162.                 $groups[$groupName] = [
  163.                     'classes' => [],
  164.                     'type' => $type,
  165.                 ];
  166.             }
  167.             $groups[$groupName]['classes'][] = $class;
  168.         }
  170.         $treeNodes = [];
  171.         if (!empty($groups)) {
  172.             $types = array_column($groups, 'type');
  173.             array_multisort($types, SORT_ASC, array_keys($groups), SORT_ASC, $groups);
  174.         }
  176.         if (!$request->get('grouped')) {
  177.             // list output
  178.             foreach ($groups as $groupName => $groupData) {
  179.                 foreach ($groupData['classes'] as $class) {
  180.                     $node = $getClassConfig($class);
  181.                     if (count($groupData['classes']) > 1 || $groupData['type'] == 'manual') {
  182.                         $node['group'] = $groupName;
  183.                     }
  184.                     $treeNodes[] = $node;
  185.                 }
  186.             }
  187.         } else {
  188.             // create json output
  189.             foreach ($groups as $groupName => $groupData) {
  190.                 if (count($groupData['classes']) === 1 && $groupData['type'] == 'auto') {
  191.                     // no group, only one child
  192.                     $node = $getClassConfig($groupData['classes'][0]);
  193.                 } else {
  194.                     // group classes
  195.                     $node = [
  196.                         'id' => 'folder_' . $groupName,
  197.                         'text' => $groupName,
  198.                         'leaf' => false,
  199.                         'expandable' => true,
  200.                         'allowChildren' => true,
  201.                         'iconCls' => 'pimcore_icon_folder',
  202.                         'children' => [],
  203.                     ];
  205.                     foreach ($groupData['classes'] as $class) {
  206.                         $node['children'][] = $getClassConfig($class);
  207.                     }
  208.                 }
  210.                 $treeNodes[] = $node;
  211.             }
  212.         }
  214.         return $this->adminJson($treeNodes);
  215.     }
  217.     /**
  218.      * @Route("/get", name="pimcore_admin_dataobject_class_get", methods={"GET"})
  219.      *
  220.      * @param Request $request
  221.      *
  222.      * @return JsonResponse
  223.      */
  224.     public function getAction(Request $request)
  225.     {
  226.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  227.         $class->setFieldDefinitions([]);
  228.         $isWriteable = $class->isWritable();
  229.         $class = $class->getObjectVars();
  230.         $class['isWriteable'] = $isWriteable;
  232.         return $this->adminJson($class);
  233.     }
  235.     /**
  236.      * @Route("/get-custom-layout", name="pimcore_admin_dataobject_class_getcustomlayout", methods={"GET"})
  237.      *
  238.      * @param Request $request
  239.      *
  240.      * @return JsonResponse
  241.      */
  242.     public function getCustomLayoutAction(Request $request)
  243.     {
  244.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  245.         $isWriteable = $customLayout->isWritable();
  246.         $customLayout = $customLayout->getObjectVars();
  247.         $customLayout['isWriteable'] = $isWriteable;
  249.         return $this->adminJson(['success' => true, 'data' => $customLayout]);
  250.     }
  252.     /**
  253.      * @Route("/add", name="pimcore_admin_dataobject_class_add", methods={"POST"})
  254.      *
  255.      * @param Request $request
  256.      *
  257.      * @return JsonResponse
  258.      */
  259.     public function addAction(Request $request)
  260.     {
  261.         $className = $request->get('className');
  262.         $className = $this->correctClassname($className);
  264.         $classId = $request->get('classIdentifier');
  265.         $existingClass = DataObject\ClassDefinition::getById($classId);
  266.         if ($existingClass) {
  267.             throw new \Exception('Class identifier already exists');
  268.         }
  270.         $class = DataObject\ClassDefinition::create(
  271.             ['name' => $className,
  272.                 'userOwner' => $this->getAdminUser()->getId(), ]
  273.         );
  275.         $class->setId($classId);
  277.         $class->save(true);
  279.         return $this->adminJson(['success' => true, 'id' => $class->getId()]);
  280.     }
  282.     /**
  283.      * @Route("/add-custom-layout", name="pimcore_admin_dataobject_class_addcustomlayout", methods={"POST"})
  284.      *
  285.      * @param Request $request
  286.      *
  287.      * @return JsonResponse
  288.      */
  289.     public function addCustomLayoutAction(Request $request)
  290.     {
  291.         $layoutId = $request->get('layoutIdentifier');
  292.         $existingLayout = DataObject\ClassDefinition\CustomLayout::getById($layoutId);
  293.         if ($existingLayout) {
  294.             throw new \Exception('Custom Layout identifier already exists');
  295.         }
  297.         $customLayout = DataObject\ClassDefinition\CustomLayout::create(
  298.             [
  299.                 'name' => $request->get('layoutName'),
  300.                 'userOwner' => $this->getAdminUser()->getId(),
  301.                 'classId' => $request->get('classId'),
  302.             ]
  303.         );
  305.         $customLayout->setId($layoutId);
  306.         $customLayout->save();
  308.         $isWriteable = $customLayout->isWritable();
  309.         $data = $customLayout->getObjectVars();
  310.         $data['isWriteable'] = $isWriteable;
  312.         return $this->adminJson(['success' => true, 'id' => $customLayout->getId(), 'name' => $customLayout->getName(),
  313.                                  'data' => $data, ]);
  314.     }
  316.     /**
  317.      * @Route("/delete", name="pimcore_admin_dataobject_class_delete", methods={"DELETE"})
  318.      *
  319.      * @param Request $request
  320.      *
  321.      * @return Response
  322.      */
  323.     public function deleteAction(Request $request)
  324.     {
  325.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  326.         $class->delete();
  328.         return new Response();
  329.     }
  331.     /**
  332.      * @Route("/delete-custom-layout", name="pimcore_admin_dataobject_class_deletecustomlayout", methods={"DELETE"})
  333.      *
  334.      * @param Request $request
  335.      *
  336.      * @return JsonResponse
  337.      */
  338.     public function deleteCustomLayoutAction(Request $request)
  339.     {
  340.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  341.         if ($customLayout) {
  342.             $customLayout->delete();
  343.         }
  345.         return $this->adminJson(['success' => true]);
  346.     }
  348.     /**
  349.      * @Route("/save-custom-layout", name="pimcore_admin_dataobject_class_savecustomlayout", methods={"PUT"})
  350.      *
  351.      * @param Request $request
  352.      *
  353.      * @return JsonResponse
  354.      */
  355.     public function saveCustomLayoutAction(Request $request)
  356.     {
  357.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  358.         $class = DataObject\ClassDefinition::getById($customLayout->getClassId());
  360.         $configuration = $this->decodeJson($request->get('configuration'));
  361.         $values = $this->decodeJson($request->get('values'));
  363.         $modificationDate = (int)$values['modificationDate'];
  364.         if ($modificationDate < $customLayout->getModificationDate()) {
  365.             return $this->adminJson(['success' => false, 'msg' => 'custom_layout_changed']);
  366.         }
  368.         $configuration['datatype'] = 'layout';
  369.         $configuration['fieldtype'] = 'panel';
  370.         $configuration['name'] = 'pimcore_root';
  372.         try {
  373.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  374.             $customLayout->setLayoutDefinitions($layout);
  375.             $customLayout->setName($values['name']);
  376.             $customLayout->setDescription($values['description']);
  377.             $customLayout->setDefault($values['default']);
  378.             $customLayout->save();
  380.             return $this->adminJson(['success' => true, 'id' => $customLayout->getId(), 'data' => $customLayout->getObjectVars()]);
  381.         } catch (\Exception $e) {
  382.             Logger::error($e->getMessage());
  384.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  385.         }
  386.     }
  388.     /**
  389.      * @Route("/save", name="pimcore_admin_dataobject_class_save", methods={"PUT"})
  390.      *
  391.      * @param Request $request
  392.      *
  393.      * @return JsonResponse
  394.      *
  395.      * @throws \Exception
  396.      */
  397.     public function saveAction(Request $request)
  398.     {
  399.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  401.         $configuration = $this->decodeJson($request->get('configuration'));
  402.         $values = $this->decodeJson($request->get('values'));
  404.         // check if the class was changed during editing in the frontend
  405.         if ($class->getModificationDate() != $values['modificationDate']) {
  406.             throw new \Exception('The class was modified during editing, please reload the class and make your changes again');
  407.         }
  409.         if ($values['name'] != $class->getName()) {
  410.             $classByName = DataObject\ClassDefinition::getByName($values['name']);
  411.             if ($classByName && $classByName->getId() != $class->getId()) {
  412.                 throw new \Exception('Class name already exists');
  413.             }
  415.             $values['name'] = $this->correctClassname($values['name']);
  416.             $class->rename($values['name']);
  417.         }
  419.         unset($values['creationDate']);
  420.         unset($values['userOwner']);
  421.         unset($values['layoutDefinitions']);
  422.         unset($values['fieldDefinitions']);
  424.         $configuration['datatype'] = 'layout';
  425.         $configuration['fieldtype'] = 'panel';
  426.         $configuration['name'] = 'pimcore_root';
  428.         $class->setValues($values);
  430.         try {
  431.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  433.             $class->setLayoutDefinitions($layout);
  435.             $class->setUserModification($this->getAdminUser()->getId());
  436.             $class->setModificationDate(time());
  438.             $propertyVisibility = [];
  439.             foreach ($values as $key => $value) {
  440.                 if (preg_match('/propertyVisibility/i', $key)) {
  441.                     if (preg_match("/\.grid\./i", $key)) {
  442.                         $propertyVisibility['grid'][preg_replace("/propertyVisibility\.grid\./i", '', $key)] = (bool) $value;
  443.                     } elseif (preg_match("/\.search\./i", $key)) {
  444.                         $propertyVisibility['search'][preg_replace("/propertyVisibility\.search\./i", '', $key)] = (bool) $value;
  445.                     }
  446.                 }
  447.             }
  448.             if (!empty($propertyVisibility)) {
  449.                 $class->setPropertyVisibility($propertyVisibility);
  450.             }
  452.             $class->save();
  454.             // set the fielddefinitions to [] because we don't need them in the response
  455.             $class->setFieldDefinitions([]);
  457.             return $this->adminJson(['success' => true, 'class' => $class]);
  458.         } catch (\Exception $e) {
  459.             Logger::error($e->getMessage());
  461.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  462.         }
  463.     }
  465.     /**
  466.      * @param string $name
  467.      *
  468.      * @return string
  469.      */
  470.     protected function correctClassname($name)
  471.     {
  472.         $name = preg_replace('/[^a-zA-Z0-9_]+/', '', $name);
  473.         $name = preg_replace('/^[0-9]+/', '', $name);
  475.         return $name;
  476.     }
  478.     /**
  479.      * @Route("/import-class", name="pimcore_admin_dataobject_class_importclass", methods={"POST", "PUT"})
  480.      *
  481.      * @param Request $request
  482.      *
  483.      * @return Response
  484.      */
  485.     public function importClassAction(Request $request)
  486.     {
  487.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  488.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  490.         $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, $json, false, true);
  492.         $response = $this->adminJson([
  493.             'success' => $success,
  494.         ]);
  495.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  496.         // Ext.form.Action.Submit and mark the submission as failed
  497.         $response->headers->set('Content-Type', 'text/html');
  499.         return $response;
  500.     }
  502.     /**
  503.      * @Route("/import-custom-layout-definition", name="pimcore_admin_dataobject_class_importcustomlayoutdefinition", methods={"POST", "PUT"})
  504.      *
  505.      * @param Request $request
  506.      *
  507.      * @return Response
  508.      */
  509.     public function importCustomLayoutDefinitionAction(Request $request)
  510.     {
  511.         $success = false;
  512.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  513.         $importData = $this->decodeJson($json);
  515.         $customLayoutId = $request->get('id');
  516.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($customLayoutId);
  517.         if ($customLayout) {
  518.             try {
  519.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($importData['layoutDefinitions'], true);
  520.                 $customLayout->setLayoutDefinitions($layout);
  521.                 $customLayout->setDescription($importData['description']);
  522.                 $customLayout->save();
  523.                 $success = true;
  524.             } catch (\Exception $e) {
  525.                 Logger::error($e->getMessage());
  526.             }
  527.         }
  529.         $response = $this->adminJson([
  530.             'success' => $success,
  531.         ]);
  533.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  534.         // Ext.form.Action.Submit and mark the submission as failed
  535.         $response->headers->set('Content-Type', 'text/html');
  537.         return $response;
  538.     }
  540.     /**
  541.      * @Route("/get-custom-layout-definitions", name="pimcore_admin_dataobject_class_getcustomlayoutdefinitions", methods={"GET"})
  542.      *
  543.      * @param Request $request
  544.      *
  545.      * @return JsonResponse
  546.      */
  547.     public function getCustomLayoutDefinitionsAction(Request $request)
  548.     {
  549.         $classId = $request->get('classId');
  550.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  552.         $list->setCondition('classId = ' . $list->quote($classId));
  553.         $list = $list->load();
  554.         $result = [];
  555.         foreach ($list as $item) {
  556.             $result[] = [
  557.                 'id' => $item->getId(),
  558.                 'name' => $item->getName() . ' (ID: ' . $item->getId() . ')',
  559.                 'default' => $item->getDefault() ?: 0,
  560.             ];
  561.         }
  563.         return $this->adminJson(['success' => true, 'data' => $result]);
  564.     }
  566.     /**
  567.      * @Route("/get-all-layouts", name="pimcore_admin_dataobject_class_getalllayouts", methods={"GET"})
  568.      *
  569.      * @param Request $request
  570.      *
  571.      * @return JsonResponse
  572.      */
  573.     public function getAllLayoutsAction(Request $request)
  574.     {
  575.         // get all classes
  576.         $resultList = [];
  577.         $mapping = [];
  579.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  580.         $customLayouts->setOrder('ASC');
  581.         $customLayouts->setOrderKey('name');
  582.         $customLayouts = $customLayouts->load();
  583.         foreach ($customLayouts as $layout) {
  584.             $mapping[$layout->getClassId()][] = $layout;
  585.         }
  587.         $classList = new DataObject\ClassDefinition\Listing();
  588.         $classList->setOrder('ASC');
  589.         $classList->setOrderKey('name');
  590.         $classList = $classList->load();
  592.         foreach ($classList as $class) {
  593.             if (isset($mapping[$class->getId()])) {
  594.                 $classMapping = $mapping[$class->getId()];
  595.                 $resultList[] = [
  596.                     'type' => 'master',
  597.                     'id' => $class->getId() . '_' . 0,
  598.                     'name' => $class->getName(),
  599.                 ];
  601.                 foreach ($classMapping as $layout) {
  602.                     $resultList[] = [
  603.                         'type' => 'custom',
  604.                         'id' => $class->getId() . '_' . $layout->getId(),
  605.                         'name' => $class->getName() . ' - ' . $layout->getName(),
  606.                     ];
  607.                 }
  608.             }
  609.         }
  611.         return $this->adminJson(['data' => $resultList]);
  612.     }
  614.     /**
  615.      * @Route("/export-class", name="pimcore_admin_dataobject_class_exportclass", methods={"GET"})
  616.      *
  617.      * @param Request $request
  618.      *
  619.      * @return Response
  620.      */
  621.     public function exportClassAction(Request $request)
  622.     {
  623.         $id = $request->get('id');
  624.         $class = DataObject\ClassDefinition::getById($id);
  626.         if (!$class instanceof DataObject\ClassDefinition) {
  627.             $errorMessage = ': Class with id [ ' . $id . ' not found. ]';
  628.             Logger::error($errorMessage);
  630.             throw $this->createNotFoundException($errorMessage);
  631.         }
  633.         $json = DataObject\ClassDefinition\Service::generateClassDefinitionJson($class);
  635.         $response = new Response($json);
  636.         $response->headers->set('Content-type', 'application/json');
  637.         $response->headers->set('Content-Disposition', 'attachment; filename="class_' . $class->getName() . '_export.json"');
  639.         return $response;
  640.     }
  642.     /**
  643.      * @Route("/export-custom-layout-definition", name="pimcore_admin_dataobject_class_exportcustomlayoutdefinition", methods={"GET"})
  644.      *
  645.      * @param Request $request
  646.      *
  647.      * @return Response
  648.      */
  649.     public function exportCustomLayoutDefinitionAction(Request $request)
  650.     {
  651.         $id = $request->get('id');
  653.         if ($id) {
  654.             $customLayout = DataObject\ClassDefinition\CustomLayout::getById($id);
  655.             if ($customLayout) {
  656.                 $name = $customLayout->getName();
  657.                 $customLayoutData = [
  658.                     'description' => $customLayout->getDescription(),
  659.                     'layoutDefinitions' => $customLayout->getLayoutDefinitions(),
  660.                     'default' => $customLayout->getDefault() ?: 0,
  661.                 ];
  663.                 $json = json_encode($customLayoutData, JSON_PRETTY_PRINT);
  665.                 $response = new Response($json);
  666.                 $response->headers->set('Content-type', 'application/json');
  667.                 $response->headers->set('Content-Disposition', 'attachment; filename="custom_definition_' . $name . '_export.json"');
  669.                 return $response;
  670.             }
  671.         }
  673.         $errorMessage = ': Custom Layout with id [ ' . $id . ' not found. ]';
  674.         Logger::error($errorMessage);
  676.         throw $this->createNotFoundException($errorMessage);
  677.     }
  679.     /**
  680.      * FIELDCOLLECTIONS
  681.      */
  683.     /**
  684.      * @Route("/fieldcollection-get", name="pimcore_admin_dataobject_class_fieldcollectionget", methods={"GET"})
  685.      *
  686.      * @param Request $request
  687.      *
  688.      * @return JsonResponse
  689.      */
  690.     public function fieldcollectionGetAction(Request $request)
  691.     {
  692.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  694.         $isWriteable = $fc->isWritable();
  695.         $fc = $fc->getObjectVars();
  696.         $fc['isWriteable'] = $isWriteable;
  698.         return $this->adminJson($fc);
  699.     }
  701.     /**
  702.      * @Route("/fieldcollection-update", name="pimcore_admin_dataobject_class_fieldcollectionupdate", methods={"PUT", "POST"})
  703.      *
  704.      * @param Request $request
  705.      *
  706.      * @return JsonResponse
  707.      */
  708.     public function fieldcollectionUpdateAction(Request $request)
  709.     {
  710.         try {
  711.             $key = $request->get('key');
  712.             $title = $request->get('title');
  713.             $group = $request->get('group');
  715.             if ($request->get('task') == 'add') {
  716.                 // check for existing fieldcollection with same name with different lower/upper cases
  717.                 $list = new DataObject\Fieldcollection\Definition\Listing();
  718.                 $list = $list->load();
  720.                 foreach ($list as $item) {
  721.                     if (strtolower($key) === strtolower($item->getKey())) {
  722.                         throw new \Exception('FieldCollection with the same name already exists (lower/upper cases may be different)');
  723.                     }
  724.                 }
  725.             }
  727.             $fcDef = new DataObject\Fieldcollection\Definition();
  728.             $fcDef->setKey($key);
  729.             $fcDef->setTitle($title);
  730.             $fcDef->setGroup($group);
  732.             if ($request->get('values')) {
  733.                 $values = $this->decodeJson($request->get('values'));
  734.                 $fcDef->setParentClass($values['parentClass']);
  735.                 $fcDef->setImplementsInterfaces($values['implementsInterfaces']);
  736.                 $fcDef->setGenerateTypeDeclarations($values['generateTypeDeclarations']);
  737.             }
  739.             if ($request->get('configuration')) {
  740.                 $configuration = $this->decodeJson($request->get('configuration'));
  742.                 $configuration['datatype'] = 'layout';
  743.                 $configuration['fieldtype'] = 'panel';
  745.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  746.                 $fcDef->setLayoutDefinitions($layout);
  747.             }
  749.             $fcDef->save();
  751.             return $this->adminJson(['success' => true, 'id' => $fcDef->getKey()]);
  752.         } catch (\Exception $e) {
  753.             Logger::error($e->getMessage());
  755.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  756.         }
  757.     }
  759.     /**
  760.      * @Route("/import-fieldcollection", name="pimcore_admin_dataobject_class_importfieldcollection", methods={"POST"})
  761.      *
  762.      * @param Request $request
  763.      *
  764.      * @return Response
  765.      */
  766.     public function importFieldcollectionAction(Request $request)
  767.     {
  768.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  770.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  772.         $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, $data);
  774.         $response = $this->adminJson([
  775.             'success' => $success,
  776.         ]);
  778.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  779.         // Ext.form.Action.Submit and mark the submission as failed
  780.         $response->headers->set('Content-Type', 'text/html');
  782.         return $response;
  783.     }
  785.     /**
  786.      * @Route("/export-fieldcollection", name="pimcore_admin_dataobject_class_exportfieldcollection", methods={"GET"})
  787.      *
  788.      * @param Request $request
  789.      *
  790.      * @return Response
  791.      */
  792.     public function exportFieldcollectionAction(Request $request)
  793.     {
  794.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  796.         if (!$fieldCollection instanceof DataObject\Fieldcollection\Definition) {
  797.             $errorMessage = ': Field-Collection with id [ ' . $request->get('id') . ' not found. ]';
  798.             Logger::error($errorMessage);
  800.             throw $this->createNotFoundException($errorMessage);
  801.         }
  803.         $json = DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection);
  804.         $response = new Response($json);
  805.         $response->headers->set('Content-type', 'application/json');
  806.         $response->headers->set('Content-Disposition', 'attachment; filename="fieldcollection_' . $fieldCollection->getKey() . '_export.json"');
  808.         return $response;
  809.     }
  811.     /**
  812.      * @Route("/fieldcollection-delete", name="pimcore_admin_dataobject_class_fieldcollectiondelete", methods={"DELETE"})
  813.      *
  814.      * @param Request $request
  815.      *
  816.      * @return JsonResponse
  817.      */
  818.     public function fieldcollectionDeleteAction(Request $request)
  819.     {
  820.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  821.         $fc->delete();
  823.         return $this->adminJson(['success' => true]);
  824.     }
  826.     /**
  827.      * @Route("/fieldcollection-tree", name="pimcore_admin_dataobject_class_fieldcollectiontree", methods={"GET", "POST"})
  828.      *
  829.      * @param Request $request
  830.      * @param EventDispatcherInterface $eventDispatcher
  831.      *
  832.      * @return JsonResponse
  833.      */
  834.     public function fieldcollectionTreeAction(Request $request, EventDispatcherInterface $eventDispatcher)
  835.     {
  836.         $list = new DataObject\Fieldcollection\Definition\Listing();
  837.         $list = $list->load();
  839.         $forObjectEditor = $request->get('forObjectEditor');
  841.         $layoutDefinitions = [];
  843.         $definitions = [];
  845.         $allowedTypes = null;
  846.         if ($request->query->has('allowedTypes')) {
  847.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  848.         }
  849.         $object = DataObject::getById($request->get('object_id'));
  851.         $currentLayoutId = $request->get('layoutId', null);
  852.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  854.         $groups = [];
  855.         foreach ($list as $item) {
  856.             if ($allowedTypes && !in_array($item->getKey(), $allowedTypes)) {
  857.                 continue;
  858.             }
  860.             if ($item->getGroup()) {
  861.                 if (!isset($groups[$item->getGroup()])) {
  862.                     $groups[$item->getGroup()] = [
  863.                         'id' => 'group_' . $item->getKey(),
  864.                         'text' => htmlspecialchars($item->getGroup()),
  865.                         'expandable' => true,
  866.                         'leaf' => false,
  867.                         'allowChildren' => true,
  868.                         'iconCls' => 'pimcore_icon_folder',
  869.                         'group' => $item->getGroup(),
  870.                         'children' => [],
  871.                     ];
  872.                 }
  873.                 if ($forObjectEditor) {
  874.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  875.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  877.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  878.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  879.                     }
  880.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  881.                 }
  882.                 $groups[$item->getGroup()]['children'][] =
  883.                     [
  884.                         'id' => $item->getKey(),
  885.                         'text' => $item->getKey(),
  886.                         'title' => $item->getTitle(),
  887.                         'key' => $item->getKey(),
  888.                         'leaf' => true,
  889.                         'iconCls' => 'pimcore_icon_fieldcollection',
  890.                     ];
  891.             } else {
  892.                 if ($forObjectEditor) {
  893.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  894.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  896.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  897.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  898.                     }
  900.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  901.                 }
  902.                 $definitions[] = [
  903.                     'id' => $item->getKey(),
  904.                     'text' => $item->getKey(),
  905.                     'title' => $item->getTitle(),
  906.                     'key' => $item->getKey(),
  907.                     'leaf' => true,
  908.                     'iconCls' => 'pimcore_icon_fieldcollection',
  909.                 ];
  910.             }
  911.         }
  913.         foreach ($groups as $group) {
  914.             $definitions[] = $group;
  915.         }
  917.         $event = new GenericEvent($this, [
  918.             'list' => $definitions,
  919.             'objectId' => $request->get('object_id'),
  920.             'layoutDefinitions' => $layoutDefinitions,
  921.         ]);
  922.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA);
  923.         $definitions = $event->getArgument('list');
  924.         $layoutDefinitions = $event->getArgument('layoutDefinitions');
  926.         if ($forObjectEditor) {
  927.             return $this->adminJson(['fieldcollections' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  928.         } else {
  929.             return $this->adminJson($definitions);
  930.         }
  931.     }
  933.     /**
  934.      * @Route("/fieldcollection-list", name="pimcore_admin_dataobject_class_fieldcollectionlist", methods={"GET"})
  935.      *
  936.      * @param Request $request
  937.      * @param EventDispatcherInterface $eventDispatcher
  938.      *
  939.      * @return JsonResponse
  940.      */
  941.     public function fieldcollectionListAction(Request $request, EventDispatcherInterface $eventDispatcher)
  942.     {
  943.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  944.         $currentLayoutId = $request->get('layoutId');
  946.         $list = new DataObject\Fieldcollection\Definition\Listing();
  947.         $list = $list->load();
  949.         if ($request->query->has('allowedTypes')) {
  950.             $filteredList = [];
  951.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  952.             foreach ($list as $type) {
  953.                 if (in_array($type->getKey(), $allowedTypes)) {
  954.                     $filteredList[] = $type;
  956.                     // mainly for objects-meta data-type
  957.                     $layoutDefinitions = $type->getLayoutDefinitions();
  958.                     $context = [
  959.                         'containerType' => 'fieldcollection',
  960.                         'containerKey' => $type->getKey(),
  961.                         'outerFieldname' => $request->get('field_name'),
  962.                     ];
  964.                     $object = DataObject::getById($request->get('object_id'));
  966.                     DataObject\Service::enrichLayoutDefinition($layoutDefinitions, $object, $context);
  968.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  969.                         DataObject\Service::createSuperLayout($layoutDefinitions);
  970.                     }
  971.                 }
  972.             }
  974.             $list = $filteredList;
  975.         }
  977.         $event = new GenericEvent($this, [
  978.             'list' => $list,
  979.             'objectId' => $request->get('object_id'),
  980.         ]);
  981.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA);
  982.         $list = $event->getArgument('list');
  984.         return $this->adminJson(['fieldcollections' => $list]);
  985.     }
  987.     /**
  988.      * @Route("/get-class-definition-for-column-config", name="pimcore_admin_dataobject_class_getclassdefinitionforcolumnconfig", methods={"GET"})
  989.      *
  990.      * @param Request $request
  991.      *
  992.      * @return JsonResponse
  993.      */
  994.     public function getClassDefinitionForColumnConfigAction(Request $request)
  995.     {
  996.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  997.         $objectId = (int)$request->get('oid');
  999.         $filteredDefinitions = DataObject\Service::getCustomLayoutDefinitionForGridColumnConfig($class, $objectId);
  1001.         $layoutDefinitions = isset($filteredDefinitions['layoutDefinition']) ? $filteredDefinitions['layoutDefinition'] : false;
  1002.         $filteredFieldDefinition = isset($filteredDefinitions['fieldDefinition']) ? $filteredDefinitions['fieldDefinition'] : false;
  1004.         $class->setFieldDefinitions([]);
  1006.         $result = [];
  1008.         DataObject\Service::enrichLayoutDefinition($layoutDefinitions);
  1010.         $result['objectColumns']['childs'] = $layoutDefinitions->getChilds();
  1011.         $result['objectColumns']['nodeLabel'] = 'object_columns';
  1012.         $result['objectColumns']['nodeType'] = 'object';
  1014.         // array("id", "fullpath", "published", "creationDate", "modificationDate", "filename", "classname");
  1015.         $systemColumnNames = DataObject\Concrete::SYSTEM_COLUMN_NAMES;
  1016.         $systemColumns = [];
  1017.         foreach ($systemColumnNames as $systemColumn) {
  1018.             $systemColumns[] = ['title' => $systemColumn, 'name' => $systemColumn, 'datatype' => 'data', 'fieldtype' => 'system'];
  1019.         }
  1020.         $result['systemColumns']['nodeLabel'] = 'system_columns';
  1021.         $result['systemColumns']['nodeType'] = 'system';
  1022.         $result['systemColumns']['childs'] = $systemColumns;
  1024.         $list = new DataObject\Objectbrick\Definition\Listing();
  1025.         $list = $list->load();
  1027.         foreach ($list as $brickDefinition) {
  1028.             $classDefs = $brickDefinition->getClassDefinitions();
  1029.             if (!empty($classDefs)) {
  1030.                 foreach ($classDefs as $classDef) {
  1031.                     if ($classDef['classname'] == $class->getName()) {
  1032.                         $fieldName = $classDef['fieldname'];
  1033.                         if ($filteredFieldDefinition && !$filteredFieldDefinition[$fieldName]) {
  1034.                             continue;
  1035.                         }
  1037.                         $key = $brickDefinition->getKey();
  1039.                         $brickLayoutDefinitions = $brickDefinition->getLayoutDefinitions();
  1040.                         $context = [
  1041.                             'containerType' => 'objectbrick',
  1042.                             'containerKey' => $key,
  1043.                             'outerFieldname' => $fieldName,
  1044.                         ];
  1045.                         DataObject\Service::enrichLayoutDefinition($brickLayoutDefinitions, null, $context);
  1047.                         $result[$key]['nodeLabel'] = $key;
  1048.                         $result[$key]['brickField'] = $fieldName;
  1049.                         $result[$key]['nodeType'] = 'objectbricks';
  1050.                         $result[$key]['childs'] = $brickLayoutDefinitions->getChildren();
  1052.                         break;
  1053.                     }
  1054.                 }
  1055.             }
  1056.         }
  1058.         return $this->adminJson($result);
  1059.     }
  1061.     /**
  1062.      * OBJECT BRICKS
  1063.      */
  1065.     /**
  1066.      * @Route("/objectbrick-get", name="pimcore_admin_dataobject_class_objectbrickget", methods={"GET"})
  1067.      *
  1068.      * @param Request $request
  1069.      *
  1070.      * @return JsonResponse
  1071.      */
  1072.     public function objectbrickGetAction(Request $request)
  1073.     {
  1074.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1076.         $isWriteable = $fc->isWritable();
  1077.         $fc = $fc->getObjectVars();
  1078.         $fc['isWriteable'] = $isWriteable;
  1080.         return $this->adminJson($fc);
  1081.     }
  1083.     /**
  1084.      * @Route("/objectbrick-update", name="pimcore_admin_dataobject_class_objectbrickupdate", methods={"PUT", "POST"})
  1085.      *
  1086.      * @param Request $request
  1087.      * @param EventDispatcherInterface $eventDispatcher
  1088.      *
  1089.      * @return JsonResponse
  1090.      */
  1091.     public function objectbrickUpdateAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1092.     {
  1093.         try {
  1094.             $key = $request->get('key');
  1095.             $title = $request->get('title');
  1096.             $group = $request->get('group');
  1098.             if ($request->get('task') == 'add') {
  1099.                 // check for existing brick with same name with different lower/upper cases
  1100.                 $list = new DataObject\Objectbrick\Definition\Listing();
  1101.                 $list = $list->load();
  1103.                 foreach ($list as $item) {
  1104.                     if (strtolower($key) === strtolower($item->getKey())) {
  1105.                         throw new \Exception('Brick with the same name already exists (lower/upper cases may be different)');
  1106.                     }
  1107.                 }
  1108.             }
  1110.             // now we create a new definition
  1111.             $brickDef = new DataObject\Objectbrick\Definition();
  1112.             $brickDef->setKey($key);
  1113.             $brickDef->setTitle($title);
  1114.             $brickDef->setGroup($group);
  1116.             if ($request->get('values')) {
  1117.                 $values = $this->decodeJson($request->get('values'));
  1119.                 $brickDef->setParentClass($values['parentClass']);
  1120.                 $brickDef->setImplementsInterfaces($values['implementsInterfaces']);
  1121.                 $brickDef->setClassDefinitions($values['classDefinitions']);
  1122.                 $brickDef->setGenerateTypeDeclarations($values['generateTypeDeclarations']);
  1123.             }
  1125.             if ($request->get('configuration')) {
  1126.                 $configuration = $this->decodeJson($request->get('configuration'));
  1128.                 $configuration['datatype'] = 'layout';
  1129.                 $configuration['fieldtype'] = 'panel';
  1131.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  1132.                 $brickDef->setLayoutDefinitions($layout);
  1133.             }
  1135.             $event = new GenericEvent($this, [
  1136.                 'brickDefinition' => $brickDef,
  1137.             ]);
  1138.             $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_UPDATE_DEFINITION);
  1139.             $brickDef = $event->getArgument('brickDefinition');
  1141.             $brickDef->save();
  1143.             return $this->adminJson(['success' => true, 'id' => $brickDef->getKey()]);
  1144.         } catch (\Exception $e) {
  1145.             Logger::error($e->getMessage());
  1147.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1148.         }
  1149.     }
  1151.     /**
  1152.      * @Route("/import-objectbrick", name="pimcore_admin_dataobject_class_importobjectbrick", methods={"POST"})
  1153.      *
  1154.      * @param Request $request
  1155.      *
  1156.      * @return JsonResponse
  1157.      */
  1158.     public function importObjectbrickAction(Request $request)
  1159.     {
  1160.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1162.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  1163.         $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($objectBrick, $data);
  1165.         $response = $this->adminJson([
  1166.             'success' => $success,
  1167.         ]);
  1169.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  1170.         // Ext.form.Action.Submit and mark the submission as failed
  1171.         $response->headers->set('Content-Type', 'text/html');
  1173.         return $response;
  1174.     }
  1176.     /**
  1177.      * @Route("/export-objectbrick", name="pimcore_admin_dataobject_class_exportobjectbrick", methods={"GET"})
  1178.      *
  1179.      * @param Request $request
  1180.      *
  1181.      * @return Response
  1182.      */
  1183.     public function exportObjectbrickAction(Request $request)
  1184.     {
  1185.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1187.         if (!$objectBrick instanceof DataObject\Objectbrick\Definition) {
  1188.             $errorMessage = ': Object-Brick with id [ ' . $request->get('id') . ' not found. ]';
  1189.             Logger::error($errorMessage);
  1191.             throw $this->createNotFoundException($errorMessage);
  1192.         }
  1194.         $xml = DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick);
  1195.         $response = new Response($xml);
  1196.         $response->headers->set('Content-type', 'application/json');
  1197.         $response->headers->set('Content-Disposition', 'attachment; filename="objectbrick_' . $objectBrick->getKey() . '_export.json"');
  1199.         return $response;
  1200.     }
  1202.     /**
  1203.      * @Route("/objectbrick-delete", name="pimcore_admin_dataobject_class_objectbrickdelete", methods={"DELETE"})
  1204.      *
  1205.      * @param Request $request
  1206.      *
  1207.      * @return JsonResponse
  1208.      */
  1209.     public function objectbrickDeleteAction(Request $request)
  1210.     {
  1211.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1212.         $fc->delete();
  1214.         return $this->adminJson(['success' => true]);
  1215.     }
  1217.     /**
  1218.      * @Route("/objectbrick-tree", name="pimcore_admin_dataobject_class_objectbricktree", methods={"GET", "POST"})
  1219.      *
  1220.      * @param Request $request
  1221.      * @param EventDispatcherInterface $eventDispatcher
  1222.      *
  1223.      * @return JsonResponse
  1224.      */
  1225.     public function objectbrickTreeAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1226.     {
  1227.         $list = new DataObject\Objectbrick\Definition\Listing();
  1228.         $list = $list->load();
  1230.         $forObjectEditor = $request->get('forObjectEditor');
  1232.         $layoutDefinitions = [];
  1233.         $groups = [];
  1234.         $definitions = [];
  1235.         $fieldname = null;
  1236.         $className = null;
  1238.         $object = DataObject::getById($request->get('object_id'));
  1240.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1241.             $classId = $request->get('class_id');
  1242.             $fieldname = $request->get('field_name');
  1243.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1244.             $className = $classDefinition->getName();
  1245.         }
  1247.         foreach ($list as $item) {
  1248.             if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1249.                 $keep = false;
  1250.                 $clsDefs = $item->getClassDefinitions();
  1251.                 if (!empty($clsDefs)) {
  1252.                     foreach ($clsDefs as $cd) {
  1253.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1254.                             $keep = true;
  1256.                             continue;
  1257.                         }
  1258.                     }
  1259.                 }
  1260.                 if (!$keep) {
  1261.                     continue;
  1262.                 }
  1263.             }
  1265.             if ($item->getGroup()) {
  1266.                 if (!isset($groups[$item->getGroup()])) {
  1267.                     $groups[$item->getGroup()] = [
  1268.                         'id' => 'group_' . $item->getKey(),
  1269.                         'text' => htmlspecialchars($item->getGroup()),
  1270.                         'expandable' => true,
  1271.                         'leaf' => false,
  1272.                         'allowChildren' => true,
  1273.                         'iconCls' => 'pimcore_icon_folder',
  1274.                         'group' => $item->getGroup(),
  1275.                         'children' => [],
  1276.                     ];
  1277.                 }
  1278.                 if ($forObjectEditor) {
  1279.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  1280.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  1282.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  1283.                 }
  1284.                 $groups[$item->getGroup()]['children'][] =
  1285.                     [
  1286.                         'id' => $item->getKey(),
  1287.                         'text' => $item->getKey(),
  1288.                         'title' => $item->getTitle(),
  1289.                         'key' => $item->getKey(),
  1290.                         'leaf' => true,
  1291.                         'iconCls' => 'pimcore_icon_objectbricks',
  1292.                     ];
  1293.             } else {
  1294.                 if ($forObjectEditor) {
  1295.                     $layout = $item->getLayoutDefinitions();
  1297.                     $currentLayoutId = $request->get('layoutId', null);
  1299.                     $user = $this->getAdminUser();
  1300.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  1301.                         DataObject\Service::createSuperLayout($layout);
  1302.                         $objectData['layout'] = $layout;
  1303.                     }
  1305.                     $context = [
  1306.                         'containerType' => 'objectbrick',
  1307.                         'containerKey' => $item->getKey(),
  1308.                         'outerFieldname' => $request->get('field_name'),
  1309.                     ];
  1311.                     DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1313.                     $layoutDefinitions[$item->getKey()] = $layout;
  1314.                 }
  1315.                 $definitions[] = [
  1316.                     'id' => $item->getKey(),
  1317.                     'text' => $item->getKey(),
  1318.                     'title' => $item->getTitle(),
  1319.                     'key' => $item->getKey(),
  1320.                     'leaf' => true,
  1321.                     'iconCls' => 'pimcore_icon_objectbricks',
  1322.                 ];
  1323.             }
  1324.         }
  1326.         foreach ($groups as $group) {
  1327.             $definitions[] = $group;
  1328.         }
  1330.         $event = new GenericEvent($this, [
  1331.             'list' => $definitions,
  1332.             'objectId' => $request->get('object_id'),
  1333.         ]);
  1334.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA);
  1335.         $definitions = $event->getArgument('list');
  1337.         if ($forObjectEditor) {
  1338.             return $this->adminJson(['objectbricks' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  1339.         } else {
  1340.             return $this->adminJson($definitions);
  1341.         }
  1342.     }
  1344.     /**
  1345.      * @Route("/objectbrick-list", name="pimcore_admin_dataobject_class_objectbricklist", methods={"GET"})
  1346.      *
  1347.      * @param Request $request
  1348.      * @param EventDispatcherInterface $eventDispatcher
  1349.      *
  1350.      * @return JsonResponse
  1351.      */
  1352.     public function objectbrickListAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1353.     {
  1354.         $list = new DataObject\Objectbrick\Definition\Listing();
  1355.         $list = $list->load();
  1357.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1358.             $filteredList = [];
  1359.             $classId = $request->get('class_id');
  1360.             $fieldname = $request->get('field_name');
  1361.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1362.             $className = $classDefinition->getName();
  1364.             foreach ($list as $type) {
  1365.                 $clsDefs = $type->getClassDefinitions();
  1366.                 if (!empty($clsDefs)) {
  1367.                     foreach ($clsDefs as $cd) {
  1368.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1369.                             $filteredList[] = $type;
  1371.                             continue;
  1372.                         }
  1373.                     }
  1374.                 }
  1376.                 $layout = $type->getLayoutDefinitions();
  1378.                 $currentLayoutId = $request->get('layoutId', null);
  1380.                 $user = $this->getAdminUser();
  1381.                 if ($currentLayoutId == -1 && $user->isAdmin()) {
  1382.                     DataObject\Service::createSuperLayout($layout);
  1383.                     $objectData['layout'] = $layout;
  1384.                 }
  1386.                 $context = [
  1387.                     'containerType' => 'objectbrick',
  1388.                     'containerKey' => $type->getKey(),
  1389.                     'outerFieldname' => $request->get('field_name'),
  1390.                 ];
  1392.                 $object = DataObject::getById($request->get('object_id'));
  1394.                 DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1395.                 $type->setLayoutDefinitions($layout);
  1396.             }
  1398.             $list = $filteredList;
  1399.         }
  1401.         $event = new GenericEvent($this, [
  1402.             'list' => $list,
  1403.             'objectId' => $request->get('object_id'),
  1404.         ]);
  1405.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA);
  1406.         $list = $event->getArgument('list');
  1408.         return $this->adminJson(['objectbricks' => $list]);
  1409.     }
  1411.     /**
  1412.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1413.      * Add option to export/import all class definitions/brick definitions etc. at once
  1414.      */
  1416.     /**
  1417.      * @Route("/bulk-import", name="pimcore_admin_dataobject_class_bulkimport", methods={"POST"})
  1418.      *
  1419.      * @param Request $request
  1420.      *
  1421.      * @return JsonResponse
  1422.      */
  1423.     public function bulkImportAction(Request $request)
  1424.     {
  1425.         $result = [];
  1427.         $tmpName = $_FILES['Filedata']['tmp_name'];
  1428.         $json = file_get_contents($tmpName);
  1430.         $tmpName = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/bulk-import-' . uniqid() . '.tmp';
  1431.         file_put_contents($tmpName, $json);
  1433.         Session::useSession(function (AttributeBagInterface $session) use ($tmpName) {
  1434.             $session->set('class_bulk_import_file', $tmpName);
  1435.         }, 'pimcore_objects');
  1437.         $json = json_decode($json, true);
  1439.         foreach ($json as $groupName => $group) {
  1440.             foreach ($group as $groupItem) {
  1441.                 $displayName = null;
  1442.                 $icon = null;
  1444.                 if ($groupName == 'class') {
  1445.                     $name = $groupItem['name'];
  1446.                     $icon = 'class';
  1447.                 } elseif ($groupName == 'customlayout') {
  1448.                     $className = $groupItem['className'];
  1450.                     $layoutData = ['className' => $className, 'name' => $groupItem['name']];
  1451.                     $name = base64_encode(json_encode($layoutData));
  1452.                     $displayName = $className . ' / ' . $groupItem['name'];
  1453.                     $icon = 'custom_views';
  1454.                 } else {
  1455.                     if ($groupName == 'objectbrick') {
  1456.                         $icon = 'objectbricks';
  1457.                     } elseif ($groupName == 'fieldcollection') {
  1458.                         $icon = 'fieldcollection';
  1459.                     }
  1460.                     $name = $groupItem['key'];
  1461.                 }
  1463.                 if (!$displayName) {
  1464.                     $displayName = $name;
  1465.                 }
  1466.                 $result[] = ['icon' => $icon, 'checked' => true, 'type' => $groupName, 'name' => $name, 'displayName' => $displayName];
  1467.             }
  1468.         }
  1470.         $response = $this->adminJson(['success' => true, 'data' => $result]);
  1471.         $response->headers->set('Content-Type', 'text/html');
  1473.         return $response;
  1474.     }
  1476.     /**
  1477.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1478.      * Add option to export/import all class definitions/brick definitions etc. at once
  1479.      */
  1481.     /**
  1482.      * @Route("/bulk-commit", name="pimcore_admin_dataobject_class_bulkcommit", methods={"POST"})
  1483.      *
  1484.      * @param Request $request
  1485.      *
  1486.      * @return JsonResponse
  1487.      *
  1488.      * @throws \Exception
  1489.      */
  1490.     public function bulkCommitAction(Request $request)
  1491.     {
  1492.         $data = json_decode($request->get('data'), true);
  1494.         $session = Session::get('pimcore_objects');
  1495.         $filename = $session->get('class_bulk_import_file');
  1496.         $json = @file_get_contents($filename);
  1497.         $json = json_decode($json, true);
  1499.         $type = $data['type'];
  1500.         $name = $data['name'];
  1501.         $list = $json[$type];
  1503.         foreach ($list as $item) {
  1504.             unset($item['creationDate']);
  1505.             unset($item['modificationDate']);
  1506.             unset($item['userOwner']);
  1507.             unset($item['userModification']);
  1509.             if ($type == 'class' && $item['name'] == $name) {
  1510.                 $class = DataObject\ClassDefinition::getByName($name);
  1511.                 if (!$class) {
  1512.                     $class = new DataObject\ClassDefinition();
  1513.                     $class->setName($name);
  1514.                 }
  1515.                 $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, json_encode($item), true);
  1517.                 return $this->adminJson(['success' => $success !== false]);
  1518.             } elseif ($type == 'objectbrick' && $item['key'] == $name) {
  1519.                 if (!$brick = DataObject\Objectbrick\Definition::getByKey($name)) {
  1520.                     $brick = new DataObject\Objectbrick\Definition();
  1521.                     $brick->setKey($name);
  1522.                 }
  1524.                 $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($brick, json_encode($item), true);
  1526.                 return $this->adminJson(['success' => $success !== false]);
  1527.             } elseif ($type == 'fieldcollection' && $item['key'] == $name) {
  1528.                 if (!$fieldCollection = DataObject\Fieldcollection\Definition::getByKey($name)) {
  1529.                     $fieldCollection = new DataObject\Fieldcollection\Definition();
  1530.                     $fieldCollection->setKey($name);
  1531.                 }
  1533.                 $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, json_encode($item), true);
  1535.                 return $this->adminJson(['success' => $success !== false]);
  1536.             } elseif ($type == 'customlayout') {
  1537.                 $layoutData = json_decode(base64_decode($data['name']), true);
  1538.                 $className = $layoutData['className'];
  1539.                 $layoutName = $layoutData['name'];
  1541.                 if ($item['name'] == $layoutName && $item['className'] == $className) {
  1542.                     $class = DataObject\ClassDefinition::getByName($className);
  1543.                     if (!$class) {
  1544.                         throw new \Exception('Class does not exist');
  1545.                     }
  1547.                     $classId = $class->getId();
  1549.                     $layoutList = new DataObject\ClassDefinition\CustomLayout\Listing();
  1550.                     $db = \Pimcore\Db::get();
  1551.                     $layoutList->setCondition('name = ' . $db->quote($layoutName) . ' AND classId = ' . $classId);
  1552.                     $layoutList = $layoutList->load();
  1554.                     $layoutDefinition = null;
  1555.                     if ($layoutList) {
  1556.                         $layoutDefinition = $layoutList[0];
  1557.                     }
  1559.                     if (!$layoutDefinition) {
  1560.                         $layoutDefinition = new DataObject\ClassDefinition\CustomLayout();
  1561.                         $layoutDefinition->setName($layoutName);
  1562.                         $layoutDefinition->setClassId($classId);
  1563.                     }
  1565.                     try {
  1566.                         $layoutDefinition->setDescription($item['description']);
  1567.                         $layoutDef = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($item['layoutDefinitions'], true);
  1568.                         $layoutDefinition->setLayoutDefinitions($layoutDef);
  1569.                         $layoutDefinition->save();
  1570.                     } catch (\Exception $e) {
  1571.                         Logger::error($e->getMessage());
  1573.                         return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1574.                     }
  1575.                 }
  1576.             }
  1577.         }
  1579.         return $this->adminJson(['success' => true]);
  1580.     }
  1582.     /**
  1583.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1584.      * Add option to export/import all class definitions/brick definitions etc. at once
  1585.      */
  1587.     /**
  1588.      * @Route("/bulk-export-prepare", name="pimcore_admin_dataobject_class_bulkexportprepare", methods={"POST"})
  1589.      *
  1590.      * @param Request $request
  1591.      *
  1592.      * @return Response
  1593.      */
  1594.     public function bulkExportPrepareAction(Request $request)
  1595.     {
  1596.         $data = $request->get('data');
  1598.         Session::useSession(function (AttributeBagInterface $session) use ($data) {
  1599.             $session->set('class_bulk_export_settings', $data);
  1600.         }, 'pimcore_objects');
  1602.         return $this->adminJson(['success' => true]);
  1603.     }
  1605.     /**
  1606.      * @Route("/bulk-export", name="pimcore_admin_dataobject_class_bulkexport", methods={"GET"})
  1607.      *
  1608.      * @param Request $request
  1609.      *
  1610.      * @return Response
  1611.      */
  1612.     public function bulkExportAction(Request $request)
  1613.     {
  1614.         $result = [];
  1616.         $fieldCollections = new DataObject\Fieldcollection\Definition\Listing();
  1617.         $fieldCollections = $fieldCollections->load();
  1619.         foreach ($fieldCollections as $fieldCollection) {
  1620.             $result[] = [
  1621.                 'icon' => 'fieldcollection',
  1622.                 'checked' => true,
  1623.                 'type' => 'fieldcollection',
  1624.                 'name' => $fieldCollection->getKey(),
  1625.                 'displayName' => $fieldCollection->getKey(),
  1626.             ];
  1627.         }
  1629.         $classes = new DataObject\ClassDefinition\Listing();
  1630.         $classes->setOrder('ASC');
  1631.         $classes->setOrderKey('id');
  1632.         $classes = $classes->load();
  1634.         foreach ($classes as $class) {
  1635.             $result[] = [
  1636.                 'icon' => 'class',
  1637.                 'checked' => true,
  1638.                 'type' => 'class',
  1639.                 'name' => $class->getName(),
  1640.                 'displayName' => $class->getName(),
  1641.             ];
  1642.         }
  1644.         $objectBricks = new DataObject\Objectbrick\Definition\Listing();
  1645.         $objectBricks = $objectBricks->load();
  1647.         foreach ($objectBricks as $objectBrick) {
  1648.             $result[] = [
  1649.                 'icon' => 'objectbricks',
  1650.                 'checked' => true,
  1651.                 'type' => 'objectbrick',
  1652.                 'name' => $objectBrick->getKey(),
  1653.                 'displayName' => $objectBrick->getKey(),
  1654.             ];
  1655.         }
  1657.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  1658.         $customLayouts = $customLayouts->load();
  1659.         foreach ($customLayouts as $customLayout) {
  1660.             $class = DataObject\ClassDefinition::getById($customLayout->getClassId());
  1661.             $displayName = $class->getName() . ' / ' .  $customLayout->getName();
  1663.             $result[] = [
  1664.                 'icon' => 'custom_views',
  1665.                 'checked' => true,
  1666.                 'type' => 'customlayout',
  1667.                 'name' => $customLayout->getId(),
  1668.                 'displayName' => $displayName,
  1669.             ];
  1670.         }
  1672.         return new JsonResponse(['success' => true, 'data' => $result]);
  1673.     }
  1675.     /**
  1676.      * @Route("/do-bulk-export", name="pimcore_admin_dataobject_class_dobulkexport", methods={"GET"})
  1677.      *
  1678.      * @param Request $request
  1679.      *
  1680.      * @return Response
  1681.      */
  1682.     public function doBulkExportAction(Request $request)
  1683.     {
  1684.         $session = Session::get('pimcore_objects');
  1685.         $list = $session->get('class_bulk_export_settings');
  1686.         $list = json_decode($list, true);
  1687.         $result = [];
  1689.         foreach ($list as $item) {
  1690.             if ($item['type'] == 'fieldcollection') {
  1691.                 $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($item['name']);
  1692.                 $key = $fieldCollection->getKey();
  1693.                 $fieldCollectionJson = json_decode(DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection));
  1694.                 $fieldCollectionJson->key = $key;
  1695.                 $result['fieldcollection'][] = $fieldCollectionJson;
  1696.             } elseif ($item['type'] == 'class') {
  1697.                 $class = DataObject\ClassDefinition::getByName($item['name']);
  1698.                 $data = json_decode(json_encode($class));
  1699.                 unset($data->fieldDefinitions);
  1700.                 $result['class'][] = $data;
  1701.             } elseif ($item['type'] == 'objectbrick') {
  1702.                 $objectBrick = DataObject\Objectbrick\Definition::getByKey($item['name']);
  1703.                 $key = $objectBrick->getKey();
  1704.                 $objectBrickJson = json_decode(DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick));
  1705.                 $objectBrickJson->key = $key;
  1706.                 $result['objectbrick'][] = $objectBrickJson;
  1707.             } elseif ($item['type'] == 'customlayout') {
  1708.                 /** @var DataObject\ClassDefinition\CustomLayout $customLayout */
  1709.                 $customLayout = DataObject\ClassDefinition\CustomLayout::getById($item['name']);
  1710.                 $classId = $customLayout->getClassId();
  1711.                 $class = DataObject\ClassDefinition::getById($classId);
  1712.                 $customLayout = $customLayout->getObjectVars();
  1713.                 $customLayout['className'] = $class->getName();
  1714.                 $result['customlayout'][] = $customLayout;
  1715.             }
  1716.         }
  1718.         $result = json_encode($result, JSON_PRETTY_PRINT);
  1719.         $response = new Response($result);
  1720.         $response->headers->set('Content-type', 'application/json');
  1721.         $response->headers->set('Content-Disposition', 'attachment; filename="bulk_export.json"');
  1723.         return $response;
  1724.     }
  1726.     /**
  1727.      * @param ControllerEvent $event
  1728.      */
  1729.     public function onKernelControllerEvent(ControllerEvent $event)
  1730.     {
  1731.         if (!$event->isMainRequest()) {
  1732.             return;
  1733.         }
  1735.         // check permissions
  1736.         $unrestrictedActions = [
  1737.             'getTreeAction', 'fieldcollectionListAction', 'fieldcollectionTreeAction', 'fieldcollectionGetAction',
  1738.             'getClassDefinitionForColumnConfigAction', 'objectbrickListAction', 'objectbrickTreeAction', 'objectbrickGetAction',
  1739.         ];
  1741.         $this->checkActionPermission($event, 'classes', $unrestrictedActions);
  1742.     }
  1744.     /**
  1745.      * @Route("/get-fieldcollection-usages", name="pimcore_admin_dataobject_class_getfieldcollectionusages", methods={"GET"})
  1746.      *
  1747.      * @param Request $request
  1748.      *
  1749.      * @return Response
  1750.      */
  1751.     public function getFieldcollectionUsagesAction(Request $request)
  1752.     {
  1753.         $key = $request->get('key');
  1754.         $result = [];
  1756.         $classes = new DataObject\ClassDefinition\Listing();
  1757.         $classes = $classes->load();
  1758.         foreach ($classes as $class) {
  1759.             $fieldDefs = $class->getFieldDefinitions();
  1760.             foreach ($fieldDefs as $fieldDef) {
  1761.                 if ($fieldDef instanceof DataObject\ClassDefinition\Data\Fieldcollections) {
  1762.                     $allowedKeys = $fieldDef->getAllowedTypes();
  1763.                     if (is_array($allowedKeys) && in_array($key, $allowedKeys)) {
  1764.                         $result[] = [
  1765.                             'class' => $class->getName(),
  1766.                             'field' => $fieldDef->getName(),
  1767.                         ];
  1768.                     }
  1769.                 }
  1770.             }
  1771.         }
  1773.         return $this->adminJson($result);
  1774.     }
  1776.     /**
  1777.      * @Route("/get-bricks-usages", name="pimcore_admin_dataobject_class_getbrickusages", methods={"GET"})
  1778.      *
  1779.      * @param Request $request
  1780.      *
  1781.      * @return Response
  1782.      */
  1783.     public function getBrickUsagesAction(Request $request)
  1784.     {
  1785.         $classId = $request->get('classId');
  1786.         $myclass = DataObject\ClassDefinition::getById($classId);
  1788.         $result = [];
  1790.         $brickDefinitions = new DataObject\Objectbrick\Definition\Listing();
  1791.         $brickDefinitions = $brickDefinitions->load();
  1792.         foreach ($brickDefinitions as $brickDefinition) {
  1793.             $classes = $brickDefinition->getClassDefinitions();
  1794.             foreach ($classes as $class) {
  1795.                 if ($myclass->getName() == $class['classname']) {
  1796.                     $result[] = [
  1797.                         'objectbrick' => $brickDefinition->getKey(),
  1798.                         'field' => $class['fieldname'],
  1799.                     ];
  1800.                 }
  1801.             }
  1802.         }
  1804.         return $this->adminJson($result);
  1805.     }
  1807.     /**
  1808.      * @Route("/get-icons", name="pimcore_admin_dataobject_class_geticons", methods={"GET"})
  1809.      *
  1810.      * @param Request $request
  1811.      * @param EventDispatcherInterface $eventDispatcher
  1812.      *
  1813.      * @return Response
  1814.      */
  1815.     public function getIconsAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1816.     {
  1817.         $classId = $request->get('classId');
  1819.         $iconDir = PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/img';
  1820.         $classIcons = rscandir($iconDir . '/object-icons/');
  1821.         $colorIcons = rscandir($iconDir . '/flat-color-icons/');
  1822.         $twemoji = rscandir($iconDir . '/twemoji/');
  1824.         $icons = array_merge($classIcons, $colorIcons, $twemoji);
  1826.         foreach ($icons as &$icon) {
  1827.             $icon = str_replace(PIMCORE_WEB_ROOT, '', $icon);
  1828.         }
  1830.         $event = new GenericEvent($this, [
  1831.             'icons' => $icons,
  1832.             'classId' => $classId,
  1833.         ]);
  1834.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECT_ICONS_PRE_SEND_DATA);
  1835.         $icons = $event->getArgument('icons');
  1837.         $result = [];
  1838.         foreach ($icons as $icon) {
  1839.             $content = file_get_contents(PIMCORE_WEB_ROOT . $icon);
  1840.             $result[] = [
  1841.                 'text' => sprintf('<img src="data:%s;base64,%s"/>', mime_content_type(PIMCORE_WEB_ROOT . $icon), base64_encode($content)),
  1842.                 'value' => $icon,
  1843.             ];
  1844.         }
  1846.         return $this->adminJson($result);
  1847.     }
  1849.     /**
  1850.      * @Route("/suggest-class-identifier", name="pimcore_admin_dataobject_class_suggestclassidentifier")
  1851.      *
  1852.      * @return Response
  1853.      */
  1854.     public function suggestClassIdentifierAction()
  1855.     {
  1856.         $db = Db::get();
  1857.         $maxId = $db->fetchOne('SELECT MAX(CAST(id AS SIGNED)) FROM classes;');
  1859.         $existingIds = $db->fetchCol('select LOWER(id) from classes');
  1861.         $result = [
  1862.             'suggestedIdentifier' => $maxId ? $maxId + 1 : 1,
  1863.             'existingIds' => $existingIds,
  1864.             ];
  1866.         return $this->adminJson($result);
  1867.     }
  1869.     /**
  1870.      * @Route("/suggest-custom-layout-identifier", name="pimcore_admin_dataobject_class_suggestcustomlayoutidentifier")
  1871.      *
  1872.      * @param Request $request
  1873.      *
  1874.      * @return Response
  1875.      */
  1876.     public function suggestCustomLayoutIdentifierAction(Request $request)
  1877.     {
  1878.         $classId = $request->get('classId');
  1880.         $identifier = DataObject\ClassDefinition\CustomLayout::getIdentifier($classId);
  1882.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  1884.         $list = $list->load();
  1885.         $existingIds = [];
  1886.         $existingNames = [];
  1888.         foreach ($list as $item) {
  1889.             $existingIds[] = $item->getId();
  1890.             if ($item->getClassId() == $classId) {
  1891.                 $existingNames[] = $item->getName();
  1892.             }
  1893.         }
  1895.         $result = [
  1896.             'suggestedIdentifier' => $identifier,
  1897.             'existingIds' => $existingIds,
  1898.             'existingNames' => $existingNames,
  1899.             ];
  1901.         return $this->adminJson($result);
  1902.     }
  1904.     /**
  1905.      * @Route("/text-layout-preview", name="pimcore_admin_dataobject_class_textlayoutpreview")
  1906.      *
  1907.      * @param Request $request
  1908.      *
  1909.      * @return Response
  1910.      */
  1911.     public function textLayoutPreviewAction(Request $request)
  1912.     {
  1913.         $objPath = $request->get('previewObject', '');
  1914.         $className = '\\Pimcore\\Model\\DataObject\\' . $request->get('className');
  1915.         $obj = DataObject::getByPath($objPath) ?? new $className();
  1917.         $textLayout = new DataObject\ClassDefinition\Layout\Text();
  1919.         $context = [
  1920.           'data' => $request->get('renderingData'),
  1921.         ];
  1923.         if ($renderingClass = $request->get('renderingClass')) {
  1924.             $textLayout->setRenderingClass($renderingClass);
  1925.         }
  1927.         if ($staticHtml = $request->get('html')) {
  1928.             $textLayout->setHtml($staticHtml);
  1929.         }
  1931.         $html = $textLayout->enrichLayoutDefinition($obj, $context)->getHtml();
  1933.         $content =
  1934.             "<html>\n" .
  1935.             "<head>\n" .
  1936.             '<style type="text/css">' . "\n" .
  1937.             file_get_contents(PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/css/admin.css') .
  1938.             "</style>\n" .
  1939.             "</head>\n\n" .
  1940.             "<body class='objectlayout_element_text'>\n" .
  1941.             $html .
  1942.             "\n\n</body>\n" .
  1943.             "</html>\n";
  1945.         $response = new Response($content);
  1946.         $response->headers->set('Content-Type', 'text/html');
  1948.         return $response;
  1949.     }
  1950. }