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

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Commercial License (PCL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  12.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  13.  */
  14. namespace Pimcore\Model\Document\Editable;
  15. use Pimcore\Logger;
  16. use Pimcore\Model;
  17. use Pimcore\Model\Asset;
  18. use Pimcore\Model\Document;
  19. use Pimcore\Model\Element;
  20. /**
  21.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  22.  */
  23. class Relation extends Model\Document\Editable
  24. {
  25.     /**
  26.      * ID of the source object
  27.      *
  28.      * @internal
  29.      *
  30.      * @var int|null
  31.      */
  32.     protected $id;
  33.     /**
  34.      * Type of the source object (document, asset, object)
  35.      *
  36.      * @internal
  37.      *
  38.      * @var string|null
  39.      */
  40.     protected $type;
  41.     /**
  42.      * Subtype of the source object (eg. page, link, video, news, ...)
  43.      *
  44.      * @internal
  45.      *
  46.      * @var string|null
  47.      */
  48.     protected $subtype;
  49.     /**
  50.      * Contains the source object
  51.      *
  52.      * @internal
  53.      *
  54.      * @var mixed
  55.      */
  56.     protected $element;
  57.     /**
  58.      * {@inheritdoc}
  59.      */
  60.     public function getType()
  61.     {
  62.         //TODO: getType != $type ... that might be dangerous
  63.         return 'relation';
  64.     }
  65.     /**
  66.      * {@inheritdoc}
  67.      */
  68.     public function getData()
  69.     {
  70.         return [
  71.             'id' => $this->id,
  72.             'type' => $this->type,
  73.             'subtype' => $this->subtype,
  74.         ];
  75.     }
  76.     /**
  77.      * Converts the data so it's suitable for the editmode
  78.      *
  79.      * @return array|null
  80.      */
  81.     public function getDataEditmode()
  82.     {
  83.         $this->setElement();
  84.         if ($this->element instanceof Element\ElementInterface) {
  85.             return [
  86.                 'id' => $this->id,
  87.                 'path' => $this->element->getRealFullPath(),
  88.                 'elementType' => $this->type,
  89.                 'subtype' => $this->subtype,
  90.             ];
  91.         }
  92.         return null;
  93.     }
  94.     /**
  95.      * {@inheritdoc}
  96.      */
  97.     public function frontend()
  98.     {
  99.         $this->setElement();
  100.         //don't give unpublished elements in frontend
  101.         if (Element\Service::doHideUnpublished($this->element) && !Element\Service::isPublished($this->element)) {
  102.             return '';
  103.         }
  104.         if ($this->element instanceof Element\ElementInterface) {
  105.             return $this->element->getFullPath();
  106.         }
  107.         return '';
  108.     }
  109.     /**
  110.      * {@inheritdoc}
  111.      */
  112.     public function setDataFromResource($data)
  113.     {
  114.         if (!empty($data)) {
  115.             $data \Pimcore\Tool\Serialize::unserialize($data);
  116.         }
  117.         $this->id $data['id'] ?? null;
  118.         $this->type $data['type'] ?? null;
  119.         $this->subtype $data['subtype'] ?? null;
  120.         $this->setElement();
  121.         return $this;
  122.     }
  123.     /**
  124.      * {@inheritdoc}
  125.      */
  126.     public function setDataFromEditmode($data)
  127.     {
  128.         $this->id $data['id'] ?? null;
  129.         $this->type $data['type'] ?? null;
  130.         $this->subtype $data['subtype'] ?? null;
  131.         $this->setElement();
  132.         return $this;
  133.     }
  134.     /**
  135.      * Sets the element by the data stored for the object
  136.      *
  137.      * @return $this
  138.      */
  139.     private function setElement()
  140.     {
  141.         if (!$this->element) {
  142.             $this->element Element\Service::getElementById($this->type$this->id);
  143.         }
  144.         return $this;
  145.     }
  146.     /**
  147.      * Returns one of them: Document, Object, Asset
  148.      *
  149.      * @return Element\ElementInterface|false|null
  150.      */
  151.     public function getElement()
  152.     {
  153.         $this->setElement();
  154.         //don't give unpublished elements in frontend
  155.         if (Element\Service::doHideUnpublished($this->element) && !Element\Service::isPublished($this->element)) {
  156.             return false;
  157.         }
  158.         return $this->element;
  159.     }
  160.     /**
  161.      * Returns the path of the linked element
  162.      *
  163.      * @return string|false|null
  164.      */
  165.     public function getFullPath()
  166.     {
  167.         $this->setElement();
  168.         //don't give unpublished elements in frontend
  169.         if (Element\Service::doHideUnpublished($this->element) && !Element\Service::isPublished($this->element)) {
  170.             return false;
  171.         }
  172.         if ($this->element instanceof Element\ElementInterface) {
  173.             return $this->element->getFullPath();
  174.         }
  175.         return null;
  176.     }
  177.     /**
  178.      * {@inheritdoc}
  179.      */
  180.     public function isEmpty()
  181.     {
  182.         $this->setElement();
  183.         if ($this->getElement() instanceof Element\ElementInterface) {
  184.             return false;
  185.         }
  186.         return true;
  187.     }
  188.     /**
  189.      * {@inheritdoc}
  190.      */
  191.     public function resolveDependencies()
  192.     {
  193.         $dependencies = [];
  194.         $this->setElement();
  195.         if ($this->element instanceof Element\ElementInterface) {
  196.             $elementType Element\Service::getElementType($this->element);
  197.             $key $elementType '_' $this->element->getId();
  198.             $dependencies[$key] = [
  199.                 'id' => $this->element->getId(),
  200.                 'type' => $elementType,
  201.             ];
  202.         }
  203.         return $dependencies;
  204.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      */
  208.     public function checkValidity()
  209.     {
  210.         $sane true;
  211.         if ($this->id) {
  212.             $el Element\Service::getElementById($this->type$this->id);
  213.             if (!$el instanceof Element\ElementInterface) {
  214.                 $sane false;
  215.                 Logger::notice('Detected insane relation, removing reference to non existent '.$this->type.' with id ['.$this->id.']');
  216.                 $this->id null;
  217.                 $this->type null;
  218.                 $this->subtype null;
  219.                 $this->element null;
  220.             }
  221.         }
  222.         return $sane;
  223.     }
  224.     /**
  225.      * {@inheritdoc}
  226.      */
  227.     public function __sleep()
  228.     {
  229.         $finalVars = [];
  230.         $parentVars parent::__sleep();
  231.         $blockedVars = ['element'];
  232.         foreach ($parentVars as $key) {
  233.             if (!in_array($key$blockedVars)) {
  234.                 $finalVars[] = $key;
  235.             }
  236.         }
  237.         return $finalVars;
  238.     }
  239.     /**
  240.      * this method is called by Document\Service::loadAllDocumentFields() to load all lazy loading fields
  241.      */
  242.     public function load()
  243.     {
  244.         if (!$this->element) {
  245.             $this->setElement();
  246.         }
  247.     }
  248.     /**
  249.      * @param int $id
  250.      *
  251.      * @return $this
  252.      */
  253.     public function setId($id)
  254.     {
  255.         $this->id $id;
  256.         return $this;
  257.     }
  258.     /**
  259.      * @return int
  260.      */
  261.     public function getId()
  262.     {
  263.         return (int) $this->id;
  264.     }
  265.     /**
  266.      * @param string $subtype
  267.      *
  268.      * @return $this
  269.      */
  270.     public function setSubtype($subtype)
  271.     {
  272.         $this->subtype $subtype;
  273.         return $this;
  274.     }
  275.     /**
  276.      * @return string
  277.      */
  278.     public function getSubtype()
  279.     {
  280.         return $this->subtype;
  281.     }
  282.     /**
  283.      * Rewrites id from source to target, $idMapping contains
  284.      * array(
  285.      *  "document" => array(
  286.      *      SOURCE_ID => TARGET_ID,
  287.      *      SOURCE_ID => TARGET_ID
  288.      *  ),
  289.      *  "object" => array(...),
  290.      *  "asset" => array(...)
  291.      * )
  292.      *
  293.      * @param array $idMapping
  294.      */
  295.     public function rewriteIds($idMapping)
  296.     {
  297.         if (array_key_exists($this->type$idMapping) && array_key_exists($this->getId(), $idMapping[$this->type])) {
  298.             $this->id $idMapping[$this->type][$this->getId()];
  299.         }
  300.     }
  301. }