vendor/pimcore/pimcore/models/Property.php line 26

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 Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @category   Pimcore
  12.  * @package    Property
  13.  *
  14.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  15.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  16.  */
  17. namespace Pimcore\Model;
  18. use Pimcore\Model\Element\ElementInterface;
  19. use Pimcore\Model\Element\Service;
  20. /**
  21.  * @method \Pimcore\Model\Property\Dao getDao()
  22.  */
  23. class Property extends AbstractModel
  24. {
  25.     /**
  26.      * @var string
  27.      */
  28.     protected $name;
  29.     /**
  30.      * @var mixed
  31.      */
  32.     protected $data;
  33.     /**
  34.      * @var string
  35.      */
  36.     protected $type;
  37.     /**
  38.      * @var string
  39.      */
  40.     protected $ctype;
  41.     /**
  42.      * @var string
  43.      */
  44.     protected $cpath;
  45.     /**
  46.      * @var int
  47.      */
  48.     protected $cid;
  49.     /**
  50.      * @var bool
  51.      */
  52.     protected $inheritable;
  53.     /**
  54.      * @var bool
  55.      */
  56.     protected $inherited false;
  57.     /**
  58.      * Takes data from editmode and convert it to internal objects
  59.      *
  60.      * @param mixed $data
  61.      *
  62.      * @return $this
  63.      */
  64.     public function setDataFromEditmode($data)
  65.     {
  66.         // IMPORTANT: if you use this method be sure that the type of the property is already set
  67.         if (in_array($this->getType(), ['document''asset''object'])) {
  68.             $el Element\Service::getElementByPath($this->getType(), $data);
  69.             $this->data null;
  70.             if ($el) {
  71.                 $this->data $el->getId();
  72.             }
  73.         } elseif ($this->type == 'bool') {
  74.             $this->data false;
  75.             if (!empty($data)) {
  76.                 $this->data true;
  77.             }
  78.         } else {
  79.             // plain text
  80.             $this->data $data;
  81.         }
  82.         return $this;
  83.     }
  84.     /**
  85.      * Takes data from resource and convert it to internal objects
  86.      *
  87.      * @param mixed $data
  88.      *
  89.      * @return static
  90.      */
  91.     public function setDataFromResource($data)
  92.     {
  93.         // IMPORTANT: if you use this method be sure that the type of the property is already set
  94.         // do not set data for object, asset and document here, this is loaded dynamically when calling $this->getData();
  95.         if ($this->type == 'date') {
  96.             $this->data = \Pimcore\Tool\Serialize::unserialize($data);
  97.         } elseif ($this->type == 'bool') {
  98.             $this->data false;
  99.             if (!empty($data)) {
  100.                 $this->data true;
  101.             }
  102.         } else {
  103.             // plain text
  104.             $this->data $data;
  105.         }
  106.         return $this;
  107.     }
  108.     /**
  109.      * @return int
  110.      */
  111.     public function getCid()
  112.     {
  113.         return $this->cid;
  114.     }
  115.     /**
  116.      * @return string
  117.      */
  118.     public function getCtype()
  119.     {
  120.         return $this->ctype;
  121.     }
  122.     /**
  123.      * @return mixed
  124.      */
  125.     public function getData()
  126.     {
  127.         // lazy-load data of type asset, document, object
  128.         if (in_array($this->getType(), ['document''asset''object']) && !$this->data instanceof ElementInterface && is_numeric($this->data)) {
  129.             return Element\Service::getElementById($this->getType(), $this->data);
  130.         }
  131.         return $this->data;
  132.     }
  133.     /**
  134.      * @return string
  135.      */
  136.     public function getName()
  137.     {
  138.         return $this->name;
  139.     }
  140.     /**
  141.      * @return string
  142.      */
  143.     public function getType()
  144.     {
  145.         return $this->type;
  146.     }
  147.     /**
  148.      * @param int $cid
  149.      *
  150.      * @return static
  151.      */
  152.     public function setCid($cid)
  153.     {
  154.         $this->cid = (int) $cid;
  155.         return $this;
  156.     }
  157.     /**
  158.      * @param string $ctype
  159.      *
  160.      * @return static
  161.      */
  162.     public function setCtype($ctype)
  163.     {
  164.         $this->ctype $ctype;
  165.         return $this;
  166.     }
  167.     /**
  168.      * @param mixed $data
  169.      *
  170.      * @return static
  171.      */
  172.     public function setData($data)
  173.     {
  174.         if ($data instanceof ElementInterface) {
  175.             $this->setType(Service::getElementType($data));
  176.             $data $data->getId();
  177.         }
  178.         $this->data $data;
  179.         return $this;
  180.     }
  181.     /**
  182.      * @param string $name
  183.      *
  184.      * @return static
  185.      */
  186.     public function setName($name)
  187.     {
  188.         $this->name $name;
  189.         return $this;
  190.     }
  191.     /**
  192.      * @param string $type
  193.      *
  194.      * @return static
  195.      */
  196.     public function setType($type)
  197.     {
  198.         $this->type $type;
  199.         return $this;
  200.     }
  201.     /**
  202.      * @return string
  203.      */
  204.     public function getCpath()
  205.     {
  206.         return $this->cpath;
  207.     }
  208.     /**
  209.      * @return bool
  210.      */
  211.     public function getInherited()
  212.     {
  213.         return $this->inherited;
  214.     }
  215.     /**
  216.      * Alias for getInherited()
  217.      *
  218.      * @return bool
  219.      */
  220.     public function isInherited()
  221.     {
  222.         return $this->getInherited();
  223.     }
  224.     /**
  225.      * @param string $cpath
  226.      *
  227.      * @return static
  228.      */
  229.     public function setCpath($cpath)
  230.     {
  231.         $this->cpath $cpath;
  232.         return $this;
  233.     }
  234.     /**
  235.      * @param bool $inherited
  236.      *
  237.      * @return static
  238.      */
  239.     public function setInherited($inherited)
  240.     {
  241.         $this->inherited = (bool) $inherited;
  242.         return $this;
  243.     }
  244.     /**
  245.      * @return bool
  246.      */
  247.     public function getInheritable()
  248.     {
  249.         return $this->inheritable;
  250.     }
  251.     /**
  252.      * @param bool $inheritable
  253.      *
  254.      * @return static
  255.      */
  256.     public function setInheritable($inheritable)
  257.     {
  258.         $this->inheritable = (bool) $inheritable;
  259.         return $this;
  260.     }
  261.     /**
  262.      * @return array
  263.      */
  264.     public function resolveDependencies()
  265.     {
  266.         $dependencies = [];
  267.         if ($this->getData() instanceof ElementInterface) {
  268.             $elementType Element\Service::getElementType($this->getData());
  269.             $key $elementType '_' $this->getData()->getId();
  270.             $dependencies[$key] = [
  271.                 'id' => $this->getData()->getId(),
  272.                 'type' => $elementType
  273.             ];
  274.         }
  275.         return $dependencies;
  276.     }
  277.     /**
  278.      * Rewrites id from source to target, $idMapping contains
  279.      * array(
  280.      *  "document" => array(
  281.      *      SOURCE_ID => TARGET_ID,
  282.      *      SOURCE_ID => TARGET_ID
  283.      *  ),
  284.      *  "object" => array(...),
  285.      *  "asset" => array(...)
  286.      * )
  287.      *
  288.      * @param array $idMapping
  289.      */
  290.     public function rewriteIds($idMapping)
  291.     {
  292.         if (!$this->isInherited()) {
  293.             if (array_key_exists($this->getType(), $idMapping)) {
  294.                 if ($this->getData() instanceof ElementInterface) {
  295.                     if (array_key_exists((int) $this->getData()->getId(), $idMapping[$this->getType()])) {
  296.                         $this->setData(Element\Service::getElementById($this->getType(), $idMapping[$this->getType()][$this->getData()->getId()]));
  297.                     }
  298.                 }
  299.             }
  300.         }
  301.     }
  302. }