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

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|Model\Element\ElementDescriptor|null
  71.      */
  72.     protected $object;
  74.     /**
  75.      * @internal
  76.      *
  77.      * @var ClassDefinition|null
  78.      */
  79.     protected ?ClassDefinition $class = null;
  81.     /**
  82.      * @internal
  83.      *
  84.      * @var array|null
  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.      * @return array
  180.      */
  181.     public function getItems(): array
  182.     {
  183.         return $this->items;
  184.     }
  186.     /**
  187.      * @param array $items
  188.      *
  189.      * @return $this
  190.      */
  191.     public function setItems(array $items)
  192.     {
  193.         $this->items = $items;
  194.         $this->markFieldDirty('_self');
  195.         $this->markAllLanguagesAsDirty();
  197.         return $this;
  198.     }
  200.     /**
  201.      * @internal
  202.      */
  203.     public function loadLazyData(): void
  204.     {
  205.         $this->getInternalData(true);
  206.     }
  208.     /**
  209.      * @internal
  210.      *
  211.      * @param bool $mark
  212.      */
  213.     public function setLoadedAllLazyData($mark = true)
  214.     {
  215.         $this->_loadedAllLazyData = $mark;
  216.     }
  218.     /**
  219.      * Note: this is for pimcore/pimcore use only.
  220.      *
  221.      * @internal
  222.      *
  223.      * @param bool $loadLazyFields
  224.      *
  225.      * @return array
  226.      */
  227.     public function getInternalData(bool $loadLazyFields = false): array
  228.     {
  229.         $loadLazyFieldNames = $this->getLazyLoadedFieldNames();
  231.         if ($loadLazyFields && !empty($loadLazyFieldNames) && !$this->_loadedAllLazyData) {
  232.             $isDirtyDetectionDisabled = DataObject::isDirtyDetectionDisabled();
  233.             DataObject::disableDirtyDetection();
  235.             foreach ($loadLazyFieldNames as $name) {
  236.                 foreach (Tool::getValidLanguages() as $language) {
  237.                     $fieldDefinition = $this->getFieldDefinition($name, $this->getContext());
  238.                     $this->loadLazyField($fieldDefinition, $name, $language);
  239.                 }
  240.             }
  242.             DataObject::setDisableDirtyDetection($isDirtyDetectionDisabled);
  243.             $this->setLoadedAllLazyData();
  244.         }
  246.         foreach ($this->getFieldDefinitions($this->getContext(), ['suppressEnrichment' => true]) as $fieldDefinition) {
  247.             if ($fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\CalculatedValue) {
  248.                 foreach (Tool::getValidLanguages() as $language) {
  249.                     $this->setLocalizedValue($fieldDefinition->getName(), null, $language, false);
  250.                 }
  251.             }
  252.         }
  254.         return $this->items;
  255.     }
  257.     /**
  258.      * @param Concrete|Model\Element\ElementDescriptor|null $object
  259.      * @param bool $markAsDirty
  260.      *
  261.      * @return $this
  262.      *
  263.      * @throws \Exception
  264.      */
  265.     public function setObject($object, bool $markAsDirty = true)
  266.     {
  267.         if ($object instanceof Model\Element\ElementDescriptor) {
  268.             $object = Service::getElementById($object->getType(), $object->getId());
  269.         }
  271.         if (!is_null($object) && !$object instanceof Concrete) {
  272.             throw new \Exception('must be instance of object concrete');
  273.         }
  275.         if ($markAsDirty) {
  276.             $this->markAllLanguagesAsDirty();
  277.         }
  278.         $this->object = $object;
  279.         $this->objectId = $object ? $object->getId() : null;
  280.         $this->setClass($object ? $object->getClass() : null);
  282.         return $this;
  283.     }
  285.     /**
  286.      * @return Concrete|null
  287.      */
  288.     public function getObject(): ?Concrete
  289.     {
  290.         if ($this->objectId && !$this->object) {
  291.             $this->setObject(Concrete::getById($this->objectId));
  292.         }
  294.         return $this->object;
  295.     }
  297.     /**
  298.      * @param ClassDefinition|null $class
  299.      *
  300.      * @return $this
  301.      */
  302.     public function setClass(?ClassDefinition $class)
  303.     {
  304.         $this->class = $class;
  306.         return $this;
  307.     }
  309.     /**
  310.      * @return ClassDefinition|null
  311.      */
  312.     public function getClass(): ?ClassDefinition
  313.     {
  314.         if (!$this->class && $this->getObject()) {
  315.             $this->class = $this->getObject()->getClass();
  316.         }
  318.         return $this->class;
  319.     }
  321.     /**
  322.      * @throws \Exception
  323.      *
  324.      * @param string|null $language
  325.      *
  326.      * @return string
  327.      */
  328.     public function getLanguage(string $language = null): string
  329.     {
  330.         if ($language) {
  331.             return $language;
  332.         }
  334.         // try to get the language from the service container
  335.         try {
  336.             $locale = \Pimcore::getContainer()->get(LocaleServiceInterface::class)->getLocale();
  338.             if (Tool::isValidLanguage($locale)) {
  339.                 return $locale;
  340.             }
  342.             if (\Pimcore::inAdmin()) {
  343.                 foreach (Tool::getValidLanguages() as $validLocale) {
  344.                     if (str_starts_with($validLocale, $locale.'_')) {
  345.                         return $validLocale;
  346.                     }
  347.                 }
  348.             }
  350.             throw new \Exception('Not supported language');
  351.         } catch (\Exception $e) {
  352.             return Tool::getDefaultLanguage();
  353.         }
  354.     }
  356.     /**
  357.      * @param string $language
  358.      *
  359.      * @return bool
  360.      */
  361.     public function languageExists(string $language): bool
  362.     {
  363.         return array_key_exists($language, $this->items);
  364.     }
  366.     /**
  367.      * @param string $name
  368.      * @param array $context
  369.      *
  370.      * @return ClassDefinition\Data|null
  371.      */
  372.     public function getFieldDefinition(string $name, $context = [])
  373.     {
  374.         if (isset($context['containerType']) && $context['containerType'] === 'fieldcollection') {
  375.             $containerKey = $context['containerKey'];
  376.             $container = Model\DataObject\Fieldcollection\Definition::getByKey($containerKey);
  377.         } elseif (isset($context['containerType']) && $context['containerType'] === 'objectbrick') {
  378.             $containerKey = $context['containerKey'];
  379.             $container = Model\DataObject\Objectbrick\Definition::getByKey($containerKey);
  380.         } elseif (isset($context['containerType']) && $context['containerType'] === 'block') {
  381.             $containerKey = $context['containerKey'];
  382.             $object = $this->getObject();
  383.             $blockDefinition = $object->getClass()->getFieldDefinition($containerKey);
  384.             $container = $blockDefinition;
  385.         } else {
  386.             $object = $this->getObject();
  387.             $container = $object->getClass();
  388.         }
  390.         /** @var Model\DataObject\ClassDefinition\Data\Localizedfields|null $localizedFields */
  391.         $localizedFields = $container->getFieldDefinition('localizedfields');
  393.         if ($localizedFields) {
  394.             return $localizedFields->getFieldDefinition($name);
  395.         }
  397.         return null;
  398.     }
  400.     /**
  401.      * @param array $context
  402.      * @param array $params
  403.      *
  404.      * @return ClassDefinition\Data[]
  405.      *
  406.      * @throws \Exception
  407.      */
  408.     protected function getFieldDefinitions($context = [], $params = []): array
  409.     {
  410.         if (isset($context['containerType']) && $context['containerType'] === 'fieldcollection') {
  411.             $containerKey = $context['containerKey'];
  412.             $fcDef = Model\DataObject\Fieldcollection\Definition::getByKey($containerKey);
  413.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $container */
  414.             $container = $fcDef->getFieldDefinition('localizedfields');
  415.         } elseif (isset($context['containerType']) && $context['containerType'] === 'objectbrick') {
  416.             $containerKey = $context['containerKey'];
  417.             $brickDef = Model\DataObject\Objectbrick\Definition::getByKey($containerKey);
  418.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $container */
  419.             $container = $brickDef->getFieldDefinition('localizedfields');
  420.         } elseif (isset($context['containerType']) && $context['containerType'] === 'block') {
  421.             $containerKey = $context['containerKey'];
  422.             $object = $this->getObject();
  423.             /** @var Model\DataObject\ClassDefinition\Data\Block $block */
  424.             $block = $object->getClass()->getFieldDefinition($containerKey);
  425.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $container */
  426.             $container = $block->getFieldDefinition('localizedfields');
  427.         } else {
  428.             $class = $this->getClass();
  429.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $container */
  430.             $container = $class->getFieldDefinition('localizedfields');
  431.         }
  433.         return $container->getFieldDefinitions($params);
  434.     }
  436.     /**
  437.      * @param ClassDefinition\Data $fieldDefinition
  438.      * @param string $name
  439.      * @param string $language
  440.      *
  441.      * @internal
  442.      */
  443.     private function loadLazyField(Model\DataObject\ClassDefinition\Data $fieldDefinition, string $name, string $language): void
  444.     {
  445.         $lazyKey = $this->buildLazyKey($name, $language);
  446.         if (!$this->isLazyKeyLoaded($lazyKey) && $fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\CustomResourcePersistingInterface) {
  447.             $params['language'] = $language;
  448.             $params['object'] = $this->getObject();
  449.             $params['context'] = $this->getContext();
  450.             $params['owner'] = $this;
  451.             $params['fieldname'] = $name;
  453.             $isDirtyDetectionDisabled = DataObject::isDirtyDetectionDisabled();
  454.             DataObject::disableDirtyDetection();
  456.             $data = $fieldDefinition->load($this, $params);
  458.             if ($data === 0 || !empty($data)) {
  459.                 $this->setLocalizedValue($name, $data, $language, false);
  460.             }
  462.             DataObject::setDisableDirtyDetection($isDirtyDetectionDisabled);
  464.             $this->markLazyKeyAsLoaded($lazyKey);
  465.         }
  466.     }
  468.     /**
  469.      * @param string $name
  470.      * @param string|null $language
  471.      * @param bool $ignoreFallbackLanguage
  472.      *
  473.      * @return mixed
  474.      *
  475.      * @throws \Exception
  476.      * @throws Model\Exception\NotFoundException
  477.      */
  478.     public function getLocalizedValue(string $name, string $language = null, bool $ignoreFallbackLanguage = false)
  479.     {
  480.         $data = null;
  481.         $language = $this->getLanguage($language);
  483.         $context = $this->getContext();
  484.         $fieldDefinition = $this->getFieldDefinition($name, $context);
  486.         if (!$fieldDefinition instanceof ClassDefinition\Data) {
  487.             throw new Model\Exception\NotFoundException(sprintf('Field "%s" does not exist in localizedfields', $name));
  488.         }
  490.         if ($fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\CalculatedValue) {
  491.             $valueData = new Model\DataObject\Data\CalculatedValue($fieldDefinition->getName());
  492.             $valueData->setContextualData('localizedfield', 'localizedfields', null, $language, null, null, $fieldDefinition);
  493.             $data = Service::getCalculatedFieldValue($this->getObject(), $valueData);
  495.             return $data;
  496.         }
  498.         if ($fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading() && !$this->_loadedAllLazyData) {
  499.             $this->loadLazyField($fieldDefinition, $name, $language);
  500.         }
  502.         if ($this->languageExists($language)) {
  503.             if (array_key_exists($name, $this->items[$language])) {
  504.                 $data = $this->items[$language][$name];
  505.             }
  506.         }
  508.         // check for inherited value
  509.         $doGetInheritedValues = DataObject::doGetInheritedValues();
  511.         $allowInheritance = $fieldDefinition->supportsInheritance();
  512.         if (isset($context['containerType']) && ($context['containerType'] === 'block' || $context['containerType'] === 'fieldcollection')) {
  513.             $allowInheritance = false;
  514.         }
  516.         if ($fieldDefinition->isEmpty($data) && $doGetInheritedValues && $allowInheritance && $this->getObject() instanceof Concrete) {
  517.             $object = $this->getObject();
  518.             $class = $object->getClass();
  519.             $allowInherit = $class->getAllowInherit();
  521.             if ($allowInherit) {
  522.                 if ($object->getParent() instanceof AbstractObject) {
  523.                     $parent = $object->getParent();
  524.                     while ($parent && $parent->getType() == AbstractObject::OBJECT_TYPE_FOLDER) {
  525.                         $parent = $parent->getParent();
  526.                     }
  528.                     if ($parent && ($parent->getType() == AbstractObject::OBJECT_TYPE_OBJECT || $parent->getType() == AbstractObject::OBJECT_TYPE_VARIANT)) {
  529.                         /** @var Concrete $parent */
  530.                         if ($parent->getClassId() == $object->getClassId()) {
  531.                             $method = 'getLocalizedfields';
  533.                             $parentContainer = $parent;
  535.                             if (isset($context['containerType']) && $context['containerType'] === 'objectbrick') {
  536.                                 if (!empty($context['fieldname'])) {
  537.                                     $brickContainerGetter = 'get' . ucfirst($context['fieldname']);
  538.                                     $brickContainer = $parent->$brickContainerGetter();
  539.                                     $brickGetter = 'get' . $context['containerKey'];
  540.                                     $brickData = $brickContainer->$brickGetter();
  541.                                     $parentContainer = $brickData;
  542.                                 }
  543.                             }
  545.                             if ($parentContainer && method_exists($parentContainer, $method)) {
  546.                                 $localizedFields = $parentContainer->getLocalizedFields();
  547.                                 if ($localizedFields instanceof Localizedfield) {
  548.                                     if ($localizedFields->getObject()->getId() != $this->getObject()->getId()) {
  549.                                         $localizedFields->setContext($this->getContext());
  550.                                         $data = $localizedFields->getLocalizedValue($name, $language, true);
  551.                                     }
  552.                                 }
  553.                             }
  554.                         }
  555.                     }
  556.                 }
  557.             }
  558.         }
  560.         // check for fallback value
  561.         if ($fieldDefinition->isEmpty($data) && !$ignoreFallbackLanguage && self::doGetFallbackValues()) {
  562.             foreach (Tool::getFallbackLanguagesFor($language) as $l) {
  563.                 // fallback-language may not exist yet for lazy-loaded field (relation)
  564.                 if ($this->languageExists($l) || ($fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading())) {
  565.                     if ($data = $this->getLocalizedValue($name, $l)) {
  566.                         break;
  567.                     }
  568.                 }
  569.             }
  570.         }
  572.         //TODO Pimcore 11: remove method_exists BC layer
  573.         if ($fieldDefinition instanceof PreGetDataInterface || method_exists($fieldDefinition, 'preGetData')) {
  574.             if (!$fieldDefinition instanceof PreGetDataInterface) {
  575.                 trigger_deprecation('pimcore/pimcore', '10.1', sprintf('Usage of method_exists is deprecated since version 10.1 and will be removed in Pimcore 11.' .
  576.                     'Implement the %s interface instead.', PreGetDataInterface::class));
  577.             }
  579.             $data = $fieldDefinition->preGetData(
  580.                 $this,
  581.                 [
  582.                     'data' => $data,
  583.                     'language' => $language,
  584.                     'name' => $name,
  585.                 ]
  586.             );
  587.         }
  589.         return $data;
  590.     }
  592.     /**
  593.      * @param string $name
  594.      * @param mixed $value
  595.      * @param string|null $language
  596.      * @param bool $markFieldAsDirty
  597.      *
  598.      * @return $this
  599.      *
  600.      * @throws \Exception
  601.      */
  602.     public function setLocalizedValue(string $name, $value, string $language = null, bool $markFieldAsDirty = true)
  603.     {
  604.         if ($markFieldAsDirty) {
  605.             $this->markFieldDirty('_self');
  606.         }
  608.         if (self::$strictMode) {
  609.             if (!$language || !in_array($language, Tool::getValidLanguages())) {
  610.                 throw new \Exception('Language '.$language.' not accepted in strict mode');
  611.             }
  612.         }
  614.         $language = $this->getLanguage($language);
  615.         if (!$this->languageExists($language)) {
  616.             $this->items[$language] = [];
  617.             $this->markLanguageAsDirty($language);
  618.         }
  620.         $contextInfo = $this->getContext();
  621.         if (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'block') {
  622.             $classId = $contextInfo['classId'];
  623.             $containerDefinition = ClassDefinition::getById($classId);
  624.             /** @var Model\DataObject\ClassDefinition\Data\Block $blockDefinition */
  625.             $blockDefinition = $containerDefinition->getFieldDefinition($contextInfo['fieldname']);
  627.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $fieldDefinition */
  628.             $fieldDefinition = $blockDefinition->getFieldDefinition('localizedfields');
  629.         } else {
  630.             if (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'fieldcollection') {
  631.                 $containerKey = $contextInfo['containerKey'];
  632.                 $containerDefinition = Fieldcollection\Definition::getByKey($containerKey);
  633.             } elseif (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'objectbrick') {
  634.                 $containerKey = $contextInfo['containerKey'];
  635.                 $containerDefinition = Model\DataObject\Objectbrick\Definition::getByKey($containerKey);
  636.             } else {
  637.                 $containerDefinition = $this->getObject()->getClass();
  638.             }
  640.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $localizedFieldDefinition */
  641.             $localizedFieldDefinition = $containerDefinition->getFieldDefinition('localizedfields');
  642.             $fieldDefinition = $localizedFieldDefinition->getFieldDefinition($name, ['object' => $this->getObject()]);
  643.         }
  645.         // if a lazy loaded field hasn't been loaded we cannot rely on the dirty check
  646.         // note that preSetData will just overwrite it with the new data and mark it as loaded
  647.         $forceLanguageDirty = false;
  648.         $isLazyLoadedField = $fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading();
  649.         $lazyKey = $this->buildLazyKey($name, $language);
  651.         if ($isLazyLoadedField) {
  652.             if (!$this->isLazyKeyLoaded($lazyKey)) {
  653.                 $forceLanguageDirty = true;
  654.             }
  655.         }
  657.         //TODO Pimcore 11: remove method_exists BC layer
  658.         if ($fieldDefinition instanceof PreSetDataInterface || method_exists($fieldDefinition, 'preSetData')) {
  659.             if (!$fieldDefinition instanceof PreSetDataInterface) {
  660.                 trigger_deprecation('pimcore/pimcore', '10.1',
  661.                     sprintf('Usage of method_exists is deprecated since version 10.1 and will be removed in Pimcore 11.' .
  662.                     'Implement the %s interface instead.', PreSetDataInterface::class));
  663.             }
  665.             $value = $fieldDefinition->preSetData(
  666.                 $this,
  667.                 $value,
  668.                 [
  669.                     'language' => $language,
  670.                     'name' => $name,
  671.                 ]
  672.             );
  673.         }
  675.         $isEqual = false;
  677.         if ($fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\EqualComparisonInterface) {
  678.             $isEqual = $fieldDefinition->isEqual($this->items[$language][$name] ?? null, $value);
  679.         }
  681.         if ($markFieldAsDirty && ($forceLanguageDirty || !$isEqual)) {
  682.             $this->markLanguageAsDirty($language);
  683.         }
  684.         $this->items[$language][$name] = $value;
  686.         if ($isLazyLoadedField) {
  687.             $this->markLazyKeyAsLoaded($lazyKey);
  688.         }
  690.         return $this;
  691.     }
  693.     /**
  694.      * {@inheritdoc}
  695.      */
  696.     public function isAllLazyKeysMarkedAsLoaded(): bool
  697.     {
  698.         $object = $this->getObject();
  699.         if ($object instanceof Concrete) {
  700.             return $this->getObject()->isAllLazyKeysMarkedAsLoaded();
  701.         }
  703.         return true;
  704.     }
  706.     /**
  707.      * @return array
  708.      */
  709.     public function __sleep(): array
  710.     {
  711.         if (!$this->isInDumpState()) {
  712.             /**
  713.              * Remove all lazy loaded fields if item gets serialized for the cache (not for versions)
  714.              * This is actually not perfect, but currently we don't have an alternative
  715.              */
  716.             $lazyLoadedFields = $this->getLazyLoadedFieldNames();
  717.             foreach ($lazyLoadedFields as $fieldName) {
  718.                 foreach (Tool::getValidLanguages() as $language) {
  719.                     unset($this->items[$language][$fieldName]);
  721.                     $lazyKey = $this->buildLazyKey($fieldName, $language);
  722.                     $this->unmarkLazyKeyAsLoaded($lazyKey);
  723.                 }
  724.             }
  725.         }
  727.         return ['items', 'context', 'objectId'];
  728.     }
  730.     /**
  731.      * @return array
  732.      */
  733.     public function getContext(): array
  734.     {
  735.         return $this->context ?? [];
  736.     }
  738.     /**
  739.      * @param array|null $context
  740.      */
  741.     public function setContext(?array $context): void
  742.     {
  743.         $this->context = $context ?? [];
  744.     }
  746.     /**
  747.      * @internal
  748.      *
  749.      * @return bool
  750.      */
  751.     public function hasDirtyLanguages(): bool
  752.     {
  753.         if (DataObject::isDirtyDetectionDisabled()) {
  754.             return true;
  755.         }
  757.         return is_array($this->o_dirtyLanguages) && count($this->o_dirtyLanguages) > 0;
  758.     }
  760.     /**
  761.      * @internal
  762.      *
  763.      * @param string $language
  764.      *
  765.      * @return bool
  766.      */
  767.     public function isLanguageDirty(string $language): bool
  768.     {
  769.         if (DataObject::isDirtyDetectionDisabled()) {
  770.             return true;
  771.         }
  773.         if (is_array($this->o_dirtyLanguages)) {
  774.             if (count($this->o_dirtyLanguages) == 0) {
  775.                 return true;
  776.             }
  777.             if (isset($this->o_dirtyLanguages[$language])) {
  778.                 return $this->o_dirtyLanguages[$language];
  779.             }
  780.         }
  782.         return false;
  783.     }
  785.     /**
  786.      * @internal
  787.      */
  788.     public function resetLanguageDirtyMap(): void
  789.     {
  790.         $this->o_dirtyLanguages = null;
  791.     }
  793.     /**
  794.      * @internal
  795.      *
  796.      * @return array|null
  797.      */
  798.     public function getDirtyLanguages(): ?array
  799.     {
  800.         return $this->o_dirtyLanguages;
  801.     }
  803.     /**
  804.      * @internal
  805.      */
  806.     public function markAllLanguagesAsDirty(): void
  807.     {
  808.         $this->o_dirtyLanguages = [];
  809.     }
  811.     /**
  812.      * @internal
  813.      *
  814.      * @return bool
  815.      */
  816.     public function allLanguagesAreDirty(): bool
  817.     {
  818.         if (DataObject::isDirtyDetectionDisabled()) {
  819.             return true;
  820.         }
  822.         return is_array($this->o_dirtyLanguages) && count($this->o_dirtyLanguages) === 0;
  823.     }
  825.     /**
  826.      * @internal
  827.      *
  828.      * @param string $language
  829.      * @param bool $dirty
  830.      */
  831.     public function markLanguageAsDirty(string $language, bool $dirty = true): void
  832.     {
  833.         if (DataObject::isDirtyDetectionDisabled()) {
  834.             return;
  835.         }
  837.         if (!is_array($this->o_dirtyLanguages) && $dirty) {
  838.             $this->o_dirtyLanguages = [];
  839.         }
  841.         if ($dirty) {
  842.             $this->o_dirtyLanguages[$language] = true;
  843.         }
  845.         if (!$this->o_dirtyLanguages) {
  846.             $this->o_dirtyLanguages = null;
  847.         }
  848.     }
  850.     /**
  851.      * @internal
  852.      *
  853.      * @return array
  854.      *
  855.      * @throws \Exception
  856.      */
  857.     protected function getLazyLoadedFieldNames(): array
  858.     {
  859.         $lazyLoadedFieldNames = [];
  861.         if (isset($this->context['containerType']) && $this->context['containerType'] === 'block') {
  862.             // if localized field is embedded in a block element there is no lazy loading. Maybe we can
  863.             // prevent this already in the class definition editor
  864.             return $lazyLoadedFieldNames;
  865.         }
  867.         $fields = $this->getFieldDefinitions($this->getContext(), ['suppressEnrichment' => true]);
  868.         foreach ($fields as $field) {
  869.             if ($field instanceof LazyLoadingSupportInterface && $field->getLazyLoading()) {
  870.                 $lazyLoadedFieldNames[] = $field->getName();
  871.             }
  872.         }
  874.         return $lazyLoadedFieldNames;
  875.     }
  877.     /**
  878.      * @return int|null
  879.      */
  880.     public function getObjectId(): ?int
  881.     {
  882.         return $this->objectId;
  883.     }
  884. }