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

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.         unset($values['creationDate']);
  459.         unset($values['userOwner']);
  460.         unset($values['layoutDefinitions']);
  461.         unset($values['fieldDefinitions']);
  463.         $configuration['datatype'] = 'layout';
  464.         $configuration['fieldtype'] = 'panel';
  465.         $configuration['name'] = 'pimcore_root';
  467.         $class->setValues($values);
  469.         try {
  470.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  472.             $class->setLayoutDefinitions($layout);
  474.             $class->setUserModification($this->getAdminUser()->getId());
  475.             $class->setModificationDate(time());
  477.             $propertyVisibility = [];
  478.             foreach ($values as $key => $value) {
  479.                 if (preg_match('/propertyVisibility/i', $key)) {
  480.                     if (preg_match("/\.grid\./i", $key)) {
  481.                         $propertyVisibility['grid'][preg_replace("/propertyVisibility\.grid\./i", '', $key)] = (bool) $value;
  482.                     } elseif (preg_match("/\.search\./i", $key)) {
  483.                         $propertyVisibility['search'][preg_replace("/propertyVisibility\.search\./i", '', $key)] = (bool) $value;
  484.                     }
  485.                 }
  486.             }
  487.             if (!empty($propertyVisibility)) {
  488.                 $class->setPropertyVisibility($propertyVisibility);
  489.             }
  491.             $class->save();
  493.             // set the fielddefinitions to [] because we don't need them in the response
  494.             $class->setFieldDefinitions([]);
  496.             return $this->adminJson(['success' => true, 'class' => $class]);
  497.         } catch (\Exception $e) {
  498.             Logger::error($e->getMessage());
  500.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  501.         }
  502.     }
  504.     /**
  505.      * @param string $name
  506.      *
  507.      * @return string
  508.      */
  509.     protected function correctClassname($name)
  510.     {
  511.         $name = preg_replace('/[^a-zA-Z0-9_]+/', '', $name);
  512.         $name = preg_replace('/^[0-9]+/', '', $name);
  514.         return $name;
  515.     }
  517.     /**
  518.      * @Route("/import-class", name="importclass", methods={"POST", "PUT"})
  519.      *
  520.      * @param Request $request
  521.      *
  522.      * @return Response
  523.      */
  524.     public function importClassAction(Request $request)
  525.     {
  526.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  527.         if (!$class) {
  528.             throw $this->createNotFoundException();
  529.         }
  530.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  532.         $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, $json, false, true);
  534.         $response = $this->adminJson([
  535.             'success' => $success,
  536.         ]);
  537.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  538.         // Ext.form.Action.Submit and mark the submission as failed
  539.         $response->headers->set('Content-Type', 'text/html');
  541.         return $response;
  542.     }
  544.     /**
  545.      * @Route("/import-custom-layout-definition", name="importcustomlayoutdefinition", methods={"POST", "PUT"})
  546.      *
  547.      * @param Request $request
  548.      *
  549.      * @return Response
  550.      */
  551.     public function importCustomLayoutDefinitionAction(Request $request)
  552.     {
  553.         $success = false;
  554.         $responseContent = [];
  555.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  556.         $importData = $this->decodeJson($json);
  558.         $existingLayout = null;
  559.         if (isset($importData['name'])) {
  560.             $existingLayout = DataObject\ClassDefinition\CustomLayout::getByName($importData['name']);
  562.             if ($existingLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  563.                 $responseContent['nameAlreadyInUse'] = true;
  564.             }
  565.         }
  567.         if (!$existingLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  568.             $customLayoutId = $request->get('id');
  569.             $customLayout = DataObject\ClassDefinition\CustomLayout::getById($customLayoutId);
  570.             if ($customLayout) {
  571.                 try {
  572.                     $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($importData['layoutDefinitions'], true);
  573.                     $customLayout->setLayoutDefinitions($layout);
  574.                     if (isset($importData['name']) === true) {
  575.                         $customLayout->setName($importData['name']);
  576.                     }
  577.                     $customLayout->setDescription($importData['description']);
  578.                     $customLayout->save();
  579.                     $success = true;
  580.                 } catch (\Exception $e) {
  581.                     Logger::error($e->getMessage());
  582.                 }
  583.             }
  585.             $responseContent['success'] = $success;
  586.         }
  588.         $response = $this->adminJson($responseContent);
  590.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  591.         // Ext.form.Action.Submit and mark the submission as failed
  592.         $response->headers->set('Content-Type', 'text/html');
  594.         return $response;
  595.     }
  597.     /**
  598.      * @Route("/get-custom-layout-definitions", name="getcustomlayoutdefinitions", methods={"GET"})
  599.      *
  600.      * @param Request $request
  601.      *
  602.      * @return JsonResponse
  603.      */
  604.     public function getCustomLayoutDefinitionsAction(Request $request)
  605.     {
  606.         $classIds = explode(',', $request->get('classId'));
  607.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  609.         $list->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($classIds) {
  610.             return in_array($layout->getClassId(), $classIds) && !str_contains($layout->getId(), '.brick.');
  611.         });
  612.         $list = $list->load();
  613.         $result = [];
  614.         foreach ($list as $item) {
  615.             $result[] = [
  616.                 'id' => $item->getId(),
  617.                 'name' => $item->getName() . ' (ID: ' . $item->getId() . ')',
  618.                 'default' => $item->getDefault() ?: 0,
  619.             ];
  620.         }
  622.         return $this->adminJson(['success' => true, 'data' => $result]);
  623.     }
  625.     /**
  626.      * @Route("/get-all-layouts", name="getalllayouts", methods={"GET"})
  627.      *
  628.      * @param Request $request
  629.      *
  630.      * @return JsonResponse
  631.      */
  632.     public function getAllLayoutsAction(Request $request)
  633.     {
  634.         // get all classes
  635.         $resultList = [];
  636.         $mapping = [];
  638.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  639.         $customLayouts->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) {
  640.             return !str_contains($layout->getId(), '.brick.');
  641.         });
  642.         $customLayouts->setOrder(function (DataObject\ClassDefinition\CustomLayout $a, DataObject\ClassDefinition\CustomLayout $b) {
  643.             return strcmp($a->getName(), $b->getName());
  644.         });
  646.         $customLayouts = $customLayouts->load();
  647.         foreach ($customLayouts as $layout) {
  648.             $mapping[$layout->getClassId()][] = $layout;
  649.         }
  651.         $classList = new DataObject\ClassDefinition\Listing();
  652.         $classList->setOrder('ASC');
  653.         $classList->setOrderKey('name');
  654.         $classList = $classList->load();
  656.         foreach ($classList as $class) {
  657.             if (isset($mapping[$class->getId()])) {
  658.                 $classMapping = $mapping[$class->getId()];
  659.                 $resultList[] = [
  660.                     'type' => 'master',
  661.                     'id' => $class->getId() . '_' . 0,
  662.                     'name' => $class->getName(),
  663.                 ];
  665.                 foreach ($classMapping as $layout) {
  666.                     $resultList[] = [
  667.                         'type' => 'custom',
  668.                         'id' => $class->getId() . '_' . $layout->getId(),
  669.                         'name' => $class->getName() . ' - ' . $layout->getName(),
  670.                     ];
  671.                 }
  672.             }
  673.         }
  675.         return $this->adminJson(['data' => $resultList]);
  676.     }
  678.     /**
  679.      * @Route("/export-class", name="exportclass", methods={"GET"})
  680.      *
  681.      * @param Request $request
  682.      *
  683.      * @return Response
  684.      */
  685.     public function exportClassAction(Request $request)
  686.     {
  687.         $id = $request->get('id');
  688.         $class = DataObject\ClassDefinition::getById($id);
  690.         if (!$class instanceof DataObject\ClassDefinition) {
  691.             $errorMessage = ': Class with id [ ' . $id . ' not found. ]';
  692.             Logger::error($errorMessage);
  694.             throw $this->createNotFoundException($errorMessage);
  695.         }
  697.         $json = DataObject\ClassDefinition\Service::generateClassDefinitionJson($class);
  699.         $response = new Response($json);
  700.         $response->headers->set('Content-type', 'application/json');
  701.         $response->headers->set('Content-Disposition', 'attachment; filename="class_' . $class->getName() . '_export.json"');
  703.         return $response;
  704.     }
  706.     /**
  707.      * @Route("/export-custom-layout-definition", name="exportcustomlayoutdefinition", methods={"GET"})
  708.      *
  709.      * @param Request $request
  710.      *
  711.      * @return Response
  712.      */
  713.     public function exportCustomLayoutDefinitionAction(Request $request)
  714.     {
  715.         $id = $request->get('id');
  717.         if ($id) {
  718.             $customLayout = DataObject\ClassDefinition\CustomLayout::getById($id);
  719.             if ($customLayout) {
  720.                 $name = $customLayout->getName();
  721.                 $json = DataObject\ClassDefinition\Service::generateCustomLayoutJson($customLayout);
  723.                 $response = new Response($json);
  724.                 $response->headers->set('Content-type', 'application/json');
  725.                 $response->headers->set('Content-Disposition', 'attachment; filename="custom_definition_' . $name . '_export.json"');
  727.                 return $response;
  728.             }
  729.         }
  731.         $errorMessage = ': Custom Layout with id [ ' . $id . ' not found. ]';
  732.         Logger::error($errorMessage);
  734.         throw $this->createNotFoundException($errorMessage);
  735.     }
  737.     /**
  738.      * FIELDCOLLECTIONS
  739.      */
  741.     /**
  742.      * @Route("/fieldcollection-get", name="fieldcollectionget", methods={"GET"})
  743.      *
  744.      * @param Request $request
  745.      *
  746.      * @return JsonResponse
  747.      */
  748.     public function fieldcollectionGetAction(Request $request)
  749.     {
  750.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  752.         $isWriteable = $fc->isWritable();
  753.         $fc = $fc->getObjectVars();
  754.         $fc['isWriteable'] = $isWriteable;
  756.         return $this->adminJson($fc);
  757.     }
  759.     /**
  760.      * @Route("/fieldcollection-update", name="fieldcollectionupdate", methods={"PUT", "POST"})
  761.      *
  762.      * @param Request $request
  763.      *
  764.      * @return JsonResponse
  765.      */
  766.     public function fieldcollectionUpdateAction(Request $request)
  767.     {
  768.         try {
  769.             $key = $request->get('key');
  770.             $title = $request->get('title');
  771.             $group = $request->get('group');
  773.             if ($request->get('task') == 'add') {
  774.                 // check for existing fieldcollection with same name with different lower/upper cases
  775.                 $list = new DataObject\Fieldcollection\Definition\Listing();
  776.                 $list = $list->load();
  778.                 foreach ($list as $item) {
  779.                     if (strtolower($key) === strtolower($item->getKey())) {
  780.                         throw new \Exception('FieldCollection with the same name already exists (lower/upper cases may be different)');
  781.                     }
  782.                 }
  783.             }
  785.             $fcDef = new DataObject\Fieldcollection\Definition();
  786.             $fcDef->setKey($key);
  787.             $fcDef->setTitle($title);
  788.             $fcDef->setGroup($group);
  790.             if ($request->get('values')) {
  791.                 $values = $this->decodeJson($request->get('values'));
  792.                 $fcDef->setParentClass($values['parentClass']);
  793.                 $fcDef->setImplementsInterfaces($values['implementsInterfaces']);
  794.                 $fcDef->setGenerateTypeDeclarations($values['generateTypeDeclarations']);
  795.             }
  797.             if ($request->get('configuration')) {
  798.                 $configuration = $this->decodeJson($request->get('configuration'));
  800.                 $configuration['datatype'] = 'layout';
  801.                 $configuration['fieldtype'] = 'panel';
  803.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  804.                 $fcDef->setLayoutDefinitions($layout);
  805.             }
  807.             $fcDef->save();
  809.             return $this->adminJson(['success' => true, 'id' => $fcDef->getKey()]);
  810.         } catch (\Exception $e) {
  811.             Logger::error($e->getMessage());
  813.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  814.         }
  815.     }
  817.     /**
  818.      * @Route("/import-fieldcollection", name="importfieldcollection", methods={"POST"})
  819.      *
  820.      * @param Request $request
  821.      *
  822.      * @return Response
  823.      */
  824.     public function importFieldcollectionAction(Request $request)
  825.     {
  826.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  828.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  830.         $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, $data);
  832.         $response = $this->adminJson([
  833.             'success' => $success,
  834.         ]);
  836.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  837.         // Ext.form.Action.Submit and mark the submission as failed
  838.         $response->headers->set('Content-Type', 'text/html');
  840.         return $response;
  841.     }
  843.     /**
  844.      * @Route("/export-fieldcollection", name="exportfieldcollection", methods={"GET"})
  845.      *
  846.      * @param Request $request
  847.      *
  848.      * @return Response
  849.      */
  850.     public function exportFieldcollectionAction(Request $request)
  851.     {
  852.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  854.         if (!$fieldCollection instanceof DataObject\Fieldcollection\Definition) {
  855.             $errorMessage = ': Field-Collection with id [ ' . $request->get('id') . ' not found. ]';
  856.             Logger::error($errorMessage);
  858.             throw $this->createNotFoundException($errorMessage);
  859.         }
  861.         $json = DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection);
  862.         $response = new Response($json);
  863.         $response->headers->set('Content-type', 'application/json');
  864.         $response->headers->set('Content-Disposition', 'attachment; filename="fieldcollection_' . $fieldCollection->getKey() . '_export.json"');
  866.         return $response;
  867.     }
  869.     /**
  870.      * @Route("/fieldcollection-delete", name="fieldcollectiondelete", methods={"DELETE"})
  871.      *
  872.      * @param Request $request
  873.      *
  874.      * @return JsonResponse
  875.      */
  876.     public function fieldcollectionDeleteAction(Request $request)
  877.     {
  878.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  879.         $fc->delete();
  881.         return $this->adminJson(['success' => true]);
  882.     }
  884.     /**
  885.      * @Route("/fieldcollection-tree", name="fieldcollectiontree", methods={"GET", "POST"})
  886.      *
  887.      * @param Request $request
  888.      * @param EventDispatcherInterface $eventDispatcher
  889.      *
  890.      * @return JsonResponse
  891.      */
  892.     public function fieldcollectionTreeAction(Request $request, EventDispatcherInterface $eventDispatcher)
  893.     {
  894.         $list = new DataObject\Fieldcollection\Definition\Listing();
  895.         $list = $list->load();
  897.         $forObjectEditor = $request->get('forObjectEditor');
  899.         $layoutDefinitions = [];
  901.         $definitions = [];
  903.         $allowedTypes = null;
  904.         if ($request->query->has('allowedTypes')) {
  905.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  906.         }
  907.         $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  909.         $currentLayoutId = $request->get('layoutId', null);
  910.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  912.         $groups = [];
  913.         foreach ($list as $item) {
  914.             if ($allowedTypes && !in_array($item->getKey(), $allowedTypes)) {
  915.                 continue;
  916.             }
  918.             if ($item->getGroup()) {
  919.                 if (!isset($groups[$item->getGroup()])) {
  920.                     $groups[$item->getGroup()] = [
  921.                         'id' => 'group_' . $item->getKey(),
  922.                         'text' => htmlspecialchars($item->getGroup()),
  923.                         'expandable' => true,
  924.                         'leaf' => false,
  925.                         'allowChildren' => true,
  926.                         'iconCls' => 'pimcore_icon_folder',
  927.                         'group' => $item->getGroup(),
  928.                         'children' => [],
  929.                     ];
  930.                 }
  931.                 if ($forObjectEditor) {
  932.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  933.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  935.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  936.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  937.                     }
  938.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  939.                 }
  940.                 $groups[$item->getGroup()]['children'][] =
  941.                     [
  942.                         'id' => $item->getKey(),
  943.                         'text' => $item->getKey(),
  944.                         'title' => $item->getTitle(),
  945.                         'key' => $item->getKey(),
  946.                         'leaf' => true,
  947.                         'iconCls' => 'pimcore_icon_fieldcollection',
  948.                     ];
  949.             } else {
  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.                     }
  958.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  959.                 }
  960.                 $definitions[] = [
  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.             }
  969.         }
  971.         foreach ($groups as $group) {
  972.             $definitions[] = $group;
  973.         }
  975.         $event = new GenericEvent($this, [
  976.             'list' => $definitions,
  977.             'objectId' => $request->get('object_id'),
  978.             'layoutDefinitions' => $layoutDefinitions,
  979.         ]);
  980.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA);
  981.         $definitions = $event->getArgument('list');
  982.         $layoutDefinitions = $event->getArgument('layoutDefinitions');
  984.         if ($forObjectEditor) {
  985.             return $this->adminJson(['fieldcollections' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  986.         }
  988.         return $this->adminJson($definitions);
  989.     }
  991.     /**
  992.      * @Route("/fieldcollection-list", name="fieldcollectionlist", methods={"GET"})
  993.      *
  994.      * @param Request $request
  995.      * @param EventDispatcherInterface $eventDispatcher
  996.      *
  997.      * @return JsonResponse
  998.      */
  999.     public function fieldcollectionListAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1000.     {
  1001.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  1002.         $currentLayoutId = $request->get('layoutId');
  1004.         $list = new DataObject\Fieldcollection\Definition\Listing();
  1005.         $list = $list->load();
  1007.         if ($request->query->has('allowedTypes')) {
  1008.             $filteredList = [];
  1009.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  1010.             foreach ($list as $type) {
  1011.                 if (in_array($type->getKey(), $allowedTypes)) {
  1012.                     $filteredList[] = $type;
  1014.                     // mainly for objects-meta data-type
  1015.                     $layoutDefinitions = $type->getLayoutDefinitions();
  1016.                     $context = [
  1017.                         'containerType' => 'fieldcollection',
  1018.                         'containerKey' => $type->getKey(),
  1019.                         'outerFieldname' => $request->get('field_name'),
  1020.                     ];
  1022.                     $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1024.                     DataObject\Service::enrichLayoutDefinition($layoutDefinitions, $object, $context);
  1026.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  1027.                         DataObject\Service::createSuperLayout($layoutDefinitions);
  1028.                     }
  1029.                 }
  1030.             }
  1032.             $list = $filteredList;
  1033.         }
  1035.         $event = new GenericEvent($this, [
  1036.             'list' => $list,
  1037.             'objectId' => $request->get('object_id'),
  1038.         ]);
  1039.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA);
  1040.         $list = $event->getArgument('list');
  1042.         return $this->adminJson(['fieldcollections' => $list]);
  1043.     }
  1045.     /**
  1046.      * @Route("/get-class-definition-for-column-config", name="getclassdefinitionforcolumnconfig", methods={"GET"})
  1047.      *
  1048.      * @param Request $request
  1049.      *
  1050.      * @return JsonResponse
  1051.      */
  1052.     public function getClassDefinitionForColumnConfigAction(Request $request)
  1053.     {
  1054.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  1055.         if (!$class) {
  1056.             throw $this->createNotFoundException();
  1057.         }
  1058.         $objectId = (int)$request->get('oid');
  1060.         $filteredDefinitions = DataObject\Service::getCustomLayoutDefinitionForGridColumnConfig($class, $objectId);
  1062.         /** @var DataObject\ClassDefinition\Layout $layoutDefinitions */
  1063.         $layoutDefinitions = isset($filteredDefinitions['layoutDefinition']) ? $filteredDefinitions['layoutDefinition'] : false;
  1064.         $filteredFieldDefinition = isset($filteredDefinitions['fieldDefinition']) ? $filteredDefinitions['fieldDefinition'] : false;
  1066.         $class->setFieldDefinitions([]);
  1068.         $result = [];
  1070.         DataObject\Service::enrichLayoutDefinition($layoutDefinitions);
  1072.         $result['objectColumns']['children'] = $layoutDefinitions->getChildren();
  1073.         $result['objectColumns']['nodeLabel'] = 'object_columns';
  1074.         $result['objectColumns']['nodeType'] = 'object';
  1076.         // array("id", "fullpath", "published", "creationDate", "modificationDate", "filename", "classname");
  1077.         $systemColumnNames = DataObject\Concrete::SYSTEM_COLUMN_NAMES;
  1078.         $systemColumns = [];
  1079.         foreach ($systemColumnNames as $systemColumn) {
  1080.             $systemColumns[] = ['title' => $systemColumn, 'name' => $systemColumn, 'datatype' => 'data', 'fieldtype' => 'system'];
  1081.         }
  1082.         $result['systemColumns']['nodeLabel'] = 'system_columns';
  1083.         $result['systemColumns']['nodeType'] = 'system';
  1084.         $result['systemColumns']['children'] = $systemColumns;
  1086.         $list = new DataObject\Objectbrick\Definition\Listing();
  1087.         $list = $list->load();
  1089.         foreach ($list as $brickDefinition) {
  1090.             $classDefs = $brickDefinition->getClassDefinitions();
  1091.             if (!empty($classDefs)) {
  1092.                 foreach ($classDefs as $classDef) {
  1093.                     if ($classDef['classname'] == $class->getName()) {
  1094.                         $fieldName = $classDef['fieldname'];
  1095.                         if ($filteredFieldDefinition && !$filteredFieldDefinition[$fieldName]) {
  1096.                             continue;
  1097.                         }
  1099.                         $key = $brickDefinition->getKey();
  1101.                         $brickLayoutDefinitions = $brickDefinition->getLayoutDefinitions();
  1102.                         $context = [
  1103.                             'containerType' => 'objectbrick',
  1104.                             'containerKey' => $key,
  1105.                             'outerFieldname' => $fieldName,
  1106.                         ];
  1107.                         DataObject\Service::enrichLayoutDefinition($brickLayoutDefinitions, null, $context);
  1109.                         $result[$key]['nodeLabel'] = $key;
  1110.                         $result[$key]['brickField'] = $fieldName;
  1111.                         $result[$key]['nodeType'] = 'objectbricks';
  1112.                         $result[$key]['children'] = $brickLayoutDefinitions->getChildren();
  1114.                         break;
  1115.                     }
  1116.                 }
  1117.             }
  1118.         }
  1120.         return $this->adminJson($result);
  1121.     }
  1123.     /**
  1124.      * OBJECT BRICKS
  1125.      */
  1127.     /**
  1128.      * @Route("/objectbrick-get", name="objectbrickget", methods={"GET"})
  1129.      *
  1130.      * @param Request $request
  1131.      *
  1132.      * @return JsonResponse
  1133.      */
  1134.     public function objectbrickGetAction(Request $request)
  1135.     {
  1136.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1138.         $isWriteable = $fc->isWritable();
  1139.         $fc = $fc->getObjectVars();
  1140.         $fc['isWriteable'] = $isWriteable;
  1142.         return $this->adminJson($fc);
  1143.     }
  1145.     /**
  1146.      * @Route("/objectbrick-update", name="objectbrickupdate", methods={"PUT", "POST"})
  1147.      *
  1148.      * @param Request $request
  1149.      * @param EventDispatcherInterface $eventDispatcher
  1150.      *
  1151.      * @return JsonResponse
  1152.      */
  1153.     public function objectbrickUpdateAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1154.     {
  1155.         try {
  1156.             $key = $request->get('key');
  1157.             $title = $request->get('title');
  1158.             $group = $request->get('group');
  1160.             if ($request->get('task') == 'add') {
  1161.                 // check for existing brick with same name with different lower/upper cases
  1162.                 $list = new DataObject\Objectbrick\Definition\Listing();
  1163.                 $list = $list->load();
  1165.                 foreach ($list as $item) {
  1166.                     if (strtolower($key) === strtolower($item->getKey())) {
  1167.                         throw new \Exception('Brick with the same name already exists (lower/upper cases may be different)');
  1168.                     }
  1169.                 }
  1170.             }
  1172.             // now we create a new definition
  1173.             $brickDef = new DataObject\Objectbrick\Definition();
  1174.             $brickDef->setKey($key);
  1175.             $brickDef->setTitle($title);
  1176.             $brickDef->setGroup($group);
  1178.             if ($request->get('values')) {
  1179.                 $values = $this->decodeJson($request->get('values'));
  1181.                 $brickDef->setParentClass($values['parentClass']);
  1182.                 $brickDef->setImplementsInterfaces($values['implementsInterfaces']);
  1183.                 $brickDef->setClassDefinitions($values['classDefinitions']);
  1184.                 $brickDef->setGenerateTypeDeclarations($values['generateTypeDeclarations']);
  1185.             }
  1187.             if ($request->get('configuration')) {
  1188.                 $configuration = $this->decodeJson($request->get('configuration'));
  1190.                 $configuration['datatype'] = 'layout';
  1191.                 $configuration['fieldtype'] = 'panel';
  1193.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  1194.                 $brickDef->setLayoutDefinitions($layout);
  1195.             }
  1197.             $event = new GenericEvent($this, [
  1198.                 'brickDefinition' => $brickDef,
  1199.             ]);
  1200.             $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_UPDATE_DEFINITION);
  1201.             $brickDef = $event->getArgument('brickDefinition');
  1203.             $brickDef->save();
  1205.             return $this->adminJson(['success' => true, 'id' => $brickDef->getKey()]);
  1206.         } catch (\Exception $e) {
  1207.             Logger::error($e->getMessage());
  1209.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1210.         }
  1211.     }
  1213.     /**
  1214.      * @Route("/import-objectbrick", name="importobjectbrick", methods={"POST"})
  1215.      *
  1216.      * @param Request $request
  1217.      *
  1218.      * @return JsonResponse
  1219.      */
  1220.     public function importObjectbrickAction(Request $request)
  1221.     {
  1222.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1224.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  1225.         $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($objectBrick, $data);
  1227.         $response = $this->adminJson([
  1228.             'success' => $success,
  1229.         ]);
  1231.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  1232.         // Ext.form.Action.Submit and mark the submission as failed
  1233.         $response->headers->set('Content-Type', 'text/html');
  1235.         return $response;
  1236.     }
  1238.     /**
  1239.      * @Route("/export-objectbrick", name="exportobjectbrick", methods={"GET"})
  1240.      *
  1241.      * @param Request $request
  1242.      *
  1243.      * @return Response
  1244.      */
  1245.     public function exportObjectbrickAction(Request $request)
  1246.     {
  1247.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1249.         if (!$objectBrick instanceof DataObject\Objectbrick\Definition) {
  1250.             $errorMessage = ': Object-Brick with id [ ' . $request->get('id') . ' not found. ]';
  1251.             Logger::error($errorMessage);
  1253.             throw $this->createNotFoundException($errorMessage);
  1254.         }
  1256.         $xml = DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick);
  1257.         $response = new Response($xml);
  1258.         $response->headers->set('Content-type', 'application/json');
  1259.         $response->headers->set('Content-Disposition', 'attachment; filename="objectbrick_' . $objectBrick->getKey() . '_export.json"');
  1261.         return $response;
  1262.     }
  1264.     /**
  1265.      * @Route("/objectbrick-delete", name="objectbrickdelete", methods={"DELETE"})
  1266.      *
  1267.      * @param Request $request
  1268.      *
  1269.      * @return JsonResponse
  1270.      */
  1271.     public function objectbrickDeleteAction(Request $request)
  1272.     {
  1273.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1274.         $fc->delete();
  1276.         return $this->adminJson(['success' => true]);
  1277.     }
  1279.     /**
  1280.      * @Route("/objectbrick-tree", name="objectbricktree", methods={"GET", "POST"})
  1281.      *
  1282.      * @param Request $request
  1283.      * @param EventDispatcherInterface $eventDispatcher
  1284.      *
  1285.      * @return JsonResponse
  1286.      */
  1287.     public function objectbrickTreeAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1288.     {
  1289.         $list = new DataObject\Objectbrick\Definition\Listing();
  1290.         $list = $list->load();
  1292.         $forObjectEditor = $request->get('forObjectEditor');
  1294.         $context = null;
  1295.         $layoutDefinitions = [];
  1296.         $groups = [];
  1297.         $definitions = [];
  1298.         $fieldname = null;
  1299.         $className = null;
  1301.         $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1303.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1304.             $classId = $request->get('class_id');
  1305.             $fieldname = $request->get('field_name');
  1306.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1307.             $className = $classDefinition->getName();
  1308.         }
  1310.         foreach ($list as $item) {
  1311.             if ($forObjectEditor) {
  1312.                 $context = [
  1313.                     'containerType' => 'objectbrick',
  1314.                     'containerKey' => $item->getKey(),
  1315.                     'outerFieldname' => $fieldname,
  1316.                 ];
  1317.             }
  1318.             if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1319.                 $keep = false;
  1320.                 $clsDefs = $item->getClassDefinitions();
  1321.                 if (!empty($clsDefs)) {
  1322.                     foreach ($clsDefs as $cd) {
  1323.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1324.                             $keep = true;
  1326.                             continue;
  1327.                         }
  1328.                     }
  1329.                 }
  1330.                 if (!$keep) {
  1331.                     continue;
  1332.                 }
  1333.             }
  1335.             if ($item->getGroup()) {
  1336.                 if (!isset($groups[$item->getGroup()])) {
  1337.                     $groups[$item->getGroup()] = [
  1338.                         'id' => 'group_' . $item->getKey(),
  1339.                         'text' => htmlspecialchars($item->getGroup()),
  1340.                         'expandable' => true,
  1341.                         'leaf' => false,
  1342.                         'allowChildren' => true,
  1343.                         'iconCls' => 'pimcore_icon_folder',
  1344.                         'group' => $item->getGroup(),
  1345.                         'children' => [],
  1346.                     ];
  1347.                 }
  1348.                 if ($forObjectEditor) {
  1349.                     $layoutId = $request->get('layoutId');
  1350.                     $itemLayoutDefinitions = null;
  1351.                     if ($layoutId) {
  1352.                         $layout = DataObject\ClassDefinition\CustomLayout::getById($layoutId.'.brick.'.$item->getKey());
  1353.                         if ($layout instanceof DataObject\ClassDefinition\CustomLayout) {
  1354.                             $itemLayoutDefinitions = $layout->getLayoutDefinitions();
  1355.                         }
  1356.                     }
  1358.                     if ($itemLayoutDefinitions === null) {
  1359.                         $itemLayoutDefinitions = $item->getLayoutDefinitions();
  1360.                     }
  1362.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object, $context);
  1364.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  1365.                 }
  1366.                 $groups[$item->getGroup()]['children'][] =
  1367.                     [
  1368.                         'id' => $item->getKey(),
  1369.                         'text' => $item->getKey(),
  1370.                         'title' => $item->getTitle(),
  1371.                         'key' => $item->getKey(),
  1372.                         'leaf' => true,
  1373.                         'iconCls' => 'pimcore_icon_objectbricks',
  1374.                     ];
  1375.             } else {
  1376.                 if ($forObjectEditor) {
  1377.                     $layout = $item->getLayoutDefinitions();
  1379.                     $currentLayoutId = $request->get('layoutId', null);
  1381.                     $user = $this->getAdminUser();
  1382.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  1383.                         DataObject\Service::createSuperLayout($layout);
  1384.                     } elseif ($currentLayoutId) {
  1385.                         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($currentLayoutId.'.brick.'.$item->getKey());
  1386.                         if ($customLayout instanceof DataObject\ClassDefinition\CustomLayout) {
  1387.                             $layout = $customLayout->getLayoutDefinitions();
  1388.                         }
  1389.                     }
  1391.                     DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1393.                     $layoutDefinitions[$item->getKey()] = $layout;
  1394.                 }
  1395.                 $definitions[] = [
  1396.                     'id' => $item->getKey(),
  1397.                     'text' => $item->getKey(),
  1398.                     'title' => $item->getTitle(),
  1399.                     'key' => $item->getKey(),
  1400.                     'leaf' => true,
  1401.                     'iconCls' => 'pimcore_icon_objectbricks',
  1402.                 ];
  1403.             }
  1404.         }
  1406.         foreach ($groups as $group) {
  1407.             $definitions[] = $group;
  1408.         }
  1410.         $event = new GenericEvent($this, [
  1411.             'list' => $definitions,
  1412.             'objectId' => $request->get('object_id'),
  1413.         ]);
  1414.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA);
  1415.         $definitions = $event->getArgument('list');
  1417.         if ($forObjectEditor) {
  1418.             return $this->adminJson(['objectbricks' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  1419.         } else {
  1420.             return $this->adminJson($definitions);
  1421.         }
  1422.     }
  1424.     /**
  1425.      * @Route("/objectbrick-list", name="objectbricklist", methods={"GET"})
  1426.      *
  1427.      * @param Request $request
  1428.      * @param EventDispatcherInterface $eventDispatcher
  1429.      *
  1430.      * @return JsonResponse
  1431.      */
  1432.     public function objectbrickListAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1433.     {
  1434.         $list = new DataObject\Objectbrick\Definition\Listing();
  1435.         $list = $list->load();
  1437.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1438.             $filteredList = [];
  1439.             $classId = $request->get('class_id');
  1440.             $fieldname = $request->get('field_name');
  1441.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1442.             $className = $classDefinition->getName();
  1444.             foreach ($list as $type) {
  1445.                 $clsDefs = $type->getClassDefinitions();
  1446.                 if (!empty($clsDefs)) {
  1447.                     foreach ($clsDefs as $cd) {
  1448.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1449.                             $filteredList[] = $type;
  1451.                             continue;
  1452.                         }
  1453.                     }
  1454.                 }
  1456.                 $layout = $type->getLayoutDefinitions();
  1458.                 $currentLayoutId = $request->get('layoutId', null);
  1460.                 $user = $this->getAdminUser();
  1461.                 if ($currentLayoutId == -1 && $user->isAdmin()) {
  1462.                     DataObject\Service::createSuperLayout($layout);
  1463.                     $objectData['layout'] = $layout;
  1464.                 }
  1466.                 $context = [
  1467.                     'containerType' => 'objectbrick',
  1468.                     'containerKey' => $type->getKey(),
  1469.                     'outerFieldname' => $request->get('field_name'),
  1470.                 ];
  1472.                 $object = DataObject\Concrete::getById((int) $request->get('object_id'));
  1474.                 DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1475.                 $type->setLayoutDefinitions($layout);
  1476.             }
  1478.             $list = $filteredList;
  1479.         }
  1481.         $event = new GenericEvent($this, [
  1482.             'list' => $list,
  1483.             'objectId' => $request->get('object_id'),
  1484.         ]);
  1485.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA);
  1486.         $list = $event->getArgument('list');
  1488.         return $this->adminJson(['objectbricks' => $list]);
  1489.     }
  1491.     /**
  1492.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1493.      * Add option to export/import all class definitions/brick definitions etc. at once
  1494.      */
  1496.     /**
  1497.      * @Route("/bulk-import", name="bulkimport", methods={"POST"})
  1498.      *
  1499.      * @param Request $request
  1500.      *
  1501.      * @return JsonResponse
  1502.      */
  1503.     public function bulkImportAction(Request $request)
  1504.     {
  1505.         $result = [];
  1507.         $tmpName = $_FILES['Filedata']['tmp_name'];
  1508.         $json = file_get_contents($tmpName);
  1510.         $tmpName = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/bulk-import-' . uniqid() . '.tmp';
  1511.         file_put_contents($tmpName, $json);
  1513.         Session::useSession(function (AttributeBagInterface $session) use ($tmpName) {
  1514.             $session->set('class_bulk_import_file', $tmpName);
  1515.         }, 'pimcore_objects');
  1517.         $json = json_decode($json, true);
  1519.         foreach ($json as $groupName => $group) {
  1520.             foreach ($group as $groupItem) {
  1521.                 $displayName = null;
  1522.                 $icon = null;
  1524.                 if ($groupName == 'class') {
  1525.                     $name = $groupItem['name'];
  1526.                     $icon = 'class';
  1527.                 } elseif ($groupName == 'customlayout') {
  1528.                     $className = $groupItem['className'];
  1530.                     $layoutData = ['className' => $className, 'name' => $groupItem['name']];
  1531.                     $name = base64_encode(json_encode($layoutData));
  1532.                     $displayName = $className . ' / ' . $groupItem['name'];
  1533.                     $icon = 'custom_views';
  1534.                 } else {
  1535.                     if ($groupName == 'objectbrick') {
  1536.                         $icon = 'objectbricks';
  1537.                     } elseif ($groupName == 'fieldcollection') {
  1538.                         $icon = 'fieldcollection';
  1539.                     }
  1540.                     $name = $groupItem['key'];
  1541.                 }
  1543.                 if (!$displayName) {
  1544.                     $displayName = $name;
  1545.                 }
  1546.                 $result[] = ['icon' => $icon, 'checked' => true, 'type' => $groupName, 'name' => $name, 'displayName' => $displayName];
  1547.             }
  1548.         }
  1550.         $response = $this->adminJson(['success' => true, 'data' => $result]);
  1551.         $response->headers->set('Content-Type', 'text/html');
  1553.         return $response;
  1554.     }
  1556.     /**
  1557.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1558.      * Add option to export/import all class definitions/brick definitions etc. at once
  1559.      */
  1561.     /**
  1562.      * @Route("/bulk-commit", name="bulkcommit", methods={"POST"})
  1563.      *
  1564.      * @param Request $request
  1565.      *
  1566.      * @return JsonResponse
  1567.      *
  1568.      * @throws \Exception
  1569.      */
  1570.     public function bulkCommitAction(Request $request)
  1571.     {
  1572.         $data = json_decode($request->get('data'), true);
  1574.         $session = Session::get('pimcore_objects');
  1575.         $filename = $session->get('class_bulk_import_file');
  1576.         $json = @file_get_contents($filename);
  1577.         $json = json_decode($json, true);
  1579.         $type = $data['type'];
  1580.         $name = $data['name'];
  1581.         $list = $json[$type];
  1583.         foreach ($list as $item) {
  1584.             unset($item['creationDate']);
  1585.             unset($item['modificationDate']);
  1586.             unset($item['userOwner']);
  1587.             unset($item['userModification']);
  1589.             if ($type == 'class' && $item['name'] == $name) {
  1590.                 $class = DataObject\ClassDefinition::getByName($name);
  1591.                 if (!$class) {
  1592.                     $class = new DataObject\ClassDefinition();
  1593.                     $class->setName($name);
  1594.                 }
  1595.                 $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, json_encode($item), true);
  1597.                 return $this->adminJson(['success' => $success !== false]);
  1598.             } elseif ($type == 'objectbrick' && $item['key'] == $name) {
  1599.                 if (!$brick = DataObject\Objectbrick\Definition::getByKey($name)) {
  1600.                     $brick = new DataObject\Objectbrick\Definition();
  1601.                     $brick->setKey($name);
  1602.                 }
  1604.                 $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($brick, json_encode($item), true);
  1606.                 return $this->adminJson(['success' => $success !== false]);
  1607.             } elseif ($type == 'fieldcollection' && $item['key'] == $name) {
  1608.                 if (!$fieldCollection = DataObject\Fieldcollection\Definition::getByKey($name)) {
  1609.                     $fieldCollection = new DataObject\Fieldcollection\Definition();
  1610.                     $fieldCollection->setKey($name);
  1611.                 }
  1613.                 $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, json_encode($item), true);
  1615.                 return $this->adminJson(['success' => $success !== false]);
  1616.             } elseif ($type == 'customlayout') {
  1617.                 $layoutData = json_decode(base64_decode($data['name']), true);
  1618.                 $className = $layoutData['className'];
  1619.                 $layoutName = $layoutData['name'];
  1621.                 if ($item['name'] == $layoutName && $item['className'] == $className) {
  1622.                     $class = DataObject\ClassDefinition::getByName($className);
  1623.                     if (!$class) {
  1624.                         throw new \Exception('Class does not exist');
  1625.                     }
  1627.                     $classId = $class->getId();
  1629.                     $layoutList = new DataObject\ClassDefinition\CustomLayout\Listing();
  1630.                     $layoutList->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($layoutName, $classId) {
  1631.                         return $layout->getName() === $layoutName && $layout->getClassId() === $classId;
  1632.                     });
  1633.                     $layoutList = $layoutList->load();
  1635.                     $layoutDefinition = null;
  1636.                     if ($layoutList) {
  1637.                         $layoutDefinition = $layoutList[0];
  1638.                     }
  1640.                     if (!$layoutDefinition) {
  1641.                         $layoutDefinition = new DataObject\ClassDefinition\CustomLayout();
  1642.                         $layoutDefinition->setName($layoutName);
  1643.                         $layoutDefinition->setClassId($classId);
  1644.                     }
  1646.                     try {
  1647.                         $layoutDefinition->setDescription($item['description']);
  1648.                         $layoutDef = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($item['layoutDefinitions'], true);
  1649.                         $layoutDefinition->setLayoutDefinitions($layoutDef);
  1650.                         $layoutDefinition->save();
  1651.                     } catch (\Exception $e) {
  1652.                         Logger::error($e->getMessage());
  1654.                         return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1655.                     }
  1656.                 }
  1657.             }
  1658.         }
  1660.         return $this->adminJson(['success' => true]);
  1661.     }
  1663.     /**
  1664.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1665.      * Add option to export/import all class definitions/brick definitions etc. at once
  1666.      */
  1668.     /**
  1669.      * @Route("/bulk-export-prepare", name="bulkexportprepare", methods={"POST"})
  1670.      *
  1671.      * @param Request $request
  1672.      *
  1673.      * @return Response
  1674.      */
  1675.     public function bulkExportPrepareAction(Request $request)
  1676.     {
  1677.         $data = $request->get('data');
  1679.         Session::useSession(function (AttributeBagInterface $session) use ($data) {
  1680.             $session->set('class_bulk_export_settings', $data);
  1681.         }, 'pimcore_objects');
  1683.         return $this->adminJson(['success' => true]);
  1684.     }
  1686.     /**
  1687.      * @Route("/bulk-export", name="bulkexport", methods={"GET"})
  1688.      *
  1689.      * @param Request $request
  1690.      *
  1691.      * @return Response
  1692.      */
  1693.     public function bulkExportAction(Request $request)
  1694.     {
  1695.         $result = [];
  1697.         $fieldCollections = new DataObject\Fieldcollection\Definition\Listing();
  1698.         $fieldCollections = $fieldCollections->load();
  1700.         foreach ($fieldCollections as $fieldCollection) {
  1701.             $result[] = [
  1702.                 'icon' => 'fieldcollection',
  1703.                 'checked' => true,
  1704.                 'type' => 'fieldcollection',
  1705.                 'name' => $fieldCollection->getKey(),
  1706.                 'displayName' => $fieldCollection->getKey(),
  1707.             ];
  1708.         }
  1710.         $classes = new DataObject\ClassDefinition\Listing();
  1711.         $classes->setOrder('ASC');
  1712.         $classes->setOrderKey('id');
  1713.         $classes = $classes->load();
  1715.         foreach ($classes as $class) {
  1716.             $result[] = [
  1717.                 'icon' => 'class',
  1718.                 'checked' => true,
  1719.                 'type' => 'class',
  1720.                 'name' => $class->getName(),
  1721.                 'displayName' => $class->getName(),
  1722.             ];
  1723.         }
  1725.         $objectBricks = new DataObject\Objectbrick\Definition\Listing();
  1726.         $objectBricks = $objectBricks->load();
  1728.         foreach ($objectBricks as $objectBrick) {
  1729.             $result[] = [
  1730.                 'icon' => 'objectbricks',
  1731.                 'checked' => true,
  1732.                 'type' => 'objectbrick',
  1733.                 'name' => $objectBrick->getKey(),
  1734.                 'displayName' => $objectBrick->getKey(),
  1735.             ];
  1736.         }
  1738.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  1739.         $customLayouts = $customLayouts->load();
  1740.         foreach ($customLayouts as $customLayout) {
  1741.             $class = DataObject\ClassDefinition::getById($customLayout->getClassId());
  1742.             $displayName = $class->getName() . ' / ' .  $customLayout->getName();
  1744.             $result[] = [
  1745.                 'icon' => 'custom_views',
  1746.                 'checked' => true,
  1747.                 'type' => 'customlayout',
  1748.                 'name' => $customLayout->getId(),
  1749.                 'displayName' => $displayName,
  1750.             ];
  1751.         }
  1753.         return new JsonResponse(['success' => true, 'data' => $result]);
  1754.     }
  1756.     /**
  1757.      * @Route("/do-bulk-export", name="dobulkexport", methods={"GET"})
  1758.      *
  1759.      * @param Request $request
  1760.      *
  1761.      * @return Response
  1762.      */
  1763.     public function doBulkExportAction(Request $request)
  1764.     {
  1765.         $session = Session::get('pimcore_objects');
  1766.         $list = $session->get('class_bulk_export_settings');
  1767.         $list = json_decode($list, true);
  1768.         $result = [];
  1770.         foreach ($list as $item) {
  1771.             if ($item['type'] == 'fieldcollection') {
  1772.                 if ($fieldCollection = DataObject\Fieldcollection\Definition::getByKey($item['name'])) {
  1773.                     $fieldCollectionJson = json_decode(DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection));
  1774.                     $fieldCollectionJson->key = $item['name'];
  1775.                     $result['fieldcollection'][] = $fieldCollectionJson;
  1776.                 }
  1777.             } elseif ($item['type'] == 'class') {
  1778.                 if ($class = DataObject\ClassDefinition::getByName($item['name'])) {
  1779.                     $data = json_decode(DataObject\ClassDefinition\Service::generateClassDefinitionJson($class));
  1780.                     $data->name = $item['name'];
  1781.                     $result['class'][] = $data;
  1782.                 }
  1783.             } elseif ($item['type'] == 'objectbrick') {
  1784.                 if ($objectBrick = DataObject\Objectbrick\Definition::getByKey($item['name'])) {
  1785.                     $objectBrickJson = json_decode(DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick));
  1786.                     $objectBrickJson->key = $item['name'];
  1787.                     $result['objectbrick'][] = $objectBrickJson;
  1788.                 }
  1789.             } elseif ($item['type'] == 'customlayout') {
  1790.                 if ($customLayout = DataObject\ClassDefinition\CustomLayout::getById($item['name'])) {
  1791.                     $classId = $customLayout->getClassId();
  1792.                     $class = DataObject\ClassDefinition::getById($classId);
  1793.                     $customLayoutJson = json_decode(DataObject\ClassDefinition\Service::generateCustomLayoutJson($customLayout));
  1794.                     $customLayoutJson->name = $customLayout->getName();
  1795.                     $customLayoutJson->className = $class->getName();
  1796.                     $result['customlayout'][] = $customLayoutJson;
  1797.                 }
  1798.             }
  1799.         }
  1801.         $result = json_encode($result, JSON_PRETTY_PRINT);
  1802.         $response = new Response($result);
  1803.         $response->headers->set('Content-type', 'application/json');
  1804.         $response->headers->set('Content-Disposition', 'attachment; filename="bulk_export.json"');
  1806.         return $response;
  1807.     }
  1809.     /**
  1810.      * @param ControllerEvent $event
  1811.      */
  1812.     public function onKernelControllerEvent(ControllerEvent $event)
  1813.     {
  1814.         if (!$event->isMainRequest()) {
  1815.             return;
  1816.         }
  1818.         // check permissions
  1819.         $unrestrictedActions = [
  1820.             'getTreeAction', 'fieldcollectionListAction', 'fieldcollectionTreeAction', 'fieldcollectionGetAction',
  1821.             'getClassDefinitionForColumnConfigAction', 'objectbrickListAction', 'objectbrickTreeAction', 'objectbrickGetAction',
  1822.         ];
  1824.         $this->checkActionPermission($event, 'classes', $unrestrictedActions);
  1825.     }
  1827.     /**
  1828.      * @Route("/get-fieldcollection-usages", name="getfieldcollectionusages", methods={"GET"})
  1829.      *
  1830.      * @param Request $request
  1831.      *
  1832.      * @return Response
  1833.      */
  1834.     public function getFieldcollectionUsagesAction(Request $request)
  1835.     {
  1836.         $key = $request->get('key');
  1837.         $result = [];
  1839.         $classes = new DataObject\ClassDefinition\Listing();
  1840.         $classes = $classes->load();
  1841.         foreach ($classes as $class) {
  1842.             $fieldDefs = $class->getFieldDefinitions();
  1843.             foreach ($fieldDefs as $fieldDef) {
  1844.                 if ($fieldDef instanceof DataObject\ClassDefinition\Data\Fieldcollections) {
  1845.                     $allowedKeys = $fieldDef->getAllowedTypes();
  1846.                     if (is_array($allowedKeys) && in_array($key, $allowedKeys)) {
  1847.                         $result[] = [
  1848.                             'class' => $class->getName(),
  1849.                             'field' => $fieldDef->getName(),
  1850.                         ];
  1851.                     }
  1852.                 }
  1853.             }
  1854.         }
  1856.         return $this->adminJson($result);
  1857.     }
  1859.     /**
  1860.      * @Route("/get-bricks-usages", name="getbrickusages", methods={"GET"})
  1861.      *
  1862.      * @param Request $request
  1863.      *
  1864.      * @return Response
  1865.      */
  1866.     public function getBrickUsagesAction(Request $request)
  1867.     {
  1868.         $classId = $request->get('classId');
  1869.         $myclass = DataObject\ClassDefinition::getById($classId);
  1871.         $result = [];
  1873.         $brickDefinitions = new DataObject\Objectbrick\Definition\Listing();
  1874.         $brickDefinitions = $brickDefinitions->load();
  1875.         foreach ($brickDefinitions as $brickDefinition) {
  1876.             $classes = $brickDefinition->getClassDefinitions();
  1877.             foreach ($classes as $class) {
  1878.                 if ($myclass->getName() == $class['classname']) {
  1879.                     $result[] = [
  1880.                         'objectbrick' => $brickDefinition->getKey(),
  1881.                         'field' => $class['fieldname'],
  1882.                     ];
  1883.                 }
  1884.             }
  1885.         }
  1887.         return $this->adminJson($result);
  1888.     }
  1890.     /**
  1891.      * @Route("/get-icons", name="geticons", methods={"GET"})
  1892.      *
  1893.      * @param Request $request
  1894.      * @param EventDispatcherInterface $eventDispatcher
  1895.      *
  1896.      * @return Response
  1897.      */
  1898.     public function getIconsAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1899.     {
  1900.         $classId = $request->get('classId');
  1902.         $iconDir = PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/img';
  1903.         $classIcons = rscandir($iconDir . '/object-icons/');
  1904.         $colorIcons = rscandir($iconDir . '/flat-color-icons/');
  1905.         $twemoji = rscandir($iconDir . '/twemoji/');
  1907.         $icons = array_merge($classIcons, $colorIcons, $twemoji);
  1909.         foreach ($icons as &$icon) {
  1910.             $icon = str_replace(PIMCORE_WEB_ROOT, '', $icon);
  1911.         }
  1913.         $event = new GenericEvent($this, [
  1914.             'icons' => $icons,
  1915.             'classId' => $classId,
  1916.         ]);
  1917.         $eventDispatcher->dispatch($event, AdminEvents::CLASS_OBJECT_ICONS_PRE_SEND_DATA);
  1918.         $icons = $event->getArgument('icons');
  1920.         $result = [];
  1921.         foreach ($icons as $icon) {
  1922.             $content = file_get_contents(PIMCORE_WEB_ROOT . $icon);
  1923.             $result[] = [
  1924.                 'text' => sprintf('<img src="data:%s;base64,%s"/>', mime_content_type(PIMCORE_WEB_ROOT . $icon), base64_encode($content)),
  1925.                 'value' => $icon,
  1926.             ];
  1927.         }
  1929.         return $this->adminJson($result);
  1930.     }
  1932.     /**
  1933.      * @Route("/suggest-class-identifier", name="suggestclassidentifier")
  1934.      *
  1935.      * @return Response
  1936.      */
  1937.     public function suggestClassIdentifierAction()
  1938.     {
  1939.         $db = Db::get();
  1940.         $maxId = $db->fetchOne('SELECT MAX(CAST(id AS SIGNED)) FROM classes;');
  1942.         $existingIds = $db->fetchFirstColumn('select LOWER(id) from classes');
  1944.         $result = [
  1945.             'suggestedIdentifier' => $maxId ? $maxId + 1 : 1,
  1946.             'existingIds' => $existingIds,
  1947.             ];
  1949.         return $this->adminJson($result);
  1950.     }
  1952.     /**
  1953.      * @Route("/suggest-custom-layout-identifier", name="suggestcustomlayoutidentifier")
  1954.      *
  1955.      * @param Request $request
  1956.      *
  1957.      * @return Response
  1958.      */
  1959.     public function suggestCustomLayoutIdentifierAction(Request $request)
  1960.     {
  1961.         $classId = $request->get('classId');
  1963.         $identifier = DataObject\ClassDefinition\CustomLayout::getIdentifier($classId);
  1965.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  1967.         $list = $list->load();
  1968.         $existingIds = [];
  1969.         $existingNames = [];
  1971.         foreach ($list as $item) {
  1972.             $existingIds[] = $item->getId();
  1973.             if ($item->getClassId() == $classId) {
  1974.                 $existingNames[] = $item->getName();
  1975.             }
  1976.         }
  1978.         $result = [
  1979.             'suggestedIdentifier' => $identifier,
  1980.             'existingIds' => $existingIds,
  1981.             'existingNames' => $existingNames,
  1982.             ];
  1984.         return $this->adminJson($result);
  1985.     }
  1987.     /**
  1988.      * @Route("/text-layout-preview", name="textlayoutpreview")
  1989.      *
  1990.      * @param Request $request
  1991.      *
  1992.      * @return Response
  1993.      */
  1994.     public function textLayoutPreviewAction(Request $request)
  1995.     {
  1996.         $objPath = $request->get('previewObject', '');
  1997.         $className = '\\Pimcore\\Model\\DataObject\\' . $request->get('className');
  1998.         $obj = DataObject::getByPath($objPath) ?? new $className();
  2000.         $textLayout = new DataObject\ClassDefinition\Layout\Text();
  2002.         $context = [
  2003.           'data' => $request->get('renderingData'),
  2004.         ];
  2006.         if ($renderingClass = $request->get('renderingClass')) {
  2007.             $textLayout->setRenderingClass($renderingClass);
  2008.         }
  2010.         if ($staticHtml = $request->get('html')) {
  2011.             $textLayout->setHtml($staticHtml);
  2012.         }
  2014.         $html = $textLayout->enrichLayoutDefinition($obj, $context)->getHtml();
  2016.         $content =
  2017.             "<html>\n" .
  2018.             "<head>\n" .
  2019.             '<style type="text/css">' . "\n" .
  2020.             file_get_contents(PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/css/admin.css') .
  2021.             "</style>\n" .
  2022.             "</head>\n\n" .
  2023.             "<body class='objectlayout_element_text'>\n" .
  2024.             $html .
  2025.             "\n\n</body>\n" .
  2026.             "</html>\n";
  2028.         $response = new Response($content);
  2029.         $response->headers->set('Content-Type', 'text/html');
  2031.         return $response;
  2032.     }
  2034.     /**
  2035.      * @Route("/video-supported-types", name="videosupportedTypestypes")
  2036.      *
  2037.      * @param Request $request
  2038.      *
  2039.      * @return Response
  2040.      */
  2041.     public function videoAllowedTypesAction(Request $request)
  2042.     {
  2043.         $videoDef = new DataObject\ClassDefinition\Data\Video();
  2044.         $res = [];
  2046.         foreach ($videoDef->getSupportedTypes() as $type) {
  2047.             $res[] = [
  2048.                 'key' => $type,
  2049.                 'value' => $this->trans($type),
  2050.             ];
  2051.         }
  2053.         return $this->adminJson($res);
  2054.     }
  2055. }