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|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.      * @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|null
  466.      *
  467.      * @throws \Exception
  468.      * @throws Model\Exception\NotFoundException
  469.      */
  470.     public function getLocalizedValue(string $name, string $language = null, bool $ignoreFallbackLanguage = false)
  471.     {
  472.         $data = null;
  473.         $language = $this->getLanguage($language);
  475.         $context = $this->getContext();
  476.         $fieldDefinition = $this->getFieldDefinition($name, $context);
  478.         if (!$fieldDefinition instanceof ClassDefinition\Data) {
  479.             throw new Model\Exception\NotFoundException(sprintf('Field "%s" does not exist in localizedfields', $name));
  480.         }
  482.         if ($fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\CalculatedValue) {
  483.             $valueData = new Model\DataObject\Data\CalculatedValue($fieldDefinition->getName());
  484.             $valueData->setContextualData('localizedfield', 'localizedfields', null, $language, null, null, $fieldDefinition);
  485.             $data = Service::getCalculatedFieldValue($this->getObject(), $valueData);
  487.             return $data;
  488.         }
  490.         if ($fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading() && !$this->_loadedAllLazyData) {
  491.             $this->loadLazyField($fieldDefinition, $name, $language);
  492.         }
  494.         if ($this->languageExists($language)) {
  495.             if (array_key_exists($name, $this->items[$language])) {
  496.                 $data = $this->items[$language][$name];
  497.             }
  498.         }
  500.         // check for inherited value
  501.         $doGetInheritedValues = DataObject::doGetInheritedValues();
  503.         $allowInheritance = $fieldDefinition->supportsInheritance();
  504.         if (isset($context['containerType']) && ($context['containerType'] === 'block' || $context['containerType'] === 'fieldcollection')) {
  505.             $allowInheritance = false;
  506.         }
  508.         if ($fieldDefinition->isEmpty($data) && $doGetInheritedValues && $allowInheritance && $this->getObject() instanceof Concrete) {
  509.             $object = $this->getObject();
  510.             $class = $object->getClass();
  511.             $allowInherit = $class->getAllowInherit();
  513.             if ($allowInherit) {
  514.                 if ($object->getParent() instanceof AbstractObject) {
  515.                     $parent = $object->getParent();
  516.                     while ($parent && $parent->getType() == AbstractObject::OBJECT_TYPE_FOLDER) {
  517.                         $parent = $parent->getParent();
  518.                     }
  520.                     if ($parent && ($parent->getType() == AbstractObject::OBJECT_TYPE_OBJECT || $parent->getType() == AbstractObject::OBJECT_TYPE_VARIANT)) {
  521.                         /** @var Concrete $parent */
  522.                         if ($parent->getClassId() == $object->getClassId()) {
  523.                             $method = 'getLocalizedfields';
  525.                             $parentContainer = $parent;
  527.                             if (isset($context['containerType']) && $context['containerType'] === 'objectbrick') {
  528.                                 if (!empty($context['fieldname'])) {
  529.                                     $brickContainerGetter = 'get' . ucfirst($context['fieldname']);
  530.                                     $brickContainer = $parent->$brickContainerGetter();
  531.                                     $brickGetter = 'get' . $context['containerKey'];
  532.                                     $brickData = $brickContainer->$brickGetter();
  533.                                     $parentContainer = $brickData;
  534.                                 }
  535.                             }
  537.                             if ($parentContainer && method_exists($parentContainer, $method)) {
  538.                                 $localizedFields = $parentContainer->getLocalizedFields();
  539.                                 if ($localizedFields instanceof Localizedfield) {
  540.                                     if ($localizedFields->getObject()->getId() != $this->getObject()->getId()) {
  541.                                         $localizedFields->setContext($this->getContext());
  542.                                         $data = $localizedFields->getLocalizedValue($name, $language, true);
  543.                                     }
  544.                                 }
  545.                             }
  546.                         }
  547.                     }
  548.                 }
  549.             }
  550.         }
  552.         // check for fallback value
  553.         if ($fieldDefinition->isEmpty($data) && !$ignoreFallbackLanguage && self::doGetFallbackValues()) {
  554.             foreach (Tool::getFallbackLanguagesFor($language) as $l) {
  555.                 // fallback-language may not exist yet for lazy-loaded field (relation)
  556.                 if ($this->languageExists($l) || ($fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading())) {
  557.                     if ($data = $this->getLocalizedValue($name, $l)) {
  558.                         break;
  559.                     }
  560.                 }
  561.             }
  562.         }
  564.         //TODO Pimcore 11: remove method_exists BC layer
  565.         if ($fieldDefinition instanceof PreGetDataInterface || method_exists($fieldDefinition, 'preGetData')) {
  566.             if (!$fieldDefinition instanceof PreGetDataInterface) {
  567.                 trigger_deprecation('pimcore/pimcore', '10.1', sprintf('Usage of method_exists is deprecated since version 10.1 and will be removed in Pimcore 11.' .
  568.                     'Implement the %s interface instead.', PreGetDataInterface::class));
  569.             }
  571.             $data = $fieldDefinition->preGetData(
  572.                 $this,
  573.                 [
  574.                     'data' => $data,
  575.                     'language' => $language,
  576.                     'name' => $name,
  577.                 ]
  578.             );
  579.         }
  581.         return $data;
  582.     }
  584.     /**
  585.      * @param string $name
  586.      * @param mixed $value
  587.      * @param string|null $language
  588.      * @param bool $markFieldAsDirty
  589.      *
  590.      * @return $this
  591.      *
  592.      * @throws \Exception
  593.      */
  594.     public function setLocalizedValue(string $name, $value, string $language = null, bool $markFieldAsDirty = true)
  595.     {
  596.         if ($markFieldAsDirty) {
  597.             $this->markFieldDirty('_self');
  598.         }
  600.         if (self::$strictMode) {
  601.             if (!$language || !in_array($language, Tool::getValidLanguages())) {
  602.                 throw new \Exception('Language '.$language.' not accepted in strict mode');
  603.             }
  604.         }
  606.         $language = $this->getLanguage($language);
  607.         if (!$this->languageExists($language)) {
  608.             $this->items[$language] = [];
  609.             $this->markLanguageAsDirty($language);
  610.         }
  612.         $contextInfo = $this->getContext();
  613.         if (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'block') {
  614.             $classId = $contextInfo['classId'];
  615.             $containerDefinition = ClassDefinition::getById($classId);
  616.             /** @var Model\DataObject\ClassDefinition\Data\Block $blockDefinition */
  617.             $blockDefinition = $containerDefinition->getFieldDefinition($contextInfo['fieldname']);
  619.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $fieldDefinition */
  620.             $fieldDefinition = $blockDefinition->getFieldDefinition('localizedfields');
  621.         } else {
  622.             if (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'fieldcollection') {
  623.                 $containerKey = $contextInfo['containerKey'];
  624.                 $containerDefinition = Fieldcollection\Definition::getByKey($containerKey);
  625.             } elseif (isset($contextInfo['containerType']) && $contextInfo['containerType'] === 'objectbrick') {
  626.                 $containerKey = $contextInfo['containerKey'];
  627.                 $containerDefinition = Model\DataObject\Objectbrick\Definition::getByKey($containerKey);
  628.             } else {
  629.                 $containerDefinition = $this->getObject()->getClass();
  630.             }
  632.             /** @var Model\DataObject\ClassDefinition\Data\Localizedfields $localizedFieldDefinition */
  633.             $localizedFieldDefinition = $containerDefinition->getFieldDefinition('localizedfields');
  634.             $fieldDefinition = $localizedFieldDefinition->getFieldDefinition($name, ['object' => $this->getObject()]);
  635.         }
  637.         // if a lazy loaded field hasn't been loaded we cannot rely on the dirty check
  638.         // note that preSetData will just overwrite it with the new data and mark it as loaded
  639.         $forceLanguageDirty = false;
  640.         $isLazyLoadedField = $fieldDefinition instanceof LazyLoadingSupportInterface && $fieldDefinition->getLazyLoading();
  641.         $lazyKey = $this->buildLazyKey($name, $language);
  643.         if ($isLazyLoadedField) {
  644.             if (!$this->isLazyKeyLoaded($lazyKey)) {
  645.                 $forceLanguageDirty = true;
  646.             }
  647.         }
  649.         //TODO Pimcore 11: remove method_exists BC layer
  650.         if ($fieldDefinition instanceof PreSetDataInterface || method_exists($fieldDefinition, 'preSetData')) {
  651.             if (!$fieldDefinition instanceof PreSetDataInterface) {
  652.                 trigger_deprecation('pimcore/pimcore', '10.1',
  653.                     sprintf('Usage of method_exists is deprecated since version 10.1 and will be removed in Pimcore 11.' .
  654.                     'Implement the %s interface instead.', PreSetDataInterface::class));
  655.             }
  657.             $value = $fieldDefinition->preSetData(
  658.                 $this,
  659.                 $value,
  660.                 [
  661.                     'language' => $language,
  662.                     'name' => $name,
  663.                 ]
  664.             );
  665.         }
  667.         $isEqual = false;
  669.         if ($fieldDefinition instanceof Model\DataObject\ClassDefinition\Data\EqualComparisonInterface) {
  670.             $isEqual = $fieldDefinition->isEqual($this->items[$language][$name] ?? null, $value);
  671.         }
  673.         if ($markFieldAsDirty && ($forceLanguageDirty || !$isEqual)) {
  674.             $this->markLanguageAsDirty($language);
  675.         }
  676.         $this->items[$language][$name] = $value;
  678.         if ($isLazyLoadedField) {
  679.             $this->markLazyKeyAsLoaded($lazyKey);
  680.         }
  682.         return $this;
  683.     }
  685.     /**
  686.      * {@inheritdoc}
  687.      */
  688.     public function isAllLazyKeysMarkedAsLoaded(): bool
  689.     {
  690.         $object = $this->getObject();
  691.         if ($object instanceof Concrete) {
  692.             return $this->getObject()->isAllLazyKeysMarkedAsLoaded();
  693.         }
  695.         return true;
  696.     }
  698.     /**
  699.      * @return array
  700.      */
  701.     public function __sleep(): array
  702.     {
  703.         if (!$this->isInDumpState()) {
  704.             /**
  705.              * Remove all lazy loaded fields if item gets serialized for the cache (not for versions)
  706.              * This is actually not perfect, but currently we don't have an alternative
  707.              */
  708.             $lazyLoadedFields = $this->getLazyLoadedFieldNames();
  709.             foreach ($lazyLoadedFields as $fieldName) {
  710.                 foreach (Tool::getValidLanguages() as $language) {
  711.                     unset($this->items[$language][$fieldName]);
  713.                     $lazyKey = $this->buildLazyKey($fieldName, $language);
  714.                     $this->unmarkLazyKeyAsLoaded($lazyKey);
  715.                 }
  716.             }
  717.         }
  719.         return ['items', 'context', 'objectId'];
  720.     }
  722.     /**
  723.      * @return array
  724.      */
  725.     public function getContext(): array
  726.     {
  727.         return $this->context ?? [];
  728.     }
  730.     /**
  731.      * @param array|null $context
  732.      */
  733.     public function setContext(?array $context): void
  734.     {
  735.         $this->context = $context ?? [];
  736.     }
  738.     /**
  739.      * @internal
  740.      *
  741.      * @return bool
  742.      */
  743.     public function hasDirtyLanguages(): bool
  744.     {
  745.         if (DataObject::isDirtyDetectionDisabled()) {
  746.             return true;
  747.         }
  749.         return is_array($this->o_dirtyLanguages) && count($this->o_dirtyLanguages) > 0;
  750.     }
  752.     /**
  753.      * @internal
  754.      *
  755.      * @param string $language
  756.      *
  757.      * @return bool
  758.      */
  759.     public function isLanguageDirty(string $language): bool
  760.     {
  761.         if (DataObject::isDirtyDetectionDisabled()) {
  762.             return true;
  763.         }
  765.         if (is_array($this->o_dirtyLanguages)) {
  766.             if (count($this->o_dirtyLanguages) == 0) {
  767.                 return true;
  768.             }
  769.             if (isset($this->o_dirtyLanguages[$language])) {
  770.                 return $this->o_dirtyLanguages[$language];
  771.             }
  772.         }
  774.         return false;
  775.     }
  777.     /**
  778.      * @internal
  779.      */
  780.     public function resetLanguageDirtyMap(): void
  781.     {
  782.         $this->o_dirtyLanguages = null;
  783.     }
  785.     /**
  786.      * @internal
  787.      *
  788.      * @return array|null
  789.      */
  790.     public function getDirtyLanguages(): ?array
  791.     {
  792.         return $this->o_dirtyLanguages;
  793.     }
  795.     /**
  796.      * @internal
  797.      */
  798.     public function markAllLanguagesAsDirty(): void
  799.     {
  800.         $this->o_dirtyLanguages = [];
  801.     }
  803.     /**
  804.      * @internal
  805.      *
  806.      * @return bool
  807.      */
  808.     public function allLanguagesAreDirty(): bool
  809.     {
  810.         if (DataObject::isDirtyDetectionDisabled()) {
  811.             return true;
  812.         }
  814.         return is_array($this->o_dirtyLanguages) && count($this->o_dirtyLanguages) === 0;
  815.     }
  817.     /**
  818.      * @internal
  819.      *
  820.      * @param string $language
  821.      * @param bool $dirty
  822.      */
  823.     public function markLanguageAsDirty(string $language, bool $dirty = true): void
  824.     {
  825.         if (DataObject::isDirtyDetectionDisabled()) {
  826.             return;
  827.         }
  829.         if (!is_array($this->o_dirtyLanguages) && $dirty) {
  830.             $this->o_dirtyLanguages = [];
  831.         }
  833.         if ($dirty) {
  834.             $this->o_dirtyLanguages[$language] = true;
  835.         }
  837.         if (!$this->o_dirtyLanguages) {
  838.             $this->o_dirtyLanguages = null;
  839.         }
  840.     }
  842.     /**
  843.      * @internal
  844.      *
  845.      * @return array
  846.      *
  847.      * @throws \Exception
  848.      */
  849.     protected function getLazyLoadedFieldNames(): array
  850.     {
  851.         $lazyLoadedFieldNames = [];
  853.         if (isset($this->context['containerType']) && $this->context['containerType'] === 'block') {
  854.             // if localized field is embedded in a block element there is no lazy loading. Maybe we can
  855.             // prevent this already in the class definition editor
  856.             return $lazyLoadedFieldNames;
  857.         }
  859.         $fields = $this->getFieldDefinitions($this->getContext(), ['suppressEnrichment' => true]);
  860.         foreach ($fields as $field) {
  861.             if ($field instanceof LazyLoadingSupportInterface && $field->getLazyLoading()) {
  862.                 $lazyLoadedFieldNames[] = $field->getName();
  863.             }
  864.         }
  866.         return $lazyLoadedFieldNames;
  867.     }
  869.     /**
  870.      * @return int|null
  871.      */
  872.     public function getObjectId(): ?int
  873.     {
  874.         return $this->objectId;
  875.     }
  876. }