vendor/pimcore/pimcore/models/DataObject/Localizedfield.php line 257

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\Localization\LocaleServiceInterface;
  19. use Pimcore\Model;
  20. use Pimcore\Model\DataObject;
  21. use Pimcore\Model\DataObject\ClassDefinition\Data\LazyLoadingSupportInterface;
  22. use Pimcore\Model\DataObject\ClassDefinition\Data\PreGetDataInterface;
  23. use Pimcore\Model\DataObject\ClassDefinition\Data\PreSetDataInterface;
  24. use Pimcore\Model\Element\DirtyIndicatorInterface;
  25. use Pimcore\Tool;
  27. /**
  28.  * @method Localizedfield\Dao getDao()*
  29.  * @method void delete($deleteQuery = true, $isUpdate = true)
  30.  * @method void load($object, $params = [])
  31.  * @method void save($params = [])
  32.  * @method void createUpdateTable($params = [])
  33.  */
  34. final class Localizedfield extends Model\AbstractModel implements
  35.     DirtyIndicatorInterface,
  36.     LazyLoadedFieldsInterface,
  37.     Model\Element\ElementDumpStateInterface,
  38.     OwnerAwareFieldInterface
  39. {
  40.     use Model\DataObject\Traits\OwnerAwareFieldTrait;
  41.     use Model\DataObject\Traits\LazyLoadedRelationTrait;
  42.     use Model\Element\Traits\DirtyIndicatorTrait;
  43.     use Model\Element\ElementDumpStateTrait;
  45.     /**
  46.      * @internal
  47.      */
  48.     const STRICT_DISABLED = 0;
  50.     /**
  51.      * @internal
  52.      */
  53.     const STRICT_ENABLED = 1;
  55.     /**
  56.      * @var bool
  57.      */
  58.     private static bool $getFallbackValues = false;
  60.     /**
  61.      * @internal
  62.      *
  63.      * @var array
  64.      */
  65.     protected array $items = [];
  67.     /**
  68.      * @internal
  69.      *
  70.      * @var Concrete|null
  71.      */
  72.     protected $object = null;
  74.     /**
  75.      * @internal
  76.      *
  77.      * @var ClassDefinition|null
  78.      */
  79.     protected ?ClassDefinition $class = null;
  81.     /**
  82.      * @internal
  83.      *
  84.      * @var array
  85.      */
  86.     protected array $context = [];
  88.     /**
  89.      * @internal
  90.      *
  91.      * @var int|null
  92.      */
  93.     protected ?int $objectId = null;
  95.     /**
  96.      * @var bool
  97.      */
  98.     private static bool $strictMode = false;
  100.     /**
  101.      * list of dirty languages. if null then no language is dirty. if empty array then all languages are dirty
  102.      *
  103.      * @internal
  104.      *
  105.      * @var array|null
  106.      */
  107.     protected ?array $o_dirtyLanguages = null;
  109.     /**
  110.      * @internal
  111.      *
  112.      * @var bool
  113.      */
  114.     protected bool $_loadedAllLazyData = false;
  116.     /**
  117.      * @param bool $getFallbackValues
  118.      */
  119.     public static function setGetFallbackValues(bool $getFallbackValues): void
  120.     {
  121.         self::$getFallbackValues = $getFallbackValues;
  122.     }
  124.     /**
  125.      * @return bool
  126.      */
  127.     public static function getGetFallbackValues(): bool
  128.     {
  129.         return self::$getFallbackValues;
  130.     }
  132.     /**
  133.      * @return bool
  134.      */
  135.     public static function isStrictMode(): bool
  136.     {
  137.         return self::$strictMode;
  138.     }
  140.     /**
  141.      * @param bool $strictMode
  142.      */
  143.     public static function setStrictMode(bool $strictMode): void
  144.     {
  145.         self::$strictMode = $strictMode;
  146.     }
  148.     /**
  149.      * @return bool
  150.      */
  151.     public static function doGetFallbackValues(): bool
  152.     {
  153.         return self::$getFallbackValues;
  154.     }
  156.     /**
  157.      * @param array|null $items
  158.      */
  159.     public function __construct(array $items = null)
  160.     {
  161.         if ($items) {
  162.             $this->setItems($items);
  163.         }
  164.         $this->markFieldDirty('_self');
  165.         $this->markAllLanguagesAsDirty();
  166.     }
  168.     /**
  169.      * @param mixed $item
  170.      */
  171.     public function addItem($item)
  172.     {
  173.         $this->items[] = $item;
  174.         $this->markFieldDirty('_self');
  175.         $this->markAllLanguagesAsDirty();
  176.     }
  178.     /**
  179.      * @param array $items
  180.      *
  181.      * @return $this
  182.      */
  183.     public function setItems(array $items)
  184.     {
  185.         $this->items = $items;
  186.         $this->markFieldDirty('_self');
  187.         $this->markAllLanguagesAsDirty();
  189.         return $this;
  190.     }
  192.     /**
  193.      * @internal
  194.      */
  195.     public function loadLazyData(): void
  196.     {
  197.         $this->getInternalData(true);
  198.     }
  200.     /**
  201.      * @internal
  202.      *
  203.      * @param bool $mark
  204.      */
  205.     public function setLoadedAllLazyData($mark = true)
  206.     {
  207.         $this->_loadedAllLazyData = $mark;
  208.     }
  210.     /**
  211.      * Note: this is for pimcore/pimcore use only.
  212.      *
  213.      * @internal
  214.      *
  215.      * @param bool $loadLazyFields
  216.      *
  217.      * @return array
  218.      */
  219.     public function getInternalData(bool $loadLazyFields = false): array
  220.     {
  221.         $loadLazyFieldNames = $this->getLazyLoadedFieldNames();
  223.         if ($loadLazyFields && !empty($loadLazyFieldNames) && !$this->_loadedAllLazyData) {
  224.             $isDirtyDetectionDisabled = DataObject::isDirtyDetectionDisabled();
  225.             DataObject::disableDirtyDetection();
  227.             foreach ($loadLazyFieldNames as $name) {
  228.                 foreach (Tool::getValidLanguages() as $language) {
  229.                     $fieldDefinition = $this->getFieldDefinition($name, $this->getContext());
  230.                     $this->loadLazyField($fieldDefinition, $name, $language);
  231.                 }
  232.             }
  234.             DataObject::setDisableDirtyDetection($isDirtyDetectionDisabled);
  235.             $this->setLoadedAllLazyData();
  236.         }
  238.         foreach ($this->getFieldDefinitions($this->getContext(), ['suppressEnrichment' => true]) as $fieldDefinition) {
  239.             if ($fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\CalculatedValue) {
  240.                 foreach (Tool::getValidLanguages() as $language) {
  241.                     $this->setLocalizedValue($fieldDefinition->getName(), null, $language, false);
  242.                 }
  243.             }
  244.         }
  246.         return $this->items;
  247.     }
  249.     /**
  250.      * @param Concrete|Model\Element\ElementDescriptor|null $object
  251.      * @param bool $markAsDirty
  252.      *
  253.      * @return $this
  254.      *
  255.      * @throws \Exception
  256.      */
  257.     public function setObject($object, bool $markAsDirty = true)
  258.     {
  259.         if ($object instanceof Model\Element\ElementDescriptor) {
  260.             $object = Service::getElementById($object->getType(), $object->getId());
  261.         }
  263.         if (!is_null($object) && !$object instanceof Concrete) {
  264.             throw new \Exception('must be instance of object concrete');
  265.         }
  267.         if ($markAsDirty) {
  268.             $this->markAllLanguagesAsDirty();
  269.         }
  270.         $this->object = $object;
  271.         $this->objectId = $object ? $object->getId() : null;
  272.         $this->setClass($object ? $object->getClass() : null);
  274.         return $this;
  275.     }
  277.     /**
  278.      * @return Concrete|null
  279.      */
  280.     public function getObject(): ?Concrete
  281.     {
  282.         if ($this->objectId && !$this->object) {
  283.             $this->setObject(Concrete::getById($this->objectId));
  284.         }
  286.         return $this->object;
  287.     }
  289.     /**
  290.      * @param ClassDefinition|null $class
  291.      *
  292.      * @return $this
  293.      */
  294.     public function setClass(?ClassDefinition $class)
  295.     {
  296.         $this->class = $class;
  298.         return $this;
  299.     }
  301.     /**
  302.      * @return ClassDefinition|null
  303.      */
  304.     public function getClass(): ?ClassDefinition
  305.     {
  306.         if (!$this->class && $this->getObject()) {
  307.             $this->class = $this->getObject()->getClass();
  308.         }
  310.         return $this->class;
  311.     }
  313.     /**
  314.      * @throws \Exception
  315.      *
  316.      * @param string|null $language
  317.      *
  318.      * @return string
  319.      */
  320.     public function getLanguage(string $language = null): string
  321.     {
  322.         if ($language) {
  323.             return $language;
  324.         }
  326.         // try to get the language from the service container
  327.         try {
  328.             $locale = \Pimcore::getContainer()->get(LocaleServiceInterface::class)->getLocale();
  330.             if (Tool::isValidLanguage($locale)) {
  331.                 return $locale;
  332.             }
  334.             if (\Pimcore::inAdmin()) {
  335.                 foreach (Tool::getValidLanguages() as $validLocale) {
  336.                     if (str_starts_with($validLocale, $locale.'_')) {
  337.                         return $validLocale;
  338.                     }
  339.                 }
  340.             }
  342.             throw new \Exception('Not supported language');
  343.         } catch (\Exception $e) {
  344.             return Tool::getDefaultLanguage();
  345.         }
  346.     }
  348.     /**
  349.      * @param string $language
  350.      *
  351.      * @return bool
  352.      */
  353.     public function languageExists(string $language): bool
  354.     {
  355.         return array_key_exists($language, $this->items);
  356.     }
  358.     /**
  359.      * @param string $name
  360.      * @param array $context
  361.      *
  362.      * @return ClassDefinition\Data|null
  363.      */
  364.     public function getFieldDefinition(string $name, $context = [])
  365.     {
  366.         if (isset($context['containerType']) && $context['containerType'] === 'fieldcollection') {
  367.             $containerKey = $context['containerKey'];
  368.             $container = Model\DataObject\Fieldcollection\Definition::getByKey($containerKey);
  369.         } elseif (isset($context['containerType']) && $context['containerType'] === 'objectbrick') {
  370.             $containerKey = $context['containerKey'];
  371.             $container = Model\DataObject\Objectbrick\Definition::getByKey($containerKey);
  372.         } elseif (isset($context['containerType']) && $context['containerType'] === 'block') {
  373.             $containerKey = $context['containerKey'];
  374.             $object = $this->getObject();
  375.             $blockDefinition = $object->getClass()->getFieldDefinition($containerKey);
  376.             $container = $blockDefinition;
  377.         } else {
  378.             $object = $this->getObject();
  379.             $container = $object->getClass();
  380.         }
  382.         /** @var Model\DataObject\ClassDefinition\Data\Localizedfields|null $localizedFields */
  383.         $localizedFields = $container->getFieldDefinition('localizedfields');
  385.         if ($localizedFields) {
  386.             return $localizedFields->getFieldDefinition($name);
  387.         }
  389.         return null;
  390.     }
  392.     /**
  393.      * @param array $context
  394.      * @param array $params
  395.      *
  396.      * @return ClassDefinition\Data[]
  397.      *
  398.      * @throws \Exception
  399.      */
  400.     protected function getFieldDefinitions($context = [], $params = []): array
  401.     {
  402.         if (isset($context['containerType']) && $context['containerType'] === 'fieldcollection') {
  403.             $containerKey = $context['containerKey'];
  404.             $fcDef = Model\DataObject\Fieldcollection\Definition::getByKey($containerKey);
  405.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $container */
  406.             $container = $fcDef->getFieldDefinition('localizedfields');
  407.         } elseif (isset($context['containerType']) && $context['containerType'] === 'objectbrick') {
  408.             $containerKey = $context['containerKey'];
  409.             $brickDef = Model\DataObject\Objectbrick\Definition::getByKey($containerKey);
  410.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $container */
  411.             $container = $brickDef->getFieldDefinition('localizedfields');
  412.         } elseif (isset($context['containerType']) && $context['containerType'] === 'block') {
  413.             $containerKey = $context['containerKey'];
  414.             $object = $this->getObject();
  415.             /** @var Model\DataObject\ClassDefinition\Data\Block $block */
  416.             $block = $object->getClass()->getFieldDefinition($containerKey);
  417.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $container */
  418.             $container = $block->getFieldDefinition('localizedfields');
  419.         } else {
  420.             $class = $this->getClass();
  421.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $container */
  422.             $container = $class->getFieldDefinition('localizedfields');
  423.         }
  425.         return $container->getFieldDefinitions($params);
  426.     }
  428.     /**
  429.      * @param ClassDefinition\Data $fieldDefinition
  430.      * @param string $name
  431.      * @param string $language
  432.      *
  433.      * @internal
  434.      */
  435.     private function loadLazyField(Model\DataObject\ClassDefinition\Data $fieldDefinition, string $name, string $language): void
  436.     {
  437.         $lazyKey = $this->buildLazyKey($name, $language);
  438.         if (!$this->isLazyKeyLoaded($lazyKey) && $fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\CustomResourcePersistingInterface) {
  439.             $params['language'] = $language;
  440.             $params['object'] = $this->getObject();
  441.             $params['context'] = $this->getContext();
  442.             $params['owner'] = $this;
  443.             $params['fieldname'] = $name;
  445.             $isDirtyDetectionDisabled = DataObject::isDirtyDetectionDisabled();
  446.             DataObject::disableDirtyDetection();
  448.             $data = $fieldDefinition->load($this, $params);
  450.             if ($data === 0 || !empty($data)) {
  451.                 $this->setLocalizedValue($name, $data, $language, false);
  452.             }
  454.             DataObject::setDisableDirtyDetection($isDirtyDetectionDisabled);
  456.             $this->markLazyKeyAsLoaded($lazyKey);
  457.         }
  458.     }
  460.     /**
  461.      * @param string $name
  462.      * @param string|null $language
  463.      * @param bool $ignoreFallbackLanguage
  464.      *
  465.      * @return mixed
  466.      */
  467.     public function getLocalizedValue(string $name, string $language = null, bool $ignoreFallbackLanguage = false)
  468.     {
  469.         $data = null;
  470.         $language = $this->getLanguage($language);
  472.         $context = $this->getContext();
  473.         $fieldDefinition = $this->getFieldDefinition($name, $context);
  475.         if ($fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\CalculatedValue) {
  476.             $valueData = new Model\DataObject\Data\CalculatedValue($fieldDefinition->getName());
  477.             $valueData->setContextualData('localizedfield', 'localizedfields', null, $language, null, null, $fieldDefinition);
  478.             $data = Service::getCalculatedFieldValue($this->getObject(), $valueData);
  480.             return $data;
  481.         }
  483.         if ($fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading() && !$this->_loadedAllLazyData) {
  484.             $this->loadLazyField($fieldDefinition, $name, $language);
  485.         }
  487.         if ($this->languageExists($language)) {
  488.             if (array_key_exists($name, $this->items[$language])) {
  489.                 $data = $this->items[$language][$name];
  490.             }
  491.         }
  493.         // check for inherited value
  494.         $doGetInheritedValues = DataObject::doGetInheritedValues();
  496.         $allowInheritance = $fieldDefinition->supportsInheritance();
  497.         if (isset($context['containerType']) && ($context['containerType'] === 'block' || $context['containerType'] === 'fieldcollection')) {
  498.             $allowInheritance = false;
  499.         }
  501.         if ($fieldDefinition->isEmpty($data) && $doGetInheritedValues && $allowInheritance && $this->getObject() instanceof Concrete) {
  502.             $object = $this->getObject();
  503.             $class = $object->getClass();
  504.             $allowInherit = $class->getAllowInherit();
  506.             if ($allowInherit) {
  507.                 if ($object->getParent() instanceof AbstractObject) {
  508.                     $parent = $object->getParent();
  509.                     while ($parent && $parent->getType() == AbstractObject::OBJECT_TYPE_FOLDER) {
  510.                         $parent = $parent->getParent();
  511.                     }
  513.                     if ($parent && ($parent->getType() == AbstractObject::OBJECT_TYPE_OBJECT || $parent->getType() == AbstractObject::OBJECT_TYPE_VARIANT)) {
  514.                         /** @var Concrete $parent */
  515.                         if ($parent->getClassId() == $object->getClassId()) {
  516.                             $method = 'getLocalizedfields';
  518.                             $parentContainer = $parent;
  520.                             if (isset($context['containerType']) && $context['containerType'] === 'objectbrick') {
  521.                                 if (!empty($context['fieldname'])) {
  522.                                     $brickContainerGetter = 'get' . ucfirst($context['fieldname']);
  523.                                     $brickContainer = $parent->$brickContainerGetter();
  524.                                     $brickGetter = 'get' . $context['containerKey'];
  525.                                     $brickData = $brickContainer->$brickGetter();
  526.                                     $parentContainer = $brickData;
  527.                                 }
  528.                             }
  530.                             if (method_exists($parentContainer, $method)) {
  531.                                 $localizedFields = $parentContainer->getLocalizedFields();
  532.                                 if ($localizedFields instanceof Localizedfield) {
  533.                                     if ($localizedFields->getObject()->getId() != $this->getObject()->getId()) {
  534.                                         $localizedFields->setContext($this->getContext());
  535.                                         $data = $localizedFields->getLocalizedValue($name, $language, true);
  536.                                     }
  537.                                 }
  538.                             }
  539.                         }
  540.                     }
  541.                 }
  542.             }
  543.         }
  545.         // check for fallback value
  546.         if ($fieldDefinition->isEmpty($data) && !$ignoreFallbackLanguage && self::doGetFallbackValues()) {
  547.             foreach (Tool::getFallbackLanguagesFor($language) as $l) {
  548.                 // fallback-language may not exist yet for lazy-loaded field (relation)
  549.                 if ($this->languageExists($l) || ($fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading())) {
  550.                     if ($data = $this->getLocalizedValue($name, $l)) {
  551.                         break;
  552.                     }
  553.                 }
  554.             }
  555.         }
  557.         //TODO Pimcore 11: remove method_exists BC layer
  558.         if ($fieldDefinition instanceof PreGetDataInterface || ($fieldDefinition && method_exists($fieldDefinition, 'preGetData'))) {
  559.             if (!$fieldDefinition instanceof PreGetDataInterface) {
  560.                 trigger_deprecation('pimcore/pimcore', '10.1', sprintf('Usage of method_exists is deprecated since version 10.1 and will be removed in Pimcore 11.' .
  561.                     'Implement the %s interface instead.', PreGetDataInterface::class));
  562.             }
  564.             $data = $fieldDefinition->preGetData(
  565.                 $this,
  566.                 [
  567.                     'data' => $data,
  568.                     'language' => $language,
  569.                     'name' => $name,
  570.                 ]
  571.             );
  572.         }
  574.         return $data;
  575.     }
  577.     /**
  578.      * @param string $name
  579.      * @param mixed $value
  580.      * @param string|null $language
  581.      * @param bool $markFieldAsDirty
  582.      *
  583.      * @return $this
  584.      *
  585.      * @throws \Exception
  586.      */
  587.     public function setLocalizedValue(string $name, $value, string $language = null, bool $markFieldAsDirty = true)
  588.     {
  589.         if ($markFieldAsDirty) {
  590.             $this->markFieldDirty('_self');
  591.         }
  593.         if (self::$strictMode) {
  594.             if (!$language || !in_array($language, Tool::getValidLanguages())) {
  595.                 throw new \Exception('Language '.$language.' not accepted in strict mode');
  596.             }
  597.         }
  599.         $language = $this->getLanguage($language);
  600.         if (!$this->languageExists($language)) {
  601.             $this->items[$language] = [];
  602.             $this->markLanguageAsDirty($language);
  603.         }
  605.         $contextInfo = $this->getContext();
  606.         if (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'block') {
  607.             $classId = $contextInfo['classId'];
  608.             $containerDefinition = ClassDefinition::getById($classId);
  609.             /** @var Model\DataObject\ClassDefinition\Data\Block $blockDefinition */
  610.             $blockDefinition = $containerDefinition->getFieldDefinition($contextInfo['fieldname']);
  612.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $fieldDefinition */
  613.             $fieldDefinition = $blockDefinition->getFieldDefinition('localizedfields');
  614.         } else {
  615.             if (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'fieldcollection') {
  616.                 $containerKey = $contextInfo['containerKey'];
  617.                 $containerDefinition = Fieldcollection\Definition::getByKey($containerKey);
  618.             } elseif (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'objectbrick') {
  619.                 $containerKey = $contextInfo['containerKey'];
  620.                 $containerDefinition = Model\DataObject\Objectbrick\Definition::getByKey($containerKey);
  621.             } else {
  622.                 $containerDefinition = $this->getObject()->getClass();
  623.             }
  625.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $localizedFieldDefinition */
  626.             $localizedFieldDefinition = $containerDefinition->getFieldDefinition('localizedfields');
  627.             $fieldDefinition = $localizedFieldDefinition->getFieldDefinition($name, ['object' => $this->getObject()]);
  628.         }
  630.         // if a lazy loaded field hasn't been loaded we cannot rely on the dirty check
  631.         // note that preSetData will just overwrite it with the new data and mark it as loaded
  632.         $forceLanguageDirty = false;
  633.         $isLazyLoadedField = $fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading();
  634.         $lazyKey = $this->buildLazyKey($name, $language);
  636.         if ($isLazyLoadedField) {
  637.             if (!$this->isLazyKeyLoaded($lazyKey)) {
  638.                 $forceLanguageDirty = true;
  639.             }
  640.         }
  642.         //TODO Pimcore 11: remove method_exists BC layer
  643.         if ($fieldDefinition instanceof PreSetDataInterface || method_exists($fieldDefinition, 'preSetData')) {
  644.             if (!$fieldDefinition instanceof PreSetDataInterface) {
  645.                 trigger_deprecation('pimcore/pimcore', '10.1',
  646.                     sprintf('Usage of method_exists is deprecated since version 10.1 and will be removed in Pimcore 11.' .
  647.                     'Implement the %s interface instead.', PreSetDataInterface::class));
  648.             }
  650.             $value = $fieldDefinition->preSetData(
  651.                 $this,
  652.                 $value,
  653.                 [
  654.                     'language' => $language,
  655.                     'name' => $name,
  656.                 ]
  657.             );
  658.         }
  660.         $isEqual = false;
  662.         if ($fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\EqualComparisonInterface) {
  663.             $isEqual = $fieldDefinition->isEqual($this->items[$language][$name] ?? null, $value);
  664.         }
  666.         if ($markFieldAsDirty && ($forceLanguageDirty || !$isEqual)) {
  667.             $this->markLanguageAsDirty($language);
  668.         }
  669.         $this->items[$language][$name] = $value;
  671.         if ($isLazyLoadedField) {
  672.             $this->markLazyKeyAsLoaded($lazyKey);
  673.         }
  675.         return $this;
  676.     }
  678.     /**
  679.      * {@inheritdoc}
  680.      */
  681.     public function isAllLazyKeysMarkedAsLoaded(): bool
  682.     {
  683.         $object = $this->getObject();
  684.         if ($object instanceof Concrete) {
  685.             return $this->getObject()->isAllLazyKeysMarkedAsLoaded();
  686.         }
  688.         return true;
  689.     }
  691.     /**
  692.      * @return array
  693.      */
  694.     public function __sleep(): array
  695.     {
  696.         if (!$this->isInDumpState()) {
  697.             /**
  698.              * Remove all lazy loaded fields if item gets serialized for the cache (not for versions)
  699.              * This is actually not perfect, but currently we don't have an alternative
  700.              */
  701.             $lazyLoadedFields = $this->getLazyLoadedFieldNames();
  702.             foreach ($lazyLoadedFields as $fieldName) {
  703.                 foreach (Tool::getValidLanguages() as $language) {
  704.                     unset($this->items[$language][$fieldName]);
  706.                     $lazyKey = $this->buildLazyKey($fieldName, $language);
  707.                     $this->unmarkLazyKeyAsLoaded($lazyKey);
  708.                 }
  709.             }
  710.         }
  712.         return ['items', 'context', 'objectId'];
  713.     }
  715.     /**
  716.      * @return array
  717.      */
  718.     public function getContext(): array
  719.     {
  720.         return $this->context;
  721.     }
  723.     /**
  724.      * @param array $context
  725.      */
  726.     public function setContext(array $context): void
  727.     {
  728.         $this->context = $context;
  729.     }
  731.     /**
  732.      * @internal
  733.      *
  734.      * @return bool
  735.      */
  736.     public function hasDirtyLanguages(): bool
  737.     {
  738.         if (DataObject::isDirtyDetectionDisabled()) {
  739.             return true;
  740.         }
  742.         return is_array($this->o_dirtyLanguages) && count($this->o_dirtyLanguages) > 0;
  743.     }
  745.     /**
  746.      * @internal
  747.      *
  748.      * @param string $language
  749.      *
  750.      * @return bool
  751.      */
  752.     public function isLanguageDirty(string $language): bool
  753.     {
  754.         if (DataObject::isDirtyDetectionDisabled()) {
  755.             return true;
  756.         }
  758.         if (is_array($this->o_dirtyLanguages)) {
  759.             if (count($this->o_dirtyLanguages) == 0) {
  760.                 return true;
  761.             }
  762.             if (isset($this->o_dirtyLanguages[$language])) {
  763.                 return $this->o_dirtyLanguages[$language];
  764.             }
  765.         }
  767.         return false;
  768.     }
  770.     /**
  771.      * @internal
  772.      */
  773.     public function resetLanguageDirtyMap(): void
  774.     {
  775.         $this->o_dirtyLanguages = null;
  776.     }
  778.     /**
  779.      * @internal
  780.      *
  781.      * @return array|null
  782.      */
  783.     public function getDirtyLanguages(): ?array
  784.     {
  785.         return $this->o_dirtyLanguages;
  786.     }
  788.     /**
  789.      * @internal
  790.      */
  791.     public function markAllLanguagesAsDirty(): void
  792.     {
  793.         $this->o_dirtyLanguages = [];
  794.     }
  796.     /**
  797.      * @internal
  798.      *
  799.      * @return bool
  800.      */
  801.     public function allLanguagesAreDirty(): bool
  802.     {
  803.         if (DataObject::isDirtyDetectionDisabled()) {
  804.             return true;
  805.         }
  807.         return is_array($this->o_dirtyLanguages) && count($this->o_dirtyLanguages) === 0;
  808.     }
  810.     /**
  811.      * @internal
  812.      *
  813.      * @param string $language
  814.      * @param bool $dirty
  815.      */
  816.     public function markLanguageAsDirty(string $language, bool $dirty = true): void
  817.     {
  818.         if (DataObject::isDirtyDetectionDisabled()) {
  819.             return;
  820.         }
  822.         if (!is_array($this->o_dirtyLanguages) && $dirty) {
  823.             $this->o_dirtyLanguages = [];
  824.         }
  826.         if ($dirty) {
  827.             $this->o_dirtyLanguages[$language] = true;
  828.         }
  830.         if (!$this->o_dirtyLanguages) {
  831.             $this->o_dirtyLanguages = null;
  832.         }
  833.     }
  835.     /**
  836.      * @internal
  837.      *
  838.      * @return array
  839.      *
  840.      * @throws \Exception
  841.      */
  842.     protected function getLazyLoadedFieldNames(): array
  843.     {
  844.         $lazyLoadedFieldNames = [];
  846.         if (isset($this->context['containerType']) && $this->context['containerType'] === 'block') {
  847.             // if localized field is embedded in a block element there is no lazy loading. Maybe we can
  848.             // prevent this already in the class definition editor
  849.             return $lazyLoadedFieldNames;
  850.         }
  852.         $fields = $this->getFieldDefinitions($this->getContext(), ['suppressEnrichment' => true]);
  853.         foreach ($fields as $field) {
  854.             if ($field instanceof LazyLoadingSupportInterface && $field->getLazyLoading()) {
  855.                 $lazyLoadedFieldNames[] = $field->getName();
  856.             }
  857.         }
  859.         return $lazyLoadedFieldNames;
  860.     }
  862.     /**
  863.      * @return int|null
  864.      */
  865.     public function getObjectId(): ?int
  866.     {
  867.         return $this->objectId;
  868.     }
  869. }