vendor/pimcore/pimcore/models/DataObject/ClassDefinition.php line 305

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\Model\DataObject;
  18. use Pimcore\Cache;
  19. use Pimcore\Cache\RuntimeCache;
  20. use Pimcore\DataObject\ClassBuilder\FieldDefinitionDocBlockBuilderInterface;
  21. use Pimcore\DataObject\ClassBuilder\PHPClassDumperInterface;
  22. use Pimcore\Db;
  23. use Pimcore\Event\DataObjectClassDefinitionEvents;
  24. use Pimcore\Event\Model\DataObject\ClassDefinitionEvent;
  25. use Pimcore\Event\Traits\RecursionBlockingEventDispatchHelperTrait;
  26. use Pimcore\Logger;
  27. use Pimcore\Model;
  28. use Pimcore\Model\DataObject;
  29. use Pimcore\Model\DataObject\ClassDefinition\Data\FieldDefinitionEnrichmentInterface;
  31. /**
  32.  * @method \Pimcore\Model\DataObject\ClassDefinition\Dao getDao()
  33.  */
  34. final class ClassDefinition extends Model\AbstractModel
  35. {
  36.     use DataObject\ClassDefinition\Helper\VarExport;
  37.     use DataObject\Traits\LocateFileTrait;
  38.     use RecursionBlockingEventDispatchHelperTrait;
  40.     /**
  41.      * @internal
  42.      *
  43.      * @var string|null
  44.      */
  45.     public $id;
  47.     /**
  48.      * @internal
  49.      *
  50.      * @var string|null
  51.      */
  52.     public $name;
  54.     /**
  55.      * @internal
  56.      *
  57.      * @var string
  58.      */
  59.     public $description = '';
  61.     /**
  62.      * @internal
  63.      *
  64.      * @var int|null
  65.      */
  66.     public $creationDate;
  68.     /**
  69.      * @internal
  70.      *
  71.      * @var int|null
  72.      */
  73.     public $modificationDate;
  75.     /**
  76.      * @internal
  77.      *
  78.      * @var int|null
  79.      */
  80.     public $userOwner;
  82.     /**
  83.      * @internal
  84.      *
  85.      * @var int|null
  86.      */
  87.     public $userModification;
  89.     /**
  90.      * @internal
  91.      *
  92.      * @var string
  93.      */
  94.     public $parentClass = '';
  96.     /**
  97.      * Comma separated list of interfaces
  98.      *
  99.      * @internal
  100.      *
  101.      * @var string|null
  102.      */
  103.     public $implementsInterfaces;
  105.     /**
  106.      * Name of the listing parent class if set
  107.      *
  108.      * @internal
  109.      *
  110.      * @var string
  111.      */
  112.     public $listingParentClass = '';
  114.     /**
  115.      * @internal
  116.      *
  117.      * @var string
  118.      */
  119.     public $useTraits = '';
  121.     /**
  122.      * @internal
  123.      *
  124.      * @var string
  125.      */
  126.     public $listingUseTraits = '';
  128.     /**
  129.      * @internal
  130.      *
  131.      * @var bool
  132.      */
  133.     protected $encryption = false;
  135.     /**
  136.      * @internal
  137.      *
  138.      * @var array
  139.      */
  140.     protected $encryptedTables = [];
  142.     /**
  143.      * @internal
  144.      *
  145.      * @var bool
  146.      */
  147.     public $allowInherit = false;
  149.     /**
  150.      * @internal
  151.      *
  152.      * @var bool
  153.      */
  154.     public $allowVariants = false;
  156.     /**
  157.      * @internal
  158.      *
  159.      * @var bool
  160.      */
  161.     public $showVariants = false;
  163.     /**
  164.      * @internal
  165.      *
  166.      * @var DataObject\ClassDefinition\Data[]
  167.      */
  168.     public array $fieldDefinitions = [];
  170.     /**
  171.      * @internal
  172.      *
  173.      * @var DataObject\ClassDefinition\Layout|null
  174.      */
  175.     public $layoutDefinitions;
  177.     /**
  178.      * @internal
  179.      *
  180.      * @var string|null
  181.      */
  182.     public $icon;
  184.     /**
  185.      * @internal
  186.      *
  187.      * @var string|null
  188.      */
  189.     public $previewUrl;
  191.     /**
  192.      * @internal
  193.      *
  194.      * @var string|null
  195.      */
  196.     public $group;
  198.     /**
  199.      * @internal
  200.      *
  201.      * @var bool
  202.      */
  203.     public $showAppLoggerTab = false;
  205.     /**
  206.      * @internal
  207.      *
  208.      * @var string
  209.      */
  210.     public $linkGeneratorReference;
  212.     /**
  213.      * @internal
  214.      *
  215.      * @var string|null
  216.      */
  217.     public $previewGeneratorReference;
  219.     /**
  220.      * @internal
  221.      *
  222.      * @var array
  223.      */
  224.     public $compositeIndices = [];
  226.     /**
  227.      * @internal
  228.      *
  229.      * @var bool
  230.      */
  231.     public $generateTypeDeclarations = true;
  233.     /**
  234.      * @internal
  235.      *
  236.      * @var bool
  237.      */
  238.     public $showFieldLookup = false;
  240.     /**
  241.      * @internal
  242.      *
  243.      * @var array
  244.      */
  245.     public $propertyVisibility = [
  246.         'grid' => [
  247.             'id' => true,
  248.             'path' => true,
  249.             'published' => true,
  250.             'modificationDate' => true,
  251.             'creationDate' => true,
  252.         ],
  253.         'search' => [
  254.             'id' => true,
  255.             'path' => true,
  256.             'published' => true,
  257.             'modificationDate' => true,
  258.             'creationDate' => true,
  259.         ],
  260.     ];
  262.     /**
  263.      * @internal
  264.      *
  265.      * @var bool
  266.      */
  267.     public $enableGridLocking = false;
  269.     /**
  270.      * @internal
  271.      *
  272.      * @var ClassDefinition\Data[]
  273.      */
  274.     private array $deletedDataComponents = [];
  276.     /**
  277.      * @param string $id
  278.      * @param bool $force
  279.      *
  280.      * @return null|ClassDefinition
  281.      *
  282.      * @throws \Exception
  283.      */
  284.     public static function getById(string $id, $force = false)
  285.     {
  286.         $cacheKey = 'class_' . $id;
  288.         try {
  289.             if ($force) {
  290.                 throw new \Exception('Forced load');
  291.             }
  292.             $class = RuntimeCache::get($cacheKey);
  293.             if (!$class) {
  294.                 throw new \Exception('Class in registry is null');
  295.             }
  296.         } catch (\Exception $e) {
  297.             try {
  298.                 $class = new self();
  299.                 $name = $class->getDao()->getNameById($id);
  300.                 if (!$name) {
  301.                     throw new \Exception('Class definition with name ' . $name . ' or ID ' . $id . ' does not exist');
  302.                 }
  304.                 $definitionFile = $class->getDefinitionFile($name);
  305.                 $class = @include $definitionFile;
  307.                 if (!$class instanceof self) {
  308.                     throw new \Exception('Class definition with name ' . $name . ' or ID ' . $id . ' does not exist');
  309.                 }
  311.                 $class->setId($id);
  313.                 RuntimeCache::set($cacheKey, $class);
  314.             } catch (\Exception $e) {
  315.                 Logger::info($e->getMessage());
  317.                 return null;
  318.             }
  319.         }
  321.         return $class;
  322.     }
  324.     /**
  325.      * @param string $name
  326.      *
  327.      * @return self|null
  328.      *
  329.      * @throws \Exception
  330.      */
  331.     public static function getByName($name)
  332.     {
  333.         try {
  334.             $class = new self();
  335.             $id = $class->getDao()->getIdByName($name);
  337.             return self::getById($id);
  338.         } catch (Model\Exception\NotFoundException $e) {
  339.             return null;
  340.         }
  341.     }
  343.     /**
  344.      * @param array $values
  345.      *
  346.      * @return self
  347.      */
  348.     public static function create($values = [])
  349.     {
  350.         $class = new self();
  351.         $class->setValues($values);
  353.         return $class;
  354.     }
  356.     /**
  357.      * @internal
  358.      *
  359.      * @param string $name
  360.      */
  361.     public function rename($name)
  362.     {
  363.         $this->deletePhpClasses();
  364.         $this->getDao()->updateClassNameInObjects($name);
  366.         $this->setName($name);
  367.         $this->save();
  368.     }
  370.     /**
  371.      * @param mixed $data
  372.      *
  373.      * @internal
  374.      */
  375.     public static function cleanupForExport(&$data)
  376.     {
  377.         if (!is_object($data)) {
  378.             return;
  379.         }
  381.         if ($data instanceof DataObject\ClassDefinition\Data\VarExporterInterface) {
  382.             $blockedVars = $data->resolveBlockedVars();
  383.             foreach ($blockedVars as $blockedVar) {
  384.                 if (isset($data->{$blockedVar})) {
  385.                     unset($data->{$blockedVar});
  386.                 }
  387.             }
  389.             if (isset($data->blockedVarsForExport)) {
  390.                 unset($data->blockedVarsForExport);
  391.             }
  392.         }
  394.         if (method_exists($data, 'getChildren')) {
  395.             $children = $data->getChildren();
  396.             if (is_array($children)) {
  397.                 foreach ($children as $child) {
  398.                     self::cleanupForExport($child);
  399.                 }
  400.             }
  401.         }
  402.     }
  404.     /**
  405.      * @return bool
  406.      */
  407.     private function exists()
  408.     {
  409.         $name = $this->getDao()->getNameById($this->getId());
  411.         return is_string($name);
  412.     }
  414.     /**
  415.      * @param bool $saveDefinitionFile
  416.      *
  417.      * @throws \Exception
  418.      * @throws DataObject\Exception\DefinitionWriteException
  419.      */
  420.     public function save($saveDefinitionFile = true)
  421.     {
  422.         if ($saveDefinitionFile && !$this->isWritable()) {
  423.             throw new DataObject\Exception\DefinitionWriteException();
  424.         }
  426.         $fieldDefinitions = $this->getFieldDefinitions();
  427.         foreach ($fieldDefinitions as $fd) {
  428.             if ($fd->isForbiddenName()) {
  429.                 throw new \Exception(sprintf('Forbidden name used for field definition: %s', $fd->getName()));
  430.             }
  432.             if ($fd instanceof DataObject\ClassDefinition\Data\DataContainerAwareInterface) {
  433.                 $fd->preSave($this);
  434.             }
  435.         }
  437.         if (!$this->getId()) {
  438.             $db = Db::get();
  439.             $maxId = $db->fetchOne('SELECT MAX(CAST(id AS SIGNED)) FROM classes;');
  440.             $maxId = $maxId ? $maxId + 1 : 1;
  441.             $this->setId((string) $maxId);
  442.         }
  444.         if (!preg_match('/[a-zA-Z][a-zA-Z0-9_]+/', $this->getName())) {
  445.             throw new \Exception(sprintf('Invalid name for class definition: %s', $this->getName()));
  446.         }
  448.         if (!preg_match('/[a-zA-Z0-9]([a-zA-Z0-9_]+)?/', $this->getId())) {
  449.             throw new \Exception(sprintf('Invalid ID `%s` for class definition %s', $this->getId(), $this->getName()));
  450.         }
  452.         foreach (['parentClass', 'listingParentClass', 'useTraits', 'listingUseTraits'] as $propertyName) {
  453.             $propertyValue = $this->{'get'.ucfirst($propertyName)}();
  454.             if ($propertyValue && !preg_match('/^[a-zA-Z_\x7f-\xff\\\][a-zA-Z0-9_\x7f-\xff\\\ ,]*$/', $propertyValue)) {
  455.                 throw new \Exception(sprintf('Invalid %s value for class definition: %s', $propertyName,
  456.                     $this->getParentClass()));
  457.             }
  458.         }
  460.         $isUpdate = $this->exists();
  462.         if (!$isUpdate) {
  463.             $this->dispatchEvent(new ClassDefinitionEvent($this), DataObjectClassDefinitionEvents::PRE_ADD);
  464.         } else {
  465.             $this->dispatchEvent(new ClassDefinitionEvent($this), DataObjectClassDefinitionEvents::PRE_UPDATE);
  466.         }
  468.         $this->setModificationDate(time());
  470.         $this->getDao()->save($isUpdate);
  472.         $this->generateClassFiles($saveDefinitionFile);
  474.         foreach ($fieldDefinitions as $fd) {
  475.             // call the method "classSaved" if exists, this is used to create additional data tables or whatever which depends on the field definition, for example for localizedfields
  476.             //TODO Pimcore 11 remove method_exists call
  477.             if (!$fd instanceof ClassDefinition\Data\DataContainerAwareInterface && method_exists($fd, 'classSaved')) {
  478.                 $fd->classSaved($this);
  479.             }
  480.         }
  482.         // empty object cache
  483.         try {
  484.             Cache::clearTag('class_'.$this->getId());
  485.         } catch (\Exception $e) {
  486.         }
  488.         foreach ($fieldDefinitions as $fd) {
  489.             if ($fd instanceof DataObject\ClassDefinition\Data\DataContainerAwareInterface) {
  490.                 $fd->postSave($this);
  491.             }
  492.         }
  494.         if ($isUpdate) {
  495.             $this->dispatchEvent(new ClassDefinitionEvent($this), DataObjectClassDefinitionEvents::POST_UPDATE);
  496.         } else {
  497.             $this->dispatchEvent(new ClassDefinitionEvent($this), DataObjectClassDefinitionEvents::POST_ADD);
  498.         }
  500.         $this->deleteDeletedDataComponentsInCustomLayout();
  501.     }
  503.     /**
  504.      * @param bool $generateDefinitionFile
  505.      *
  506.      * @throws \Exception
  507.      *
  508.      * @internal
  509.      */
  510.     public function generateClassFiles($generateDefinitionFile = true)
  511.     {
  512.         \Pimcore::getContainer()->get(PHPClassDumperInterface::class)->dumpPHPClasses($this);
  514.         if ($generateDefinitionFile) {
  515.             // save definition as a php file
  516.             $definitionFile = $this->getDefinitionFile();
  517.             if (!is_writable(dirname($definitionFile)) || (is_file($definitionFile) && !is_writable($definitionFile))) {
  518.                 throw new \Exception(
  519.                     'Cannot write definition file in: '.$definitionFile.' please check write permission on this directory.'
  520.                 );
  521.             }
  522.             /** @var self $clone */
  523.             $clone = DataObject\Service::cloneDefinition($this);
  524.             $clone->setDao(null);
  525.             $clone->fieldDefinitions = [];
  527.             self::cleanupForExport($clone->layoutDefinitions);
  529.             $exportedClass = var_export($clone, true);
  531.             $data = '<?php';
  532.             $data .= "\n\n";
  533.             $data .= $this->getInfoDocBlock();
  534.             $data .= "\n\n";
  536.             $data .= 'return '.$exportedClass.";\n";
  538.             \Pimcore\File::putPhpFile($definitionFile, $data);
  539.         }
  540.     }
  542.     /**
  543.      * @return string
  544.      *
  545.      * @internal
  546.      */
  547.     protected function getInfoDocBlock(): string
  548.     {
  549.         $cd = '/**' . "\n";
  550.         $cd .= ' * Inheritance: '.($this->getAllowInherit() ? 'yes' : 'no')."\n";
  551.         $cd .= ' * Variants: '.($this->getAllowVariants() ? 'yes' : 'no')."\n";
  553.         if ($description = $this->getDescription()) {
  554.             $description = str_replace(['/**', '*/', '//'], '', $description);
  555.             $description = str_replace("\n", "\n * ", $description);
  557.             $cd .= ' * '.$description."\n";
  558.         }
  560.         $cd .= " *\n";
  561.         $cd .= " * Fields Summary:\n";
  563.         $fieldDefinitionDocBlockBuilder = \Pimcore::getContainer()->get(FieldDefinitionDocBlockBuilderInterface::class);
  564.         foreach ($this->getFieldDefinitions() as $fieldDefinition) {
  565.             $cd .= ' * ' . str_replace("\n", "\n * ", trim($fieldDefinitionDocBlockBuilder->buildFieldDefinitionDocBlock($fieldDefinition))) . "\n";
  566.         }
  568.         $cd .= ' */';
  570.         return $cd;
  571.     }
  573.     public function delete()
  574.     {
  575.         $this->dispatchEvent(new ClassDefinitionEvent($this), DataObjectClassDefinitionEvents::PRE_DELETE);
  577.         // delete all objects using this class
  578.         $list = new Listing();
  579.         $list->setCondition('o_classId = ?', $this->getId());
  580.         $list->load();
  582.         foreach ($list->getObjects() as $o) {
  583.             $o->delete();
  584.         }
  586.         $this->deletePhpClasses();
  588.         // empty object cache
  589.         try {
  590.             Cache::clearTag('class_'.$this->getId());
  591.         } catch (\Exception $e) {
  592.         }
  594.         // empty output cache
  595.         try {
  596.             Cache::clearTag('output');
  597.         } catch (\Exception $e) {
  598.         }
  600.         $customLayouts = new ClassDefinition\CustomLayout\Listing();
  601.         $id = $this->getId();
  602.         $customLayouts->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($id) {
  603.             return $layout->getClassId() === $id;
  604.         });
  605.         $customLayouts = $customLayouts->load();
  607.         foreach ($customLayouts as $customLayout) {
  608.             $customLayout->delete();
  609.         }
  611.         $brickListing = new DataObject\Objectbrick\Definition\Listing();
  612.         $brickListing = $brickListing->load();
  613.         foreach ($brickListing as $brickDefinition) {
  614.             $modified = false;
  616.             $classDefinitions = $brickDefinition->getClassDefinitions();
  617.             if (is_array($classDefinitions)) {
  618.                 foreach ($classDefinitions as $key => $classDefinition) {
  619.                     if ($classDefinition['classname'] == $this->getId()) {
  620.                         unset($classDefinitions[$key]);
  621.                         $modified = true;
  622.                     }
  623.                 }
  624.             }
  625.             if ($modified) {
  626.                 $brickDefinition->setClassDefinitions($classDefinitions);
  627.                 $brickDefinition->save();
  628.             }
  629.         }
  631.         $this->getDao()->delete();
  633.         $this->dispatchEvent(new ClassDefinitionEvent($this), DataObjectClassDefinitionEvents::POST_DELETE);
  634.     }
  636.     private function deletePhpClasses()
  637.     {
  638.         // delete the class files
  639.         @unlink($this->getPhpClassFile());
  640.         @unlink($this->getPhpListingClassFile());
  641.         @rmdir(dirname($this->getPhpListingClassFile()));
  642.         @unlink($this->getDefinitionFile());
  643.     }
  645.     /**
  646.      * @internal
  647.      *
  648.      * with PIMCORE_CLASS_DEFINITION_WRITABLE set, it globally allow/disallow creation and change in classes
  649.      * when the ENV is not set, it allows modification and creation of new in classes in /var/classes but disables modification of classes in config/pimcore/classes
  650.      * more details in 05_Deployment_Tools.md
  651.      *
  652.      * @return bool
  653.      */
  654.     public function isWritable(): bool
  655.     {
  656.         return $_SERVER['PIMCORE_CLASS_DEFINITION_WRITABLE'] ?? !str_starts_with($this->getDefinitionFile(), PIMCORE_CUSTOM_CONFIGURATION_DIRECTORY);
  657.     }
  659.     /**
  660.      * @internal
  661.      *
  662.      * @param string|null $name
  663.      *
  664.      * @return string
  665.      */
  666.     public function getDefinitionFile($name = null)
  667.     {
  668.         return $this->locateDefinitionFile($name ?? $this->getName(), 'definition_%s.php');
  669.     }
  671.     /**
  672.      * @internal
  673.      */
  674.     public function getPhpClassFile(): string
  675.     {
  676.         return $this->locateFile(ucfirst($this->getName()), 'DataObject/%s.php');
  677.     }
  679.     /**
  680.      * @internal
  681.      */
  682.     public function getPhpListingClassFile(): string
  683.     {
  684.         return $this->locateFile(ucfirst($this->getName()), 'DataObject/%s/Listing.php');
  685.     }
  687.     /**
  688.      * @return string|null
  689.      */
  690.     public function getId()
  691.     {
  692.         return $this->id;
  693.     }
  695.     /**
  696.      * @return string|null
  697.      */
  698.     public function getName()
  699.     {
  700.         return $this->name;
  701.     }
  703.     /**
  704.      * @return int|null
  705.      */
  706.     public function getCreationDate()
  707.     {
  708.         return $this->creationDate;
  709.     }
  711.     /**
  712.      * @return int|null
  713.      */
  714.     public function getModificationDate()
  715.     {
  716.         return $this->modificationDate;
  717.     }
  719.     /**
  720.      * @return int|null
  721.      */
  722.     public function getUserOwner()
  723.     {
  724.         return $this->userOwner;
  725.     }
  727.     /**
  728.      * @return int|null
  729.      */
  730.     public function getUserModification()
  731.     {
  732.         return $this->userModification;
  733.     }
  735.     /**
  736.      * @param string $id
  737.      *
  738.      * @return $this
  739.      */
  740.     public function setId($id)
  741.     {
  742.         $this->id = $id;
  744.         return $this;
  745.     }
  747.     /**
  748.      * @param string $name
  749.      *
  750.      * @return $this
  751.      */
  752.     public function setName($name)
  753.     {
  754.         $this->name = $name;
  756.         return $this;
  757.     }
  759.     /**
  760.      * @param int $creationDate
  761.      *
  762.      * @return $this
  763.      */
  764.     public function setCreationDate($creationDate)
  765.     {
  766.         $this->creationDate = (int)$creationDate;
  768.         return $this;
  769.     }
  771.     /**
  772.      * @param int $modificationDate
  773.      *
  774.      * @return $this
  775.      */
  776.     public function setModificationDate($modificationDate)
  777.     {
  778.         $this->modificationDate = (int)$modificationDate;
  780.         return $this;
  781.     }
  783.     /**
  784.      * @param int $userOwner
  785.      *
  786.      * @return $this
  787.      */
  788.     public function setUserOwner($userOwner)
  789.     {
  790.         $this->userOwner = (int)$userOwner;
  792.         return $this;
  793.     }
  795.     /**
  796.      * @param int $userModification
  797.      *
  798.      * @return $this
  799.      */
  800.     public function setUserModification($userModification)
  801.     {
  802.         $this->userModification = (int)$userModification;
  804.         return $this;
  805.     }
  807.     /**
  808.      * @param array $context
  809.      *
  810.      * @return DataObject\ClassDefinition\Data[]
  811.      */
  812.     public function getFieldDefinitions($context = [])
  813.     {
  814.         if (!\Pimcore::inAdmin() || (isset($context['suppressEnrichment']) && $context['suppressEnrichment'])) {
  815.             return $this->fieldDefinitions;
  816.         }
  818.         $enrichedFieldDefinitions = [];
  819.         foreach ($this->fieldDefinitions as $key => $fieldDefinition) {
  820.             $fieldDefinition = $this->doEnrichFieldDefinition($fieldDefinition, $context);
  821.             $enrichedFieldDefinitions[$key] = $fieldDefinition;
  822.         }
  824.         return $enrichedFieldDefinitions;
  825.     }
  827.     /**
  828.      * @internal
  829.      */
  830.     protected function doEnrichFieldDefinition($fieldDefinition, $context = [])
  831.     {
  832.         //TODO Pimcore 11: remove method_exists BC layer
  833.         if ($fieldDefinition instanceof FieldDefinitionEnrichmentInterface || method_exists($fieldDefinition, 'enrichFieldDefinition')) {
  834.             if (!$fieldDefinition instanceof FieldDefinitionEnrichmentInterface) {
  835.                 trigger_deprecation('pimcore/pimcore', '10.1',
  836.                     sprintf('Usage of method_exists is deprecated since version 10.1 and will be removed in Pimcore 11.' .
  837.                     'Implement the %s interface instead.', FieldDefinitionEnrichmentInterface::class));
  838.             }
  839.             $context['class'] = $this;
  840.             $fieldDefinition = $fieldDefinition->enrichFieldDefinition($context);
  841.         }
  843.         return $fieldDefinition;
  844.     }
  846.     /**
  847.      * @return DataObject\ClassDefinition\Layout|null
  848.      */
  849.     public function getLayoutDefinitions()
  850.     {
  851.         return $this->layoutDefinitions;
  852.     }
  854.     /**
  855.      * @param DataObject\ClassDefinition\Data[] $fieldDefinitions
  856.      *
  857.      * @return $this
  858.      */
  859.     public function setFieldDefinitions(array $fieldDefinitions)
  860.     {
  861.         $this->fieldDefinitions = $fieldDefinitions;
  863.         return $this;
  864.     }
  866.     /**
  867.      * @param string $key
  868.      * @param DataObject\ClassDefinition\Data $data
  869.      *
  870.      * @return $this
  871.      */
  872.     public function addFieldDefinition($key, $data)
  873.     {
  874.         $this->fieldDefinitions[$key] = $data;
  876.         return $this;
  877.     }
  879.     /**
  880.      * @param string $key
  881.      * @param array $context
  882.      *
  883.      * @return DataObject\ClassDefinition\Data|null
  884.      */
  885.     public function getFieldDefinition($key, $context = [])
  886.     {
  887.         if (array_key_exists($key, $this->fieldDefinitions)) {
  888.             if (!\Pimcore::inAdmin() || (isset($context['suppressEnrichment']) && $context['suppressEnrichment'])) {
  889.                 return $this->fieldDefinitions[$key];
  890.             }
  891.             $fieldDefinition = $this->doEnrichFieldDefinition($this->fieldDefinitions[$key], $context);
  893.             return $fieldDefinition;
  894.         }
  896.         return null;
  897.     }
  899.     /**
  900.      * @param DataObject\ClassDefinition\Layout|null $layoutDefinitions
  901.      *
  902.      * @return $this
  903.      */
  904.     public function setLayoutDefinitions($layoutDefinitions)
  905.     {
  906.         $oldFieldDefinitions = null;
  907.         if ($this->layoutDefinitions !== null) {
  908.             $this->setDeletedDataComponents([]);
  909.             $oldFieldDefinitions = $this->getFieldDefinitions();
  910.         }
  912.         $this->layoutDefinitions = $layoutDefinitions;
  914.         $this->fieldDefinitions = [];
  915.         $this->extractDataDefinitions($this->layoutDefinitions);
  917.         if ($oldFieldDefinitions !== null) {
  918.             $newFieldDefinitions = $this->getFieldDefinitions();
  919.             $deletedComponents = [];
  920.             foreach ($oldFieldDefinitions as $fieldDefinition) {
  921.                 if (!array_key_exists($fieldDefinition->getName(), $newFieldDefinitions)) {
  922.                     array_push($deletedComponents, $fieldDefinition);
  923.                 }
  924.             }
  925.             $this->setDeletedDataComponents($deletedComponents);
  926.         }
  928.         return $this;
  929.     }
  931.     /**
  932.      * @param DataObject\ClassDefinition\Layout|DataObject\ClassDefinition\Data $def
  933.      */
  934.     private function extractDataDefinitions($def)
  935.     {
  936.         if ($def instanceof DataObject\ClassDefinition\Layout) {
  937.             if ($def->hasChildren()) {
  938.                 foreach ($def->getChildren() as $child) {
  939.                     $this->extractDataDefinitions($child);
  940.                 }
  941.             }
  942.         }
  944.         if ($def instanceof DataObject\ClassDefinition\Data) {
  945.             $existing = $this->getFieldDefinition($def->getName());
  947.             if (!$existing && method_exists($def, 'addReferencedField') && method_exists($def, 'setReferencedFields')) {
  948.                 $def->setReferencedFields([]);
  949.             }
  951.             if ($existing && method_exists($existing, 'addReferencedField')) {
  952.                 // this is especially for localized fields which get aggregated here into one field definition
  953.                 // in the case that there are more than one localized fields in the class definition
  954.                 // see also pimcore.object.edit.addToDataFields();
  955.                 $existing->addReferencedField($def);
  956.             } else {
  957.                 $this->addFieldDefinition($def->getName(), $def);
  958.             }
  959.         }
  960.     }
  962.     /**
  963.      * @return string
  964.      */
  965.     public function getParentClass()
  966.     {
  967.         return $this->parentClass;
  968.     }
  970.     /**
  971.      * @return string
  972.      */
  973.     public function getListingParentClass()
  974.     {
  975.         return $this->listingParentClass;
  976.     }
  978.     /**
  979.      * @return string
  980.      */
  981.     public function getUseTraits()
  982.     {
  983.         return $this->useTraits;
  984.     }
  986.     /**
  987.      * @param string $useTraits
  988.      *
  989.      * @return ClassDefinition
  990.      */
  991.     public function setUseTraits($useTraits)
  992.     {
  993.         $this->useTraits = (string) $useTraits;
  995.         return $this;
  996.     }
  998.     /**
  999.      * @return string
  1000.      */
  1001.     public function getListingUseTraits()
  1002.     {
  1003.         return $this->listingUseTraits;
  1004.     }
  1006.     /**
  1007.      * @param string $listingUseTraits
  1008.      *
  1009.      * @return ClassDefinition
  1010.      */
  1011.     public function setListingUseTraits($listingUseTraits)
  1012.     {
  1013.         $this->listingUseTraits = (string) $listingUseTraits;
  1015.         return $this;
  1016.     }
  1018.     /**
  1019.      * @return bool
  1020.      */
  1021.     public function getAllowInherit()
  1022.     {
  1023.         return $this->allowInherit;
  1024.     }
  1026.     /**
  1027.      * @return bool
  1028.      */
  1029.     public function getAllowVariants()
  1030.     {
  1031.         return $this->allowVariants;
  1032.     }
  1034.     /**
  1035.      * @param string $parentClass
  1036.      *
  1037.      * @return $this
  1038.      */
  1039.     public function setParentClass($parentClass)
  1040.     {
  1041.         $this->parentClass = $parentClass;
  1043.         return $this;
  1044.     }
  1046.     /**
  1047.      * @param string $listingParentClass
  1048.      *
  1049.      * @return $this
  1050.      */
  1051.     public function setListingParentClass($listingParentClass)
  1052.     {
  1053.         $this->listingParentClass = (string) $listingParentClass;
  1055.         return $this;
  1056.     }
  1058.     /**
  1059.      * @return bool
  1060.      */
  1061.     public function getEncryption(): bool
  1062.     {
  1063.         return $this->encryption;
  1064.     }
  1066.     /**
  1067.      * @param bool $encryption
  1068.      *
  1069.      * @return $this
  1070.      */
  1071.     public function setEncryption(bool $encryption)
  1072.     {
  1073.         $this->encryption = $encryption;
  1075.         return $this;
  1076.     }
  1078.     /**
  1079.      * @internal
  1080.      *
  1081.      * @param array $tables
  1082.      */
  1083.     public function addEncryptedTables(array $tables)
  1084.     {
  1085.         $this->encryptedTables = array_unique(array_merge($this->encryptedTables, $tables));
  1086.     }
  1088.     /**
  1089.      * @internal
  1090.      *
  1091.      * @param array $tables
  1092.      */
  1093.     public function removeEncryptedTables(array $tables)
  1094.     {
  1095.         foreach ($tables as $table) {
  1096.             if (($key = array_search($table, $this->encryptedTables)) !== false) {
  1097.                 unset($this->encryptedTables[$key]);
  1098.             }
  1099.         }
  1100.     }
  1102.     /**
  1103.      * @internal
  1104.      *
  1105.      * @param string $table
  1106.      *
  1107.      * @return bool
  1108.      */
  1109.     public function isEncryptedTable(string $table): bool
  1110.     {
  1111.         return (array_search($table, $this->encryptedTables) === false) ? false : true;
  1112.     }
  1114.     /**
  1115.      * @return bool
  1116.      */
  1117.     public function hasEncryptedTables(): bool
  1118.     {
  1119.         return (bool) count($this->encryptedTables);
  1120.     }
  1122.     /**
  1123.      * @internal
  1124.      *
  1125.      * @param array $encryptedTables
  1126.      *
  1127.      * @return $this
  1128.      */
  1129.     public function setEncryptedTables(array $encryptedTables)
  1130.     {
  1131.         $this->encryptedTables = $encryptedTables;
  1133.         return $this;
  1134.     }
  1136.     /**
  1137.      * @param bool $allowInherit
  1138.      *
  1139.      * @return $this
  1140.      */
  1141.     public function setAllowInherit($allowInherit)
  1142.     {
  1143.         $this->allowInherit = (bool)$allowInherit;
  1145.         return $this;
  1146.     }
  1148.     /**
  1149.      * @param bool $allowVariants
  1150.      *
  1151.      * @return $this
  1152.      */
  1153.     public function setAllowVariants($allowVariants)
  1154.     {
  1155.         $this->allowVariants = (bool)$allowVariants;
  1157.         return $this;
  1158.     }
  1160.     /**
  1161.      * @return string|null
  1162.      */
  1163.     public function getIcon()
  1164.     {
  1165.         return $this->icon;
  1166.     }
  1168.     /**
  1169.      * @param string|null $icon
  1170.      *
  1171.      * @return $this
  1172.      */
  1173.     public function setIcon($icon)
  1174.     {
  1175.         $this->icon = $icon;
  1177.         return $this;
  1178.     }
  1180.     /**
  1181.      * @return array
  1182.      */
  1183.     public function getPropertyVisibility()
  1184.     {
  1185.         return $this->propertyVisibility;
  1186.     }
  1188.     /**
  1189.      * @param array $propertyVisibility
  1190.      *
  1191.      * @return $this
  1192.      */
  1193.     public function setPropertyVisibility($propertyVisibility)
  1194.     {
  1195.         if (is_array($propertyVisibility)) {
  1196.             $this->propertyVisibility = $propertyVisibility;
  1197.         }
  1199.         return $this;
  1200.     }
  1202.     /**
  1203.      * @param string|null $previewUrl
  1204.      *
  1205.      * @return $this
  1206.      */
  1207.     public function setPreviewUrl($previewUrl)
  1208.     {
  1209.         $this->previewUrl = $previewUrl;
  1211.         return $this;
  1212.     }
  1214.     /**
  1215.      * @return string|null
  1216.      */
  1217.     public function getPreviewUrl()
  1218.     {
  1219.         return $this->previewUrl;
  1220.     }
  1222.     /**
  1223.      * @return string|null
  1224.      */
  1225.     public function getGroup()
  1226.     {
  1227.         return $this->group;
  1228.     }
  1230.     /**
  1231.      * @param string|null $group
  1232.      *
  1233.      * @return $this
  1234.      */
  1235.     public function setGroup($group)
  1236.     {
  1237.         $this->group = $group;
  1239.         return $this;
  1240.     }
  1242.     /**
  1243.      * @param string $description
  1244.      *
  1245.      * @return $this
  1246.      */
  1247.     public function setDescription($description)
  1248.     {
  1249.         $this->description = $description;
  1251.         return $this;
  1252.     }
  1254.     /**
  1255.      * @return string
  1256.      */
  1257.     public function getDescription()
  1258.     {
  1259.         return $this->description;
  1260.     }
  1262.     /**
  1263.      * @param bool $showVariants
  1264.      *
  1265.      * @return $this
  1266.      */
  1267.     public function setShowVariants($showVariants)
  1268.     {
  1269.         $this->showVariants = (bool)$showVariants;
  1271.         return $this;
  1272.     }
  1274.     /**
  1275.      * @return bool
  1276.      */
  1277.     public function getShowVariants()
  1278.     {
  1279.         return $this->showVariants;
  1280.     }
  1282.     /**
  1283.      * @return bool
  1284.      */
  1285.     public function getShowAppLoggerTab()
  1286.     {
  1287.         return $this->showAppLoggerTab;
  1288.     }
  1290.     /**
  1291.      * @param bool $showAppLoggerTab
  1292.      *
  1293.      * @return $this
  1294.      */
  1295.     public function setShowAppLoggerTab($showAppLoggerTab)
  1296.     {
  1297.         $this->showAppLoggerTab = (bool) $showAppLoggerTab;
  1299.         return $this;
  1300.     }
  1302.     /**
  1303.      * @return bool
  1304.      */
  1305.     public function getShowFieldLookup()
  1306.     {
  1307.         return $this->showFieldLookup;
  1308.     }
  1310.     /**
  1311.      * @param bool $showFieldLookup
  1312.      *
  1313.      * @return $this
  1314.      */
  1315.     public function setShowFieldLookup($showFieldLookup)
  1316.     {
  1317.         $this->showFieldLookup = (bool) $showFieldLookup;
  1319.         return $this;
  1320.     }
  1322.     /**
  1323.      * @return string
  1324.      */
  1325.     public function getLinkGeneratorReference()
  1326.     {
  1327.         return $this->linkGeneratorReference;
  1328.     }
  1330.     /**
  1331.      * @param string $linkGeneratorReference
  1332.      *
  1333.      * @return $this
  1334.      */
  1335.     public function setLinkGeneratorReference($linkGeneratorReference)
  1336.     {
  1337.         $this->linkGeneratorReference = $linkGeneratorReference;
  1339.         return $this;
  1340.     }
  1342.     /**
  1343.      * @return DataObject\ClassDefinition\LinkGeneratorInterface|null
  1344.      */
  1345.     public function getLinkGenerator()
  1346.     {
  1347.         return DataObject\ClassDefinition\Helper\LinkGeneratorResolver::resolveGenerator($this->getLinkGeneratorReference());
  1348.     }
  1350.     /**
  1351.      * @return string|null
  1352.      */
  1353.     public function getPreviewGeneratorReference(): ?string
  1354.     {
  1355.         return $this->previewGeneratorReference;
  1356.     }
  1358.     /**
  1359.      * @param string|null $previewGeneratorReference
  1360.      */
  1361.     public function setPreviewGeneratorReference(?string $previewGeneratorReference): void
  1362.     {
  1363.         $this->previewGeneratorReference = $previewGeneratorReference;
  1364.     }
  1366.     /**
  1367.      * @return DataObject\ClassDefinition\PreviewGeneratorInterface|null
  1368.      */
  1369.     public function getPreviewGenerator()
  1370.     {
  1371.         return DataObject\ClassDefinition\Helper\PreviewGeneratorResolver::resolveGenerator($this->getPreviewGeneratorReference());
  1372.     }
  1374.     /**
  1375.      * @return bool
  1376.      */
  1377.     public function isEnableGridLocking(): bool
  1378.     {
  1379.         return $this->enableGridLocking;
  1380.     }
  1382.     /**
  1383.      * @param bool $enableGridLocking
  1384.      */
  1385.     public function setEnableGridLocking(bool $enableGridLocking): void
  1386.     {
  1387.         $this->enableGridLocking = $enableGridLocking;
  1388.     }
  1390.     /**
  1391.      * @return string|null
  1392.      */
  1393.     public function getImplementsInterfaces(): ?string
  1394.     {
  1395.         return $this->implementsInterfaces;
  1396.     }
  1398.     /**
  1399.      * @param string|null $implementsInterfaces
  1400.      *
  1401.      * @return $this
  1402.      */
  1403.     public function setImplementsInterfaces(?string $implementsInterfaces)
  1404.     {
  1405.         $this->implementsInterfaces = $implementsInterfaces;
  1407.         return $this;
  1408.     }
  1410.     /**
  1411.      * @return array
  1412.      */
  1413.     public function getCompositeIndices(): array
  1414.     {
  1415.         return $this->compositeIndices;
  1416.     }
  1418.     /**
  1419.      * @param array|null $compositeIndices
  1420.      *
  1421.      * @return $this
  1422.      */
  1423.     public function setCompositeIndices($compositeIndices)
  1424.     {
  1425.         $this->compositeIndices = $compositeIndices ?? [];
  1427.         return $this;
  1428.     }
  1430.     /**
  1431.      * @return bool
  1432.      */
  1433.     public function getGenerateTypeDeclarations()
  1434.     {
  1435.         return (bool) $this->generateTypeDeclarations;
  1436.     }
  1438.     /**
  1439.      * @param bool $generateTypeDeclarations
  1440.      *
  1441.      * @return $this
  1442.      */
  1443.     public function setGenerateTypeDeclarations($generateTypeDeclarations)
  1444.     {
  1445.         $this->generateTypeDeclarations = (bool) $generateTypeDeclarations;
  1447.         return $this;
  1448.     }
  1450.     /**
  1451.      * @return ClassDefinition\Data[]
  1452.      */
  1453.     public function getDeletedDataComponents()
  1454.     {
  1455.         return $this->deletedDataComponents;
  1456.     }
  1458.     /**
  1459.      * @param ClassDefinition\Data[] $deletedDataComponents
  1460.      *
  1461.      * @return $this
  1462.      */
  1463.     public function setDeletedDataComponents(array $deletedDataComponents): ClassDefinition
  1464.     {
  1465.         $this->deletedDataComponents = $deletedDataComponents;
  1467.         return $this;
  1468.     }
  1470.     private function deleteDeletedDataComponentsInCustomLayout(): void
  1471.     {
  1472.         if (empty($this->getDeletedDataComponents())) {
  1473.             return;
  1474.         }
  1475.         $customLayouts = new ClassDefinition\CustomLayout\Listing();
  1476.         $id = $this->getId();
  1477.         $customLayouts->setFilter(function (DataObject\ClassDefinition\CustomLayout $layout) use ($id) {
  1478.             return $layout->getClassId() === $id;
  1479.         });
  1480.         $customLayouts = $customLayouts->load();
  1482.         foreach ($customLayouts as $customLayout) {
  1483.             $layoutDefinition = $customLayout->getLayoutDefinitions();
  1484.             $this->deleteDeletedDataComponentsInLayoutDefinition($layoutDefinition);
  1485.             $customLayout->setLayoutDefinitions($layoutDefinition);
  1486.             $customLayout->save();
  1487.         }
  1488.     }
  1490.     private function deleteDeletedDataComponentsInLayoutDefinition(ClassDefinition\Layout $layoutDefinition): void
  1491.     {
  1492.         $componentsToDelete = $this->getDeletedDataComponents();
  1493.         $componentDeleted = false;
  1495.         $children = &$layoutDefinition->getChildrenByRef();
  1496.         $count = count($children);
  1497.         for ($i = 0; $i < $count; $i++) {
  1498.             $component = $children[$i];
  1499.             if (in_array($component, $componentsToDelete)) {
  1500.                 unset($children[$i]);
  1501.                 $componentDeleted = true;
  1502.             }
  1503.             if ($component instanceof ClassDefinition\Layout) {
  1504.                 $this->deleteDeletedDataComponentsInLayoutDefinition($component);
  1505.             }
  1506.         }
  1507.         if ($componentDeleted) {
  1508.             $children = array_values($children);
  1509.         }
  1510.     }
  1512.     public static function getByIdIgnoreCase(string $id): ClassDefinition|null
  1513.     {
  1514.         try {
  1515.             $class = new self();
  1516.             $name = $class->getDao()->getNameByIdIgnoreCase($id);
  1517.             $definitionFile = $class->getDefinitionFile($name);
  1518.             $class = @include $definitionFile;
  1520.             if (!$class instanceof self) {
  1521.                 throw new \Exception('Class definition with name ' . $name . ' or ID ' . $id . ' does not exist');
  1522.             }
  1524.             $class->setId($id);
  1525.         } catch (\Exception $e) {
  1526.             Logger::info($e->getMessage());
  1528.             return null;
  1529.         }
  1531.         return $class;
  1532.     }
  1533. }