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

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  12.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  13.  */
  15. namespace Pimcore\Bundle\AdminBundle\Controller\Admin\DataObject;
  17. use Pimcore\Bundle\AdminBundle\Controller\AdminController;
  18. use Pimcore\Bundle\AdminBundle\HttpFoundation\JsonResponse;
  19. use Pimcore\Controller\EventedControllerInterface;
  20. use Pimcore\Db;
  21. use Pimcore\Event\AdminEvents;
  22. use Pimcore\Logger;
  23. use Pimcore\Model;
  24. use Pimcore\Model\Asset;
  25. use Pimcore\Model\DataObject;
  26. use Pimcore\Model\Document;
  27. use Pimcore\Tool\Session;
  28. use Symfony\Component\EventDispatcher\GenericEvent;
  29. use Symfony\Component\HttpFoundation\Request;
  30. use Symfony\Component\HttpFoundation\Response;
  31. use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBagInterface;
  32. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  33. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  34. use Symfony\Component\Routing\Annotation\Route;
  36. /**
  37.  * @Route("/class")
  38.  */
  39. class ClassController extends AdminController implements EventedControllerInterface
  40. {
  41.     /**
  42.      * @Route("/get-document-types", name="pimcore_admin_dataobject_class_getdocumenttypes", methods={"GET"})
  43.      *
  44.      * @param Request $request
  45.      *
  46.      * @return JsonResponse
  47.      */
  48.     public function getDocumentTypesAction(Request $request)
  49.     {
  50.         $documentTypes = Document::getTypes();
  51.         $typeItems = [];
  52.         foreach ($documentTypes as $documentType) {
  53.             $typeItems[] = [
  54.                 'text' => $documentType
  55.             ];
  56.         }
  58.         return $this->adminJson($typeItems);
  59.     }
  61.     /**
  62.      * @Route("/get-asset-types", name="pimcore_admin_dataobject_class_getassettypes", methods={"GET"})
  63.      *
  64.      * @param Request $request
  65.      *
  66.      * @return JsonResponse
  67.      */
  68.     public function getAssetTypesAction(Request $request)
  69.     {
  70.         $assetTypes = Asset::getTypes();
  71.         $typeItems = [];
  72.         foreach ($assetTypes as $assetType) {
  73.             $typeItems[] = [
  74.                 'text' => $assetType
  75.             ];
  76.         }
  78.         return $this->adminJson($typeItems);
  79.     }
  81.     /**
  82.      * @Route("/get-tree", name="pimcore_admin_dataobject_class_gettree", methods={"GET", "POST"})
  83.      *
  84.      * @param Request $request
  85.      *
  86.      * @return JsonResponse
  87.      */
  88.     public function getTreeAction(Request $request)
  89.     {
  90.         $defaultIcon = '/bundles/pimcoreadmin/img/flat-color-icons/class.svg';
  92.         $classesList = new DataObject\ClassDefinition\Listing();
  93.         $classesList->setOrderKey('name');
  94.         $classesList->setOrder('asc');
  95.         $classes = $classesList->load();
  97.         // filter classes
  98.         if ($request->get('createAllowed')) {
  99.             $tmpClasses = [];
  100.             foreach ($classes as $class) {
  101.                 if ($this->getAdminUser()->isAllowed($class->getId(), 'class')) {
  102.                     $tmpClasses[] = $class;
  103.                 }
  104.             }
  105.             $classes = $tmpClasses;
  106.         }
  108.         $withId = $request->get('withId');
  109.         $getClassConfig = function ($class) use ($defaultIcon, $withId) {
  110.             $text = $class->getname();
  111.             if ($withId) {
  112.                 $text .= ' (' . $class->getId() . ')';
  113.             }
  115.             return [
  116.                 'id' => $class->getId(),
  117.                 'text' => $text,
  118.                 'leaf' => true,
  119.                 'icon' => $class->getIcon() ? $class->getIcon() : $defaultIcon,
  120.                 'cls' => 'pimcore_class_icon',
  121.                 'propertyVisibility' => $class->getPropertyVisibility(),
  122.                 'enableGridLocking' => $class->isEnableGridLocking()
  123.             ];
  124.         };
  126.         // build groups
  127.         $groups = [];
  128.         foreach ($classes as $class) {
  129.             if (!$class) {
  130.                 continue;
  131.             }
  132.             $groupName = null;
  134.             if ($class->getGroup()) {
  135.                 $type = 'manual';
  136.                 $groupName = $class->getGroup();
  137.             } else {
  138.                 $type = 'auto';
  139.                 if (preg_match('@^([A-Za-z])([^A-Z]+)@', $class->getName(), $matches)) {
  140.                     $groupName = $matches[0];
  141.                 }
  143.                 if (!$groupName) {
  144.                     // this is eg. the case when class name uses only capital letters
  145.                     $groupName = $class->getName();
  146.                 }
  147.             }
  149.             $groupName = \Pimcore\Model\Translation\Admin::getByKeyLocalized($groupName, true, true);
  151.             if (!isset($groups[$groupName])) {
  152.                 $groups[$groupName] = [
  153.                     'classes' => [],
  154.                     'type' => $type
  155.                 ];
  156.             }
  157.             $groups[$groupName]['classes'][] = $class;
  158.         }
  160.         $treeNodes = [];
  162.         if (!$request->get('grouped')) {
  163.             // list output
  164.             foreach ($groups as $groupName => $groupData) {
  165.                 foreach ($groupData['classes'] as $class) {
  166.                     $node = $getClassConfig($class);
  167.                     if (count($groupData['classes']) > 1 || $groupData['type'] == 'manual') {
  168.                         $node['group'] = $groupName;
  169.                     }
  170.                     $treeNodes[] = $node;
  171.                 }
  172.             }
  173.         } else {
  174.             // create json output
  175.             foreach ($groups as $groupName => $groupData) {
  176.                 if (count($groupData['classes']) === 1 && $groupData['type'] == 'auto') {
  177.                     // no group, only one child
  178.                     $node = $getClassConfig($groupData['classes'][0]);
  179.                 } else {
  180.                     // group classes
  181.                     $node = [
  182.                         'id' => 'folder_' . $groupName,
  183.                         'text' => $groupName,
  184.                         'leaf' => false,
  185.                         'expandable' => true,
  186.                         'allowChildren' => true,
  187.                         'iconCls' => 'pimcore_icon_folder',
  188.                         'children' => []
  189.                     ];
  191.                     foreach ($groupData['classes'] as $class) {
  192.                         $node['children'][] = $getClassConfig($class);
  193.                     }
  194.                 }
  196.                 $treeNodes[] = $node;
  197.             }
  198.         }
  200.         return $this->adminJson($treeNodes);
  201.     }
  203.     /**
  204.      * @Route("/get", name="pimcore_admin_dataobject_class_get", methods={"GET"})
  205.      *
  206.      * @param Request $request
  207.      *
  208.      * @return JsonResponse
  209.      */
  210.     public function getAction(Request $request)
  211.     {
  212.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  213.         $class->setFieldDefinitions([]);
  215.         return $this->adminJson($class);
  216.     }
  218.     /**
  219.      * @Route("/get-custom-layout", name="pimcore_admin_dataobject_class_getcustomlayout", methods={"GET"})
  220.      *
  221.      * @param Request $request
  222.      *
  223.      * @return JsonResponse
  224.      */
  225.     public function getCustomLayoutAction(Request $request)
  226.     {
  227.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  229.         return $this->adminJson(['success' => true, 'data' => $customLayout]);
  230.     }
  232.     /**
  233.      * @Route("/add", name="pimcore_admin_dataobject_class_add", methods={"POST"})
  234.      *
  235.      * @param Request $request
  236.      *
  237.      * @return JsonResponse
  238.      */
  239.     public function addAction(Request $request)
  240.     {
  241.         $className = $request->get('className');
  242.         $className = $this->correctClassname($className);
  244.         $classId = $request->get('classIdentifier');
  245.         $existingClass = DataObject\ClassDefinition::getById($classId);
  246.         if ($existingClass) {
  247.             throw new \Exception('Class identifier already exists');
  248.         }
  250.         $class = DataObject\ClassDefinition::create(
  251.             ['name' => $className,
  252.                 'userOwner' => $this->getAdminUser()->getId()]
  253.         );
  255.         $class->setId($classId);
  257.         $class->save(true);
  259.         return $this->adminJson(['success' => true, 'id' => $class->getId()]);
  260.     }
  262.     /**
  263.      * @Route("/add-custom-layout", name="pimcore_admin_dataobject_class_addcustomlayout", methods={"POST"})
  264.      *
  265.      * @param Request $request
  266.      *
  267.      * @return JsonResponse
  268.      */
  269.     public function addCustomLayoutAction(Request $request)
  270.     {
  271.         $layoutId = $request->get('layoutIdentifier');
  272.         $existingLayout = DataObject\ClassDefinition\CustomLayout::getById($layoutId);
  273.         if ($existingLayout) {
  274.             throw new \Exception('Custom Layout identifier already exists');
  275.         }
  277.         $customLayout = DataObject\ClassDefinition\CustomLayout::create(
  278.             [
  279.                 'name' => $request->get('layoutName'),
  280.                 'userOwner' => $this->getAdminUser()->getId(),
  281.                 'classId' => $request->get('classId')
  282.             ]
  283.         );
  285.         $customLayout->setId($layoutId);
  286.         $customLayout->save();
  288.         return $this->adminJson(['success' => true, 'id' => $customLayout->getId(), 'name' => $customLayout->getName(),
  289.                                  'data' => $customLayout]);
  290.     }
  292.     /**
  293.      * @Route("/delete", name="pimcore_admin_dataobject_class_delete", methods={"DELETE"})
  294.      *
  295.      * @param Request $request
  296.      *
  297.      * @return Response
  298.      */
  299.     public function deleteAction(Request $request)
  300.     {
  301.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  302.         $class->delete();
  304.         return new Response();
  305.     }
  307.     /**
  308.      * @Route("/delete-custom-layout", name="pimcore_admin_dataobject_class_deletecustomlayout", methods={"DELETE"})
  309.      *
  310.      * @param Request $request
  311.      *
  312.      * @return JsonResponse
  313.      */
  314.     public function deleteCustomLayoutAction(Request $request)
  315.     {
  316.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  317.         if ($customLayout) {
  318.             $customLayout->delete();
  319.         }
  321.         return $this->adminJson(['success' => true]);
  322.     }
  324.     /**
  325.      * @Route("/save-custom-layout", name="pimcore_admin_dataobject_class_savecustomlayout", methods={"PUT"})
  326.      *
  327.      * @param Request $request
  328.      *
  329.      * @return JsonResponse
  330.      */
  331.     public function saveCustomLayoutAction(Request $request)
  332.     {
  333.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($request->get('id'));
  334.         $class = DataObject\ClassDefinition::getById($customLayout->getClassId());
  336.         $configuration = $this->decodeJson($request->get('configuration'));
  337.         $values = $this->decodeJson($request->get('values'));
  339.         $modificationDate = intval($values['modificationDate']);
  340.         if ($modificationDate < $customLayout->getModificationDate()) {
  341.             return $this->adminJson(['success' => false, 'msg' => 'custom_layout_changed']);
  342.         }
  344.         $configuration['datatype'] = 'layout';
  345.         $configuration['fieldtype'] = 'panel';
  346.         $configuration['name'] = 'pimcore_root';
  348.         try {
  349.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  350.             $customLayout->setLayoutDefinitions($layout);
  351.             $customLayout->setName($values['name']);
  352.             $customLayout->setDescription($values['description']);
  353.             $customLayout->setDefault($values['default']);
  354.             $customLayout->save();
  356.             return $this->adminJson(['success' => true, 'id' => $customLayout->getId(), 'data' => $customLayout]);
  357.         } catch (\Exception $e) {
  358.             Logger::error($e->getMessage());
  360.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  361.         }
  362.     }
  364.     /**
  365.      * @Route("/save", name="pimcore_admin_dataobject_class_save", methods={"PUT"})
  366.      *
  367.      * @param Request $request
  368.      *
  369.      * @return JsonResponse
  370.      *
  371.      * @throws \Exception
  372.      */
  373.     public function saveAction(Request $request)
  374.     {
  375.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  377.         $configuration = $this->decodeJson($request->get('configuration'));
  378.         $values = $this->decodeJson($request->get('values'));
  380.         // check if the class was changed during editing in the frontend
  381.         if ($class->getModificationDate() != $values['modificationDate']) {
  382.             throw new \Exception('The class was modified during editing, please reload the class and make your changes again');
  383.         }
  385.         if ($values['name'] != $class->getName()) {
  386.             $classByName = DataObject\ClassDefinition::getByName($values['name']);
  387.             if ($classByName && $classByName->getId() != $class->getId()) {
  388.                 throw new \Exception('Class name already exists');
  389.             }
  391.             $values['name'] = $this->correctClassname($values['name']);
  392.             $class->rename($values['name']);
  393.         }
  395.         unset($values['creationDate']);
  396.         unset($values['userOwner']);
  397.         unset($values['layoutDefinitions']);
  398.         unset($values['fieldDefinitions']);
  400.         $configuration['datatype'] = 'layout';
  401.         $configuration['fieldtype'] = 'panel';
  402.         $configuration['name'] = 'pimcore_root';
  404.         $class->setValues($values);
  406.         try {
  407.             $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  409.             $class->setLayoutDefinitions($layout);
  411.             $class->setUserModification($this->getAdminUser()->getId());
  412.             $class->setModificationDate(time());
  414.             $propertyVisibility = [];
  415.             foreach ($values as $key => $value) {
  416.                 if (preg_match('/propertyVisibility/i', $key)) {
  417.                     if (preg_match("/\.grid\./i", $key)) {
  418.                         $propertyVisibility['grid'][preg_replace("/propertyVisibility\.grid\./i", '', $key)] = (bool) $value;
  419.                     } elseif (preg_match("/\.search\./i", $key)) {
  420.                         $propertyVisibility['search'][preg_replace("/propertyVisibility\.search\./i", '', $key)] = (bool) $value;
  421.                     }
  422.                 }
  423.             }
  424.             if (!empty($propertyVisibility)) {
  425.                 $class->setPropertyVisibility($propertyVisibility);
  426.             }
  428.             $class->save();
  430.             // set the fielddefinitions to [] because we don't need them in the response
  431.             $class->setFieldDefinitions([]);
  433.             return $this->adminJson(['success' => true, 'class' => $class]);
  434.         } catch (\Exception $e) {
  435.             Logger::error($e->getMessage());
  437.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  438.         }
  439.     }
  441.     /**
  442.      * @param string $name
  443.      *
  444.      * @return string
  445.      */
  446.     protected function correctClassname($name)
  447.     {
  448.         $name = preg_replace('/[^a-zA-Z0-9_]+/', '', $name);
  449.         $name = preg_replace('/^[0-9]+/', '', $name);
  451.         return $name;
  452.     }
  454.     /**
  455.      * @Route("/import-class", name="pimcore_admin_dataobject_class_importclass", methods={"POST", "PUT"})
  456.      *
  457.      * @param Request $request
  458.      *
  459.      * @return Response
  460.      */
  461.     public function importClassAction(Request $request)
  462.     {
  463.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  464.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  466.         $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, $json, false, true);
  468.         $response = $this->adminJson([
  469.             'success' => $success
  470.         ]);
  471.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  472.         // Ext.form.Action.Submit and mark the submission as failed
  473.         $response->headers->set('Content-Type', 'text/html');
  475.         return $response;
  476.     }
  478.     /**
  479.      * @Route("/import-custom-layout-definition", name="pimcore_admin_dataobject_class_importcustomlayoutdefinition", methods={"POST", "PUT"})
  480.      *
  481.      * @param Request $request
  482.      *
  483.      * @return Response
  484.      */
  485.     public function importCustomLayoutDefinitionAction(Request $request)
  486.     {
  487.         $success = false;
  488.         $json = file_get_contents($_FILES['Filedata']['tmp_name']);
  489.         $importData = $this->decodeJson($json);
  491.         $customLayoutId = $request->get('id');
  492.         $customLayout = DataObject\ClassDefinition\CustomLayout::getById($customLayoutId);
  493.         if ($customLayout) {
  494.             try {
  495.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($importData['layoutDefinitions'], true);
  496.                 $customLayout->setLayoutDefinitions($layout);
  497.                 $customLayout->setDescription($importData['description']);
  498.                 $customLayout->save();
  499.                 $success = true;
  500.             } catch (\Exception $e) {
  501.                 Logger::error($e->getMessage());
  502.             }
  503.         }
  505.         $response = $this->adminJson([
  506.             'success' => $success
  507.         ]);
  509.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  510.         // Ext.form.Action.Submit and mark the submission as failed
  511.         $response->headers->set('Content-Type', 'text/html');
  513.         return $response;
  514.     }
  516.     /**
  517.      * @Route("/get-custom-layout-definitions", name="pimcore_admin_dataobject_class_getcustomlayoutdefinitions", methods={"GET"})
  518.      *
  519.      * @param Request $request
  520.      *
  521.      * @return JsonResponse
  522.      */
  523.     public function getCustomLayoutDefinitionsAction(Request $request)
  524.     {
  525.         $classId = $request->get('classId');
  526.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  528.         $list->setCondition('classId = ' . $list->quote($classId));
  529.         $list = $list->load();
  530.         $result = [];
  531.         /** @var DataObject\ClassDefinition\CustomLayout $item */
  532.         foreach ($list as $item) {
  533.             $result[] = [
  534.                 'id' => $item->getId(),
  535.                 'name' => $item->getName() . ' (ID: ' . $item->getId() . ')',
  536.                 'default' => $item->getDefault() ?: 0,
  537.             ];
  538.         }
  540.         return $this->adminJson(['success' => true, 'data' => $result]);
  541.     }
  543.     /**
  544.      * @Route("/get-all-layouts", name="pimcore_admin_dataobject_class_getalllayouts", methods={"GET"})
  545.      *
  546.      * @param Request $request
  547.      *
  548.      * @return JsonResponse
  549.      */
  550.     public function getAllLayoutsAction(Request $request)
  551.     {
  552.         // get all classes
  553.         $resultList = [];
  554.         $mapping = [];
  556.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  557.         $customLayouts->setOrder('ASC');
  558.         $customLayouts->setOrderKey('name');
  559.         $customLayouts = $customLayouts->load();
  560.         foreach ($customLayouts as $layout) {
  561.             $mapping[$layout->getClassId()][] = $layout;
  562.         }
  564.         $classList = new DataObject\ClassDefinition\Listing();
  565.         $classList->setOrder('ASC');
  566.         $classList->setOrderKey('name');
  567.         $classList = $classList->load();
  569.         foreach ($classList as $class) {
  570.             if (isset($mapping[$class->getId()])) {
  571.                 $classMapping = $mapping[$class->getId()];
  572.                 $resultList[] = [
  573.                     'type' => 'master',
  574.                     'id' => $class->getId() . '_' . 0,
  575.                     'name' => $class->getName()
  576.                 ];
  578.                 foreach ($classMapping as $layout) {
  579.                     $resultList[] = [
  580.                         'type' => 'custom',
  581.                         'id' => $class->getId() . '_' . $layout->getId(),
  582.                         'name' => $class->getName() . ' - ' . $layout->getName()
  583.                     ];
  584.                 }
  585.             }
  586.         }
  588.         return $this->adminJson(['data' => $resultList]);
  589.     }
  591.     /**
  592.      * @Route("/export-class", name="pimcore_admin_dataobject_class_exportclass", methods={"GET"})
  593.      *
  594.      * @param Request $request
  595.      *
  596.      * @return Response
  597.      */
  598.     public function exportClassAction(Request $request)
  599.     {
  600.         $id = $request->get('id');
  601.         $class = DataObject\ClassDefinition::getById($id);
  603.         if (!$class instanceof DataObject\ClassDefinition) {
  604.             $errorMessage = ': Class with id [ ' . $id . ' not found. ]';
  605.             Logger::error($errorMessage);
  606.             throw $this->createNotFoundException($errorMessage);
  607.         }
  609.         $json = DataObject\ClassDefinition\Service::generateClassDefinitionJson($class);
  611.         $response = new Response($json);
  612.         $response->headers->set('Content-type', 'application/json');
  613.         $response->headers->set('Content-Disposition', 'attachment; filename="class_' . $class->getName() . '_export.json"');
  615.         return $response;
  616.     }
  618.     /**
  619.      * @Route("/export-custom-layout-definition", name="pimcore_admin_dataobject_class_exportcustomlayoutdefinition", methods={"GET"})
  620.      *
  621.      * @param Request $request
  622.      *
  623.      * @return Response
  624.      */
  625.     public function exportCustomLayoutDefinitionAction(Request $request)
  626.     {
  627.         $id = $request->get('id');
  629.         if ($id) {
  630.             $customLayout = DataObject\ClassDefinition\CustomLayout::getById($id);
  631.             if ($customLayout) {
  632.                 $name = $customLayout->getName();
  633.                 unset($customLayout->id);
  634.                 unset($customLayout->classId);
  635.                 unset($customLayout->name);
  636.                 unset($customLayout->creationDate);
  637.                 unset($customLayout->modificationDate);
  638.                 unset($customLayout->userOwner);
  639.                 unset($customLayout->userModification);
  640.                 unset($customLayout->fieldDefinitions);
  642.                 $json = json_encode($customLayout, JSON_PRETTY_PRINT);
  644.                 $response = new Response($json);
  645.                 $response->headers->set('Content-type', 'application/json');
  646.                 $response->headers->set('Content-Disposition', 'attachment; filename="custom_definition_' . $name . '_export.json"');
  648.                 return $response;
  649.             }
  650.         }
  652.         $errorMessage = ': Custom Layout with id [ ' . $id . ' not found. ]';
  653.         Logger::error($errorMessage);
  654.         throw $this->createNotFoundException($errorMessage);
  655.     }
  657.     /**
  658.      * FIELDCOLLECTIONS
  659.      */
  661.     /**
  662.      * @Route("/fieldcollection-get", name="pimcore_admin_dataobject_class_fieldcollectionget", methods={"GET"})
  663.      *
  664.      * @param Request $request
  665.      *
  666.      * @return JsonResponse
  667.      */
  668.     public function fieldcollectionGetAction(Request $request)
  669.     {
  670.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  672.         return $this->adminJson($fc);
  673.     }
  675.     /**
  676.      * @Route("/fieldcollection-update", name="pimcore_admin_dataobject_class_fieldcollectionupdate", methods={"PUT", "POST"})
  677.      *
  678.      * @param Request $request
  679.      *
  680.      * @return JsonResponse
  681.      */
  682.     public function fieldcollectionUpdateAction(Request $request)
  683.     {
  684.         try {
  685.             $key = $request->get('key');
  686.             $title = $request->get('title');
  687.             $group = $request->get('group');
  689.             if ($request->get('task') == 'add') {
  690.                 // check for existing fieldcollection with same name with different lower/upper cases
  691.                 $list = new DataObject\Fieldcollection\Definition\Listing();
  692.                 $list = $list->load();
  694.                 foreach ($list as $item) {
  695.                     if (strtolower($key) === strtolower($item->getKey())) {
  696.                         throw new \Exception('FieldCollection with the same name already exists (lower/upper cases may be different)');
  697.                     }
  698.                 }
  699.             }
  701.             $fcDef = new DataObject\Fieldcollection\Definition();
  702.             $fcDef->setKey($key);
  703.             $fcDef->setTitle($title);
  704.             $fcDef->setGroup($group);
  706.             if ($request->get('values')) {
  707.                 $values = $this->decodeJson($request->get('values'));
  708.                 $fcDef->setParentClass($values['parentClass']);
  709.                 $fcDef->setImplementsInterfaces($values['implementsInterfaces']);
  710.             }
  712.             if ($request->get('configuration')) {
  713.                 $configuration = $this->decodeJson($request->get('configuration'));
  715.                 $configuration['datatype'] = 'layout';
  716.                 $configuration['fieldtype'] = 'panel';
  718.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  719.                 $fcDef->setLayoutDefinitions($layout);
  720.             }
  722.             $fcDef->save();
  724.             return $this->adminJson(['success' => true, 'id' => $fcDef->getKey()]);
  725.         } catch (\Exception $e) {
  726.             Logger::error($e->getMessage());
  728.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  729.         }
  730.     }
  732.     /**
  733.      * @Route("/import-fieldcollection", name="pimcore_admin_dataobject_class_importfieldcollection", methods={"POST"})
  734.      *
  735.      * @param Request $request
  736.      *
  737.      * @return Response
  738.      */
  739.     public function importFieldcollectionAction(Request $request)
  740.     {
  741.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  743.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  745.         $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, $data);
  747.         $response = $this->adminJson([
  748.             'success' => $success
  749.         ]);
  751.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  752.         // Ext.form.Action.Submit and mark the submission as failed
  753.         $response->headers->set('Content-Type', 'text/html');
  755.         return $response;
  756.     }
  758.     /**
  759.      * @Route("/export-fieldcollection", name="pimcore_admin_dataobject_class_exportfieldcollection", methods={"GET"})
  760.      *
  761.      * @param Request $request
  762.      *
  763.      * @return Response
  764.      */
  765.     public function exportFieldcollectionAction(Request $request)
  766.     {
  767.         $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  769.         if (!$fieldCollection instanceof DataObject\Fieldcollection\Definition) {
  770.             $errorMessage = ': Field-Collection with id [ ' . $request->get('id') . ' not found. ]';
  771.             Logger::error($errorMessage);
  772.             throw $this->createNotFoundException($errorMessage);
  773.         }
  775.         $json = DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection);
  776.         $response = new Response($json);
  777.         $response->headers->set('Content-type', 'application/json');
  778.         $response->headers->set('Content-Disposition', 'attachment; filename="fieldcollection_' . $fieldCollection->getKey() . '_export.json"');
  780.         return $response;
  781.     }
  783.     /**
  784.      * @Route("/fieldcollection-delete", name="pimcore_admin_dataobject_class_fieldcollectiondelete", methods={"DELETE"})
  785.      *
  786.      * @param Request $request
  787.      *
  788.      * @return JsonResponse
  789.      */
  790.     public function fieldcollectionDeleteAction(Request $request)
  791.     {
  792.         $fc = DataObject\Fieldcollection\Definition::getByKey($request->get('id'));
  793.         $fc->delete();
  795.         return $this->adminJson(['success' => true]);
  796.     }
  798.     /**
  799.      * @Route("/fieldcollection-tree", name="pimcore_admin_dataobject_class_fieldcollectiontree", methods={"GET", "POST"})
  800.      *
  801.      * @param Request $request
  802.      *
  803.      * @return JsonResponse
  804.      */
  805.     public function fieldcollectionTreeAction(Request $request)
  806.     {
  807.         $list = new DataObject\Fieldcollection\Definition\Listing();
  808.         $list = $list->load();
  810.         $forObjectEditor = $request->get('forObjectEditor');
  812.         $layoutDefinitions = [];
  814.         $definitions = [];
  816.         $allowedTypes = null;
  817.         if ($request->query->has('allowedTypes')) {
  818.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  819.         }
  820.         $object = DataObject\AbstractObject::getById($request->get('object_id'));
  822.         $currentLayoutId = $request->get('layoutId', null);
  823.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  825.         $groups = [];
  826.         /** @var DataObject\Fieldcollection\Definition $item */
  827.         foreach ($list as $item) {
  828.             if ($allowedTypes && !in_array($item->getKey(), $allowedTypes)) {
  829.                 continue;
  830.             }
  832.             if ($item->getGroup()) {
  833.                 if (!isset($groups[$item->getGroup()])) {
  834.                     $groups[$item->getGroup()] = [
  835.                         'id' => 'group_' . $item->getKey(),
  836.                         'text' => $item->getGroup(),
  837.                         'expandable' => true,
  838.                         'leaf' => false,
  839.                         'allowChildren' => true,
  840.                         'iconCls' => 'pimcore_icon_folder',
  841.                         'group' => $item->getGroup(),
  842.                         'children' => []
  843.                     ];
  844.                 }
  845.                 if ($forObjectEditor) {
  846.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  847.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  849.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  850.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  851.                     }
  852.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  853.                 }
  854.                 $groups[$item->getGroup()]['children'][] =
  855.                     [
  856.                         'id' => $item->getKey(),
  857.                         'text' => $item->getKey(),
  858.                         'title' => $item->getTitle(),
  859.                         'key' => $item->getKey(),
  860.                         'leaf' => true,
  861.                         'iconCls' => 'pimcore_icon_fieldcollection'
  862.                     ];
  863.             } else {
  864.                 if ($forObjectEditor) {
  865.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  866.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  868.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  869.                         DataObject\Service::createSuperLayout($itemLayoutDefinitions);
  870.                     }
  872.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  873.                 }
  874.                 $definitions[] = [
  875.                     'id' => $item->getKey(),
  876.                     'text' => $item->getKey(),
  877.                     'title' => $item->getTitle(),
  878.                     'key' => $item->getKey(),
  879.                     'leaf' => true,
  880.                     'iconCls' => 'pimcore_icon_fieldcollection'
  881.                 ];
  882.             }
  883.         }
  885.         foreach ($groups as $group) {
  886.             $definitions[] = $group;
  887.         }
  889.         $event = new GenericEvent($this, [
  890.             'list' => $definitions,
  891.             'objectId' => $request->get('object_id')
  892.         ]);
  893.         \Pimcore::getEventDispatcher()->dispatch(AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA, $event);
  894.         $definitions = $event->getArgument('list');
  896.         if ($forObjectEditor) {
  897.             return $this->adminJson(['fieldcollections' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  898.         } else {
  899.             return $this->adminJson($definitions);
  900.         }
  901.     }
  903.     /**
  904.      * @Route("/fieldcollection-list", name="pimcore_admin_dataobject_class_fieldcollectionlist", methods={"GET"})
  905.      *
  906.      * @param Request $request
  907.      *
  908.      * @return JsonResponse
  909.      */
  910.     public function fieldcollectionListAction(Request $request)
  911.     {
  912.         $user = \Pimcore\Tool\Admin::getCurrentUser();
  913.         $currentLayoutId = $request->get('layoutId');
  915.         $list = new DataObject\Fieldcollection\Definition\Listing();
  916.         $list = $list->load();
  918.         if ($request->query->has('allowedTypes')) {
  919.             $filteredList = [];
  920.             $allowedTypes = explode(',', $request->get('allowedTypes'));
  921.             /** @var DataObject\Fieldcollection\Definition $type */
  922.             foreach ($list as $type) {
  923.                 if (in_array($type->getKey(), $allowedTypes)) {
  924.                     $filteredList[] = $type;
  926.                     // mainly for objects-meta data-type
  927.                     $layoutDefinitions = $type->getLayoutDefinitions();
  928.                     $context = [
  929.                         'containerType' => 'fieldcollection',
  930.                         'containerKey' => $type->getKey(),
  931.                         'outerFieldname' => $request->get('field_name')
  932.                     ];
  934.                     $object = DataObject\AbstractObject::getById($request->get('object_id'));
  936.                     DataObject\Service::enrichLayoutDefinition($layoutDefinitions, $object, $context);
  938.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  939.                         DataObject\Service::createSuperLayout($layoutDefinitions);
  940.                     }
  941.                 }
  942.             }
  944.             $list = $filteredList;
  945.         }
  947.         $event = new GenericEvent($this, [
  948.             'list' => $list,
  949.             'objectId' => $request->get('object_id')
  950.         ]);
  951.         \Pimcore::getEventDispatcher()->dispatch(AdminEvents::CLASS_FIELDCOLLECTION_LIST_PRE_SEND_DATA, $event);
  952.         $list = $event->getArgument('list');
  954.         return $this->adminJson(['fieldcollections' => $list]);
  955.     }
  957.     /**
  958.      * @Route("/get-class-definition-for-column-config", name="pimcore_admin_dataobject_class_getclassdefinitionforcolumnconfig", methods={"GET"})
  959.      *
  960.      * @param Request $request
  961.      *
  962.      * @return JsonResponse
  963.      */
  964.     public function getClassDefinitionForColumnConfigAction(Request $request)
  965.     {
  966.         $class = DataObject\ClassDefinition::getById($request->get('id'));
  967.         $objectId = intval($request->get('oid'));
  969.         $filteredDefinitions = DataObject\Service::getCustomLayoutDefinitionForGridColumnConfig($class, $objectId);
  971.         $layoutDefinitions = isset($filteredDefinitions['layoutDefinition']) ? $filteredDefinitions['layoutDefinition'] : false;
  972.         $filteredFieldDefinition = isset($filteredDefinitions['fieldDefinition']) ? $filteredDefinitions['fieldDefinition'] : false;
  974.         $class->setFieldDefinitions([]);
  976.         $result = [];
  978.         $result['objectColumns']['childs'] = $layoutDefinitions->getChilds();
  979.         $result['objectColumns']['nodeLabel'] = 'object_columns';
  980.         $result['objectColumns']['nodeType'] = 'object';
  982.         // array("id", "fullpath", "published", "creationDate", "modificationDate", "filename", "classname");
  983.         $systemColumnNames = DataObject\Concrete::$systemColumnNames;
  984.         $systemColumns = [];
  985.         foreach ($systemColumnNames as $systemColumn) {
  986.             $systemColumns[] = ['title' => $systemColumn, 'name' => $systemColumn, 'datatype' => 'data', 'fieldtype' => 'system'];
  987.         }
  988.         $result['systemColumns']['nodeLabel'] = 'system_columns';
  989.         $result['systemColumns']['nodeType'] = 'system';
  990.         $result['systemColumns']['childs'] = $systemColumns;
  992.         $list = new DataObject\Objectbrick\Definition\Listing();
  993.         $list = $list->load();
  995.         foreach ($list as $brickDefinition) {
  996.             $classDefs = $brickDefinition->getClassDefinitions();
  997.             if (!empty($classDefs)) {
  998.                 foreach ($classDefs as $classDef) {
  999.                     if ($classDef['classname'] == $class->getName()) {
  1000.                         $fieldName = $classDef['fieldname'];
  1001.                         if ($filteredFieldDefinition && !$filteredFieldDefinition[$fieldName]) {
  1002.                             continue;
  1003.                         }
  1005.                         $key = $brickDefinition->getKey();
  1007.                         $result[$key]['nodeLabel'] = $key;
  1008.                         $result[$key]['brickField'] = $fieldName;
  1009.                         $result[$key]['nodeType'] = 'objectbricks';
  1010.                         $result[$key]['childs'] = $brickDefinition->getLayoutDefinitions()->getChildren();
  1011.                         break;
  1012.                     }
  1013.                 }
  1014.             }
  1015.         }
  1017.         return $this->adminJson($result);
  1018.     }
  1020.     /**
  1021.      * OBJECT BRICKS
  1022.      */
  1024.     /**
  1025.      * @Route("/objectbrick-get", name="pimcore_admin_dataobject_class_objectbrickget", methods={"GET"})
  1026.      *
  1027.      * @param Request $request
  1028.      *
  1029.      * @return JsonResponse
  1030.      */
  1031.     public function objectbrickGetAction(Request $request)
  1032.     {
  1033.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1035.         return $this->adminJson($fc);
  1036.     }
  1038.     /**
  1039.      * @Route("/objectbrick-update", name="pimcore_admin_dataobject_class_objectbrickupdate", methods={"PUT", "POST"})
  1040.      *
  1041.      * @param Request $request
  1042.      *
  1043.      * @return JsonResponse
  1044.      */
  1045.     public function objectbrickUpdateAction(Request $request)
  1046.     {
  1047.         try {
  1048.             $key = $request->get('key');
  1049.             $title = $request->get('title');
  1050.             $group = $request->get('group');
  1052.             if ($request->get('task') == 'add') {
  1053.                 // check for existing brick with same name with different lower/upper cases
  1054.                 $list = new DataObject\Objectbrick\Definition\Listing();
  1055.                 $list = $list->load();
  1057.                 foreach ($list as $item) {
  1058.                     if (strtolower($key) === strtolower($item->getKey())) {
  1059.                         throw new \Exception('Brick with the same name already exists (lower/upper cases may be different)');
  1060.                     }
  1061.                 }
  1062.             }
  1064.             // now we create a new definition
  1065.             $brickDef = new DataObject\Objectbrick\Definition();
  1066.             $brickDef->setKey($key);
  1067.             $brickDef->setTitle($title);
  1068.             $brickDef->setGroup($group);
  1070.             if ($request->get('values')) {
  1071.                 $values = $this->decodeJson($request->get('values'));
  1073.                 $brickDef->setParentClass($values['parentClass']);
  1074.                 $brickDef->setImplementsInterfaces($values['implementsInterfaces']);
  1075.                 $brickDef->setClassDefinitions($values['classDefinitions']);
  1076.             }
  1078.             if ($request->get('configuration')) {
  1079.                 $configuration = $this->decodeJson($request->get('configuration'));
  1081.                 $configuration['datatype'] = 'layout';
  1082.                 $configuration['fieldtype'] = 'panel';
  1084.                 $layout = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($configuration, true);
  1085.                 $brickDef->setLayoutDefinitions($layout);
  1086.             }
  1088.             $event = new GenericEvent($this, [
  1089.                 'brickDefinition' => $brickDef
  1090.             ]);
  1091.             \Pimcore::getEventDispatcher()->dispatch(AdminEvents::CLASS_OBJECTBRICK_UPDATE_DEFINITION, $event);
  1092.             $brickDef = $event->getArgument('brickDefinition');
  1094.             $brickDef->save();
  1096.             return $this->adminJson(['success' => true, 'id' => $brickDef->getKey()]);
  1097.         } catch (\Exception $e) {
  1098.             Logger::error($e->getMessage());
  1100.             return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1101.         }
  1102.     }
  1104.     /**
  1105.      * @Route("/import-objectbrick", name="pimcore_admin_dataobject_class_importobjectbrick", methods={"POST"})
  1106.      *
  1107.      * @param Request $request
  1108.      *
  1109.      * @return JsonResponse
  1110.      */
  1111.     public function importObjectbrickAction(Request $request)
  1112.     {
  1113.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1115.         $data = file_get_contents($_FILES['Filedata']['tmp_name']);
  1116.         $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($objectBrick, $data);
  1118.         $response = $this->adminJson([
  1119.             'success' => $success
  1120.         ]);
  1122.         // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  1123.         // Ext.form.Action.Submit and mark the submission as failed
  1124.         $response->headers->set('Content-Type', 'text/html');
  1126.         return $response;
  1127.     }
  1129.     /**
  1130.      * @Route("/export-objectbrick", name="pimcore_admin_dataobject_class_exportobjectbrick", methods={"GET"})
  1131.      *
  1132.      * @param Request $request
  1133.      *
  1134.      * @return Response
  1135.      */
  1136.     public function exportObjectbrickAction(Request $request)
  1137.     {
  1138.         $objectBrick = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1140.         if (!$objectBrick instanceof DataObject\Objectbrick\Definition) {
  1141.             $errorMessage = ': Object-Brick with id [ ' . $request->get('id') . ' not found. ]';
  1142.             Logger::error($errorMessage);
  1143.             throw $this->createNotFoundException($errorMessage);
  1144.         }
  1146.         $xml = DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick);
  1147.         $response = new Response($xml);
  1148.         $response->headers->set('Content-type', 'application/json');
  1149.         $response->headers->set('Content-Disposition', 'attachment; filename="objectbrick_' . $objectBrick->getKey() . '_export.json"');
  1151.         return $response;
  1152.     }
  1154.     /**
  1155.      * @Route("/objectbrick-delete", name="pimcore_admin_dataobject_class_objectbrickdelete", methods={"DELETE"})
  1156.      *
  1157.      * @param Request $request
  1158.      *
  1159.      * @return JsonResponse
  1160.      */
  1161.     public function objectbrickDeleteAction(Request $request)
  1162.     {
  1163.         $fc = DataObject\Objectbrick\Definition::getByKey($request->get('id'));
  1164.         $fc->delete();
  1166.         return $this->adminJson(['success' => true]);
  1167.     }
  1169.     /**
  1170.      * @Route("/objectbrick-tree", name="pimcore_admin_dataobject_class_objectbricktree", methods={"GET", "POST"})
  1171.      *
  1172.      * @param Request $request
  1173.      *
  1174.      * @return JsonResponse
  1175.      */
  1176.     public function objectbrickTreeAction(Request $request)
  1177.     {
  1178.         $list = new DataObject\Objectbrick\Definition\Listing();
  1179.         $list = $list->load();
  1181.         $forObjectEditor = $request->get('forObjectEditor');
  1183.         $layoutDefinitions = [];
  1184.         $groups = [];
  1185.         $definitions = [];
  1186.         $fieldname = null;
  1187.         $className = null;
  1189.         $object = DataObject\AbstractObject::getById($request->get('object_id'));
  1191.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1192.             $classId = $request->get('class_id');
  1193.             $fieldname = $request->get('field_name');
  1194.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1195.             $className = $classDefinition->getName();
  1196.         }
  1198.         /** @var DataObject\Objectbrick\Definition $item */
  1199.         foreach ($list as $item) {
  1200.             if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1201.                 $keep = false;
  1202.                 $clsDefs = $item->getClassDefinitions();
  1203.                 if (!empty($clsDefs)) {
  1204.                     foreach ($clsDefs as $cd) {
  1205.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1206.                             $keep = true;
  1207.                             continue;
  1208.                         }
  1209.                     }
  1210.                 }
  1211.                 if (!$keep) {
  1212.                     continue;
  1213.                 }
  1214.             }
  1216.             if ($item->getGroup()) {
  1217.                 if (!isset($groups[$item->getGroup()])) {
  1218.                     $groups[$item->getGroup()] = [
  1219.                         'id' => 'group_' . $item->getKey(),
  1220.                         'text' => $item->getGroup(),
  1221.                         'expandable' => true,
  1222.                         'leaf' => false,
  1223.                         'allowChildren' => true,
  1224.                         'iconCls' => 'pimcore_icon_folder',
  1225.                         'group' => $item->getGroup(),
  1226.                         'children' => []
  1227.                     ];
  1228.                 }
  1229.                 if ($forObjectEditor) {
  1230.                     $itemLayoutDefinitions = $item->getLayoutDefinitions();
  1231.                     DataObject\Service::enrichLayoutDefinition($itemLayoutDefinitions, $object);
  1233.                     $layoutDefinitions[$item->getKey()] = $itemLayoutDefinitions;
  1234.                 }
  1235.                 $groups[$item->getGroup()]['children'][] =
  1236.                     [
  1237.                         'id' => $item->getKey(),
  1238.                         'text' => $item->getKey(),
  1239.                         'title' => $item->getTitle(),
  1240.                         'key' => $item->getKey(),
  1241.                         'leaf' => true,
  1242.                         'iconCls' => 'pimcore_icon_objectbricks'
  1243.                     ];
  1244.             } else {
  1245.                 if ($forObjectEditor) {
  1246.                     $layout = $item->getLayoutDefinitions();
  1248.                     $currentLayoutId = $request->get('layoutId', null);
  1250.                     $user = $this->getAdminUser();
  1251.                     if ($currentLayoutId == -1 && $user->isAdmin()) {
  1252.                         DataObject\Service::createSuperLayout($layout);
  1253.                         $objectData['layout'] = $layout;
  1254.                     }
  1256.                     $context = [
  1257.                         'containerType' => 'objectbrick',
  1258.                         'containerKey' => $item->getKey(),
  1259.                         'outerFieldname' => $request->get('field_name')
  1260.                     ];
  1262.                     DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1264.                     $layoutDefinitions[$item->getKey()] = $layout;
  1265.                 }
  1266.                 $definitions[] = [
  1267.                     'id' => $item->getKey(),
  1268.                     'text' => $item->getKey(),
  1269.                     'title' => $item->getTitle(),
  1270.                     'key' => $item->getKey(),
  1271.                     'leaf' => true,
  1272.                     'iconCls' => 'pimcore_icon_objectbricks'
  1273.                 ];
  1274.             }
  1275.         }
  1277.         foreach ($groups as $group) {
  1278.             $definitions[] = $group;
  1279.         }
  1281.         $event = new GenericEvent($this, [
  1282.             'list' => $definitions,
  1283.             'objectId' => $request->get('object_id')
  1284.         ]);
  1285.         \Pimcore::getEventDispatcher()->dispatch(AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA, $event);
  1286.         $definitions = $event->getArgument('list');
  1288.         if ($forObjectEditor) {
  1289.             return $this->adminJson(['objectbricks' => $definitions, 'layoutDefinitions' => $layoutDefinitions]);
  1290.         } else {
  1291.             return $this->adminJson($definitions);
  1292.         }
  1293.     }
  1295.     /**
  1296.      * @Route("/objectbrick-list", name="pimcore_admin_dataobject_class_objectbricklist", methods={"GET"})
  1297.      *
  1298.      * @param Request $request
  1299.      *
  1300.      * @return JsonResponse
  1301.      */
  1302.     public function objectbrickListAction(Request $request)
  1303.     {
  1304.         $list = new DataObject\Objectbrick\Definition\Listing();
  1305.         $list = $list->load();
  1307.         if ($request->query->has('class_id') && $request->query->has('field_name')) {
  1308.             $filteredList = [];
  1309.             $classId = $request->get('class_id');
  1310.             $fieldname = $request->get('field_name');
  1311.             $classDefinition = DataObject\ClassDefinition::getById($classId);
  1312.             $className = $classDefinition->getName();
  1314.             foreach ($list as $type) {
  1315.                 $clsDefs = $type->getClassDefinitions();
  1316.                 if (!empty($clsDefs)) {
  1317.                     foreach ($clsDefs as $cd) {
  1318.                         if ($cd['classname'] == $className && $cd['fieldname'] == $fieldname) {
  1319.                             $filteredList[] = $type;
  1320.                             continue;
  1321.                         }
  1322.                     }
  1323.                 }
  1325.                 $layout = $type->getLayoutDefinitions();
  1327.                 $currentLayoutId = $request->get('layoutId', null);
  1329.                 $user = $this->getAdminUser();
  1330.                 if ($currentLayoutId == -1 && $user->isAdmin()) {
  1331.                     DataObject\Service::createSuperLayout($layout);
  1332.                     $objectData['layout'] = $layout;
  1333.                 }
  1335.                 $context = [
  1336.                     'containerType' => 'objectbrick',
  1337.                     'containerKey' => $type->getKey(),
  1338.                     'outerFieldname' => $request->get('field_name')
  1339.                 ];
  1341.                 $object = DataObject\AbstractObject::getById($request->get('object_id'));
  1343.                 DataObject\Service::enrichLayoutDefinition($layout, $object, $context);
  1344.                 $type->setLayoutDefinitions($layout);
  1345.             }
  1347.             $list = $filteredList;
  1348.         }
  1350.         $event = new GenericEvent($this, [
  1351.             'list' => $list,
  1352.             'objectId' => $request->get('object_id')
  1353.         ]);
  1354.         \Pimcore::getEventDispatcher()->dispatch(AdminEvents::CLASS_OBJECTBRICK_LIST_PRE_SEND_DATA, $event);
  1355.         $list = $event->getArgument('list');
  1357.         return $this->adminJson(['objectbricks' => $list]);
  1358.     }
  1360.     /**
  1361.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1362.      * Add option to export/import all class definitions/brick definitions etc. at once
  1363.      */
  1365.     /**
  1366.      * @Route("/bulk-import", name="pimcore_admin_dataobject_class_bulkimport", methods={"POST"})
  1367.      *
  1368.      * @param Request $request
  1369.      *
  1370.      * @return JsonResponse
  1371.      */
  1372.     public function bulkImportAction(Request $request)
  1373.     {
  1374.         $result = [];
  1376.         $tmpName = $_FILES['Filedata']['tmp_name'];
  1377.         $json = file_get_contents($tmpName);
  1379.         $tmpName = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/bulk-import-' . uniqid() . '.tmp';
  1380.         file_put_contents($tmpName, $json);
  1382.         Session::useSession(function (AttributeBagInterface $session) use ($tmpName) {
  1383.             $session->set('class_bulk_import_file', $tmpName);
  1384.         }, 'pimcore_objects');
  1386.         $json = json_decode($json, true);
  1388.         foreach ($json as $groupName => $group) {
  1389.             foreach ($group as $groupItem) {
  1390.                 $displayName = null;
  1391.                 $icon = null;
  1393.                 if ($groupName == 'class') {
  1394.                     $name = $groupItem['name'];
  1395.                     $icon = 'class';
  1396.                 } elseif ($groupName == 'customlayout') {
  1397.                     $className = $groupItem['className'];
  1399.                     $layoutData = ['className' => $className, 'name' => $groupItem['name']];
  1400.                     $name = base64_encode(json_encode($layoutData));
  1401.                     $displayName = $className . ' / ' . $groupItem['name'];
  1402.                     $icon = 'custom_views';
  1403.                 } else {
  1404.                     if ($groupName == 'objectbrick') {
  1405.                         $icon = 'objectbricks';
  1406.                     } elseif ($groupName == 'fieldcollection') {
  1407.                         $icon = 'fieldcollection';
  1408.                     }
  1409.                     $name = $groupItem['key'];
  1410.                 }
  1412.                 if (!$displayName) {
  1413.                     $displayName = $name;
  1414.                 }
  1415.                 $result[] = ['icon' => $icon, 'checked' => true, 'type' => $groupName, 'name' => $name, 'displayName' => $displayName];
  1416.             }
  1417.         }
  1419.         $response = $this->adminJson(['success' => true, 'data' => $result]);
  1420.         $response->headers->set('Content-Type', 'text/html');
  1422.         return $response;
  1423.     }
  1425.     /**
  1426.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1427.      * Add option to export/import all class definitions/brick definitions etc. at once
  1428.      */
  1430.     /**
  1431.      * @Route("/bulk-commit", name="pimcore_admin_dataobject_class_bulkcommit", methods={"POST"})
  1432.      *
  1433.      * @param Request $request
  1434.      *
  1435.      * @return JsonResponse
  1436.      *
  1437.      * @throws \Exception
  1438.      */
  1439.     public function bulkCommitAction(Request $request)
  1440.     {
  1441.         $data = json_decode($request->get('data'), true);
  1443.         $session = Session::get('pimcore_objects');
  1444.         $filename = $session->get('class_bulk_import_file');
  1445.         $json = @file_get_contents($filename);
  1446.         $json = json_decode($json, true);
  1448.         $type = $data['type'];
  1449.         $name = $data['name'];
  1450.         $list = $json[$type];
  1452.         foreach ($list as $item) {
  1453.             unset($item['creationDate']);
  1454.             unset($item['modificationDate']);
  1455.             unset($item['userOwner']);
  1456.             unset($item['userModification']);
  1458.             if ($type == 'class' && $item['name'] == $name) {
  1459.                 $class = DataObject\ClassDefinition::getByName($name);
  1460.                 if (!$class) {
  1461.                     $class = new DataObject\ClassDefinition();
  1462.                     $class->setName($name);
  1463.                 }
  1464.                 $success = DataObject\ClassDefinition\Service::importClassDefinitionFromJson($class, json_encode($item), true);
  1466.                 return $this->adminJson(['success' => $success !== false]);
  1467.             } elseif ($type == 'objectbrick' && $item['key'] == $name) {
  1468.                 if (!$brick = DataObject\Objectbrick\Definition::getByKey($name)) {
  1469.                     $brick = new DataObject\Objectbrick\Definition();
  1470.                     $brick->setKey($name);
  1471.                 }
  1473.                 $success = DataObject\ClassDefinition\Service::importObjectBrickFromJson($brick, json_encode($item), true);
  1475.                 return $this->adminJson(['success' => $success !== false]);
  1476.             } elseif ($type == 'fieldcollection' && $item['key'] == $name) {
  1477.                 if (!$fieldCollection = DataObject\Fieldcollection\Definition::getByKey($name)) {
  1478.                     $fieldCollection = new DataObject\Fieldcollection\Definition();
  1479.                     $fieldCollection->setKey($name);
  1480.                 }
  1482.                 $success = DataObject\ClassDefinition\Service::importFieldCollectionFromJson($fieldCollection, json_encode($item), true);
  1484.                 return $this->adminJson(['success' => $success !== false]);
  1485.             } elseif ($type == 'customlayout') {
  1486.                 $layoutData = json_decode(base64_decode($data['name']), true);
  1487.                 $className = $layoutData['className'];
  1488.                 $layoutName = $layoutData['name'];
  1490.                 if ($item['name'] == $layoutName && $item['className'] == $className) {
  1491.                     $class = DataObject\ClassDefinition::getByName($className);
  1492.                     if (!$class) {
  1493.                         throw new \Exception('Class does not exist');
  1494.                     }
  1496.                     $classId = $class->getId();
  1498.                     $layoutList = new DataObject\ClassDefinition\CustomLayout\Listing();
  1499.                     $db = \Pimcore\Db::get();
  1500.                     $layoutList->setCondition('name = ' . $db->quote($layoutName) . ' AND classId = ' . $classId);
  1501.                     $layoutList = $layoutList->load();
  1503.                     $layoutDefinition = null;
  1504.                     if ($layoutList) {
  1505.                         $layoutDefinition = $layoutList[0];
  1506.                     }
  1508.                     if (!$layoutDefinition) {
  1509.                         $layoutDefinition = new DataObject\ClassDefinition\CustomLayout();
  1510.                         $layoutDefinition->setName($layoutName);
  1511.                         $layoutDefinition->setClassId($classId);
  1512.                     }
  1514.                     try {
  1515.                         $layoutDefinition->setDescription($item['description']);
  1516.                         $layoutDef = DataObject\ClassDefinition\Service::generateLayoutTreeFromArray($item['layoutDefinitions'], true);
  1517.                         $layoutDefinition->setLayoutDefinitions($layoutDef);
  1518.                         $layoutDefinition->save();
  1519.                     } catch (\Exception $e) {
  1520.                         Logger::error($e->getMessage());
  1522.                         return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1523.                     }
  1524.                 }
  1525.             }
  1526.         }
  1528.         return $this->adminJson(['success' => true]);
  1529.     }
  1531.     /**
  1532.      * See http://www.pimcore.org/issues/browse/PIMCORE-2358
  1533.      * Add option to export/import all class definitions/brick definitions etc. at once
  1534.      */
  1536.     /**
  1537.      * @Route("/bulk-export-prepare", name="pimcore_admin_dataobject_class_bulkexportprepare", methods={"POST"})
  1538.      *
  1539.      * @param Request $request
  1540.      *
  1541.      * @return Response
  1542.      */
  1543.     public function bulkExportPrepareAction(Request $request)
  1544.     {
  1545.         $data = $request->get('data');
  1547.         Session::useSession(function (AttributeBagInterface $session) use ($data) {
  1548.             $session->set('class_bulk_export_settings', $data);
  1549.         }, 'pimcore_objects');
  1551.         return $this->adminJson(['success' => true]);
  1552.     }
  1554.     /**
  1555.      * @Route("/bulk-export", name="pimcore_admin_dataobject_class_bulkexport", methods={"GET"})
  1556.      *
  1557.      * @param Request $request
  1558.      *
  1559.      * @return Response
  1560.      */
  1561.     public function bulkExportAction(Request $request)
  1562.     {
  1563.         $result = [];
  1565.         $fieldCollections = new DataObject\Fieldcollection\Definition\Listing();
  1566.         $fieldCollections = $fieldCollections->load();
  1568.         foreach ($fieldCollections as $fieldCollection) {
  1569.             $result[] = [
  1570.                 'icon' => 'fieldcollection',
  1571.                 'checked' => true,
  1572.                 'type' => 'fieldcollection',
  1573.                 'name' => $fieldCollection->getKey(),
  1574.                 'displayName' => $fieldCollection->getKey()
  1575.             ];
  1576.         }
  1578.         $classes = new DataObject\ClassDefinition\Listing();
  1579.         $classes->setOrder('ASC');
  1580.         $classes->setOrderKey('id');
  1581.         $classes = $classes->load();
  1583.         foreach ($classes as $class) {
  1584.             $result[] = [
  1585.                 'icon' => 'class',
  1586.                 'checked' => true,
  1587.                 'type' => 'class',
  1588.                 'name' => $class->getName(),
  1589.                 'displayName' => $class->getName()
  1590.             ];
  1591.         }
  1593.         $objectBricks = new DataObject\Objectbrick\Definition\Listing();
  1594.         $objectBricks = $objectBricks->load();
  1596.         foreach ($objectBricks as $objectBrick) {
  1597.             $result[] = [
  1598.                 'icon' => 'objectbricks',
  1599.                 'checked' => true,
  1600.                 'type' => 'objectbrick',
  1601.                 'name' => $objectBrick->getKey(),
  1602.                 'displayName' => $objectBrick->getKey()
  1603.             ];
  1604.         }
  1606.         $customLayouts = new DataObject\ClassDefinition\CustomLayout\Listing();
  1607.         $customLayouts = $customLayouts->load();
  1608.         foreach ($customLayouts as $customLayout) {
  1609.             $class = DataObject\ClassDefinition::getById($customLayout->getClassId());
  1610.             $displayName = $class->getName() . ' / ' .  $customLayout->getName();
  1612.             $result[] = [
  1613.                 'icon' => 'custom_views',
  1614.                 'checked' => true,
  1615.                 'type' => 'customlayout',
  1616.                 'name' => $customLayout->getId(),
  1617.                 'displayName' => $displayName
  1618.             ];
  1619.         }
  1621.         return new JsonResponse(['success' => true, 'data' => $result]);
  1622.     }
  1624.     /**
  1625.      * @Route("/do-bulk-export", name="pimcore_admin_dataobject_class_dobulkexport", methods={"GET"})
  1626.      *
  1627.      * @param Request $request
  1628.      *
  1629.      * @return Response
  1630.      */
  1631.     public function doBulkExportAction(Request $request)
  1632.     {
  1633.         $session = Session::get('pimcore_objects');
  1634.         $list = $session->get('class_bulk_export_settings');
  1635.         $list = json_decode($list, true);
  1636.         $result = [];
  1638.         foreach ($list as $item) {
  1639.             if ($item['type'] == 'fieldcollection') {
  1640.                 $fieldCollection = DataObject\Fieldcollection\Definition::getByKey($item['name']);
  1641.                 $key = $fieldCollection->getKey();
  1642.                 $fieldCollectionJson = json_decode(DataObject\ClassDefinition\Service::generateFieldCollectionJson($fieldCollection));
  1643.                 $fieldCollectionJson->key = $key;
  1644.                 $result['fieldcollection'][] = $fieldCollectionJson;
  1645.             } elseif ($item['type'] == 'class') {
  1646.                 $class = DataObject\ClassDefinition::getByName($item['name']);
  1647.                 $data = Model\Webservice\Data\Mapper::map($class, '\\Pimcore\\Model\\Webservice\\Data\\ClassDefinition\\Out', 'out');
  1648.                 unset($data->fieldDefinitions);
  1649.                 $result['class'][] = $data;
  1650.             } elseif ($item['type'] == 'objectbrick') {
  1651.                 $objectBrick = DataObject\Objectbrick\Definition::getByKey($item['name']);
  1652.                 $key = $objectBrick->getKey();
  1653.                 $objectBrickJson = json_decode(DataObject\ClassDefinition\Service::generateObjectBrickJson($objectBrick));
  1654.                 $objectBrickJson->key = $key;
  1655.                 $result['objectbrick'][] = $objectBrickJson;
  1656.             } elseif ($item['type'] == 'customlayout') {
  1657.                 /** @var DataObject\ClassDefinition\CustomLayout $customLayout */
  1658.                 $customLayout = DataObject\ClassDefinition\CustomLayout::getById($item['name']);
  1659.                 $classId = $customLayout->getClassId();
  1660.                 $class = DataObject\ClassDefinition::getById($classId);
  1661.                 $customLayout = $customLayout->getObjectVars();
  1662.                 $customLayout['className'] = $class->getName();
  1663.                 $result['customlayout'][] = $customLayout;
  1664.             }
  1665.         }
  1667.         $result = json_encode($result, JSON_PRETTY_PRINT);
  1668.         $response = new Response($result);
  1669.         $response->headers->set('Content-type', 'application/json');
  1670.         $response->headers->set('Content-Disposition', 'attachment; filename="bulk_export.json"');
  1672.         return $response;
  1673.     }
  1675.     /**
  1676.      * @param FilterControllerEvent $event
  1677.      */
  1678.     public function onKernelController(FilterControllerEvent $event)
  1679.     {
  1680.         $isMasterRequest = $event->isMasterRequest();
  1681.         if (!$isMasterRequest) {
  1682.             return;
  1683.         }
  1685.         // check permissions
  1686.         $unrestrictedActions = [
  1687.             'getTreeAction', 'fieldcollectionListAction', 'fieldcollectionTreeAction', 'fieldcollectionGetAction',
  1688.             'getClassDefinitionForColumnConfigAction', 'objectbrickListAction', 'objectbrickTreeAction', 'objectbrickGetAction'
  1689.         ];
  1691.         $this->checkActionPermission($event, 'classes', $unrestrictedActions);
  1692.     }
  1694.     /**
  1695.      * @param FilterResponseEvent $event
  1696.      */
  1697.     public function onKernelResponse(FilterResponseEvent $event)
  1698.     {
  1699.         // nothing to do
  1700.     }
  1702.     /**
  1703.      * @Route("/get-fieldcollection-usages", name="pimcore_admin_dataobject_class_getfieldcollectionusages", methods={"GET"})
  1704.      *
  1705.      * @param Request $request
  1706.      *
  1707.      * @return Response
  1708.      */
  1709.     public function getFieldcollectionUsagesAction(Request $request)
  1710.     {
  1711.         $key = $request->get('key');
  1712.         $result = [];
  1714.         $classes = new DataObject\ClassDefinition\Listing();
  1715.         $classes = $classes->load();
  1716.         foreach ($classes as $class) {
  1717.             $fieldDefs = $class->getFieldDefinitions();
  1718.             foreach ($fieldDefs as $fieldDef) {
  1719.                 if ($fieldDef instanceof DataObject\ClassDefinition\Data\Fieldcollections) {
  1720.                     $allowedKeys = $fieldDef->getAllowedTypes();
  1721.                     if (is_array($allowedKeys) && in_array($key, $allowedKeys)) {
  1722.                         $result[] = [
  1723.                             'class' => $class->getName(),
  1724.                             'field' => $fieldDef->getName()
  1725.                         ];
  1726.                     }
  1727.                 }
  1728.             }
  1729.         }
  1731.         return $this->adminJson($result);
  1732.     }
  1734.     /**
  1735.      * @Route("/get-bricks-usages", name="pimcore_admin_dataobject_class_getbrickusages", methods={"GET"})
  1736.      *
  1737.      * @param Request $request
  1738.      *
  1739.      * @return Response
  1740.      */
  1741.     public function getBrickUsagesAction(Request $request)
  1742.     {
  1743.         $classId = $request->get('classId');
  1744.         $myclass = DataObject\ClassDefinition::getById($classId);
  1746.         $result = [];
  1748.         $brickDefinitions = new DataObject\Objectbrick\Definition\Listing();
  1749.         $brickDefinitions = $brickDefinitions->load();
  1750.         foreach ($brickDefinitions as $brickDefinition) {
  1751.             $classes = $brickDefinition->getClassDefinitions();
  1752.             foreach ($classes as $class) {
  1753.                 if ($myclass->getName() == $class['classname']) {
  1754.                     $result[] = [
  1755.                         'objectbrick' => $brickDefinition->getKey(),
  1756.                         'field' => $class['fieldname']
  1757.                     ];
  1758.                 }
  1759.             }
  1760.         }
  1762.         return $this->adminJson($result);
  1763.     }
  1765.     /**
  1766.      * @Route("/get-icons", name="pimcore_admin_dataobject_class_geticons", methods={"GET"})
  1767.      *
  1768.      * @param Request $request
  1769.      *
  1770.      * @return Response
  1771.      */
  1772.     public function getIconsAction(Request $request)
  1773.     {
  1774.         $classId = $request->get('classId');
  1776.         $iconDir = PIMCORE_WEB_ROOT . '/bundles/pimcoreadmin/img';
  1777.         $classIcons = rscandir($iconDir . '/object-icons/');
  1778.         $colorIcons = rscandir($iconDir . '/flat-color-icons/');
  1779.         $twemoji = rscandir($iconDir . '/twemoji/');
  1781.         $icons = array_merge($classIcons, $colorIcons, $twemoji);
  1783.         foreach ($icons as &$icon) {
  1784.             $icon = str_replace(PIMCORE_WEB_ROOT, '', $icon);
  1785.         }
  1787.         $event = new GenericEvent($this, [
  1788.             'icons' => $icons,
  1789.             'classId' => $classId
  1790.         ]);
  1791.         \Pimcore::getEventDispatcher()->dispatch(AdminEvents::CLASS_OBJECT_ICONS_PRE_SEND_DATA, $event);
  1792.         $icons = $event->getArgument('icons');
  1794.         $result = [];
  1795.         foreach ($icons as $icon) {
  1796.             $result[] = [
  1797.                 'text' => "<img src='{$icon}'>",
  1798.                 'value' => $icon
  1799.             ];
  1800.         }
  1802.         return $this->adminJson($result);
  1803.     }
  1805.     /**
  1806.      * @Route("/suggest-class-identifier", name="pimcore_admin_dataobject_class_suggestclassidentifier")
  1807.      *
  1808.      * @return Response
  1809.      */
  1810.     public function suggestClassIdentifierAction()
  1811.     {
  1812.         $db = Db::get();
  1813.         $maxId = $db->fetchOne('SELECT MAX(CAST(id AS SIGNED)) FROM classes;');
  1815.         $existingIds = $db->fetchCol('select LOWER(id) from classes');
  1817.         $result = [
  1818.             'suggestedIdentifier' => $maxId ? $maxId + 1 : 1,
  1819.             'existingIds' => $existingIds
  1820.             ];
  1822.         return $this->adminJson($result);
  1823.     }
  1825.     /**
  1826.      * @Route("/suggest-custom-layout-identifier", name="pimcore_admin_dataobject_class_suggestcustomlayoutidentifier")
  1827.      *
  1828.      * @param Request $request
  1829.      *
  1830.      * @return Response
  1831.      */
  1832.     public function suggestCustomLayoutIdentifierAction(Request $request)
  1833.     {
  1834.         $classId = $request->get('classId');
  1836.         $identifier = DataObject\ClassDefinition\CustomLayout::getIdentifier($classId);
  1838.         $list = new DataObject\ClassDefinition\CustomLayout\Listing();
  1840.         $list = $list->load();
  1841.         $existingIds = [];
  1842.         $existingNames = [];
  1844.         /** @var DataObject\ClassDefinition\CustomLayout $item */
  1845.         foreach ($list as $item) {
  1846.             $existingIds[] = $item->getId();
  1847.             if ($item->getClassId() == $classId) {
  1848.                 $existingNames[] = $item->getName();
  1849.             }
  1850.         }
  1852.         $result = [
  1853.             'suggestedIdentifier' => $identifier,
  1854.             'existingIds' => $existingIds,
  1855.             'existingNames' => $existingNames
  1856.             ];
  1858.         return $this->adminJson($result);
  1859.     }
  1860. }