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

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\AdminAbstractController;
  19. use Pimcore\Controller\KernelControllerEventInterface;
  20. use Pimcore\Db;
  21. use Pimcore\Event\AdminEvents;
  22. use Pimcore\Logger;
  23. use Pimcore\Model\Asset;
  24. use Pimcore\Model\DataObject;
  25. use Pimcore\Model\Document;
  26. use Pimcore\Model\Translation;
  27. use Pimcore\Tool\Session;
  28. use Symfony\Component\EventDispatcher\GenericEvent;
  29. use Symfony\Component\HttpFoundation\JsonResponse;
  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\HttpKernel\Exception\AccessDeniedHttpException;
  35. use Symfony\Component\Routing\Annotation\Route;
  36. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  37. use Symfony\Contracts\Translation\TranslatorInterface;
  39. /**
  40.  * @Route("/class", name="pimcore_admin_dataobject_class_")
  41.  *
  42.  * @internal
  43.  */
  44. class ClassController extends AdminAbstractController implements KernelControllerEventInterface
  45. {
  46.     /**
  47.      * @Route("/get-document-types", name="getdocumenttypes", methods={"GET"})
  48.      *
  49.      * @param Request $request
  50.      *
  51.      * @return JsonResponse
  52.      */
  53.     public function getDocumentTypesAction(Request $request)
  54.     {
  55.         $documentTypes = Document::getTypes();
  56.         $typeItems = [];
  57.         foreach ($documentTypes as $documentType) {
  58.             $typeItems[] = [
  59.                 'text' => $documentType,
  60.             ];
  61.         }
  63.         return $this->adminJson($typeItems);
  64.     }
  66.     /**
  67.      * @Route("/get-asset-types", name="getassettypes", methods={"GET"})
  68.      *
  69.      * @param Request $request
  70.      *
  71.      * @return JsonResponse
  72.      */
  73.     public function getAssetTypesAction(Request $request)
  74.     {
  75.         $assetTypes = Asset::getTypes();
  76.         $typeItems = [];
  77.         foreach ($assetTypes as $assetType) {
  78.             $typeItems[] = [
  79.                 'text' => $assetType,
  80.             ];
  81.         }
  83.         return $this->adminJson($typeItems);
  84.     }
  86.     /**
  87.      * @Route("/get-tree", name="gettree", methods={"GET", "POST"})
  88.      *
  89.      * @param Request $request
  90.      *
  91.      * @return JsonResponse
  92.      */
  93.     public function getTreeAction(Request $request)
  94.     {
  95.         try {
  96.             // we need to check objects permission for listing in pimcore.model.objecttypes ext model
  97.             $this->checkPermission('objects');
  98.         } catch (AccessDeniedHttpException $e) {
  99.             Logger::log('[Startup] Object types are not loaded as "objects" permission is missing');
  100.             //return empty string to avoid error on startup
  101.             return $this->adminJson([]);
  102.         }
  104.         $defaultIcon = '/bundles/pimcoreadmin/img/flat-color-icons/class.svg';
  106.         $classesList = new DataObject\ClassDefinition\Listing();
  107.         $classesList->setOrderKey('name');
  108.         $classesList->setOrder('asc');
  109.         $classes = $classesList->load();
  111.         // filter classes
  112.         if ($request->get('createAllowed')) {
  113.             $tmpClasses = [];
  114.             foreach ($classes as $class) {
  115.                 if ($this->getAdminUser()->isAllowed($class->getId(), 'class')) {
  116.                     $tmpClasses[] = $class;
  117.                 }
  118.             }
  119.             $classes = $tmpClasses;
  120.         }
  122.         $withId = $request->get('withId');
  123.         $getClassConfig = function ($class) use ($defaultIcon, $withId) {
  124.             $text = $class->getname();
  125.             if ($withId) {
  126.                 $text .= ' (' . $class->getId() . ')';
  127.             }
  129.             $hasBrickField = false;
  130.             foreach ($class->getFieldDefinitions() as $fieldDefinition) {
  131.                 if ($fieldDefinition instanceof DataObject\ClassDefinition\Data\Objectbricks) {
  132.                     $hasBrickField = true;
  134.                     break;
  135.                 }
  136.             }
  138.             return [
  139.                 'id' => $class->getId(),
  140.                 'text' => $text,
  141.                 'leaf' => true,
  142.                 'icon' => $class->getIcon() ? htmlspecialchars($class->getIcon()) : $defaultIcon,
  143.                 'cls' => 'pimcore_class_icon',
  144.                 'propertyVisibility' => $class->getPropertyVisibility(),
  145.                 'enableGridLocking' => $class->isEnableGridLocking(),
  146.                 'hasBrickField' => $hasBrickField,
  147.             ];
  148.         };
  150.         // build groups
  151.         $groups = [];
  152.         foreach ($classes as $class) {
  153.             $groupName = null;
  155.             if ($class->getGroup()) {
  156.                 $type = 'manual';
  157.                 $groupName = $class->getGroup();
  158.             } else {
  159.                 $type = 'auto';
  160.                 if (preg_match('@^([A-Za-z])([^A-Z]+)@', $class->getName(), $matches)) {
  161.                     $groupName = $matches[0];
  162.                 }
  164.                 if (!$groupName) {
  165.                     // this is eg. the case when class name uses only capital letters
  166.                     $groupName = $class->getName();
  167.                 }
  168.             }
  170.             $groupName = Translation::getByKeyLocalized($groupName, Translation::DOMAIN_ADMIN, true, true);
  172.             if (!isset($groups[$groupName])) {
  173.                 $groups[$groupName] = [
  174.                     'classes' => [],
  175.                     'type' => $type,
  176.                 ];
  177.             }
  178.             $groups[$groupName]['classes'][] = $class;
  179.         }
  181.         $treeNodes = [];
  182.         if (!empty($groups)) {
  183.             $types = array_column($groups, 'type');
  184.             array_multisort($types, SORT_ASC, array_keys($groups), SORT_ASC, $groups);
  185.         }
  187.         if (!$request->get('grouped')) {
  188.             // list output
  189.             foreach ($groups as $groupName => $groupData) {
  190.                 foreach ($groupData['classes'] as $class) {
  191.                     $node = $getClassConfig($class);
  192.                     if (count($groupData['classes']) > 1 || $groupData['type'] == 'manual') {
  193.                         $node['group'] = $groupName;
  194.                     }
  195.                     $treeNodes[] = $node;
  196.                 }
  197.             }
  198.         } else {
  199.             // create json output
  200.             foreach ($groups as $groupName => $groupData) {
  201.                 if (count($groupData['classes']) === 1 && $groupData['type'] == 'auto') {
  202.                     // no group, only one child
  203.                     $node = $getClassConfig($groupData['classes'][0]);
  204.                 } else {
  205.                     // group classes
  206.                     $node = [
  207.                         'id' => 'folder_' . $groupName,
  208.                         'text' => $groupName,
  209.                         'leaf' => false,
  210.                         'expandable' => true,
  211.                         'allowChildren' => true,
  212.                         'iconCls' => 'pimcore_icon_folder',
  213.                         'children' => [],
  214.                     ];
  216.                     foreach ($groupData['classes'] as $class) {
  217.                         $node['children'][] = $getClassConfig($class);
  218.                     }
  219.                 }
  221.                 $treeNodes[] = $node;
  222.             }
  223.         }
  225.         return $this->adminJson($treeNodes);
  226.     }
  228.     /**
  229.      * @Route("/get", name="get", methods={"GET"})
  230.      *
  231.      * @param Request $request
  232.      *
  233.      * @return JsonResponse
  234.      */
  235.     public function getAction(Request $request)
  236.     {
  237.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  238.         if (!$class) {
  239.             throw $this->createNotFoundException();
  240.         }
  241.         $class->setFieldDefinitions([]);
  242.         $isWriteable = $class->isWritable();
  243.         $class = $class->getObjectVars();
  244.         $class['isWriteable'] = $isWriteable;
  246.         return $this->adminJson($class);
  247.     }
  249.     /**
  250.      * @Route("/get-custom-layout", name="getcustomlayout", methods={"GET"})
  251.      *
  252.      * @param Request $request
  253.      *
  254.      * @return JsonResponse
  255.      */
  256.     public function getCustomLayoutAction(Request $request)
  257.     {
  258.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  259.         if (!$customLayout) {
  260.             $brickLayoutSeparator = strpos($request->get('id'), '.brick.');
  261.             if ($brickLayoutSeparator !== false) {
  262.                 $customLayout = DataObject\ClassDefinition\CustomLayout::getById(substr($request->get('id'), 0, $brickLayoutSeparator));
  263.                 if ($customLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  264.                     $customLayout = DataObject\ClassDefinition\CustomLayout::create(
  265.                         [
  266.                             'name' => $customLayout->getName().' '.substr($request->get('id'), $brickLayoutSeparator+strlen('.brick.')),
  267.                             'userOwner' => $this->getAdminUser()->getId(),
  268.                             'classId' => $customLayout->getClassId(),
  269.                         ]
  270.                     );
  272.                     $customLayout->setId($request->get('id'));
  273.                     $customLayout->save();
  274.                 }
  275.             }
  277.             if (!$customLayout) {
  278.                 throw $this->createNotFoundException();
  279.             }
  280.         }
  281.         $isWriteable = $customLayout->isWritable();
  282.         $customLayout = $customLayout->getObjectVars();
  283.         $customLayout['isWriteable'] = $isWriteable;
  285.         return $this->adminJson(['success' => true, 'data' => $customLayout]);
  286.     }
  288.     /**
  289.      * @Route("/add", name="add", methods={"POST"})
  290.      *
  291.      * @param Request $request
  292.      *
  293.      * @return JsonResponse
  294.      */
  295.     public function addAction(Request $request)
  296.     {
  297.         $className = $request->get('className');
  298.         $className = $this->correctClassname($className);
  300.         $classId = $request->get('classIdentifier');
  301.         $existingClass = DataObject\ClassDefinition::getById($classId);
  302.         if ($existingClass) {
  303.             throw new \Exception('Class identifier already exists');
  304.         }
  306.         $class = DataObject\ClassDefinition::create(
  307.             ['name' => $className,
  308.                 'userOwner' => $this->getAdminUser()->getId(), ]
  309.         );
  311.         $class->setId($classId);
  313.         $class->save(true);
  315.         return $this->adminJson(['success' => true, 'id' => $class->getId()]);
  316.     }
  318.     /**
  319.      * @Route("/add-custom-layout", name="addcustomlayout", methods={"POST"})
  320.      *
  321.      * @param Request $request
  322.      *
  323.      * @return JsonResponse
  324.      */
  325.     public function addCustomLayoutAction(Request $request)
  326.     {
  327.         $layoutId = $request->get('layoutIdentifier');
  328.         $existingLayout = DataObject\ClassDefinition\CustomLayout::getById($layoutId);
  329.         if ($existingLayout) {
  330.             throw new \Exception('Custom Layout identifier already exists');
  331.         }
  333.         $customLayout = DataObject\ClassDefinition\CustomLayout::create(
  334.             [
  335.                 'name' => $request->get('layoutName'),
  336.                 'userOwner' => $this->getAdminUser()->getId(),
  337.                 'classId' => $request->get('classId'),
  338.             ]
  339.         );
  341.         $customLayout->setId($layoutId);
  342.         $customLayout->save();
  344.         $isWriteable = $customLayout->isWritable();
  345.         $data = $customLayout->getObjectVars();
  346.         $data['isWriteable'] = $isWriteable;
  348.         return $this->adminJson(['success' => true, 'id' => $customLayout->getId(), 'name' => $customLayout->getName(),
  349.                                  'data' => $data, ]);
  350.     }
  352.     /**
  353.      * @Route("/delete", name="delete", methods={"DELETE"})
  354.      *
  355.      * @param Request $request
  356.      *
  357.      * @return Response
  358.      */
  359.     public function deleteAction(Request $request)
  360.     {
  361.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  362.         if ($class) {
  363.             $class->delete();
  364.         }
  366.         return new Response();
  367.     }
  369.     /**
  370.      * @Route("/delete-custom-layout", name="deletecustomlayout", methods={"DELETE"})
  371.      *
  372.      * @param Request $request
  373.      *
  374.      * @return JsonResponse
  375.      */
  376.     public function deleteCustomLayoutAction(Request $request)
  377.     {
  378.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  379.         $id = $request->get('id');
  380.         $customLayouts->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($id) {
  381.             $currentLayoutId = $layout->getId();
  383.             return $currentLayoutId === $id || str_starts_with($currentLayoutId, $id . '.brick.');
  384.         });
  386.         foreach ($customLayouts->getLayoutDefinitions() as $customLayout) {
  387.             $customLayout->delete();
  388.         }
  390.         return $this->adminJson(['success' => true]);
  391.     }
  393.     /**
  394.      * @Route("/save-custom-layout", name="savecustomlayout", methods={"PUT"})
  395.      *
  396.      * @param Request $request
  397.      *
  398.      * @return JsonResponse
  399.      */
  400.     public function saveCustomLayoutAction(Request $request)
  401.     {
  402.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  403.         if (!$customLayout) {
  404.             throw $this->createNotFoundException();
  405.         }
  407.         $configuration = $this->decodeJson($request->get('configuration'));
  408.         $values = $this->decodeJson($request->get('values'));
  410.         $modificationDate = (int)$values['modificationDate'];
  411.         if ($modificationDate < $customLayout->getModificationDate()) {
  412.             return $this->adminJson(['success' => false, 'msg' => 'custom_layout_changed']);
  413.         }
  415.         $configuration['datatype'] = 'layout';
  416.         $configuration['fieldtype'] = 'panel';
  417.         $configuration['name'] = 'pimcore_root';
  419.         try {
  420.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  421.             $customLayout->setLayoutDefinitions($layout);
  422.             $customLayout->setName($values['name']);
  423.             $customLayout->setDescription($values['description']);
  424.             $customLayout->setDefault($values['default']);
  425.             $customLayout->save();
  427.             return $this->adminJson(['success' => true, 'id' => $customLayout->getId(), 'data' => $customLayout->getObjectVars()]);
  428.         } catch (\Exception $e) {
  429.             Logger::error($e->getMessage());
  431.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  432.         }
  433.     }
  435.     /**
  436.      * @Route("/save", name="save", methods={"PUT"})
  437.      *
  438.      * @param Request $request
  439.      *
  440.      * @return JsonResponse
  441.      *
  442.      * @throws \Exception
  443.      */
  444.     public function saveAction(Request $request)
  445.     {
  446.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  447.         if (!$class) {
  448.             throw $this->createNotFoundException();
  449.         }
  451.         $configuration = $this->decodeJson($request->get('configuration'));
  452.         $values = $this->decodeJson($request->get('values'));
  454.         // check if the class was changed during editing in the frontend
  455.         if ($class->getModificationDate() != $values['modificationDate']) {
  456.             throw new \Exception('The class was modified during editing, please reload the class and make your changes again');
  457.         }
  459.         if ($values['name'] != $class->getName()) {
  460.             $classByName = DataObject\ClassDefinition::getByName($values['name']);
  461.             if ($classByName && $classByName->getId() != $class->getId()) {
  462.                 throw new \Exception('Class name already exists');
  463.             }
  465.             $values['name'] = $this->correctClassname($values['name']);
  466.             $class->rename($values['name']);
  467.         }
  469.         if ($values['compositeIndices']) {
  470.             foreach ($values['compositeIndices'] as $index => $compositeIndex) {
  471.                 if ($compositeIndex['index_key'] !== ($sanitizedKey = preg_replace('/[^a-za-z0-9_\-+]/', '', $compositeIndex['index_key']))) {
  472.                     $values['compositeIndices'][$index]['index_key'] = $sanitizedKey;
  473.                 }
  474.             }
  475.         }
  477.         unset($values['creationDate']);
  478.         unset($values['userOwner']);
  479.         unset($values['layoutDefinitions']);
  480.         unset($values['fieldDefinitions']);
  482.         $configuration['datatype'] = 'layout';
  483.         $configuration['fieldtype'] = 'panel';
  484.         $configuration['name'] = 'pimcore_root';
  486.         $class->setValues($values);
  488.         try {
  489.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  491.             $class->setLayoutDefinitions($layout);
  493.             $class->setUserModification($this->getAdminUser()->getId());
  494.             $class->setModificationDate(time());
  496.             $propertyVisibility = [];
  497.             foreach ($values as $key => $value) {
  498.                 if (preg_match('/propertyVisibility/i', $key)) {
  499.                     if (preg_match("/\.grid\./i", $key)) {
  500.                         $propertyVisibility['grid'][preg_replace("/propertyVisibility\.grid\./i", '', $key)] = (bool) $value;
  501.                     } elseif (preg_match("/\.search\./i", $key)) {
  502.                         $propertyVisibility['search'][preg_replace("/propertyVisibility\.search\./i", '', $key)] = (bool) $value;
  503.                     }
  504.                 }
  505.             }
  506.             if (!empty($propertyVisibility)) {
  507.                 $class->setPropertyVisibility($propertyVisibility);
  508.             }
  510.             $class->save();
  512.             // set the fielddefinitions to [] because we don't need them in the response
  513.             $class->setFieldDefinitions([]);
  515.             return $this->adminJson(['success' => true, 'class' => $class]);
  516.         } catch (\Exception $e) {
  517.             Logger::error($e->getMessage());
  519.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  520.         }
  521.     }
  523.     /**
  524.      * @param string $name
  525.      *
  526.      * @return string
  527.      */
  528.     protected function correctClassname($name)
  529.     {
  530.         $name = preg_replace('/[^a-zA-Z0-9_]+/', '', $name);
  531.         $name = preg_replace('/^[0-9]+/', '', $name);
  533.         return $name;
  534.     }
  536.     /**
  537.      * @Route("/import-class", name="importclass", methods={"POST", "PUT"})
  538.      *
  539.      * @param Request $request
  540.      *
  541.      * @return Response
  542.      */
  543.     public function importClassAction(Request $request)
  544.     {
  545.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  546.         if (!$class) {
  547.             throw $this->createNotFoundException();
  548.         }
  549.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  551.         $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, $json, false, true);
  553.         $response = $this->adminJson([
  554.             'success' => $success,
  555.         ]);
  556.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  557.         // Ext.form.Action.Submit and mark the submission as failed
  558.         $response->headers->set('Content-Type', 'text/html');
  560.         return $response;
  561.     }
  563.     /**
  564.      * @Route("/import-custom-layout-definition", name="importcustomlayoutdefinition", methods={"POST", "PUT"})
  565.      *
  566.      * @param Request $request
  567.      *
  568.      * @return Response
  569.      */
  570.     public function importCustomLayoutDefinitionAction(Request $request)
  571.     {
  572.         $success = false;
  573.         $responseContent = [];
  574.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  575.         $importData = $this->decodeJson($json);
  577.         $existingLayout = null;
  578.         if (isset($importData['name'])) {
  579.             $existingLayout = DataObject\ClassDefinition\CustomLayout::getByName($importData['name']);
  581.             if ($existingLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  582.                 $responseContent['nameAlreadyInUse'] = true;
  583.             }
  584.         }
  586.         if (!$existingLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  587.             $customLayoutId = $request->get('id');
  588.             $customLayout = DataObject\ClassDefinition\CustomLayout::getById($customLayoutId);
  589.             if ($customLayout) {
  590.                 try {
  591.                     $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($importData['layoutDefinitions'], true);
  592.                     $customLayout->setLayoutDefinitions($layout);
  593.                     if (isset($importData['name']) === true) {
  594.                         $customLayout->setName($importData['name']);
  595.                     }
  596.                     $customLayout->setDescription($importData['description']);
  597.                     $customLayout->save();
  598.                     $success = true;
  599.                 } catch (\Exception $e) {
  600.                     Logger::error($e->getMessage());
  601.                 }
  602.             }
  604.             $responseContent['success'] = $success;
  605.         }
  607.         $response = $this->adminJson($responseContent);
  609.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  610.         // Ext.form.Action.Submit and mark the submission as failed
  611.         $response->headers->set('Content-Type', 'text/html');
  613.         return $response;
  614.     }
  616.     /**
  617.      * @Route("/get-custom-layout-definitions", name="getcustomlayoutdefinitions", methods={"GET"})
  618.      *
  619.      * @param Request $request
  620.      *
  621.      * @return JsonResponse
  622.      */
  623.     public function getCustomLayoutDefinitionsAction(Request $request)
  624.     {
  625.         $classIds = explode(',', $request->get('classId'));
  626.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  628.         $list->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($classIds) {
  629.             return in_array($layout->getClassId(), $classIds) && !str_contains($layout->getId(), '.brick.');
  630.         });
  631.         $list = $list->load();
  632.         $result = [];
  633.         foreach ($list as $item) {
  634.             $result[] = [
  635.                 'id' => $item->getId(),
  636.                 'name' => $item->getName() . ' (ID: ' . $item->getId() . ')',
  637.                 'default' => $item->getDefault() ?: 0,
  638.             ];
  639.         }
  641.         return $this->adminJson(['success' => true, 'data' => $result]);
  642.     }
  644.     /**
  645.      * @Route("/get-all-layouts", name="getalllayouts", methods={"GET"})
  646.      *
  647.      * @param Request $request
  648.      *
  649.      * @return JsonResponse
  650.      */
  651.     public function getAllLayoutsAction(Request $request)
  652.     {
  653.         // get all classes
  654.         $resultList = [];
  655.         $mapping = [];
  657.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  658.         $customLayouts->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) {
  659.             return !str_contains($layout->getId(), '.brick.');
  660.         });
  661.         $customLayouts->setOrder(function (DataObject\ClassDefinition\CustomLayout $a, DataObject\ClassDefinition\CustomLayout $b) {
  662.             return strcmp($a->getName(), $b->getName());
  663.         });
  665.         $customLayouts = $customLayouts->load();
  666.         foreach ($customLayouts as $layout) {
  667.             $mapping[$layout->getClassId()][] = $layout;
  668.         }
  670.         $classList = new DataObject\ClassDefinition\Listing();
  671.         $classList->setOrder('ASC');
  672.         $classList->setOrderKey('name');
  673.         $classList = $classList->load();
  675.         foreach ($classList as $class) {
  676.             if (isset($mapping[$class->getId()])) {
  677.                 $classMapping = $mapping[$class->getId()];
  678.                 $resultList[] = [
  679.                     'type' => 'main',
  680.                     'id' => $class->getId() . '_' . 0,
  681.                     'name' => $class->getName(),
  682.                 ];
  684.                 foreach ($classMapping as $layout) {
  685.                     $resultList[] = [
  686.                         'type' => 'custom',
  687.                         'id' => $class->getId() . '_' . $layout->getId(),
  688.                         'name' => $class->getName() . ' - ' . $layout->getName(),
  689.                     ];
  690.                 }
  691.             }
  692.         }
  694.         return $this->adminJson(['data' => $resultList]);
  695.     }
  697.     /**
  698.      * @Route("/export-class", name="exportclass", methods={"GET"})
  699.      *
  700.      * @param Request $request
  701.      *
  702.      * @return Response
  703.      */
  704.     public function exportClassAction(Request $request)
  705.     {
  706.         $id = $request->get('id');
  707.         $class = DataObject\ClassDefinition::getById($id);
  709.         if (!$class instanceof DataObject\ClassDefinition) {
  710.             $errorMessage = ': Class with id [ ' . $id . ' not found. ]';
  711.             Logger::error($errorMessage);
  713.             throw $this->createNotFoundException($errorMessage);
  714.         }
  716.         $json = DataObject\ClassDefinition\Service::generateClassDefinitionJson($class);
  718.         $response = new Response($json);
  719.         $response->headers->set('Content-type', 'application/json');
  720.         $response->headers->set('Content-Disposition', 'attachment; filename="class_' . $class->getName() . '_export.json"');
  722.         return $response;
  723.     }
  725.     /**
  726.      * @Route("/export-custom-layout-definition", name="exportcustomlayoutdefinition", methods={"GET"})
  727.      *
  728.      * @param Request $request
  729.      *
  730.      * @return Response
  731.      */
  732.     public function exportCustomLayoutDefinitionAction(Request $request)
  733.     {
  734.         $id = $request->get('id');
  736.         if ($id) {
  737.             $customLayout = DataObject\ClassDefinition\CustomLayout::getById($id);
  738.             if ($customLayout) {
  739.                 $name = $customLayout->getName();
  740.                 $json = DataObject\ClassDefinition\Service::generateCustomLayoutJson($customLayout);
  742.                 $response = new Response($json);
  743.                 $response->headers->set('Content-type', 'application/json');
  744.                 $response->headers->set('Content-Disposition', 'attachment; filename="custom_definition_' . $name . '_export.json"');
  746.                 return $response;
  747.             }
  748.         }
  750.         $errorMessage = ': Custom Layout with id [ ' . $id . ' not found. ]';
  751.         Logger::error($errorMessage);
  753.         throw $this->createNotFoundException($errorMessage);
  754.     }
  756.     /**
  757.      * FIELDCOLLECTIONS
  758.      */
  760.     /**
  761.      * @Route("/fieldcollection-get", name="fieldcollectionget", methods={"GET"})
  762.      *
  763.      * @param Request $request
  764.      *
  765.      * @return JsonResponse
  766.      */
  767.     public function fieldcollectionGetAction(Request $request)
  768.     {
  769.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  771.         $isWriteable = $fc->isWritable();
  772.         $fc = $fc->getObjectVars();
  773.         $fc['isWriteable'] = $isWriteable;
  775.         return $this->adminJson($fc);
  776.     }
  778.     /**
  779.      * @Route("/fieldcollection-update", name="fieldcollectionupdate", methods={"PUT", "POST"})
  780.      *
  781.      * @param Request $request
  782.      *
  783.      * @return JsonResponse
  784.      */
  785.     public function fieldcollectionUpdateAction(Request $request)
  786.     {
  787.         try {
  788.             $key = $request->get('key');
  789.             $title = $request->get('title');
  790.             $group = $request->get('group');
  792.             if ($request->get('task') == 'add') {
  793.                 // check for existing fieldcollection with same name with different lower/upper cases
  794.                 $list = new DataObject\Fieldcollection\Definition\Listing();
  795.                 $list = $list->load();
  797.                 foreach ($list as $item) {
  798.                     if (strtolower($key) === strtolower($item->getKey())) {
  799.                         throw new \Exception('FieldCollection with the same name already exists (lower/upper cases may be different)');
  800.                     }
  801.                 }
  802.             }
  804.             $fcDef = new DataObject\Fieldcollection\Definition();
  805.             $fcDef->setKey($key);
  806.             $fcDef->setTitle($title);
  807.             $fcDef->setGroup($group);
  809.             if ($request->get('values')) {
  810.                 $values = $this->decodeJson($request->get('values'));
  811.                 $fcDef->setParentClass($values['parentClass']);
  812.                 $fcDef->setImplementsInterfaces($values['implementsInterfaces']);
  813.                 $fcDef->setGenerateTypeDeclarations($values['generateTypeDeclarations']);
  814.             }
  816.             if ($request->get('configuration')) {
  817.                 $configuration = $this->decodeJson($request->get('configuration'));
  819.                 $configuration['datatype'] = 'layout';
  820.                 $configuration['fieldtype'] = 'panel';
  822.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  823.                 $fcDef->setLayoutDefinitions($layout);
  824.             }
  826.             $fcDef->save();
  828.             return $this->adminJson(['success' => true, 'id' => $fcDef->getKey()]);
  829.         } catch (\Exception $e) {
  830.             Logger::error($e->getMessage());
  832.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  833.         }
  834.     }
  836.     /**
  837.      * @Route("/import-fieldcollection", name="importfieldcollection", methods={"POST"})
  838.      *
  839.      * @param Request $request
  840.      *
  841.      * @return Response
  842.      */
  843.     public function importFieldcollectionAction(Request $request)
  844.     {
  845.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  847.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  849.         $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, $data);
  851.         $response = $this->adminJson([
  852.             'success' => $success,
  853.         ]);
  855.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  856.         // Ext.form.Action.Submit and mark the submission as failed
  857.         $response->headers->set('Content-Type', 'text/html');
  859.         return $response;
  860.     }
  862.     /**
  863.      * @Route("/export-fieldcollection", name="exportfieldcollection", methods={"GET"})
  864.      *
  865.      * @param Request $request
  866.      *
  867.      * @return Response
  868.      */
  869.     public function exportFieldcollectionAction(Request $request)
  870.     {
  871.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  873.         if (!$fieldCollection instanceof DataObject\Fieldcollection\Definition) {
  874.             $errorMessage = ': Field-Collection with id [ ' . $request->get('id') . ' not found. ]';
  875.             Logger::error($errorMessage);
  877.             throw $this->createNotFoundException($errorMessage);
  878.         }
  880.         $json = DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection);
  881.         $response = new Response($json);
  882.         $response->headers->set('Content-type', 'application/json');
  883.         $response->headers->set('Content-Disposition', 'attachment; filename="fieldcollection_' . $fieldCollection->getKey() . '_export.json"');
  885.         return $response;
  886.     }
  888.     /**
  889.      * @Route("/fieldcollection-delete", name="fieldcollectiondelete", methods={"DELETE"})
  890.      *
  891.      * @param Request $request
  892.      *
  893.      * @return JsonResponse
  894.      */
  895.     public function fieldcollectionDeleteAction(Request $request)
  896.     {
  897.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  898.         $fc->delete();
  900.         return $this->adminJson(['success' => true]);
  901.     }
  903.     /**
  904.      * @Route("/fieldcollection-tree", name="fieldcollectiontree", methods={"GET", "POST"})
  905.      *
  906.      * @param Request $request
  907.      * @param EventDispatcherInterface $eventDispatcher
  908.      *
  909.      * @return JsonResponse
  910.      */
  911.     public function fieldcollectionTreeAction(Request $request, EventDispatcherInterface $eventDispatcher)
  912.     {
  913.         $list = new DataObject\Fieldcollection\Definition\Listing();
  914.         $list = $list->load();
  916.         $forObjectEditor = $request->get('forObjectEditor');
  918.         $layoutDefinitions = [];
  920.         $definitions = [];
  922.         $allowedTypes = null;
  923.         if ($request->query->has('allowedTypes')) {
  924.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  925.         }
  926.         $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  928.         $currentLayoutId = $request->get('layoutId', null);
  929.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  931.         $groups = [];
  932.         foreach ($list as $item) {
  933.             if ($allowedTypes && !in_array($item->getKey(), $allowedTypes)) {
  934.                 continue;
  935.             }
  937.             if ($item->getGroup()) {
  938.                 if (!isset($groups[$item->getGroup()])) {
  939.                     $groups[$item->getGroup()] = [
  940.                         'id' => 'group_' . $item->getKey(),
  941.                         'text' => htmlspecialchars($item->getGroup()),
  942.                         'expandable' => true,
  943.                         'leaf' => false,
  944.                         'allowChildren' => true,
  945.                         'iconCls' => 'pimcore_icon_folder',
  946.                         'group' => $item->getGroup(),
  947.                         'children' => [],
  948.                     ];
  949.                 }
  950.                 if ($forObjectEditor) {
  951.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  952.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  954.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  955.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  956.                     }
  957.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  958.                 }
  959.                 $groups[$item->getGroup()]['children'][] =
  960.                     [
  961.                         'id' => $item->getKey(),
  962.                         'text' => $item->getKey(),
  963.                         'title' => $item->getTitle(),
  964.                         'key' => $item->getKey(),
  965.                         'leaf' => true,
  966.                         'iconCls' => 'pimcore_icon_fieldcollection',
  967.                     ];
  968.             } else {
  969.                 if ($forObjectEditor) {
  970.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  971.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  973.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  974.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  975.                     }
  977.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  978.                 }
  979.                 $definitions[] = [
  980.                     'id' => $item->getKey(),
  981.                     'text' => $item->getKey(),
  982.                     'title' => $item->getTitle(),
  983.                     'key' => $item->getKey(),
  984.                     'leaf' => true,
  985.                     'iconCls' => 'pimcore_icon_fieldcollection',
  986.                 ];
  987.             }
  988.         }
  990.         foreach ($groups as $group) {
  991.             $definitions[] = $group;
  992.         }
  994.         $event = new GenericEvent($this, [
  995.             'list' => $definitions,
  996.             'objectId' => $request->get('object_id'),
  997.             'layoutDefinitions' => $layoutDefinitions,
  998.         ]);
  999.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA);
  1000.         $definitions = $event->getArgument('list');
  1001.         $layoutDefinitions = $event->getArgument('layoutDefinitions');
  1003.         if ($forObjectEditor) {
  1004.             return $this->adminJson(['fieldcollections' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  1005.         }
  1007.         return $this->adminJson($definitions);
  1008.     }
  1010.     /**
  1011.      * @Route("/fieldcollection-list", name="fieldcollectionlist", methods={"GET"})
  1012.      *
  1013.      * @param Request $request
  1014.      * @param EventDispatcherInterface $eventDispatcher
  1015.      *
  1016.      * @return JsonResponse
  1017.      */
  1018.     public function fieldcollectionListAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1019.     {
  1020.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  1021.         $currentLayoutId = $request->get('layoutId');
  1023.         $list = new DataObject\Fieldcollection\Definition\Listing();
  1024.         $list = $list->load();
  1026.         if ($request->query->has('allowedTypes')) {
  1027.             $filteredList = [];
  1028.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  1029.             foreach ($list as $type) {
  1030.                 if (in_array($type->getKey(), $allowedTypes)) {
  1031.                     $filteredList[] = $type;
  1033.                     // mainly for objects-meta data-type
  1034.                     $layoutDefinitions = $type->getLayoutDefinitions();
  1035.                     $context = [
  1036.                         'containerType' => 'fieldcollection',
  1037.                         'containerKey' => $type->getKey(),
  1038.                         'outerFieldname' => $request->get('field_name'),
  1039.                     ];
  1041.                     $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1043.                     DataObject\Service::enrichLayoutDefinition($layoutDefinitions, $object, $context);
  1045.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  1046.                         DataObject\Service::createSuperLayout($layoutDefinitions);
  1047.                     }
  1048.                 }
  1049.             }
  1051.             $list = $filteredList;
  1052.         }
  1054.         $event = new GenericEvent($this, [
  1055.             'list' => $list,
  1056.             'objectId' => $request->get('object_id'),
  1057.         ]);
  1058.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA);
  1059.         $list = $event->getArgument('list');
  1061.         return $this->adminJson(['fieldcollections' => $list]);
  1062.     }
  1064.     /**
  1065.      * @Route("/get-class-definition-for-column-config", name="getclassdefinitionforcolumnconfig", methods={"GET"})
  1066.      *
  1067.      * @param Request $request
  1068.      *
  1069.      * @return JsonResponse
  1070.      */
  1071.     public function getClassDefinitionForColumnConfigAction(Request $request)
  1072.     {
  1073.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  1074.         if (!$class) {
  1075.             throw $this->createNotFoundException();
  1076.         }
  1077.         $objectId = (int)$request->get('oid');
  1079.         $filteredDefinitions = DataObject\Service::getCustomLayoutDefinitionForGridColumnConfig($class, $objectId);
  1081.         /** @var DataObject\ClassDefinition\Layout $layoutDefinitions */
  1082.         $layoutDefinitions = isset($filteredDefinitions['layoutDefinition']) ? $filteredDefinitions['layoutDefinition'] : false;
  1083.         $filteredFieldDefinition = isset($filteredDefinitions['fieldDefinition']) ? $filteredDefinitions['fieldDefinition'] : false;
  1085.         $class->setFieldDefinitions([]);
  1087.         $result = [];
  1089.         DataObject\Service::enrichLayoutDefinition($layoutDefinitions);
  1091.         $result['objectColumns']['children'] = $layoutDefinitions->getChildren();
  1092.         $result['objectColumns']['nodeLabel'] = 'object_columns';
  1093.         $result['objectColumns']['nodeType'] = 'object';
  1095.         // array("id", "fullpath", "published", "creationDate", "modificationDate", "filename", "classname");
  1096.         $systemColumnNames = DataObject\Concrete::SYSTEM_COLUMN_NAMES;
  1097.         $systemColumns = [];
  1098.         foreach ($systemColumnNames as $systemColumn) {
  1099.             $systemColumns[] = ['title' => $systemColumn, 'name' => $systemColumn, 'datatype' => 'data', 'fieldtype' => 'system'];
  1100.         }
  1101.         $result['systemColumns']['nodeLabel'] = 'system_columns';
  1102.         $result['systemColumns']['nodeType'] = 'system';
  1103.         $result['systemColumns']['children'] = $systemColumns;
  1105.         $list = new DataObject\Objectbrick\Definition\Listing();
  1106.         $list = $list->load();
  1108.         foreach ($list as $brickDefinition) {
  1109.             $classDefs = $brickDefinition->getClassDefinitions();
  1110.             if (!empty($classDefs)) {
  1111.                 foreach ($classDefs as $classDef) {
  1112.                     if ($classDef['classname'] == $class->getName()) {
  1113.                         $fieldName = $classDef['fieldname'];
  1114.                         if ($filteredFieldDefinition && !$filteredFieldDefinition[$fieldName]) {
  1115.                             continue;
  1116.                         }
  1118.                         $key = $brickDefinition->getKey();
  1120.                         $brickLayoutDefinitions = $brickDefinition->getLayoutDefinitions();
  1121.                         $context = [
  1122.                             'containerType' => 'objectbrick',
  1123.                             'containerKey' => $key,
  1124.                             'outerFieldname' => $fieldName,
  1125.                         ];
  1126.                         DataObject\Service::enrichLayoutDefinition($brickLayoutDefinitions, null, $context);
  1128.                         $result[$key]['nodeLabel'] = $key;
  1129.                         $result[$key]['brickField'] = $fieldName;
  1130.                         $result[$key]['nodeType'] = 'objectbricks';
  1131.                         $result[$key]['children'] = $brickLayoutDefinitions->getChildren();
  1133.                         break;
  1134.                     }
  1135.                 }
  1136.             }
  1137.         }
  1139.         return $this->adminJson($result);
  1140.     }
  1142.     /**
  1143.      * OBJECT BRICKS
  1144.      */
  1146.     /**
  1147.      * @Route("/objectbrick-get", name="objectbrickget", methods={"GET"})
  1148.      *
  1149.      * @param Request $request
  1150.      *
  1151.      * @return JsonResponse
  1152.      */
  1153.     public function objectbrickGetAction(Request $request)
  1154.     {
  1155.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1157.         $isWriteable = $fc->isWritable();
  1158.         $fc = $fc->getObjectVars();
  1159.         $fc['isWriteable'] = $isWriteable;
  1161.         return $this->adminJson($fc);
  1162.     }
  1164.     /**
  1165.      * @Route("/objectbrick-update", name="objectbrickupdate", methods={"PUT", "POST"})
  1166.      *
  1167.      * @param Request $request
  1168.      * @param EventDispatcherInterface $eventDispatcher
  1169.      *
  1170.      * @return JsonResponse
  1171.      */
  1172.     public function objectbrickUpdateAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1173.     {
  1174.         try {
  1175.             $key = $request->get('key');
  1176.             $title = $request->get('title');
  1177.             $group = $request->get('group');
  1179.             if ($request->get('task') == 'add') {
  1180.                 // check for existing brick with same name with different lower/upper cases
  1181.                 $list = new DataObject\Objectbrick\Definition\Listing();
  1182.                 $list = $list->load();
  1184.                 foreach ($list as $item) {
  1185.                     if (strtolower($key) === strtolower($item->getKey())) {
  1186.                         throw new \Exception('Brick with the same name already exists (lower/upper cases may be different)');
  1187.                     }
  1188.                 }
  1189.             }
  1191.             // now we create a new definition
  1192.             $brickDef = new DataObject\Objectbrick\Definition();
  1193.             $brickDef->setKey($key);
  1194.             $brickDef->setTitle($title);
  1195.             $brickDef->setGroup($group);
  1197.             if ($request->get('values')) {
  1198.                 $values = $this->decodeJson($request->get('values'));
  1200.                 $brickDef->setParentClass($values['parentClass']);
  1201.                 $brickDef->setImplementsInterfaces($values['implementsInterfaces']);
  1202.                 $brickDef->setClassDefinitions($values['classDefinitions']);
  1203.                 $brickDef->setGenerateTypeDeclarations($values['generateTypeDeclarations']);
  1204.             }
  1206.             if ($request->get('configuration')) {
  1207.                 $configuration = $this->decodeJson($request->get('configuration'));
  1209.                 $configuration['datatype'] = 'layout';
  1210.                 $configuration['fieldtype'] = 'panel';
  1212.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  1213.                 $brickDef->setLayoutDefinitions($layout);
  1214.             }
  1216.             $event = new GenericEvent($this, [
  1217.                 'brickDefinition' => $brickDef,
  1218.             ]);
  1219.             $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_UPDATE_DEFINITION);
  1220.             $brickDef = $event->getArgument('brickDefinition');
  1222.             $brickDef->save();
  1224.             return $this->adminJson(['success' => true, 'id' => $brickDef->getKey()]);
  1225.         } catch (\Exception $e) {
  1226.             Logger::error($e->getMessage());
  1228.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1229.         }
  1230.     }
  1232.     /**
  1233.      * @Route("/import-objectbrick", name="importobjectbrick", methods={"POST"})
  1234.      *
  1235.      * @param Request $request
  1236.      *
  1237.      * @return JsonResponse
  1238.      */
  1239.     public function importObjectbrickAction(Request $request)
  1240.     {
  1241.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1243.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  1244.         $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($objectBrick, $data);
  1246.         $response = $this->adminJson([
  1247.             'success' => $success,
  1248.         ]);
  1250.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  1251.         // Ext.form.Action.Submit and mark the submission as failed
  1252.         $response->headers->set('Content-Type', 'text/html');
  1254.         return $response;
  1255.     }
  1257.     /**
  1258.      * @Route("/export-objectbrick", name="exportobjectbrick", methods={"GET"})
  1259.      *
  1260.      * @param Request $request
  1261.      *
  1262.      * @return Response
  1263.      */
  1264.     public function exportObjectbrickAction(Request $request)
  1265.     {
  1266.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1268.         if (!$objectBrick instanceof DataObject\Objectbrick\Definition) {
  1269.             $errorMessage = ': Object-Brick with id [ ' . $request->get('id') . ' not found. ]';
  1270.             Logger::error($errorMessage);
  1272.             throw $this->createNotFoundException($errorMessage);
  1273.         }
  1275.         $xml = DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick);
  1276.         $response = new Response($xml);
  1277.         $response->headers->set('Content-type', 'application/json');
  1278.         $response->headers->set('Content-Disposition', 'attachment; filename="objectbrick_' . $objectBrick->getKey() . '_export.json"');
  1280.         return $response;
  1281.     }
  1283.     /**
  1284.      * @Route("/objectbrick-delete", name="objectbrickdelete", methods={"DELETE"})
  1285.      *
  1286.      * @param Request $request
  1287.      *
  1288.      * @return JsonResponse
  1289.      */
  1290.     public function objectbrickDeleteAction(Request $request)
  1291.     {
  1292.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1293.         $fc->delete();
  1295.         return $this->adminJson(['success' => true]);
  1296.     }
  1298.     /**
  1299.      * @Route("/objectbrick-tree", name="objectbricktree", methods={"GET", "POST"})
  1300.      *
  1301.      * @param Request $request
  1302.      * @param EventDispatcherInterface $eventDispatcher
  1303.      *
  1304.      * @return JsonResponse
  1305.      */
  1306.     public function objectbrickTreeAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1307.     {
  1308.         $list = new DataObject\Objectbrick\Definition\Listing();
  1309.         $list = $list->load();
  1311.         $forObjectEditor = $request->get('forObjectEditor');
  1313.         $context = null;
  1314.         $layoutDefinitions = [];
  1315.         $groups = [];
  1316.         $definitions = [];
  1317.         $fieldname = null;
  1318.         $className = null;
  1320.         $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1322.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1323.             $classId = $request->get('class_id');
  1324.             $fieldname = $request->get('field_name');
  1325.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1326.             $className = $classDefinition->getName();
  1327.         }
  1329.         foreach ($list as $item) {
  1330.             if ($forObjectEditor) {
  1331.                 $context = [
  1332.                     'containerType' => 'objectbrick',
  1333.                     'containerKey' => $item->getKey(),
  1334.                     'outerFieldname' => $fieldname,
  1335.                 ];
  1336.             }
  1337.             if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1338.                 $keep = false;
  1339.                 $clsDefs = $item->getClassDefinitions();
  1340.                 if (!empty($clsDefs)) {
  1341.                     foreach ($clsDefs as $cd) {
  1342.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1343.                             $keep = true;
  1345.                             continue;
  1346.                         }
  1347.                     }
  1348.                 }
  1349.                 if (!$keep) {
  1350.                     continue;
  1351.                 }
  1352.             }
  1354.             if ($item->getGroup()) {
  1355.                 if (!isset($groups[$item->getGroup()])) {
  1356.                     $groups[$item->getGroup()] = [
  1357.                         'id' => 'group_' . $item->getKey(),
  1358.                         'text' => htmlspecialchars($item->getGroup()),
  1359.                         'expandable' => true,
  1360.                         'leaf' => false,
  1361.                         'allowChildren' => true,
  1362.                         'iconCls' => 'pimcore_icon_folder',
  1363.                         'group' => $item->getGroup(),
  1364.                         'children' => [],
  1365.                     ];
  1366.                 }
  1367.                 if ($forObjectEditor) {
  1368.                     $layoutId = $request->get('layoutId');
  1369.                     $itemLayoutDefinitions = null;
  1370.                     if ($layoutId) {
  1371.                         $layout = DataObject\ClassDefinition\CustomLayout::getById($layoutId.'.brick.'.$item->getKey());
  1372.                         if ($layout instanceof DataObject\ClassDefinition\CustomLayout) {
  1373.                             $itemLayoutDefinitions = $layout->getLayoutDefinitions();
  1374.                         }
  1375.                     }
  1377.                     if ($itemLayoutDefinitions === null) {
  1378.                         $itemLayoutDefinitions = $item->getLayoutDefinitions();
  1379.                     }
  1381.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object, $context);
  1383.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  1384.                 }
  1385.                 $groups[$item->getGroup()]['children'][] =
  1386.                     [
  1387.                         'id' => $item->getKey(),
  1388.                         'text' => $item->getKey(),
  1389.                         'title' => $item->getTitle(),
  1390.                         'key' => $item->getKey(),
  1391.                         'leaf' => true,
  1392.                         'iconCls' => 'pimcore_icon_objectbricks',
  1393.                     ];
  1394.             } else {
  1395.                 if ($forObjectEditor) {
  1396.                     $layout = $item->getLayoutDefinitions();
  1398.                     $currentLayoutId = $request->get('layoutId', null);
  1400.                     $user = $this->getAdminUser();
  1401.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  1402.                         DataObject\Service::createSuperLayout($layout);
  1403.                     } elseif ($currentLayoutId) {
  1404.                         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($currentLayoutId.'.brick.'.$item->getKey());
  1405.                         if ($customLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  1406.                             $layout = $customLayout->getLayoutDefinitions();
  1407.                         }
  1408.                     }
  1410.                     DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1412.                     $layoutDefinitions[$item->getKey()] = $layout;
  1413.                 }
  1414.                 $definitions[] = [
  1415.                     'id' => $item->getKey(),
  1416.                     'text' => $item->getKey(),
  1417.                     'title' => $item->getTitle(),
  1418.                     'key' => $item->getKey(),
  1419.                     'leaf' => true,
  1420.                     'iconCls' => 'pimcore_icon_objectbricks',
  1421.                 ];
  1422.             }
  1423.         }
  1425.         foreach ($groups as $group) {
  1426.             $definitions[] = $group;
  1427.         }
  1429.         $event = new GenericEvent($this, [
  1430.             'list' => $definitions,
  1431.             'objectId' => $request->get('object_id'),
  1432.         ]);
  1433.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA);
  1434.         $definitions = $event->getArgument('list');
  1436.         if ($forObjectEditor) {
  1437.             return $this->adminJson(['objectbricks' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  1438.         } else {
  1439.             return $this->adminJson($definitions);
  1440.         }
  1441.     }
  1443.     /**
  1444.      * @Route("/objectbrick-list", name="objectbricklist", methods={"GET"})
  1445.      *
  1446.      * @param Request $request
  1447.      * @param EventDispatcherInterface $eventDispatcher
  1448.      *
  1449.      * @return JsonResponse
  1450.      */
  1451.     public function objectbrickListAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1452.     {
  1453.         $list = new DataObject\Objectbrick\Definition\Listing();
  1454.         $list = $list->load();
  1456.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1457.             $filteredList = [];
  1458.             $classId = $request->get('class_id');
  1459.             $fieldname = $request->get('field_name');
  1460.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1461.             $className = $classDefinition->getName();
  1463.             foreach ($list as $type) {
  1464.                 $clsDefs = $type->getClassDefinitions();
  1465.                 if (!empty($clsDefs)) {
  1466.                     foreach ($clsDefs as $cd) {
  1467.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1468.                             $filteredList[] = $type;
  1470.                             continue;
  1471.                         }
  1472.                     }
  1473.                 }
  1475.                 $layout = $type->getLayoutDefinitions();
  1477.                 $currentLayoutId = $request->get('layoutId', null);
  1479.                 $user = $this->getAdminUser();
  1480.                 if ($currentLayoutId == -1 && $user->isAdmin()) {
  1481.                     DataObject\Service::createSuperLayout($layout);
  1482.                     $objectData['layout'] = $layout;
  1483.                 }
  1485.                 $context = [
  1486.                     'containerType' => 'objectbrick',
  1487.                     'containerKey' => $type->getKey(),
  1488.                     'outerFieldname' => $request->get('field_name'),
  1489.                 ];
  1491.                 $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1493.                 DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1494.                 $type->setLayoutDefinitions($layout);
  1495.             }
  1497.             $list = $filteredList;
  1498.         }
  1500.         $event = new GenericEvent($this, [
  1501.             'list' => $list,
  1502.             'objectId' => $request->get('object_id'),
  1503.         ]);
  1504.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA);
  1505.         $list = $event->getArgument('list');
  1507.         return $this->adminJson(['objectbricks' => $list]);
  1508.     }
  1510.     /**
  1511.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1512.      * Add option to export/import all class definitions/brick definitions etc. at once
  1513.      */
  1515.     /**
  1516.      * @Route("/bulk-import", name="bulkimport", methods={"POST"})
  1517.      *
  1518.      * @param Request $request
  1519.      *
  1520.      * @return JsonResponse
  1521.      */
  1522.     public function bulkImportAction(Request $request)
  1523.     {
  1524.         $result = [];
  1526.         $tmpName = $_FILES['Filedata']['tmp_name'];
  1527.         $json = file_get_contents($tmpName);
  1529.         $tmpName = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/bulk-import-' . uniqid() . '.tmp';
  1530.         file_put_contents($tmpName, $json);
  1532.         Session::useSession(function (AttributeBagInterface $session) use ($tmpName) {
  1533.             $session->set('class_bulk_import_file', $tmpName);
  1534.         }, 'pimcore_objects');
  1536.         $json = json_decode($json, true);
  1538.         foreach ($json as $groupName => $group) {
  1539.             foreach ($group as $groupItem) {
  1540.                 $displayName = null;
  1541.                 $icon = null;
  1543.                 if ($groupName == 'class') {
  1544.                     $name = $groupItem['name'];
  1545.                     $icon = 'class';
  1546.                 } elseif ($groupName == 'customlayout') {
  1547.                     $className = $groupItem['className'];
  1549.                     $layoutData = ['className' => $className, 'name' => $groupItem['name']];
  1550.                     $name = base64_encode(json_encode($layoutData));
  1551.                     $displayName = $className . ' / ' . $groupItem['name'];
  1552.                     $icon = 'custom_views';
  1553.                 } else {
  1554.                     if ($groupName == 'objectbrick') {
  1555.                         $icon = 'objectbricks';
  1556.                     } elseif ($groupName == 'fieldcollection') {
  1557.                         $icon = 'fieldcollection';
  1558.                     }
  1559.                     $name = $groupItem['key'];
  1560.                 }
  1562.                 if (!$displayName) {
  1563.                     $displayName = $name;
  1564.                 }
  1565.                 $result[] = ['icon' => $icon, 'checked' => true, 'type' => $groupName, 'name' => $name, 'displayName' => $displayName];
  1566.             }
  1567.         }
  1569.         $response = $this->adminJson(['success' => true, 'data' => $result]);
  1570.         $response->headers->set('Content-Type', 'text/html');
  1572.         return $response;
  1573.     }
  1575.     /**
  1576.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1577.      * Add option to export/import all class definitions/brick definitions etc. at once
  1578.      */
  1580.     /**
  1581.      * @Route("/bulk-commit", name="bulkcommit", methods={"POST"})
  1582.      *
  1583.      * @param Request $request
  1584.      *
  1585.      * @return JsonResponse
  1586.      *
  1587.      * @throws \Exception
  1588.      */
  1589.     public function bulkCommitAction(Request $request)
  1590.     {
  1591.         $data = json_decode($request->get('data'), true);
  1593.         $session = Session::get('pimcore_objects');
  1594.         $filename = $session->get('class_bulk_import_file');
  1595.         $json = @file_get_contents($filename);
  1596.         $json = json_decode($json, true);
  1598.         $type = $data['type'];
  1599.         $name = $data['name'];
  1600.         $list = $json[$type];
  1602.         foreach ($list as $item) {
  1603.             unset($item['creationDate']);
  1604.             unset($item['modificationDate']);
  1605.             unset($item['userOwner']);
  1606.             unset($item['userModification']);
  1608.             if ($type == 'class' && $item['name'] == $name) {
  1609.                 $class = DataObject\ClassDefinition::getByName($name);
  1610.                 if (!$class) {
  1611.                     $class = new DataObject\ClassDefinition();
  1612.                     $class->setName($name);
  1613.                 }
  1614.                 $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, json_encode($item), true);
  1616.                 return $this->adminJson(['success' => $success !== false]);
  1617.             } elseif ($type == 'objectbrick' && $item['key'] == $name) {
  1618.                 if (!$brick = DataObject\Objectbrick\Definition::getByKey($name)) {
  1619.                     $brick = new DataObject\Objectbrick\Definition();
  1620.                     $brick->setKey($name);
  1621.                 }
  1623.                 $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($brick, json_encode($item), true);
  1625.                 return $this->adminJson(['success' => $success !== false]);
  1626.             } elseif ($type == 'fieldcollection' && $item['key'] == $name) {
  1627.                 if (!$fieldCollection = DataObject\Fieldcollection\Definition::getByKey($name)) {
  1628.                     $fieldCollection = new DataObject\Fieldcollection\Definition();
  1629.                     $fieldCollection->setKey($name);
  1630.                 }
  1632.                 $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, json_encode($item), true);
  1634.                 return $this->adminJson(['success' => $success !== false]);
  1635.             } elseif ($type == 'customlayout') {
  1636.                 $layoutData = json_decode(base64_decode($data['name']), true);
  1637.                 $className = $layoutData['className'];
  1638.                 $layoutName = $layoutData['name'];
  1640.                 if ($item['name'] == $layoutName && $item['className'] == $className) {
  1641.                     $class = DataObject\ClassDefinition::getByName($className);
  1642.                     if (!$class) {
  1643.                         throw new \Exception('Class does not exist');
  1644.                     }
  1646.                     $classId = $class->getId();
  1648.                     $layoutList = new DataObject\ClassDefinition\CustomLayout\Listing();
  1649.                     $layoutList->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($layoutName, $classId) {
  1650.                         return $layout->getName() === $layoutName && $layout->getClassId() === $classId;
  1651.                     });
  1652.                     $layoutList = $layoutList->load();
  1654.                     $layoutDefinition = null;
  1655.                     if ($layoutList) {
  1656.                         $layoutDefinition = $layoutList[0];
  1657.                     }
  1659.                     if (!$layoutDefinition) {
  1660.                         $layoutDefinition = new DataObject\ClassDefinition\CustomLayout();
  1661.                         $layoutDefinition->setName($layoutName);
  1662.                         $layoutDefinition->setClassId($classId);
  1663.                     }
  1665.                     try {
  1666.                         $layoutDefinition->setDescription($item['description']);
  1667.                         $layoutDef = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($item['layoutDefinitions'], true);
  1668.                         $layoutDefinition->setLayoutDefinitions($layoutDef);
  1669.                         $layoutDefinition->save();
  1670.                     } catch (\Exception $e) {
  1671.                         Logger::error($e->getMessage());
  1673.                         return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1674.                     }
  1675.                 }
  1676.             }
  1677.         }
  1679.         return $this->adminJson(['success' => true]);
  1680.     }
  1682.     /**
  1683.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1684.      * Add option to export/import all class definitions/brick definitions etc. at once
  1685.      */
  1687.     /**
  1688.      * @Route("/bulk-export-prepare", name="bulkexportprepare", methods={"POST"})
  1689.      *
  1690.      * @param Request $request
  1691.      *
  1692.      * @return Response
  1693.      */
  1694.     public function bulkExportPrepareAction(Request $request)
  1695.     {
  1696.         $data = $request->get('data');
  1698.         Session::useSession(function (AttributeBagInterface $session) use ($data) {
  1699.             $session->set('class_bulk_export_settings', $data);
  1700.         }, 'pimcore_objects');
  1702.         return $this->adminJson(['success' => true]);
  1703.     }
  1705.     /**
  1706.      * @Route("/bulk-export", name="bulkexport", methods={"GET"})
  1707.      *
  1708.      * @param Request $request
  1709.      *
  1710.      * @return Response
  1711.      */
  1712.     public function bulkExportAction(Request $request)
  1713.     {
  1714.         $result = [];
  1716.         $fieldCollections = new DataObject\Fieldcollection\Definition\Listing();
  1717.         $fieldCollections = $fieldCollections->load();
  1719.         foreach ($fieldCollections as $fieldCollection) {
  1720.             $result[] = [
  1721.                 'icon' => 'fieldcollection',
  1722.                 'checked' => true,
  1723.                 'type' => 'fieldcollection',
  1724.                 'name' => $fieldCollection->getKey(),
  1725.                 'displayName' => $fieldCollection->getKey(),
  1726.             ];
  1727.         }
  1729.         $classes = new DataObject\ClassDefinition\Listing();
  1730.         $classes->setOrder('ASC');
  1731.         $classes->setOrderKey('id');
  1732.         $classes = $classes->load();
  1734.         foreach ($classes as $class) {
  1735.             $result[] = [
  1736.                 'icon' => 'class',
  1737.                 'checked' => true,
  1738.                 'type' => 'class',
  1739.                 'name' => $class->getName(),
  1740.                 'displayName' => $class->getName(),
  1741.             ];
  1742.         }
  1744.         $objectBricks = new DataObject\Objectbrick\Definition\Listing();
  1745.         $objectBricks = $objectBricks->load();
  1747.         foreach ($objectBricks as $objectBrick) {
  1748.             $result[] = [
  1749.                 'icon' => 'objectbricks',
  1750.                 'checked' => true,
  1751.                 'type' => 'objectbrick',
  1752.                 'name' => $objectBrick->getKey(),
  1753.                 'displayName' => $objectBrick->getKey(),
  1754.             ];
  1755.         }
  1757.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  1758.         $customLayouts = $customLayouts->load();
  1759.         foreach ($customLayouts as $customLayout) {
  1760.             $class = DataObject\ClassDefinition::getById($customLayout->getClassId());
  1761.             $displayName = $class->getName() . ' / ' .  $customLayout->getName();
  1763.             $result[] = [
  1764.                 'icon' => 'custom_views',
  1765.                 'checked' => true,
  1766.                 'type' => 'customlayout',
  1767.                 'name' => $customLayout->getId(),
  1768.                 'displayName' => $displayName,
  1769.             ];
  1770.         }
  1772.         return new JsonResponse(['success' => true, 'data' => $result]);
  1773.     }
  1775.     /**
  1776.      * @Route("/do-bulk-export", name="dobulkexport", methods={"GET"})
  1777.      *
  1778.      * @param Request $request
  1779.      *
  1780.      * @return Response
  1781.      */
  1782.     public function doBulkExportAction(Request $request)
  1783.     {
  1784.         $session = Session::get('pimcore_objects');
  1785.         $list = $session->get('class_bulk_export_settings');
  1786.         $list = json_decode($list, true);
  1787.         $result = [];
  1789.         foreach ($list as $item) {
  1790.             if ($item['type'] == 'fieldcollection') {
  1791.                 if ($fieldCollection = DataObject\Fieldcollection\Definition::getByKey($item['name'])) {
  1792.                     $fieldCollectionJson = json_decode(DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection));
  1793.                     $fieldCollectionJson->key = $item['name'];
  1794.                     $result['fieldcollection'][] = $fieldCollectionJson;
  1795.                 }
  1796.             } elseif ($item['type'] == 'class') {
  1797.                 if ($class = DataObject\ClassDefinition::getByName($item['name'])) {
  1798.                     $data = json_decode(DataObject\ClassDefinition\Service::generateClassDefinitionJson($class));
  1799.                     $data->name = $item['name'];
  1800.                     $result['class'][] = $data;
  1801.                 }
  1802.             } elseif ($item['type'] == 'objectbrick') {
  1803.                 if ($objectBrick = DataObject\Objectbrick\Definition::getByKey($item['name'])) {
  1804.                     $objectBrickJson = json_decode(DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick));
  1805.                     $objectBrickJson->key = $item['name'];
  1806.                     $result['objectbrick'][] = $objectBrickJson;
  1807.                 }
  1808.             } elseif ($item['type'] == 'customlayout') {
  1809.                 if ($customLayout = DataObject\ClassDefinition\CustomLayout::getById($item['name'])) {
  1810.                     $classId = $customLayout->getClassId();
  1811.                     $class = DataObject\ClassDefinition::getById($classId);
  1812.                     $customLayoutJson = json_decode(DataObject\ClassDefinition\Service::generateCustomLayoutJson($customLayout));
  1813.                     $customLayoutJson->name = $customLayout->getName();
  1814.                     $customLayoutJson->className = $class->getName();
  1815.                     $result['customlayout'][] = $customLayoutJson;
  1816.                 }
  1817.             }
  1818.         }
  1820.         $result = json_encode($result, JSON_PRETTY_PRINT);
  1821.         $response = new Response($result);
  1822.         $response->headers->set('Content-type', 'application/json');
  1823.         $response->headers->set('Content-Disposition', 'attachment; filename="bulk_export.json"');
  1825.         return $response;
  1826.     }
  1828.     /**
  1829.      * @param ControllerEvent $event
  1830.      */
  1831.     public function onKernelControllerEvent(ControllerEvent $event)
  1832.     {
  1833.         if (!$event->isMainRequest()) {
  1834.             return;
  1835.         }
  1837.         // check permissions
  1838.         $unrestrictedActions = [
  1839.             'getTreeAction', 'fieldcollectionListAction', 'fieldcollectionTreeAction', 'fieldcollectionGetAction',
  1840.             'getClassDefinitionForColumnConfigAction', 'objectbrickListAction', 'objectbrickTreeAction', 'objectbrickGetAction',
  1841.         ];
  1843.         $this->checkActionPermission($event, 'classes', $unrestrictedActions);
  1844.     }
  1846.     /**
  1847.      * @Route("/get-fieldcollection-usages", name="getfieldcollectionusages", methods={"GET"})
  1848.      *
  1849.      * @param Request $request
  1850.      *
  1851.      * @return Response
  1852.      */
  1853.     public function getFieldcollectionUsagesAction(Request $request)
  1854.     {
  1855.         $key = $request->get('key');
  1856.         $result = [];
  1858.         $classes = new DataObject\ClassDefinition\Listing();
  1859.         $classes = $classes->load();
  1860.         foreach ($classes as $class) {
  1861.             $fieldDefs = $class->getFieldDefinitions();
  1862.             foreach ($fieldDefs as $fieldDef) {
  1863.                 if ($fieldDef instanceof DataObject\ClassDefinition\Data\Fieldcollections) {
  1864.                     $allowedKeys = $fieldDef->getAllowedTypes();
  1865.                     if (is_array($allowedKeys) && in_array($key, $allowedKeys)) {
  1866.                         $result[] = [
  1867.                             'class' => $class->getName(),
  1868.                             'field' => $fieldDef->getName(),
  1869.                         ];
  1870.                     }
  1871.                 }
  1872.             }
  1873.         }
  1875.         return $this->adminJson($result);
  1876.     }
  1878.     /**
  1879.      * @Route("/get-bricks-usages", name="getbrickusages", methods={"GET"})
  1880.      *
  1881.      * @param Request $request
  1882.      *
  1883.      * @return Response
  1884.      */
  1885.     public function getBrickUsagesAction(Request $request)
  1886.     {
  1887.         $classId = $request->get('classId');
  1888.         $myclass = DataObject\ClassDefinition::getById($classId);
  1890.         $result = [];
  1892.         $brickDefinitions = new DataObject\Objectbrick\Definition\Listing();
  1893.         $brickDefinitions = $brickDefinitions->load();
  1894.         foreach ($brickDefinitions as $brickDefinition) {
  1895.             $classes = $brickDefinition->getClassDefinitions();
  1896.             foreach ($classes as $class) {
  1897.                 if ($myclass->getName() == $class['classname']) {
  1898.                     $result[] = [
  1899.                         'objectbrick' => $brickDefinition->getKey(),
  1900.                         'field' => $class['fieldname'],
  1901.                     ];
  1902.                 }
  1903.             }
  1904.         }
  1906.         return $this->adminJson($result);
  1907.     }
  1909.     /**
  1910.      * @Route("/get-icons", name="geticons", methods={"GET"})
  1911.      *
  1912.      * @param Request $request
  1913.      * @param EventDispatcherInterface $eventDispatcher
  1914.      *
  1915.      * @return Response
  1916.      */
  1917.     public function getIconsAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1918.     {
  1919.         $classId = $request->get('classId');
  1921.         $iconDir = PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/img';
  1922.         $classIcons = rscandir($iconDir . '/object-icons/');
  1923.         $colorIcons = rscandir($iconDir . '/flat-color-icons/');
  1924.         $twemoji = rscandir($iconDir . '/twemoji/');
  1926.         $icons = array_merge($classIcons, $colorIcons, $twemoji);
  1928.         foreach ($icons as &$icon) {
  1929.             $icon = str_replace(PIMCORE_WEB_ROOT, '', $icon);
  1930.         }
  1932.         $event = new GenericEvent($this, [
  1933.             'icons' => $icons,
  1934.             'classId' => $classId,
  1935.         ]);
  1936.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECT_ICONS_PRE_SEND_DATA);
  1937.         $icons = $event->getArgument('icons');
  1939.         $result = [];
  1940.         foreach ($icons as $icon) {
  1941.             $content = file_get_contents(PIMCORE_WEB_ROOT . $icon);
  1942.             $result[] = [
  1943.                 'text' => sprintf('<img src="data:%s;base64,%s"/>', mime_content_type(PIMCORE_WEB_ROOT . $icon), base64_encode($content)),
  1944.                 'value' => $icon,
  1945.             ];
  1946.         }
  1948.         return $this->adminJson($result);
  1949.     }
  1951.     /**
  1952.      * @Route("/suggest-class-identifier", name="suggestclassidentifier")
  1953.      *
  1954.      * @return Response
  1955.      */
  1956.     public function suggestClassIdentifierAction()
  1957.     {
  1958.         $db = Db::get();
  1959.         $maxId = $db->fetchOne('SELECT MAX(CAST(id AS SIGNED)) FROM classes;');
  1961.         $existingIds = $db->fetchFirstColumn('select LOWER(id) from classes');
  1963.         $result = [
  1964.             'suggestedIdentifier' => $maxId ? $maxId + 1 : 1,
  1965.             'existingIds' => $existingIds,
  1966.             ];
  1968.         return $this->adminJson($result);
  1969.     }
  1971.     /**
  1972.      * @Route("/suggest-custom-layout-identifier", name="suggestcustomlayoutidentifier")
  1973.      *
  1974.      * @param Request $request
  1975.      *
  1976.      * @return Response
  1977.      */
  1978.     public function suggestCustomLayoutIdentifierAction(Request $request)
  1979.     {
  1980.         $classId = $request->get('classId');
  1982.         $identifier = DataObject\ClassDefinition\CustomLayout::getIdentifier($classId);
  1984.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  1986.         $list = $list->load();
  1987.         $existingIds = [];
  1988.         $existingNames = [];
  1990.         foreach ($list as $item) {
  1991.             $existingIds[] = $item->getId();
  1992.             if ($item->getClassId() == $classId) {
  1993.                 $existingNames[] = $item->getName();
  1994.             }
  1995.         }
  1997.         $result = [
  1998.             'suggestedIdentifier' => $identifier,
  1999.             'existingIds' => $existingIds,
  2000.             'existingNames' => $existingNames,
  2001.             ];
  2003.         return $this->adminJson($result);
  2004.     }
  2006.     /**
  2007.      * @Route("/text-layout-preview", name="textlayoutpreview")
  2008.      *
  2009.      * @param Request $request
  2010.      *
  2011.      * @return Response
  2012.      */
  2013.     public function textLayoutPreviewAction(Request $request)
  2014.     {
  2015.         $objPath = $request->get('previewObject', '');
  2016.         $className = '\\Pimcore\\Model\\DataObject\\' . $request->get('className');
  2017.         $obj = DataObject::getByPath($objPath) ?? new $className();
  2019.         $textLayout = new DataObject\ClassDefinition\Layout\Text();
  2021.         $context = [
  2022.           'data' => $request->get('renderingData'),
  2023.         ];
  2025.         if ($renderingClass = $request->get('renderingClass')) {
  2026.             $textLayout->setRenderingClass($renderingClass);
  2027.         }
  2029.         if ($staticHtml = $request->get('html')) {
  2030.             $textLayout->setHtml($staticHtml);
  2031.         }
  2033.         $html = $textLayout->enrichLayoutDefinition($obj, $context)->getHtml();
  2035.         $content =
  2036.             "<html>\n" .
  2037.             "<head>\n" .
  2038.             '<style type="text/css">' . "\n" .
  2039.             file_get_contents(PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/css/admin.css') .
  2040.             "</style>\n" .
  2041.             "</head>\n\n" .
  2042.             "<body class='objectlayout_element_text'>\n" .
  2043.             $html .
  2044.             "\n\n</body>\n" .
  2045.             "</html>\n";
  2047.         $response = new Response($content);
  2048.         $response->headers->set('Content-Type', 'text/html');
  2050.         return $response;
  2051.     }
  2053.     /**
  2054.      * @Route("/video-supported-types", name="videosupportedTypestypes")
  2055.      *
  2056.      * @param Request $request
  2057.      * @param TranslatorInterface $translator
  2058.      *
  2059.      * @return Response
  2060.      */
  2061.     public function videoAllowedTypesAction(Request $request, TranslatorInterface $translator)
  2062.     {
  2063.         $videoDef = new DataObject\ClassDefinition\Data\Video();
  2064.         $res = [];
  2066.         foreach ($videoDef->getSupportedTypes() as $type) {
  2067.             $res[] = [
  2068.                 'key' => $type,
  2069.                 'value' => $translator->trans($type, [], 'admin'),
  2070.             ];
  2071.         }
  2073.         return $this->adminJson($res);
  2074.     }
  2075. }