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. }