src/Core/Framework/DataAbstractionLayer/Entity.php line 55

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer;
  5. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InternalFieldAccessNotAllowedException;
  6. use Shopware\Core\Framework\Log\Package;
  7. use Shopware\Core\Framework\Struct\ArrayEntity;
  8. use Shopware\Core\Framework\Struct\ArrayStruct;
  9. use Shopware\Core\Framework\Struct\Struct;
  11. #[Package('core')]
  12. class Entity extends Struct
  13. {
  14.     /**
  15.      * @var string
  16.      */
  17.     protected $_uniqueIdentifier;
  19.     /**
  20.      * @var string|null
  21.      */
  22.     protected $versionId;
  24.     /**
  25.      * @var array
  26.      */
  27.     protected $translated = [];
  29.     /**
  30.      * @var \DateTimeInterface|null
  31.      */
  32.     protected $createdAt;
  34.     /**
  35.      * @var \DateTimeInterface|null
  36.      */
  37.     protected $updatedAt;
  39.     /**
  40.      * @var string
  41.      */
  42.     private $_entityName;
  44.     private ?FieldVisibility $_fieldVisibility = null;
  46.     public function __get($name)
  47.     {
  48.         if (FieldVisibility::$isInTwigRenderingContext) {
  49.             $this->checkIfPropertyAccessIsAllowed($name);
  50.         }
  52.         return $this->$name;
  53.     }
  55.     public function __set($name, $value): void
  56.     {
  57.         $this->$name = $value;
  58.     }
  60.     public function __isset($name)
  61.     {
  62.         if (FieldVisibility::$isInTwigRenderingContext) {
  63.             if (!$this->isPropertyVisible($name)) {
  64.                 return false;
  65.             }
  66.         }
  68.         return isset($this->$name);
  69.     }
  71.     public function setUniqueIdentifier(string $identifier): void
  72.     {
  73.         $this->_uniqueIdentifier = $identifier;
  74.     }
  76.     public function getUniqueIdentifier(): string
  77.     {
  78.         return $this->_uniqueIdentifier;
  79.     }
  81.     public function getVersionId(): ?string
  82.     {
  83.         return $this->versionId;
  84.     }
  86.     public function setVersionId(string $versionId): void
  87.     {
  88.         $this->versionId = $versionId;
  89.     }
  91.     /**
  92.      * @return mixed|Struct|null
  93.      */
  94.     public function get(string $property)
  95.     {
  96.         if (FieldVisibility::$isInTwigRenderingContext) {
  97.             $this->checkIfPropertyAccessIsAllowed($property);
  98.         }
  100.         if ($this->has($property)) {
  101.             return $this->$property;
  102.         }
  104.         if ($this->hasExtension($property)) {
  105.             return $this->getExtension($property);
  106.         }
  108.         /** @var ArrayStruct<string, mixed>|null $extension */
  109.         $extension = $this->getExtension('foreignKeys');
  110.         if ($extension && $extension instanceof ArrayStruct && $extension->has($property)) {
  111.             return $extension->get($property);
  112.         }
  114.         throw new \InvalidArgumentException(
  115.             sprintf('Property %s do not exist in class %s', $property, static::class)
  116.         );
  117.     }
  119.     public function has(string $property): bool
  120.     {
  121.         if (FieldVisibility::$isInTwigRenderingContext) {
  122.             if (!$this->isPropertyVisible($property)) {
  123.                 return false;
  124.             }
  125.         }
  127.         return property_exists($this, $property);
  128.     }
  130.     public function getTranslated(): array
  131.     {
  132.         return $this->translated;
  133.     }
  135.     /**
  136.      * @return mixed|null
  137.      */
  138.     public function getTranslation(string $field)
  139.     {
  140.         return $this->translated[$field] ?? null;
  141.     }
  143.     public function setTranslated(array $translated): void
  144.     {
  145.         $this->translated = $translated;
  146.     }
  148.     public function addTranslated(string $key, mixed $value): void
  149.     {
  150.         $this->translated[$key] = $value;
  151.     }
  153.     public function getCreatedAt(): ?\DateTimeInterface
  154.     {
  155.         return $this->createdAt;
  156.     }
  158.     public function setCreatedAt(\DateTimeInterface $createdAt): void
  159.     {
  160.         $this->createdAt = $createdAt;
  161.     }
  163.     public function getUpdatedAt(): ?\DateTimeInterface
  164.     {
  165.         return $this->updatedAt;
  166.     }
  168.     public function setUpdatedAt(\DateTimeInterface $updatedAt): void
  169.     {
  170.         $this->updatedAt = $updatedAt;
  171.     }
  173.     /**
  174.      * @return array<mixed>
  175.      */
  176.     public function jsonSerialize(): array
  177.     {
  178.         $data = parent::jsonSerialize();
  180.         unset($data['_entityName']);
  181.         unset($data['_fieldVisibility']);
  183.         $data = $this->filterInvisibleFields($data);
  185.         if (!$this->hasExtension('foreignKeys')) {
  186.             return $data;
  187.         }
  189.         $extension = $this->getExtension('foreignKeys');
  191.         if (!$extension instanceof ArrayEntity) {
  192.             return $data;
  193.         }
  195.         foreach ($extension->all() as $key => $value) {
  196.             if (\array_key_exists($key, $data)) {
  197.                 continue;
  198.             }
  199.             $data[$key] = $value;
  200.         }
  202.         return $data;
  203.     }
  205.     public function getVars(): array
  206.     {
  207.         $data = parent::getVars();
  209.         return $this->filterInvisibleFields($data);
  210.     }
  212.     public function getApiAlias(): string
  213.     {
  214.         if ($this->_entityName !== null) {
  215.             return $this->_entityName;
  216.         }
  218.         $class = static::class;
  219.         $class = explode('\\', $class);
  220.         $class = end($class);
  222.         /** @var string $entityName */
  223.         $entityName = preg_replace(
  224.             '/_entity$/',
  225.             '',
  226.             ltrim(mb_strtolower((string) preg_replace('/[A-Z]/', '_$0', $class)), '_')
  227.         );
  229.         $this->_entityName = $entityName;
  231.         return $entityName;
  232.     }
  234.     /**
  235.      * @internal
  236.      */
  237.     public function internalSetEntityData(string $entityName, FieldVisibility $fieldVisibility): self
  238.     {
  239.         $this->_entityName = $entityName;
  240.         $this->_fieldVisibility = $fieldVisibility;
  242.         return $this;
  243.     }
  245.     /**
  246.      * @internal
  247.      */
  248.     public function getInternalEntityName(): ?string
  249.     {
  250.         return $this->_entityName;
  251.     }
  253.     /**
  254.      * @internal
  255.      */
  256.     protected function filterInvisibleFields(array $data): array
  257.     {
  258.         if (!$this->_fieldVisibility) {
  259.             return $data;
  260.         }
  262.         return $this->_fieldVisibility->filterInvisible($data);
  263.     }
  265.     /**
  266.      * @internal
  267.      */
  268.     protected function checkIfPropertyAccessIsAllowed(string $property): void
  269.     {
  270.         if (!$this->isPropertyVisible($property)) {
  271.             throw new InternalFieldAccessNotAllowedException($property, $this);
  272.         }
  273.     }
  275.     /**
  276.      * @internal
  277.      */
  278.     protected function isPropertyVisible(string $property): bool
  279.     {
  280.         if (!$this->_fieldVisibility) {
  281.             return true;
  282.         }
  284.         return $this->_fieldVisibility->isVisible($property);
  285.     }
  286. }