vendor/pimcore/pimcore/models/Document/Editable/Relations.php line 27

  1. <?php
  2. declare(strict_types=1);
  4. /**
  5.  * Pimcore
  6.  *
  7.  * This source file is available under two different licenses:
  8.  * - GNU General Public License version 3 (GPLv3)
  9.  * - Pimcore Commercial License (PCL)
  10.  * Full copyright and license information is available in
  11.  * LICENSE.md which is distributed with this source code.
  12.  *
  13.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  14.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  15.  */
  17. namespace Pimcore\Model\Document\Editable;
  19. use Pimcore\Model;
  20. use Pimcore\Model\Asset;
  21. use Pimcore\Model\DataObject;
  22. use Pimcore\Model\Document;
  23. use Pimcore\Model\Element;
  25. /**
  26.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  27.  */
  28. class Relations extends Model\Document\Editable implements \Iterator, IdRewriterInterface, EditmodeDataInterface, LazyLoadingInterface
  29. {
  30.     /**
  31.      * @internal
  32.      *
  33.      * @var Element\ElementInterface[]
  34.      */
  35.     protected array $elements = [];
  37.     /**
  38.      * @internal
  39.      *
  40.      */
  41.     protected array $elementIds = [];
  43.     public function getType(): string
  44.     {
  45.         return 'relations';
  46.     }
  48.     public function setElements(): static
  49.     {
  50.         if (empty($this->elements)) {
  51.             $this->elements = [];
  52.             foreach ($this->elementIds as $elementId) {
  53.                 $el = Element\Service::getElementById($elementId['type'], $elementId['id']);
  54.                 if ($el instanceof Element\ElementInterface) {
  55.                     $this->elements[] = $el;
  56.                 }
  57.             }
  58.         }
  60.         return $this;
  61.     }
  63.     public function getElementIds(): array
  64.     {
  65.         return $this->elementIds;
  66.     }
  68.     public function getData(): mixed
  69.     {
  70.         $this->setElements();
  72.         return $this->elements;
  73.     }
  75.     public function getDataForResource(): mixed
  76.     {
  77.         return $this->elementIds;
  78.     }
  80.     public function getDataEditmode(): array
  81.     {
  82.         $this->setElements();
  83.         $return = [];
  85.         foreach ($this->elements as $element) {
  86.             if ($element instanceof DataObject\Concrete) {
  87.                 $return[] = [$element->getId(), $element->getRealFullPath(), DataObject::OBJECT_TYPE_OBJECT, $element->getClassName()];
  88.             } elseif ($element instanceof DataObject\AbstractObject) {
  89.                 $return[] = [$element->getId(), $element->getRealFullPath(), DataObject::OBJECT_TYPE_OBJECT, DataObject::OBJECT_TYPE_VARIANT, DataObject::OBJECT_TYPE_FOLDER];
  90.             } elseif ($element instanceof Asset) {
  91.                 $return[] = [$element->getId(), $element->getRealFullPath(), 'asset', $element->getType()];
  92.             } elseif ($element instanceof Document) {
  93.                 $return[] = [$element->getId(), $element->getRealFullPath(), 'document', $element->getType()];
  94.             }
  95.         }
  97.         return $return;
  98.     }
  100.     public function frontend()
  101.     {
  102.         $this->setElements();
  103.         $return = '';
  105.         foreach ($this->getElements() as $element) {
  106.             if ($element instanceof Element\ElementInterface) {
  107.                 $return .= Element\Service::getElementType($element) . ': ' . $element->getFullPath() . '<br />';
  108.             }
  109.         }
  111.         return $return;
  112.     }
  114.     public function setDataFromResource(mixed $data): static
  115.     {
  116.         if ($data = \Pimcore\Tool\Serialize::unserialize($data)) {
  117.             $this->setDataFromEditmode($data);
  118.         }
  120.         return $this;
  121.     }
  123.     public function setDataFromEditmode(mixed $data): static
  124.     {
  125.         if (is_array($data)) {
  126.             $this->elementIds = $data;
  127.             $this->elements = [];
  128.         }
  130.         return $this;
  131.     }
  133.     /**
  134.      * @return Element\ElementInterface[]
  135.      */
  136.     public function getElements(): array
  137.     {
  138.         $this->setElements();
  140.         $elements = [];
  142.         foreach ($this->elements as $element) {
  143.             if (Element\Service::doHideUnpublished($element)) {
  144.                 if (Element\Service::isPublished($element)) {
  145.                     $elements[] = $element;
  146.                 }
  147.             } else {
  148.                 $elements[] = $element;
  149.             }
  150.         }
  152.         return $elements;
  153.     }
  155.     public function isEmpty(): bool
  156.     {
  157.         $this->setElements();
  159.         return count($this->elements) > 0 ? false : true;
  160.     }
  162.     public function resolveDependencies(): array
  163.     {
  164.         $this->setElements();
  165.         $dependencies = [];
  167.         foreach ($this->elements as $element) {
  168.             if ($element instanceof Element\ElementInterface) {
  169.                 $elementType = Element\Service::getElementType($element);
  170.                 $key = $elementType . '_' . $element->getId();
  172.                 $dependencies[$key] = [
  173.                     'id' => $element->getId(),
  174.                     'type' => $elementType,
  175.                 ];
  176.             }
  177.         }
  179.         return $dependencies;
  180.     }
  182.     public function rewriteIds(array $idMapping): void
  183.     {
  184.         // reset existing elements store
  185.         $this->elements = [];
  187.         foreach ($this->elementIds as &$elementId) {
  188.             $type = $elementId['type'];
  189.             $id = $elementId['id'];
  191.             if (array_key_exists($type, $idMapping) && array_key_exists((int) $id, $idMapping[$type])) {
  192.                 $elementId['id'] = $idMapping[$type][$id];
  193.             }
  194.         }
  196.         $this->setElements();
  197.     }
  199.     public function __sleep(): array
  200.     {
  201.         $finalVars = [];
  202.         $parentVars = parent::__sleep();
  203.         $blockedVars = ['elements'];
  204.         foreach ($parentVars as $key) {
  205.             if (!in_array($key, $blockedVars)) {
  206.                 $finalVars[] = $key;
  207.             }
  208.         }
  210.         return $finalVars;
  211.     }
  213.     public function load(): void
  214.     {
  215.         $this->setElements();
  216.     }
  218.     /**
  219.      * Methods for Iterator
  220.      */
  221.     public function rewind(): void
  222.     {
  223.         $this->setElements();
  224.         reset($this->elements);
  225.     }
  227.     public function current(): false|Element\ElementInterface
  228.     {
  229.         $this->setElements();
  231.         return current($this->elements);
  232.     }
  234.     public function key(): ?int
  235.     {
  236.         $this->setElements();
  238.         return key($this->elements);
  239.     }
  241.     public function next(): void
  242.     {
  243.         $this->setElements();
  244.         next($this->elements);
  245.     }
  247.     public function valid(): bool
  248.     {
  249.         $this->setElements();
  251.         $el = $this->current();
  252.         if (
  253.             $el instanceof Element\ElementInterface &&
  254.             Element\Service::doHideUnpublished($el) &&
  255.             !Element\Service::isPublished($el)
  256.         ) {
  257.             $this->next();
  258.         }
  260.         return $this->current() !== false;
  261.     }
  262. }