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

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", name="pimcore_admin_dataobject_class_")
  39.  *
  40.  * @internal
  41.  */
  42. class ClassController extends AdminController implements KernelControllerEventInterface
  43. {
  44.     /**
  45.      * @Route("/get-document-types", name="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="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="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="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.         if (!$class) {
  228.             throw $this->createNotFoundException();
  229.         }
  230.         $class->setFieldDefinitions([]);
  231.         $isWriteable = $class->isWritable();
  232.         $class = $class->getObjectVars();
  233.         $class['isWriteable'] = $isWriteable;
  235.         return $this->adminJson($class);
  236.     }
  238.     /**
  239.      * @Route("/get-custom-layout", name="getcustomlayout", methods={"GET"})
  240.      *
  241.      * @param Request $request
  242.      *
  243.      * @return JsonResponse
  244.      */
  245.     public function getCustomLayoutAction(Request $request)
  246.     {
  247.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  248.         if (!$customLayout) {
  249.             $brickLayoutSeparator = strpos($request->get('id'), '.brick.');
  250.             if ($brickLayoutSeparator !== false) {
  251.                 $customLayout = DataObject\ClassDefinition\CustomLayout::getById(substr($request->get('id'), 0, $brickLayoutSeparator));
  252.                 if ($customLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  253.                     $customLayout = DataObject\ClassDefinition\CustomLayout::create(
  254.                         [
  255.                             'name' => $customLayout->getName().' '.substr($request->get('id'), $brickLayoutSeparator+strlen('.brick.')),
  256.                             'userOwner' => $this->getAdminUser()->getId(),
  257.                             'classId' => $customLayout->getClassId(),
  258.                         ]
  259.                     );
  261.                     $customLayout->setId($request->get('id'));
  262.                     $customLayout->save();
  263.                 }
  264.             }
  266.             if (!$customLayout) {
  267.                 throw $this->createNotFoundException();
  268.             }
  269.         }
  270.         $isWriteable = $customLayout->isWritable();
  271.         $customLayout = $customLayout->getObjectVars();
  272.         $customLayout['isWriteable'] = $isWriteable;
  274.         return $this->adminJson(['success' => true, 'data' => $customLayout]);
  275.     }
  277.     /**
  278.      * @Route("/add", name="add", methods={"POST"})
  279.      *
  280.      * @param Request $request
  281.      *
  282.      * @return JsonResponse
  283.      */
  284.     public function addAction(Request $request)
  285.     {
  286.         $className = $request->get('className');
  287.         $className = $this->correctClassname($className);
  289.         $classId = $request->get('classIdentifier');
  290.         $existingClass = DataObject\ClassDefinition::getById($classId);
  291.         if ($existingClass) {
  292.             throw new \Exception('Class identifier already exists');
  293.         }
  295.         $class = DataObject\ClassDefinition::create(
  296.             ['name' => $className,
  297.                 'userOwner' => $this->getAdminUser()->getId(), ]
  298.         );
  300.         $class->setId($classId);
  302.         $class->save(true);
  304.         return $this->adminJson(['success' => true, 'id' => $class->getId()]);
  305.     }
  307.     /**
  308.      * @Route("/add-custom-layout", name="addcustomlayout", methods={"POST"})
  309.      *
  310.      * @param Request $request
  311.      *
  312.      * @return JsonResponse
  313.      */
  314.     public function addCustomLayoutAction(Request $request)
  315.     {
  316.         $layoutId = $request->get('layoutIdentifier');
  317.         $existingLayout = DataObject\ClassDefinition\CustomLayout::getById($layoutId);
  318.         if ($existingLayout) {
  319.             throw new \Exception('Custom Layout identifier already exists');
  320.         }
  322.         $customLayout = DataObject\ClassDefinition\CustomLayout::create(
  323.             [
  324.                 'name' => $request->get('layoutName'),
  325.                 'userOwner' => $this->getAdminUser()->getId(),
  326.                 'classId' => $request->get('classId'),
  327.             ]
  328.         );
  330.         $customLayout->setId($layoutId);
  331.         $customLayout->save();
  333.         $isWriteable = $customLayout->isWritable();
  334.         $data = $customLayout->getObjectVars();
  335.         $data['isWriteable'] = $isWriteable;
  337.         return $this->adminJson(['success' => true, 'id' => $customLayout->getId(), 'name' => $customLayout->getName(),
  338.                                  'data' => $data, ]);
  339.     }
  341.     /**
  342.      * @Route("/delete", name="delete", methods={"DELETE"})
  343.      *
  344.      * @param Request $request
  345.      *
  346.      * @return Response
  347.      */
  348.     public function deleteAction(Request $request)
  349.     {
  350.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  351.         if ($class) {
  352.             $class->delete();
  353.         }
  355.         return new Response();
  356.     }
  358.     /**
  359.      * @Route("/delete-custom-layout", name="deletecustomlayout", methods={"DELETE"})
  360.      *
  361.      * @param Request $request
  362.      *
  363.      * @return JsonResponse
  364.      */
  365.     public function deleteCustomLayoutAction(Request $request)
  366.     {
  367.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  368.         $id = $request->get('id');
  369.         $customLayouts->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($id) {
  370.             $currentLayoutId = $layout->getId();
  372.             return $currentLayoutId === $id || str_starts_with($currentLayoutId, $id . '.brick.');
  373.         });
  375.         foreach ($customLayouts->getLayoutDefinitions() as $customLayout) {
  376.             $customLayout->delete();
  377.         }
  379.         return $this->adminJson(['success' => true]);
  380.     }
  382.     /**
  383.      * @Route("/save-custom-layout", name="savecustomlayout", methods={"PUT"})
  384.      *
  385.      * @param Request $request
  386.      *
  387.      * @return JsonResponse
  388.      */
  389.     public function saveCustomLayoutAction(Request $request)
  390.     {
  391.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  392.         if (!$customLayout) {
  393.             throw $this->createNotFoundException();
  394.         }
  396.         $configuration = $this->decodeJson($request->get('configuration'));
  397.         $values = $this->decodeJson($request->get('values'));
  399.         $modificationDate = (int)$values['modificationDate'];
  400.         if ($modificationDate < $customLayout->getModificationDate()) {
  401.             return $this->adminJson(['success' => false, 'msg' => 'custom_layout_changed']);
  402.         }
  404.         $configuration['datatype'] = 'layout';
  405.         $configuration['fieldtype'] = 'panel';
  406.         $configuration['name'] = 'pimcore_root';
  408.         try {
  409.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  410.             $customLayout->setLayoutDefinitions($layout);
  411.             $customLayout->setName($values['name']);
  412.             $customLayout->setDescription($values['description']);
  413.             $customLayout->setDefault($values['default']);
  414.             $customLayout->save();
  416.             return $this->adminJson(['success' => true, 'id' => $customLayout->getId(), 'data' => $customLayout->getObjectVars()]);
  417.         } catch (\Exception $e) {
  418.             Logger::error($e->getMessage());
  420.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  421.         }
  422.     }
  424.     /**
  425.      * @Route("/save", name="save", methods={"PUT"})
  426.      *
  427.      * @param Request $request
  428.      *
  429.      * @return JsonResponse
  430.      *
  431.      * @throws \Exception
  432.      */
  433.     public function saveAction(Request $request)
  434.     {
  435.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  436.         if (!$class) {
  437.             throw $this->createNotFoundException();
  438.         }
  440.         $configuration = $this->decodeJson($request->get('configuration'));
  441.         $values = $this->decodeJson($request->get('values'));
  443.         // check if the class was changed during editing in the frontend
  444.         if ($class->getModificationDate() != $values['modificationDate']) {
  445.             throw new \Exception('The class was modified during editing, please reload the class and make your changes again');
  446.         }
  448.         if ($values['name'] != $class->getName()) {
  449.             $classByName = DataObject\ClassDefinition::getByName($values['name']);
  450.             if ($classByName && $classByName->getId() != $class->getId()) {
  451.                 throw new \Exception('Class name already exists');
  452.             }
  454.             $values['name'] = $this->correctClassname($values['name']);
  455.             $class->rename($values['name']);
  456.         }
  458.         if ($values['compositeIndices']) {
  459.             foreach ($values['compositeIndices'] as $index => $compositeIndex) {
  460.                 if ($compositeIndex['index_key'] !== ($sanitizedKey = preg_replace('/[^a-za-z0-9_\-+]/', '', $compositeIndex['index_key']))) {
  461.                     $values['compositeIndices'][$index]['index_key'] = $sanitizedKey;
  462.                 }
  463.             }
  464.         }
  466.         unset($values['creationDate']);
  467.         unset($values['userOwner']);
  468.         unset($values['layoutDefinitions']);
  469.         unset($values['fieldDefinitions']);
  471.         $configuration['datatype'] = 'layout';
  472.         $configuration['fieldtype'] = 'panel';
  473.         $configuration['name'] = 'pimcore_root';
  475.         $class->setValues($values);
  477.         try {
  478.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  480.             $class->setLayoutDefinitions($layout);
  482.             $class->setUserModification($this->getAdminUser()->getId());
  483.             $class->setModificationDate(time());
  485.             $propertyVisibility = [];
  486.             foreach ($values as $key => $value) {
  487.                 if (preg_match('/propertyVisibility/i', $key)) {
  488.                     if (preg_match("/\.grid\./i", $key)) {
  489.                         $propertyVisibility['grid'][preg_replace("/propertyVisibility\.grid\./i", '', $key)] = (bool) $value;
  490.                     } elseif (preg_match("/\.search\./i", $key)) {
  491.                         $propertyVisibility['search'][preg_replace("/propertyVisibility\.search\./i", '', $key)] = (bool) $value;
  492.                     }
  493.                 }
  494.             }
  495.             if (!empty($propertyVisibility)) {
  496.                 $class->setPropertyVisibility($propertyVisibility);
  497.             }
  499.             $class->save();
  501.             // set the fielddefinitions to [] because we don't need them in the response
  502.             $class->setFieldDefinitions([]);
  504.             return $this->adminJson(['success' => true, 'class' => $class]);
  505.         } catch (\Exception $e) {
  506.             Logger::error($e->getMessage());
  508.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  509.         }
  510.     }
  512.     /**
  513.      * @param string $name
  514.      *
  515.      * @return string
  516.      */
  517.     protected function correctClassname($name)
  518.     {
  519.         $name = preg_replace('/[^a-zA-Z0-9_]+/', '', $name);
  520.         $name = preg_replace('/^[0-9]+/', '', $name);
  522.         return $name;
  523.     }
  525.     /**
  526.      * @Route("/import-class", name="importclass", methods={"POST", "PUT"})
  527.      *
  528.      * @param Request $request
  529.      *
  530.      * @return Response
  531.      */
  532.     public function importClassAction(Request $request)
  533.     {
  534.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  535.         if (!$class) {
  536.             throw $this->createNotFoundException();
  537.         }
  538.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  540.         $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, $json, false, true);
  542.         $response = $this->adminJson([
  543.             'success' => $success,
  544.         ]);
  545.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  546.         // Ext.form.Action.Submit and mark the submission as failed
  547.         $response->headers->set('Content-Type', 'text/html');
  549.         return $response;
  550.     }
  552.     /**
  553.      * @Route("/import-custom-layout-definition", name="importcustomlayoutdefinition", methods={"POST", "PUT"})
  554.      *
  555.      * @param Request $request
  556.      *
  557.      * @return Response
  558.      */
  559.     public function importCustomLayoutDefinitionAction(Request $request)
  560.     {
  561.         $success = false;
  562.         $responseContent = [];
  563.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  564.         $importData = $this->decodeJson($json);
  566.         $existingLayout = null;
  567.         if (isset($importData['name'])) {
  568.             $existingLayout = DataObject\ClassDefinition\CustomLayout::getByName($importData['name']);
  570.             if ($existingLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  571.                 $responseContent['nameAlreadyInUse'] = true;
  572.             }
  573.         }
  575.         if (!$existingLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  576.             $customLayoutId = $request->get('id');
  577.             $customLayout = DataObject\ClassDefinition\CustomLayout::getById($customLayoutId);
  578.             if ($customLayout) {
  579.                 try {
  580.                     $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($importData['layoutDefinitions'], true);
  581.                     $customLayout->setLayoutDefinitions($layout);
  582.                     if (isset($importData['name']) === true) {
  583.                         $customLayout->setName($importData['name']);
  584.                     }
  585.                     $customLayout->setDescription($importData['description']);
  586.                     $customLayout->save();
  587.                     $success = true;
  588.                 } catch (\Exception $e) {
  589.                     Logger::error($e->getMessage());
  590.                 }
  591.             }
  593.             $responseContent['success'] = $success;
  594.         }
  596.         $response = $this->adminJson($responseContent);
  598.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  599.         // Ext.form.Action.Submit and mark the submission as failed
  600.         $response->headers->set('Content-Type', 'text/html');
  602.         return $response;
  603.     }
  605.     /**
  606.      * @Route("/get-custom-layout-definitions", name="getcustomlayoutdefinitions", methods={"GET"})
  607.      *
  608.      * @param Request $request
  609.      *
  610.      * @return JsonResponse
  611.      */
  612.     public function getCustomLayoutDefinitionsAction(Request $request)
  613.     {
  614.         $classIds = explode(',', $request->get('classId'));
  615.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  617.         $list->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($classIds) {
  618.             return in_array($layout->getClassId(), $classIds) && !str_contains($layout->getId(), '.brick.');
  619.         });
  620.         $list = $list->load();
  621.         $result = [];
  622.         foreach ($list as $item) {
  623.             $result[] = [
  624.                 'id' => $item->getId(),
  625.                 'name' => $item->getName() . ' (ID: ' . $item->getId() . ')',
  626.                 'default' => $item->getDefault() ?: 0,
  627.             ];
  628.         }
  630.         return $this->adminJson(['success' => true, 'data' => $result]);
  631.     }
  633.     /**
  634.      * @Route("/get-all-layouts", name="getalllayouts", methods={"GET"})
  635.      *
  636.      * @param Request $request
  637.      *
  638.      * @return JsonResponse
  639.      */
  640.     public function getAllLayoutsAction(Request $request)
  641.     {
  642.         // get all classes
  643.         $resultList = [];
  644.         $mapping = [];
  646.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  647.         $customLayouts->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) {
  648.             return !str_contains($layout->getId(), '.brick.');
  649.         });
  650.         $customLayouts->setOrder(function (DataObject\ClassDefinition\CustomLayout $a, DataObject\ClassDefinition\CustomLayout $b) {
  651.             return strcmp($a->getName(), $b->getName());
  652.         });
  654.         $customLayouts = $customLayouts->load();
  655.         foreach ($customLayouts as $layout) {
  656.             $mapping[$layout->getClassId()][] = $layout;
  657.         }
  659.         $classList = new DataObject\ClassDefinition\Listing();
  660.         $classList->setOrder('ASC');
  661.         $classList->setOrderKey('name');
  662.         $classList = $classList->load();
  664.         foreach ($classList as $class) {
  665.             if (isset($mapping[$class->getId()])) {
  666.                 $classMapping = $mapping[$class->getId()];
  667.                 $resultList[] = [
  668.                     'type' => 'master',
  669.                     'id' => $class->getId() . '_' . 0,
  670.                     'name' => $class->getName(),
  671.                 ];
  673.                 foreach ($classMapping as $layout) {
  674.                     $resultList[] = [
  675.                         'type' => 'custom',
  676.                         'id' => $class->getId() . '_' . $layout->getId(),
  677.                         'name' => $class->getName() . ' - ' . $layout->getName(),
  678.                     ];
  679.                 }
  680.             }
  681.         }
  683.         return $this->adminJson(['data' => $resultList]);
  684.     }
  686.     /**
  687.      * @Route("/export-class", name="exportclass", methods={"GET"})
  688.      *
  689.      * @param Request $request
  690.      *
  691.      * @return Response
  692.      */
  693.     public function exportClassAction(Request $request)
  694.     {
  695.         $id = $request->get('id');
  696.         $class = DataObject\ClassDefinition::getById($id);
  698.         if (!$class instanceof DataObject\ClassDefinition) {
  699.             $errorMessage = ': Class with id [ ' . $id . ' not found. ]';
  700.             Logger::error($errorMessage);
  702.             throw $this->createNotFoundException($errorMessage);
  703.         }
  705.         $json = DataObject\ClassDefinition\Service::generateClassDefinitionJson($class);
  707.         $response = new Response($json);
  708.         $response->headers->set('Content-type', 'application/json');
  709.         $response->headers->set('Content-Disposition', 'attachment; filename="class_' . $class->getName() . '_export.json"');
  711.         return $response;
  712.     }
  714.     /**
  715.      * @Route("/export-custom-layout-definition", name="exportcustomlayoutdefinition", methods={"GET"})
  716.      *
  717.      * @param Request $request
  718.      *
  719.      * @return Response
  720.      */
  721.     public function exportCustomLayoutDefinitionAction(Request $request)
  722.     {
  723.         $id = $request->get('id');
  725.         if ($id) {
  726.             $customLayout = DataObject\ClassDefinition\CustomLayout::getById($id);
  727.             if ($customLayout) {
  728.                 $name = $customLayout->getName();
  729.                 $json = DataObject\ClassDefinition\Service::generateCustomLayoutJson($customLayout);
  731.                 $response = new Response($json);
  732.                 $response->headers->set('Content-type', 'application/json');
  733.                 $response->headers->set('Content-Disposition', 'attachment; filename="custom_definition_' . $name . '_export.json"');
  735.                 return $response;
  736.             }
  737.         }
  739.         $errorMessage = ': Custom Layout with id [ ' . $id . ' not found. ]';
  740.         Logger::error($errorMessage);
  742.         throw $this->createNotFoundException($errorMessage);
  743.     }
  745.     /**
  746.      * FIELDCOLLECTIONS
  747.      */
  749.     /**
  750.      * @Route("/fieldcollection-get", name="fieldcollectionget", methods={"GET"})
  751.      *
  752.      * @param Request $request
  753.      *
  754.      * @return JsonResponse
  755.      */
  756.     public function fieldcollectionGetAction(Request $request)
  757.     {
  758.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  760.         $isWriteable = $fc->isWritable();
  761.         $fc = $fc->getObjectVars();
  762.         $fc['isWriteable'] = $isWriteable;
  764.         return $this->adminJson($fc);
  765.     }
  767.     /**
  768.      * @Route("/fieldcollection-update", name="fieldcollectionupdate", methods={"PUT", "POST"})
  769.      *
  770.      * @param Request $request
  771.      *
  772.      * @return JsonResponse
  773.      */
  774.     public function fieldcollectionUpdateAction(Request $request)
  775.     {
  776.         try {
  777.             $key = $request->get('key');
  778.             $title = $request->get('title');
  779.             $group = $request->get('group');
  781.             if ($request->get('task') == 'add') {
  782.                 // check for existing fieldcollection with same name with different lower/upper cases
  783.                 $list = new DataObject\Fieldcollection\Definition\Listing();
  784.                 $list = $list->load();
  786.                 foreach ($list as $item) {
  787.                     if (strtolower($key) === strtolower($item->getKey())) {
  788.                         throw new \Exception('FieldCollection with the same name already exists (lower/upper cases may be different)');
  789.                     }
  790.                 }
  791.             }
  793.             $fcDef = new DataObject\Fieldcollection\Definition();
  794.             $fcDef->setKey($key);
  795.             $fcDef->setTitle($title);
  796.             $fcDef->setGroup($group);
  798.             if ($request->get('values')) {
  799.                 $values = $this->decodeJson($request->get('values'));
  800.                 $fcDef->setParentClass($values['parentClass']);
  801.                 $fcDef->setImplementsInterfaces($values['implementsInterfaces']);
  802.                 $fcDef->setGenerateTypeDeclarations($values['generateTypeDeclarations']);
  803.             }
  805.             if ($request->get('configuration')) {
  806.                 $configuration = $this->decodeJson($request->get('configuration'));
  808.                 $configuration['datatype'] = 'layout';
  809.                 $configuration['fieldtype'] = 'panel';
  811.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  812.                 $fcDef->setLayoutDefinitions($layout);
  813.             }
  815.             $fcDef->save();
  817.             return $this->adminJson(['success' => true, 'id' => $fcDef->getKey()]);
  818.         } catch (\Exception $e) {
  819.             Logger::error($e->getMessage());
  821.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  822.         }
  823.     }
  825.     /**
  826.      * @Route("/import-fieldcollection", name="importfieldcollection", methods={"POST"})
  827.      *
  828.      * @param Request $request
  829.      *
  830.      * @return Response
  831.      */
  832.     public function importFieldcollectionAction(Request $request)
  833.     {
  834.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  836.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  838.         $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, $data);
  840.         $response = $this->adminJson([
  841.             'success' => $success,
  842.         ]);
  844.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  845.         // Ext.form.Action.Submit and mark the submission as failed
  846.         $response->headers->set('Content-Type', 'text/html');
  848.         return $response;
  849.     }
  851.     /**
  852.      * @Route("/export-fieldcollection", name="exportfieldcollection", methods={"GET"})
  853.      *
  854.      * @param Request $request
  855.      *
  856.      * @return Response
  857.      */
  858.     public function exportFieldcollectionAction(Request $request)
  859.     {
  860.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  862.         if (!$fieldCollection instanceof DataObject\Fieldcollection\Definition) {
  863.             $errorMessage = ': Field-Collection with id [ ' . $request->get('id') . ' not found. ]';
  864.             Logger::error($errorMessage);
  866.             throw $this->createNotFoundException($errorMessage);
  867.         }
  869.         $json = DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection);
  870.         $response = new Response($json);
  871.         $response->headers->set('Content-type', 'application/json');
  872.         $response->headers->set('Content-Disposition', 'attachment; filename="fieldcollection_' . $fieldCollection->getKey() . '_export.json"');
  874.         return $response;
  875.     }
  877.     /**
  878.      * @Route("/fieldcollection-delete", name="fieldcollectiondelete", methods={"DELETE"})
  879.      *
  880.      * @param Request $request
  881.      *
  882.      * @return JsonResponse
  883.      */
  884.     public function fieldcollectionDeleteAction(Request $request)
  885.     {
  886.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  887.         $fc->delete();
  889.         return $this->adminJson(['success' => true]);
  890.     }
  892.     /**
  893.      * @Route("/fieldcollection-tree", name="fieldcollectiontree", methods={"GET", "POST"})
  894.      *
  895.      * @param Request $request
  896.      * @param EventDispatcherInterface $eventDispatcher
  897.      *
  898.      * @return JsonResponse
  899.      */
  900.     public function fieldcollectionTreeAction(Request $request, EventDispatcherInterface $eventDispatcher)
  901.     {
  902.         $list = new DataObject\Fieldcollection\Definition\Listing();
  903.         $list = $list->load();
  905.         $forObjectEditor = $request->get('forObjectEditor');
  907.         $layoutDefinitions = [];
  909.         $definitions = [];
  911.         $allowedTypes = null;
  912.         if ($request->query->has('allowedTypes')) {
  913.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  914.         }
  915.         $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  917.         $currentLayoutId = $request->get('layoutId', null);
  918.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  920.         $groups = [];
  921.         foreach ($list as $item) {
  922.             if ($allowedTypes && !in_array($item->getKey(), $allowedTypes)) {
  923.                 continue;
  924.             }
  926.             if ($item->getGroup()) {
  927.                 if (!isset($groups[$item->getGroup()])) {
  928.                     $groups[$item->getGroup()] = [
  929.                         'id' => 'group_' . $item->getKey(),
  930.                         'text' => htmlspecialchars($item->getGroup()),
  931.                         'expandable' => true,
  932.                         'leaf' => false,
  933.                         'allowChildren' => true,
  934.                         'iconCls' => 'pimcore_icon_folder',
  935.                         'group' => $item->getGroup(),
  936.                         'children' => [],
  937.                     ];
  938.                 }
  939.                 if ($forObjectEditor) {
  940.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  941.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  943.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  944.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  945.                     }
  946.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  947.                 }
  948.                 $groups[$item->getGroup()]['children'][] =
  949.                     [
  950.                         'id' => $item->getKey(),
  951.                         'text' => $item->getKey(),
  952.                         'title' => $item->getTitle(),
  953.                         'key' => $item->getKey(),
  954.                         'leaf' => true,
  955.                         'iconCls' => 'pimcore_icon_fieldcollection',
  956.                     ];
  957.             } else {
  958.                 if ($forObjectEditor) {
  959.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  960.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  962.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  963.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  964.                     }
  966.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  967.                 }
  968.                 $definitions[] = [
  969.                     'id' => $item->getKey(),
  970.                     'text' => $item->getKey(),
  971.                     'title' => $item->getTitle(),
  972.                     'key' => $item->getKey(),
  973.                     'leaf' => true,
  974.                     'iconCls' => 'pimcore_icon_fieldcollection',
  975.                 ];
  976.             }
  977.         }
  979.         foreach ($groups as $group) {
  980.             $definitions[] = $group;
  981.         }
  983.         $event = new GenericEvent($this, [
  984.             'list' => $definitions,
  985.             'objectId' => $request->get('object_id'),
  986.             'layoutDefinitions' => $layoutDefinitions,
  987.         ]);
  988.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA);
  989.         $definitions = $event->getArgument('list');
  990.         $layoutDefinitions = $event->getArgument('layoutDefinitions');
  992.         if ($forObjectEditor) {
  993.             return $this->adminJson(['fieldcollections' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  994.         }
  996.         return $this->adminJson($definitions);
  997.     }
  999.     /**
  1000.      * @Route("/fieldcollection-list", name="fieldcollectionlist", methods={"GET"})
  1001.      *
  1002.      * @param Request $request
  1003.      * @param EventDispatcherInterface $eventDispatcher
  1004.      *
  1005.      * @return JsonResponse
  1006.      */
  1007.     public function fieldcollectionListAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1008.     {
  1009.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  1010.         $currentLayoutId = $request->get('layoutId');
  1012.         $list = new DataObject\Fieldcollection\Definition\Listing();
  1013.         $list = $list->load();
  1015.         if ($request->query->has('allowedTypes')) {
  1016.             $filteredList = [];
  1017.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  1018.             foreach ($list as $type) {
  1019.                 if (in_array($type->getKey(), $allowedTypes)) {
  1020.                     $filteredList[] = $type;
  1022.                     // mainly for objects-meta data-type
  1023.                     $layoutDefinitions = $type->getLayoutDefinitions();
  1024.                     $context = [
  1025.                         'containerType' => 'fieldcollection',
  1026.                         'containerKey' => $type->getKey(),
  1027.                         'outerFieldname' => $request->get('field_name'),
  1028.                     ];
  1030.                     $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1032.                     DataObject\Service::enrichLayoutDefinition($layoutDefinitions, $object, $context);
  1034.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  1035.                         DataObject\Service::createSuperLayout($layoutDefinitions);
  1036.                     }
  1037.                 }
  1038.             }
  1040.             $list = $filteredList;
  1041.         }
  1043.         $event = new GenericEvent($this, [
  1044.             'list' => $list,
  1045.             'objectId' => $request->get('object_id'),
  1046.         ]);
  1047.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA);
  1048.         $list = $event->getArgument('list');
  1050.         return $this->adminJson(['fieldcollections' => $list]);
  1051.     }
  1053.     /**
  1054.      * @Route("/get-class-definition-for-column-config", name="getclassdefinitionforcolumnconfig", methods={"GET"})
  1055.      *
  1056.      * @param Request $request
  1057.      *
  1058.      * @return JsonResponse
  1059.      */
  1060.     public function getClassDefinitionForColumnConfigAction(Request $request)
  1061.     {
  1062.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  1063.         if (!$class) {
  1064.             throw $this->createNotFoundException();
  1065.         }
  1066.         $objectId = (int)$request->get('oid');
  1068.         $filteredDefinitions = DataObject\Service::getCustomLayoutDefinitionForGridColumnConfig($class, $objectId);
  1070.         /** @var DataObject\ClassDefinition\Layout $layoutDefinitions */
  1071.         $layoutDefinitions = isset($filteredDefinitions['layoutDefinition']) ? $filteredDefinitions['layoutDefinition'] : false;
  1072.         $filteredFieldDefinition = isset($filteredDefinitions['fieldDefinition']) ? $filteredDefinitions['fieldDefinition'] : false;
  1074.         $class->setFieldDefinitions([]);
  1076.         $result = [];
  1078.         DataObject\Service::enrichLayoutDefinition($layoutDefinitions);
  1080.         $result['objectColumns']['children'] = $layoutDefinitions->getChildren();
  1081.         $result['objectColumns']['nodeLabel'] = 'object_columns';
  1082.         $result['objectColumns']['nodeType'] = 'object';
  1084.         // array("id", "fullpath", "published", "creationDate", "modificationDate", "filename", "classname");
  1085.         $systemColumnNames = DataObject\Concrete::SYSTEM_COLUMN_NAMES;
  1086.         $systemColumns = [];
  1087.         foreach ($systemColumnNames as $systemColumn) {
  1088.             $systemColumns[] = ['title' => $systemColumn, 'name' => $systemColumn, 'datatype' => 'data', 'fieldtype' => 'system'];
  1089.         }
  1090.         $result['systemColumns']['nodeLabel'] = 'system_columns';
  1091.         $result['systemColumns']['nodeType'] = 'system';
  1092.         $result['systemColumns']['children'] = $systemColumns;
  1094.         $list = new DataObject\Objectbrick\Definition\Listing();
  1095.         $list = $list->load();
  1097.         foreach ($list as $brickDefinition) {
  1098.             $classDefs = $brickDefinition->getClassDefinitions();
  1099.             if (!empty($classDefs)) {
  1100.                 foreach ($classDefs as $classDef) {
  1101.                     if ($classDef['classname'] == $class->getName()) {
  1102.                         $fieldName = $classDef['fieldname'];
  1103.                         if ($filteredFieldDefinition && !$filteredFieldDefinition[$fieldName]) {
  1104.                             continue;
  1105.                         }
  1107.                         $key = $brickDefinition->getKey();
  1109.                         $brickLayoutDefinitions = $brickDefinition->getLayoutDefinitions();
  1110.                         $context = [
  1111.                             'containerType' => 'objectbrick',
  1112.                             'containerKey' => $key,
  1113.                             'outerFieldname' => $fieldName,
  1114.                         ];
  1115.                         DataObject\Service::enrichLayoutDefinition($brickLayoutDefinitions, null, $context);
  1117.                         $result[$key]['nodeLabel'] = $key;
  1118.                         $result[$key]['brickField'] = $fieldName;
  1119.                         $result[$key]['nodeType'] = 'objectbricks';
  1120.                         $result[$key]['children'] = $brickLayoutDefinitions->getChildren();
  1122.                         break;
  1123.                     }
  1124.                 }
  1125.             }
  1126.         }
  1128.         return $this->adminJson($result);
  1129.     }
  1131.     /**
  1132.      * OBJECT BRICKS
  1133.      */
  1135.     /**
  1136.      * @Route("/objectbrick-get", name="objectbrickget", methods={"GET"})
  1137.      *
  1138.      * @param Request $request
  1139.      *
  1140.      * @return JsonResponse
  1141.      */
  1142.     public function objectbrickGetAction(Request $request)
  1143.     {
  1144.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1146.         $isWriteable = $fc->isWritable();
  1147.         $fc = $fc->getObjectVars();
  1148.         $fc['isWriteable'] = $isWriteable;
  1150.         return $this->adminJson($fc);
  1151.     }
  1153.     /**
  1154.      * @Route("/objectbrick-update", name="objectbrickupdate", methods={"PUT", "POST"})
  1155.      *
  1156.      * @param Request $request
  1157.      * @param EventDispatcherInterface $eventDispatcher
  1158.      *
  1159.      * @return JsonResponse
  1160.      */
  1161.     public function objectbrickUpdateAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1162.     {
  1163.         try {
  1164.             $key = $request->get('key');
  1165.             $title = $request->get('title');
  1166.             $group = $request->get('group');
  1168.             if ($request->get('task') == 'add') {
  1169.                 // check for existing brick with same name with different lower/upper cases
  1170.                 $list = new DataObject\Objectbrick\Definition\Listing();
  1171.                 $list = $list->load();
  1173.                 foreach ($list as $item) {
  1174.                     if (strtolower($key) === strtolower($item->getKey())) {
  1175.                         throw new \Exception('Brick with the same name already exists (lower/upper cases may be different)');
  1176.                     }
  1177.                 }
  1178.             }
  1180.             // now we create a new definition
  1181.             $brickDef = new DataObject\Objectbrick\Definition();
  1182.             $brickDef->setKey($key);
  1183.             $brickDef->setTitle($title);
  1184.             $brickDef->setGroup($group);
  1186.             if ($request->get('values')) {
  1187.                 $values = $this->decodeJson($request->get('values'));
  1189.                 $brickDef->setParentClass($values['parentClass']);
  1190.                 $brickDef->setImplementsInterfaces($values['implementsInterfaces']);
  1191.                 $brickDef->setClassDefinitions($values['classDefinitions']);
  1192.                 $brickDef->setGenerateTypeDeclarations($values['generateTypeDeclarations']);
  1193.             }
  1195.             if ($request->get('configuration')) {
  1196.                 $configuration = $this->decodeJson($request->get('configuration'));
  1198.                 $configuration['datatype'] = 'layout';
  1199.                 $configuration['fieldtype'] = 'panel';
  1201.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  1202.                 $brickDef->setLayoutDefinitions($layout);
  1203.             }
  1205.             $event = new GenericEvent($this, [
  1206.                 'brickDefinition' => $brickDef,
  1207.             ]);
  1208.             $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_UPDATE_DEFINITION);
  1209.             $brickDef = $event->getArgument('brickDefinition');
  1211.             $brickDef->save();
  1213.             return $this->adminJson(['success' => true, 'id' => $brickDef->getKey()]);
  1214.         } catch (\Exception $e) {
  1215.             Logger::error($e->getMessage());
  1217.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1218.         }
  1219.     }
  1221.     /**
  1222.      * @Route("/import-objectbrick", name="importobjectbrick", methods={"POST"})
  1223.      *
  1224.      * @param Request $request
  1225.      *
  1226.      * @return JsonResponse
  1227.      */
  1228.     public function importObjectbrickAction(Request $request)
  1229.     {
  1230.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1232.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  1233.         $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($objectBrick, $data);
  1235.         $response = $this->adminJson([
  1236.             'success' => $success,
  1237.         ]);
  1239.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  1240.         // Ext.form.Action.Submit and mark the submission as failed
  1241.         $response->headers->set('Content-Type', 'text/html');
  1243.         return $response;
  1244.     }
  1246.     /**
  1247.      * @Route("/export-objectbrick", name="exportobjectbrick", methods={"GET"})
  1248.      *
  1249.      * @param Request $request
  1250.      *
  1251.      * @return Response
  1252.      */
  1253.     public function exportObjectbrickAction(Request $request)
  1254.     {
  1255.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1257.         if (!$objectBrick instanceof DataObject\Objectbrick\Definition) {
  1258.             $errorMessage = ': Object-Brick with id [ ' . $request->get('id') . ' not found. ]';
  1259.             Logger::error($errorMessage);
  1261.             throw $this->createNotFoundException($errorMessage);
  1262.         }
  1264.         $xml = DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick);
  1265.         $response = new Response($xml);
  1266.         $response->headers->set('Content-type', 'application/json');
  1267.         $response->headers->set('Content-Disposition', 'attachment; filename="objectbrick_' . $objectBrick->getKey() . '_export.json"');
  1269.         return $response;
  1270.     }
  1272.     /**
  1273.      * @Route("/objectbrick-delete", name="objectbrickdelete", methods={"DELETE"})
  1274.      *
  1275.      * @param Request $request
  1276.      *
  1277.      * @return JsonResponse
  1278.      */
  1279.     public function objectbrickDeleteAction(Request $request)
  1280.     {
  1281.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1282.         $fc->delete();
  1284.         return $this->adminJson(['success' => true]);
  1285.     }
  1287.     /**
  1288.      * @Route("/objectbrick-tree", name="objectbricktree", methods={"GET", "POST"})
  1289.      *
  1290.      * @param Request $request
  1291.      * @param EventDispatcherInterface $eventDispatcher
  1292.      *
  1293.      * @return JsonResponse
  1294.      */
  1295.     public function objectbrickTreeAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1296.     {
  1297.         $list = new DataObject\Objectbrick\Definition\Listing();
  1298.         $list = $list->load();
  1300.         $forObjectEditor = $request->get('forObjectEditor');
  1302.         $context = null;
  1303.         $layoutDefinitions = [];
  1304.         $groups = [];
  1305.         $definitions = [];
  1306.         $fieldname = null;
  1307.         $className = null;
  1309.         $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1311.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1312.             $classId = $request->get('class_id');
  1313.             $fieldname = $request->get('field_name');
  1314.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1315.             $className = $classDefinition->getName();
  1316.         }
  1318.         foreach ($list as $item) {
  1319.             if ($forObjectEditor) {
  1320.                 $context = [
  1321.                     'containerType' => 'objectbrick',
  1322.                     'containerKey' => $item->getKey(),
  1323.                     'outerFieldname' => $fieldname,
  1324.                 ];
  1325.             }
  1326.             if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1327.                 $keep = false;
  1328.                 $clsDefs = $item->getClassDefinitions();
  1329.                 if (!empty($clsDefs)) {
  1330.                     foreach ($clsDefs as $cd) {
  1331.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1332.                             $keep = true;
  1334.                             continue;
  1335.                         }
  1336.                     }
  1337.                 }
  1338.                 if (!$keep) {
  1339.                     continue;
  1340.                 }
  1341.             }
  1343.             if ($item->getGroup()) {
  1344.                 if (!isset($groups[$item->getGroup()])) {
  1345.                     $groups[$item->getGroup()] = [
  1346.                         'id' => 'group_' . $item->getKey(),
  1347.                         'text' => htmlspecialchars($item->getGroup()),
  1348.                         'expandable' => true,
  1349.                         'leaf' => false,
  1350.                         'allowChildren' => true,
  1351.                         'iconCls' => 'pimcore_icon_folder',
  1352.                         'group' => $item->getGroup(),
  1353.                         'children' => [],
  1354.                     ];
  1355.                 }
  1356.                 if ($forObjectEditor) {
  1357.                     $layoutId = $request->get('layoutId');
  1358.                     $itemLayoutDefinitions = null;
  1359.                     if ($layoutId) {
  1360.                         $layout = DataObject\ClassDefinition\CustomLayout::getById($layoutId.'.brick.'.$item->getKey());
  1361.                         if ($layout instanceof DataObject\ClassDefinition\CustomLayout) {
  1362.                             $itemLayoutDefinitions = $layout->getLayoutDefinitions();
  1363.                         }
  1364.                     }
  1366.                     if ($itemLayoutDefinitions === null) {
  1367.                         $itemLayoutDefinitions = $item->getLayoutDefinitions();
  1368.                     }
  1370.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object, $context);
  1372.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  1373.                 }
  1374.                 $groups[$item->getGroup()]['children'][] =
  1375.                     [
  1376.                         'id' => $item->getKey(),
  1377.                         'text' => $item->getKey(),
  1378.                         'title' => $item->getTitle(),
  1379.                         'key' => $item->getKey(),
  1380.                         'leaf' => true,
  1381.                         'iconCls' => 'pimcore_icon_objectbricks',
  1382.                     ];
  1383.             } else {
  1384.                 if ($forObjectEditor) {
  1385.                     $layout = $item->getLayoutDefinitions();
  1387.                     $currentLayoutId = $request->get('layoutId', null);
  1389.                     $user = $this->getAdminUser();
  1390.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  1391.                         DataObject\Service::createSuperLayout($layout);
  1392.                     } elseif ($currentLayoutId) {
  1393.                         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($currentLayoutId.'.brick.'.$item->getKey());
  1394.                         if ($customLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  1395.                             $layout = $customLayout->getLayoutDefinitions();
  1396.                         }
  1397.                     }
  1399.                     DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1401.                     $layoutDefinitions[$item->getKey()] = $layout;
  1402.                 }
  1403.                 $definitions[] = [
  1404.                     'id' => $item->getKey(),
  1405.                     'text' => $item->getKey(),
  1406.                     'title' => $item->getTitle(),
  1407.                     'key' => $item->getKey(),
  1408.                     'leaf' => true,
  1409.                     'iconCls' => 'pimcore_icon_objectbricks',
  1410.                 ];
  1411.             }
  1412.         }
  1414.         foreach ($groups as $group) {
  1415.             $definitions[] = $group;
  1416.         }
  1418.         $event = new GenericEvent($this, [
  1419.             'list' => $definitions,
  1420.             'objectId' => $request->get('object_id'),
  1421.         ]);
  1422.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA);
  1423.         $definitions = $event->getArgument('list');
  1425.         if ($forObjectEditor) {
  1426.             return $this->adminJson(['objectbricks' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  1427.         } else {
  1428.             return $this->adminJson($definitions);
  1429.         }
  1430.     }
  1432.     /**
  1433.      * @Route("/objectbrick-list", name="objectbricklist", methods={"GET"})
  1434.      *
  1435.      * @param Request $request
  1436.      * @param EventDispatcherInterface $eventDispatcher
  1437.      *
  1438.      * @return JsonResponse
  1439.      */
  1440.     public function objectbrickListAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1441.     {
  1442.         $list = new DataObject\Objectbrick\Definition\Listing();
  1443.         $list = $list->load();
  1445.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1446.             $filteredList = [];
  1447.             $classId = $request->get('class_id');
  1448.             $fieldname = $request->get('field_name');
  1449.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1450.             $className = $classDefinition->getName();
  1452.             foreach ($list as $type) {
  1453.                 $clsDefs = $type->getClassDefinitions();
  1454.                 if (!empty($clsDefs)) {
  1455.                     foreach ($clsDefs as $cd) {
  1456.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1457.                             $filteredList[] = $type;
  1459.                             continue;
  1460.                         }
  1461.                     }
  1462.                 }
  1464.                 $layout = $type->getLayoutDefinitions();
  1466.                 $currentLayoutId = $request->get('layoutId', null);
  1468.                 $user = $this->getAdminUser();
  1469.                 if ($currentLayoutId == -1 && $user->isAdmin()) {
  1470.                     DataObject\Service::createSuperLayout($layout);
  1471.                     $objectData['layout'] = $layout;
  1472.                 }
  1474.                 $context = [
  1475.                     'containerType' => 'objectbrick',
  1476.                     'containerKey' => $type->getKey(),
  1477.                     'outerFieldname' => $request->get('field_name'),
  1478.                 ];
  1480.                 $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1482.                 DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1483.                 $type->setLayoutDefinitions($layout);
  1484.             }
  1486.             $list = $filteredList;
  1487.         }
  1489.         $event = new GenericEvent($this, [
  1490.             'list' => $list,
  1491.             'objectId' => $request->get('object_id'),
  1492.         ]);
  1493.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA);
  1494.         $list = $event->getArgument('list');
  1496.         return $this->adminJson(['objectbricks' => $list]);
  1497.     }
  1499.     /**
  1500.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1501.      * Add option to export/import all class definitions/brick definitions etc. at once
  1502.      */
  1504.     /**
  1505.      * @Route("/bulk-import", name="bulkimport", methods={"POST"})
  1506.      *
  1507.      * @param Request $request
  1508.      *
  1509.      * @return JsonResponse
  1510.      */
  1511.     public function bulkImportAction(Request $request)
  1512.     {
  1513.         $result = [];
  1515.         $tmpName = $_FILES['Filedata']['tmp_name'];
  1516.         $json = file_get_contents($tmpName);
  1518.         $tmpName = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/bulk-import-' . uniqid() . '.tmp';
  1519.         file_put_contents($tmpName, $json);
  1521.         Session::useSession(function (AttributeBagInterface $session) use ($tmpName) {
  1522.             $session->set('class_bulk_import_file', $tmpName);
  1523.         }, 'pimcore_objects');
  1525.         $json = json_decode($json, true);
  1527.         foreach ($json as $groupName => $group) {
  1528.             foreach ($group as $groupItem) {
  1529.                 $displayName = null;
  1530.                 $icon = null;
  1532.                 if ($groupName == 'class') {
  1533.                     $name = $groupItem['name'];
  1534.                     $icon = 'class';
  1535.                 } elseif ($groupName == 'customlayout') {
  1536.                     $className = $groupItem['className'];
  1538.                     $layoutData = ['className' => $className, 'name' => $groupItem['name']];
  1539.                     $name = base64_encode(json_encode($layoutData));
  1540.                     $displayName = $className . ' / ' . $groupItem['name'];
  1541.                     $icon = 'custom_views';
  1542.                 } else {
  1543.                     if ($groupName == 'objectbrick') {
  1544.                         $icon = 'objectbricks';
  1545.                     } elseif ($groupName == 'fieldcollection') {
  1546.                         $icon = 'fieldcollection';
  1547.                     }
  1548.                     $name = $groupItem['key'];
  1549.                 }
  1551.                 if (!$displayName) {
  1552.                     $displayName = $name;
  1553.                 }
  1554.                 $result[] = ['icon' => $icon, 'checked' => true, 'type' => $groupName, 'name' => $name, 'displayName' => $displayName];
  1555.             }
  1556.         }
  1558.         $response = $this->adminJson(['success' => true, 'data' => $result]);
  1559.         $response->headers->set('Content-Type', 'text/html');
  1561.         return $response;
  1562.     }
  1564.     /**
  1565.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1566.      * Add option to export/import all class definitions/brick definitions etc. at once
  1567.      */
  1569.     /**
  1570.      * @Route("/bulk-commit", name="bulkcommit", methods={"POST"})
  1571.      *
  1572.      * @param Request $request
  1573.      *
  1574.      * @return JsonResponse
  1575.      *
  1576.      * @throws \Exception
  1577.      */
  1578.     public function bulkCommitAction(Request $request)
  1579.     {
  1580.         $data = json_decode($request->get('data'), true);
  1582.         $session = Session::get('pimcore_objects');
  1583.         $filename = $session->get('class_bulk_import_file');
  1584.         $json = @file_get_contents($filename);
  1585.         $json = json_decode($json, true);
  1587.         $type = $data['type'];
  1588.         $name = $data['name'];
  1589.         $list = $json[$type];
  1591.         foreach ($list as $item) {
  1592.             unset($item['creationDate']);
  1593.             unset($item['modificationDate']);
  1594.             unset($item['userOwner']);
  1595.             unset($item['userModification']);
  1597.             if ($type == 'class' && $item['name'] == $name) {
  1598.                 $class = DataObject\ClassDefinition::getByName($name);
  1599.                 if (!$class) {
  1600.                     $class = new DataObject\ClassDefinition();
  1601.                     $class->setName($name);
  1602.                 }
  1603.                 $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, json_encode($item), true);
  1605.                 return $this->adminJson(['success' => $success !== false]);
  1606.             } elseif ($type == 'objectbrick' && $item['key'] == $name) {
  1607.                 if (!$brick = DataObject\Objectbrick\Definition::getByKey($name)) {
  1608.                     $brick = new DataObject\Objectbrick\Definition();
  1609.                     $brick->setKey($name);
  1610.                 }
  1612.                 $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($brick, json_encode($item), true);
  1614.                 return $this->adminJson(['success' => $success !== false]);
  1615.             } elseif ($type == 'fieldcollection' && $item['key'] == $name) {
  1616.                 if (!$fieldCollection = DataObject\Fieldcollection\Definition::getByKey($name)) {
  1617.                     $fieldCollection = new DataObject\Fieldcollection\Definition();
  1618.                     $fieldCollection->setKey($name);
  1619.                 }
  1621.                 $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, json_encode($item), true);
  1623.                 return $this->adminJson(['success' => $success !== false]);
  1624.             } elseif ($type == 'customlayout') {
  1625.                 $layoutData = json_decode(base64_decode($data['name']), true);
  1626.                 $className = $layoutData['className'];
  1627.                 $layoutName = $layoutData['name'];
  1629.                 if ($item['name'] == $layoutName && $item['className'] == $className) {
  1630.                     $class = DataObject\ClassDefinition::getByName($className);
  1631.                     if (!$class) {
  1632.                         throw new \Exception('Class does not exist');
  1633.                     }
  1635.                     $classId = $class->getId();
  1637.                     $layoutList = new DataObject\ClassDefinition\CustomLayout\Listing();
  1638.                     $layoutList->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($layoutName, $classId) {
  1639.                         return $layout->getName() === $layoutName && $layout->getClassId() === $classId;
  1640.                     });
  1641.                     $layoutList = $layoutList->load();
  1643.                     $layoutDefinition = null;
  1644.                     if ($layoutList) {
  1645.                         $layoutDefinition = $layoutList[0];
  1646.                     }
  1648.                     if (!$layoutDefinition) {
  1649.                         $layoutDefinition = new DataObject\ClassDefinition\CustomLayout();
  1650.                         $layoutDefinition->setName($layoutName);
  1651.                         $layoutDefinition->setClassId($classId);
  1652.                     }
  1654.                     try {
  1655.                         $layoutDefinition->setDescription($item['description']);
  1656.                         $layoutDef = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($item['layoutDefinitions'], true);
  1657.                         $layoutDefinition->setLayoutDefinitions($layoutDef);
  1658.                         $layoutDefinition->save();
  1659.                     } catch (\Exception $e) {
  1660.                         Logger::error($e->getMessage());
  1662.                         return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1663.                     }
  1664.                 }
  1665.             }
  1666.         }
  1668.         return $this->adminJson(['success' => true]);
  1669.     }
  1671.     /**
  1672.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1673.      * Add option to export/import all class definitions/brick definitions etc. at once
  1674.      */
  1676.     /**
  1677.      * @Route("/bulk-export-prepare", name="bulkexportprepare", methods={"POST"})
  1678.      *
  1679.      * @param Request $request
  1680.      *
  1681.      * @return Response
  1682.      */
  1683.     public function bulkExportPrepareAction(Request $request)
  1684.     {
  1685.         $data = $request->get('data');
  1687.         Session::useSession(function (AttributeBagInterface $session) use ($data) {
  1688.             $session->set('class_bulk_export_settings', $data);
  1689.         }, 'pimcore_objects');
  1691.         return $this->adminJson(['success' => true]);
  1692.     }
  1694.     /**
  1695.      * @Route("/bulk-export", name="bulkexport", methods={"GET"})
  1696.      *
  1697.      * @param Request $request
  1698.      *
  1699.      * @return Response
  1700.      */
  1701.     public function bulkExportAction(Request $request)
  1702.     {
  1703.         $result = [];
  1705.         $fieldCollections = new DataObject\Fieldcollection\Definition\Listing();
  1706.         $fieldCollections = $fieldCollections->load();
  1708.         foreach ($fieldCollections as $fieldCollection) {
  1709.             $result[] = [
  1710.                 'icon' => 'fieldcollection',
  1711.                 'checked' => true,
  1712.                 'type' => 'fieldcollection',
  1713.                 'name' => $fieldCollection->getKey(),
  1714.                 'displayName' => $fieldCollection->getKey(),
  1715.             ];
  1716.         }
  1718.         $classes = new DataObject\ClassDefinition\Listing();
  1719.         $classes->setOrder('ASC');
  1720.         $classes->setOrderKey('id');
  1721.         $classes = $classes->load();
  1723.         foreach ($classes as $class) {
  1724.             $result[] = [
  1725.                 'icon' => 'class',
  1726.                 'checked' => true,
  1727.                 'type' => 'class',
  1728.                 'name' => $class->getName(),
  1729.                 'displayName' => $class->getName(),
  1730.             ];
  1731.         }
  1733.         $objectBricks = new DataObject\Objectbrick\Definition\Listing();
  1734.         $objectBricks = $objectBricks->load();
  1736.         foreach ($objectBricks as $objectBrick) {
  1737.             $result[] = [
  1738.                 'icon' => 'objectbricks',
  1739.                 'checked' => true,
  1740.                 'type' => 'objectbrick',
  1741.                 'name' => $objectBrick->getKey(),
  1742.                 'displayName' => $objectBrick->getKey(),
  1743.             ];
  1744.         }
  1746.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  1747.         $customLayouts = $customLayouts->load();
  1748.         foreach ($customLayouts as $customLayout) {
  1749.             $class = DataObject\ClassDefinition::getById($customLayout->getClassId());
  1750.             $displayName = $class->getName() . ' / ' .  $customLayout->getName();
  1752.             $result[] = [
  1753.                 'icon' => 'custom_views',
  1754.                 'checked' => true,
  1755.                 'type' => 'customlayout',
  1756.                 'name' => $customLayout->getId(),
  1757.                 'displayName' => $displayName,
  1758.             ];
  1759.         }
  1761.         return new JsonResponse(['success' => true, 'data' => $result]);
  1762.     }
  1764.     /**
  1765.      * @Route("/do-bulk-export", name="dobulkexport", methods={"GET"})
  1766.      *
  1767.      * @param Request $request
  1768.      *
  1769.      * @return Response
  1770.      */
  1771.     public function doBulkExportAction(Request $request)
  1772.     {
  1773.         $session = Session::get('pimcore_objects');
  1774.         $list = $session->get('class_bulk_export_settings');
  1775.         $list = json_decode($list, true);
  1776.         $result = [];
  1778.         foreach ($list as $item) {
  1779.             if ($item['type'] == 'fieldcollection') {
  1780.                 if ($fieldCollection = DataObject\Fieldcollection\Definition::getByKey($item['name'])) {
  1781.                     $fieldCollectionJson = json_decode(DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection));
  1782.                     $fieldCollectionJson->key = $item['name'];
  1783.                     $result['fieldcollection'][] = $fieldCollectionJson;
  1784.                 }
  1785.             } elseif ($item['type'] == 'class') {
  1786.                 if ($class = DataObject\ClassDefinition::getByName($item['name'])) {
  1787.                     $data = json_decode(DataObject\ClassDefinition\Service::generateClassDefinitionJson($class));
  1788.                     $data->name = $item['name'];
  1789.                     $result['class'][] = $data;
  1790.                 }
  1791.             } elseif ($item['type'] == 'objectbrick') {
  1792.                 if ($objectBrick = DataObject\Objectbrick\Definition::getByKey($item['name'])) {
  1793.                     $objectBrickJson = json_decode(DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick));
  1794.                     $objectBrickJson->key = $item['name'];
  1795.                     $result['objectbrick'][] = $objectBrickJson;
  1796.                 }
  1797.             } elseif ($item['type'] == 'customlayout') {
  1798.                 if ($customLayout = DataObject\ClassDefinition\CustomLayout::getById($item['name'])) {
  1799.                     $classId = $customLayout->getClassId();
  1800.                     $class = DataObject\ClassDefinition::getById($classId);
  1801.                     $customLayoutJson = json_decode(DataObject\ClassDefinition\Service::generateCustomLayoutJson($customLayout));
  1802.                     $customLayoutJson->name = $customLayout->getName();
  1803.                     $customLayoutJson->className = $class->getName();
  1804.                     $result['customlayout'][] = $customLayoutJson;
  1805.                 }
  1806.             }
  1807.         }
  1809.         $result = json_encode($result, JSON_PRETTY_PRINT);
  1810.         $response = new Response($result);
  1811.         $response->headers->set('Content-type', 'application/json');
  1812.         $response->headers->set('Content-Disposition', 'attachment; filename="bulk_export.json"');
  1814.         return $response;
  1815.     }
  1817.     /**
  1818.      * @param ControllerEvent $event
  1819.      */
  1820.     public function onKernelControllerEvent(ControllerEvent $event)
  1821.     {
  1822.         if (!$event->isMainRequest()) {
  1823.             return;
  1824.         }
  1826.         // check permissions
  1827.         $unrestrictedActions = [
  1828.             'getTreeAction', 'fieldcollectionListAction', 'fieldcollectionTreeAction', 'fieldcollectionGetAction',
  1829.             'getClassDefinitionForColumnConfigAction', 'objectbrickListAction', 'objectbrickTreeAction', 'objectbrickGetAction',
  1830.         ];
  1832.         $this->checkActionPermission($event, 'classes', $unrestrictedActions);
  1833.     }
  1835.     /**
  1836.      * @Route("/get-fieldcollection-usages", name="getfieldcollectionusages", methods={"GET"})
  1837.      *
  1838.      * @param Request $request
  1839.      *
  1840.      * @return Response
  1841.      */
  1842.     public function getFieldcollectionUsagesAction(Request $request)
  1843.     {
  1844.         $key = $request->get('key');
  1845.         $result = [];
  1847.         $classes = new DataObject\ClassDefinition\Listing();
  1848.         $classes = $classes->load();
  1849.         foreach ($classes as $class) {
  1850.             $fieldDefs = $class->getFieldDefinitions();
  1851.             foreach ($fieldDefs as $fieldDef) {
  1852.                 if ($fieldDef instanceof DataObject\ClassDefinition\Data\Fieldcollections) {
  1853.                     $allowedKeys = $fieldDef->getAllowedTypes();
  1854.                     if (is_array($allowedKeys) && in_array($key, $allowedKeys)) {
  1855.                         $result[] = [
  1856.                             'class' => $class->getName(),
  1857.                             'field' => $fieldDef->getName(),
  1858.                         ];
  1859.                     }
  1860.                 }
  1861.             }
  1862.         }
  1864.         return $this->adminJson($result);
  1865.     }
  1867.     /**
  1868.      * @Route("/get-bricks-usages", name="getbrickusages", methods={"GET"})
  1869.      *
  1870.      * @param Request $request
  1871.      *
  1872.      * @return Response
  1873.      */
  1874.     public function getBrickUsagesAction(Request $request)
  1875.     {
  1876.         $classId = $request->get('classId');
  1877.         $myclass = DataObject\ClassDefinition::getById($classId);
  1879.         $result = [];
  1881.         $brickDefinitions = new DataObject\Objectbrick\Definition\Listing();
  1882.         $brickDefinitions = $brickDefinitions->load();
  1883.         foreach ($brickDefinitions as $brickDefinition) {
  1884.             $classes = $brickDefinition->getClassDefinitions();
  1885.             foreach ($classes as $class) {
  1886.                 if ($myclass->getName() == $class['classname']) {
  1887.                     $result[] = [
  1888.                         'objectbrick' => $brickDefinition->getKey(),
  1889.                         'field' => $class['fieldname'],
  1890.                     ];
  1891.                 }
  1892.             }
  1893.         }
  1895.         return $this->adminJson($result);
  1896.     }
  1898.     /**
  1899.      * @Route("/get-icons", name="geticons", methods={"GET"})
  1900.      *
  1901.      * @param Request $request
  1902.      * @param EventDispatcherInterface $eventDispatcher
  1903.      *
  1904.      * @return Response
  1905.      */
  1906.     public function getIconsAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1907.     {
  1908.         $classId = $request->get('classId');
  1910.         $iconDir = PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/img';
  1911.         $classIcons = rscandir($iconDir . '/object-icons/');
  1912.         $colorIcons = rscandir($iconDir . '/flat-color-icons/');
  1913.         $twemoji = rscandir($iconDir . '/twemoji/');
  1915.         $icons = array_merge($classIcons, $colorIcons, $twemoji);
  1917.         foreach ($icons as &$icon) {
  1918.             $icon = str_replace(PIMCORE_WEB_ROOT, '', $icon);
  1919.         }
  1921.         $event = new GenericEvent($this, [
  1922.             'icons' => $icons,
  1923.             'classId' => $classId,
  1924.         ]);
  1925.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECT_ICONS_PRE_SEND_DATA);
  1926.         $icons = $event->getArgument('icons');
  1928.         $result = [];
  1929.         foreach ($icons as $icon) {
  1930.             $content = file_get_contents(PIMCORE_WEB_ROOT . $icon);
  1931.             $result[] = [
  1932.                 'text' => sprintf('<img src="data:%s;base64,%s"/>', mime_content_type(PIMCORE_WEB_ROOT . $icon), base64_encode($content)),
  1933.                 'value' => $icon,
  1934.             ];
  1935.         }
  1937.         return $this->adminJson($result);
  1938.     }
  1940.     /**
  1941.      * @Route("/suggest-class-identifier", name="suggestclassidentifier")
  1942.      *
  1943.      * @return Response
  1944.      */
  1945.     public function suggestClassIdentifierAction()
  1946.     {
  1947.         $db = Db::get();
  1948.         $maxId = $db->fetchOne('SELECT MAX(CAST(id AS SIGNED)) FROM classes;');
  1950.         $existingIds = $db->fetchFirstColumn('select LOWER(id) from classes');
  1952.         $result = [
  1953.             'suggestedIdentifier' => $maxId ? $maxId + 1 : 1,
  1954.             'existingIds' => $existingIds,
  1955.             ];
  1957.         return $this->adminJson($result);
  1958.     }
  1960.     /**
  1961.      * @Route("/suggest-custom-layout-identifier", name="suggestcustomlayoutidentifier")
  1962.      *
  1963.      * @param Request $request
  1964.      *
  1965.      * @return Response
  1966.      */
  1967.     public function suggestCustomLayoutIdentifierAction(Request $request)
  1968.     {
  1969.         $classId = $request->get('classId');
  1971.         $identifier = DataObject\ClassDefinition\CustomLayout::getIdentifier($classId);
  1973.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  1975.         $list = $list->load();
  1976.         $existingIds = [];
  1977.         $existingNames = [];
  1979.         foreach ($list as $item) {
  1980.             $existingIds[] = $item->getId();
  1981.             if ($item->getClassId() == $classId) {
  1982.                 $existingNames[] = $item->getName();
  1983.             }
  1984.         }
  1986.         $result = [
  1987.             'suggestedIdentifier' => $identifier,
  1988.             'existingIds' => $existingIds,
  1989.             'existingNames' => $existingNames,
  1990.             ];
  1992.         return $this->adminJson($result);
  1993.     }
  1995.     /**
  1996.      * @Route("/text-layout-preview", name="textlayoutpreview")
  1997.      *
  1998.      * @param Request $request
  1999.      *
  2000.      * @return Response
  2001.      */
  2002.     public function textLayoutPreviewAction(Request $request)
  2003.     {
  2004.         $objPath = $request->get('previewObject', '');
  2005.         $className = '\\Pimcore\\Model\\DataObject\\' . $request->get('className');
  2006.         $obj = DataObject::getByPath($objPath) ?? new $className();
  2008.         $textLayout = new DataObject\ClassDefinition\Layout\Text();
  2010.         $context = [
  2011.           'data' => $request->get('renderingData'),
  2012.         ];
  2014.         if ($renderingClass = $request->get('renderingClass')) {
  2015.             $textLayout->setRenderingClass($renderingClass);
  2016.         }
  2018.         if ($staticHtml = $request->get('html')) {
  2019.             $textLayout->setHtml($staticHtml);
  2020.         }
  2022.         $html = $textLayout->enrichLayoutDefinition($obj, $context)->getHtml();
  2024.         $content =
  2025.             "<html>\n" .
  2026.             "<head>\n" .
  2027.             '<style type="text/css">' . "\n" .
  2028.             file_get_contents(PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/css/admin.css') .
  2029.             "</style>\n" .
  2030.             "</head>\n\n" .
  2031.             "<body class='objectlayout_element_text'>\n" .
  2032.             $html .
  2033.             "\n\n</body>\n" .
  2034.             "</html>\n";
  2036.         $response = new Response($content);
  2037.         $response->headers->set('Content-Type', 'text/html');
  2039.         return $response;
  2040.     }
  2042.     /**
  2043.      * @Route("/video-supported-types", name="videosupportedTypestypes")
  2044.      *
  2045.      * @param Request $request
  2046.      *
  2047.      * @return Response
  2048.      */
  2049.     public function videoAllowedTypesAction(Request $request)
  2050.     {
  2051.         $videoDef = new DataObject\ClassDefinition\Data\Video();
  2052.         $res = [];
  2054.         foreach ($videoDef->getSupportedTypes() as $type) {
  2055.             $res[] = [
  2056.                 'key' => $type,
  2057.                 'value' => $this->trans($type),
  2058.             ];
  2059.         }
  2061.         return $this->adminJson($res);
  2062.     }
  2063. }