vendor/pimcore/pimcore/models/Document/Editable/Relation.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\Logger;
  20. use Pimcore\Model;
  21. use Pimcore\Model\Asset;
  22. use Pimcore\Model\Document;
  23. use Pimcore\Model\Element;
  25. /**
  26.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  27.  */
  28. class Relation extends Model\Document\Editable implements IdRewriterInterface, EditmodeDataInterface, LazyLoadingInterface
  29. {
  30.     /**
  31.      * ID of the source object
  32.      *
  33.      * @internal
  34.      *
  35.      */
  36.     protected ?int $id = null;
  38.     /**
  39.      * Type of the source object (document, asset, object)
  40.      *
  41.      * @internal
  42.      *
  43.      */
  44.     protected ?string $type = null;
  46.     /**
  47.      * Subtype of the source object (eg. page, link, video, news, ...)
  48.      *
  49.      * @internal
  50.      *
  51.      */
  52.     protected ?string $subtype = null;
  54.     /**
  55.      * Contains the source object
  56.      *
  57.      * @internal
  58.      *
  59.      */
  60.     protected mixed $element = null;
  62.     public function getType(): string
  63.     {
  64.         //TODO: getType != $type ... that might be dangerous
  65.         return 'relation';
  66.     }
  68.     public function getData(): mixed
  69.     {
  70.         return [
  71.             'id' => $this->id,
  72.             'type' => $this->type,
  73.             'subtype' => $this->subtype,
  74.         ];
  75.     }
  77.     public function getDataEditmode(): ?array
  78.     {
  79.         $this->setElement();
  81.         if ($this->element instanceof Element\ElementInterface) {
  82.             return [
  83.                 'id' => $this->id,
  84.                 'path' => $this->element->getRealFullPath(),
  85.                 'elementType' => $this->type,
  86.                 'subtype' => $this->subtype,
  87.             ];
  88.         }
  90.         return null;
  91.     }
  93.     public function frontend()
  94.     {
  95.         $this->setElement();
  97.         //don't give unpublished elements in frontend
  98.         if (Element\Service::doHideUnpublished($this->element) && !Element\Service::isPublished($this->element)) {
  99.             return '';
  100.         }
  102.         if ($this->element instanceof Element\ElementInterface) {
  103.             return $this->element->getFullPath();
  104.         }
  106.         return '';
  107.     }
  109.     public function setDataFromResource(mixed $data): static
  110.     {
  111.         if (!empty($data)) {
  112.             $data = \Pimcore\Tool\Serialize::unserialize($data);
  113.         }
  115.         $this->id = $data['id'] ?? null;
  116.         $this->type = $data['type'] ?? null;
  117.         $this->subtype = $data['subtype'] ?? null;
  119.         $this->setElement();
  121.         return $this;
  122.     }
  124.     public function setDataFromEditmode(mixed $data): static
  125.     {
  126.         $this->id = $data['id'] ?? null;
  127.         $this->type = $data['type'] ?? null;
  128.         $this->subtype = $data['subtype'] ?? null;
  130.         $this->setElement();
  132.         return $this;
  133.     }
  135.     /**
  136.      * Sets the element by the data stored for the object
  137.      *
  138.      * @return $this
  139.      */
  140.     private function setElement(): static
  141.     {
  142.         if (!$this->element && $this->type && $this->id) {
  143.             $this->element = Element\Service::getElementById($this->type, $this->id);
  144.         }
  146.         return $this;
  147.     }
  149.     /**
  150.      * Returns one of them: Document, Object, Asset
  151.      *
  152.      * @return Element\ElementInterface|false|null
  153.      */
  154.     public function getElement(): bool|Element\ElementInterface|null
  155.     {
  156.         $this->setElement();
  158.         //don't give unpublished elements in frontend
  159.         if (Element\Service::doHideUnpublished($this->element) && !Element\Service::isPublished($this->element)) {
  160.             return false;
  161.         }
  163.         return $this->element;
  164.     }
  166.     /**
  167.      * Returns the path of the linked element
  168.      *
  169.      * @return string|false|null
  170.      */
  171.     public function getFullPath(): bool|string|null
  172.     {
  173.         $this->setElement();
  175.         //don't give unpublished elements in frontend
  176.         if (Element\Service::doHideUnpublished($this->element) && !Element\Service::isPublished($this->element)) {
  177.             return false;
  178.         }
  179.         if ($this->element instanceof Element\ElementInterface) {
  180.             return $this->element->getFullPath();
  181.         }
  183.         return null;
  184.     }
  186.     public function isEmpty(): bool
  187.     {
  188.         $this->setElement();
  190.         if ($this->getElement() instanceof Element\ElementInterface) {
  191.             return false;
  192.         }
  194.         return true;
  195.     }
  197.     public function resolveDependencies(): array
  198.     {
  199.         $dependencies = [];
  200.         $this->setElement();
  202.         if ($this->element instanceof Element\ElementInterface) {
  203.             $elementType = Element\Service::getElementType($this->element);
  204.             $key = $elementType . '_' . $this->element->getId();
  205.             $dependencies[$key] = [
  206.                 'id' => $this->element->getId(),
  207.                 'type' => $elementType,
  208.             ];
  209.         }
  211.         return $dependencies;
  212.     }
  214.     public function checkValidity(): bool
  215.     {
  216.         $sane = true;
  217.         if ($this->id) {
  218.             $el = Element\Service::getElementById($this->type, $this->id);
  219.             if (!$el instanceof Element\ElementInterface) {
  220.                 $sane = false;
  221.                 Logger::notice('Detected insane relation, removing reference to non existent '.$this->type.' with id ['.$this->id.']');
  222.                 $this->id = null;
  223.                 $this->type = null;
  224.                 $this->subtype = null;
  225.                 $this->element = null;
  226.             }
  227.         }
  229.         return $sane;
  230.     }
  232.     public function __sleep(): array
  233.     {
  234.         $finalVars = [];
  235.         $parentVars = parent::__sleep();
  236.         $blockedVars = ['element'];
  237.         foreach ($parentVars as $key) {
  238.             if (!in_array($key, $blockedVars)) {
  239.                 $finalVars[] = $key;
  240.             }
  241.         }
  243.         return $finalVars;
  244.     }
  246.     public function load(): void
  247.     {
  248.         if (!$this->element) {
  249.             $this->setElement();
  250.         }
  251.     }
  253.     public function setId(int $id): static
  254.     {
  255.         $this->id = $id;
  257.         return $this;
  258.     }
  260.     public function getId(): int
  261.     {
  262.         return (int) $this->id;
  263.     }
  265.     public function setSubtype(string $subtype): static
  266.     {
  267.         $this->subtype = $subtype;
  269.         return $this;
  270.     }
  272.     public function getSubtype(): ?string
  273.     {
  274.         return $this->subtype;
  275.     }
  277.     public function rewriteIds(array $idMapping): void
  278.     {
  279.         if (array_key_exists($this->type, $idMapping) && array_key_exists($this->getId(), $idMapping[$this->type])) {
  280.             $this->id = $idMapping[$this->type][$this->getId()];
  281.         }
  282.     }
  283. }