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

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;
  15. use Pimcore\Model\Element\ElementInterface;
  16. use Pimcore\Model\Element\Service;
  17. /**
  18.  * @method \Pimcore\Model\Property\Dao getDao()
  19.  * @method void save()
  20.  */
  21. final class Property extends AbstractModel
  22. {
  23.     /**
  24.      * @var string
  25.      */
  26.     protected $name;
  27.     /**
  28.      * @var mixed
  29.      */
  30.     protected $data;
  31.     /**
  32.      * @var string
  33.      */
  34.     protected $type;
  35.     /**
  36.      * @var string
  37.      */
  38.     protected $ctype;
  39.     /**
  40.      * @var string
  41.      */
  42.     protected $cpath;
  43.     /**
  44.      * @var int
  45.      */
  46.     protected $cid;
  47.     /**
  48.      * @var bool
  49.      */
  50.     protected $inheritable;
  51.     /**
  52.      * @var bool
  53.      */
  54.     protected $inherited false;
  55.     /**
  56.      * @internal
  57.      *
  58.      * @param mixed $data
  59.      *
  60.      * @return $this
  61.      */
  62.     public function setDataFromEditmode($data)
  63.     {
  64.         // IMPORTANT: if you use this method be sure that the type of the property is already set
  65.         if (in_array($this->getType(), ['document''asset''object'])) {
  66.             $el Element\Service::getElementByPath($this->getType(), $data);
  67.             $this->data null;
  68.             if ($el) {
  69.                 $this->data $el->getId();
  70.             }
  71.         } elseif ($this->type == 'bool') {
  72.             $this->data false;
  73.             if (!empty($data)) {
  74.                 $this->data true;
  75.             }
  76.         } else {
  77.             // plain text
  78.             $this->data $data;
  79.         }
  80.         return $this;
  81.     }
  82.     /**
  83.      * @internal
  84.      *
  85.      * @param mixed $data
  86.      *
  87.      * @return static
  88.      */
  89.     public function setDataFromResource($data)
  90.     {
  91.         // IMPORTANT: if you use this method be sure that the type of the property is already set
  92.         // do not set data for object, asset and document here, this is loaded dynamically when calling $this->getData();
  93.         if ($this->type == 'date') {
  94.             $this->data \Pimcore\Tool\Serialize::unserialize($data);
  95.         } elseif ($this->type == 'bool') {
  96.             $this->data false;
  97.             if (!empty($data)) {
  98.                 $this->data true;
  99.             }
  100.         } else {
  101.             // plain text
  102.             $this->data $data;
  103.         }
  104.         return $this;
  105.     }
  106.     /**
  107.      * @return int
  108.      */
  109.     public function getCid()
  110.     {
  111.         return $this->cid;
  112.     }
  113.     /**
  114.      * @return string
  115.      */
  116.     public function getCtype()
  117.     {
  118.         return $this->ctype;
  119.     }
  120.     /**
  121.      * @return mixed
  122.      */
  123.     public function getData()
  124.     {
  125.         // lazy-load data of type asset, document, object
  126.         if (in_array($this->getType(), ['document''asset''object']) && !$this->data instanceof ElementInterface && is_numeric($this->data)) {
  127.             return Element\Service::getElementById($this->getType(), $this->data);
  128.         }
  129.         return $this->data;
  130.     }
  131.     /**
  132.      * @return string
  133.      */
  134.     public function getName()
  135.     {
  136.         return $this->name;
  137.     }
  138.     /**
  139.      * @return string
  140.      */
  141.     public function getType()
  142.     {
  143.         return $this->type;
  144.     }
  145.     /**
  146.      * @param int $cid
  147.      *
  148.      * @return static
  149.      */
  150.     public function setCid($cid)
  151.     {
  152.         $this->cid = (int) $cid;
  153.         return $this;
  154.     }
  155.     /**
  156.      * @param string $ctype
  157.      *
  158.      * @return static
  159.      */
  160.     public function setCtype($ctype)
  161.     {
  162.         $this->ctype $ctype;
  163.         return $this;
  164.     }
  165.     /**
  166.      * @param mixed $data
  167.      *
  168.      * @return static
  169.      */
  170.     public function setData($data)
  171.     {
  172.         if ($data instanceof ElementInterface) {
  173.             $this->setType(Service::getElementType($data));
  174.             $data $data->getId();
  175.         }
  176.         $this->data $data;
  177.         return $this;
  178.     }
  179.     /**
  180.      * @param string $name
  181.      *
  182.      * @return static
  183.      */
  184.     public function setName($name)
  185.     {
  186.         $this->name $name;
  187.         return $this;
  188.     }
  189.     /**
  190.      * @param string $type
  191.      *
  192.      * @return static
  193.      */
  194.     public function setType($type)
  195.     {
  196.         $this->type $type;
  197.         return $this;
  198.     }
  199.     /**
  200.      * @return string
  201.      */
  202.     public function getCpath()
  203.     {
  204.         return $this->cpath;
  205.     }
  206.     /**
  207.      * @return bool
  208.      */
  209.     public function getInherited()
  210.     {
  211.         return $this->inherited;
  212.     }
  213.     /**
  214.      * Alias for getInherited()
  215.      *
  216.      * @return bool
  217.      */
  218.     public function isInherited()
  219.     {
  220.         return $this->getInherited();
  221.     }
  222.     /**
  223.      * @param string $cpath
  224.      *
  225.      * @return static
  226.      */
  227.     public function setCpath($cpath)
  228.     {
  229.         $this->cpath $cpath;
  230.         return $this;
  231.     }
  232.     /**
  233.      * @param bool $inherited
  234.      *
  235.      * @return static
  236.      */
  237.     public function setInherited($inherited)
  238.     {
  239.         $this->inherited = (bool) $inherited;
  240.         return $this;
  241.     }
  242.     /**
  243.      * @return bool
  244.      */
  245.     public function getInheritable()
  246.     {
  247.         return $this->inheritable;
  248.     }
  249.     /**
  250.      * @param bool $inheritable
  251.      *
  252.      * @return static
  253.      */
  254.     public function setInheritable($inheritable)
  255.     {
  256.         $this->inheritable = (bool) $inheritable;
  257.         return $this;
  258.     }
  259.     /**
  260.      * @internal
  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.      * @internal
  289.      *
  290.      * @param array $idMapping
  291.      */
  292.     public function rewriteIds($idMapping)
  293.     {
  294.         if (!$this->isInherited()) {
  295.             if (array_key_exists($this->getType(), $idMapping)) {
  296.                 if ($this->getData() instanceof ElementInterface) {
  297.                     if (array_key_exists((int) $this->getData()->getId(), $idMapping[$this->getType()])) {
  298.                         $this->setData(Element\Service::getElementById($this->getType(), $idMapping[$this->getType()][$this->getData()->getId()]));
  299.                     }
  300.                 }
  301.             }
  302.         }
  303.     }
  304.     /**
  305.      * @internal
  306.      *
  307.      * @return array
  308.      */
  309.     public function serialize()
  310.     {
  311.         return [
  312.           'name' => $this->getName(),
  313.           'type' => $this->getType(),
  314.           'data' => $this->getData(),
  315.         ];
  316.     }
  317. }