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