vendor/easycorp/easyadmin-bundle/src/Dto/EntityDto.php line 20

  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Dto;
  5. use Doctrine\ORM\Mapping\ClassMetadata;
  6. use Doctrine\ORM\Mapping\FieldMapping;
  7. use Doctrine\ORM\Mapping\ManyToManyAssociationMapping;
  8. use Doctrine\ORM\Mapping\ManyToOneAssociationMapping;
  9. use Doctrine\ORM\Mapping\OneToManyAssociationMapping;
  10. use Doctrine\ORM\Mapping\OneToOneAssociationMapping;
  11. use EasyCorp\Bundle\EasyAdminBundle\Collection\ActionCollection;
  12. use EasyCorp\Bundle\EasyAdminBundle\Collection\FieldCollection;
  13. use EasyCorp\Bundle\EasyAdminBundle\Config\KeyValueStore;
  14. use Symfony\Component\ExpressionLanguage\Expression;
  15. use Symfony\Component\PropertyAccess\PropertyAccess;
  17. /**
  18.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  19.  */
  20. final class EntityDto
  21. {
  22.     private bool $isAccessible = true;
  23.     private string $fqcn;
  24.     private ClassMetadata $metadata;
  25.     private $instance;
  26.     private $primaryKeyName;
  27.     private mixed $primaryKeyValue = null;
  28.     private string|Expression|null $permission;
  29.     private ?FieldCollection $fields = null;
  30.     private ?ActionCollection $actions = null;
  32.     public function __construct(string $entityFqcn, ClassMetadata $entityMetadata, string|Expression|null $entityPermission = null, /* ?object */ $entityInstance = null)
  33.     {
  34.         if (!\is_object($entityInstance)
  35.             && null !== $entityInstance) {
  36.             trigger_deprecation(
  37.                 'easycorp/easyadmin-bundle',
  38.                 '4.0.5',
  39.                 'Argument "%s" for "%s" must be one of these types: %s. Passing type "%s" will cause an error in 5.0.0.',
  40.                 '$entityInstance',
  41.                 __METHOD__,
  42.                 '"object" or "null"',
  43.                 \gettype($entityInstance)
  44.             );
  45.         }
  47.         $this->fqcn = $entityFqcn;
  48.         $this->metadata = $entityMetadata;
  49.         $this->instance = $entityInstance;
  50.         $this->primaryKeyName = $this->metadata->getIdentifierFieldNames()[0];
  51.         $this->permission = $entityPermission;
  52.     }
  54.     public function __toString(): string
  55.     {
  56.         return $this->toString();
  57.     }
  59.     public function getFqcn(): string
  60.     {
  61.         return $this->fqcn;
  62.     }
  64.     public function getName(): string
  65.     {
  66.         return basename(str_replace('\\', '/', $this->fqcn));
  67.     }
  69.     public function toString(): string
  70.     {
  71.         if (null === $this->instance) {
  72.             return '';
  73.         }
  75.         if (method_exists($this->instance, '__toString')) {
  76.             return (string) $this->instance;
  77.         }
  79.         return sprintf('%s #%s', $this->getName(), substr($this->getPrimaryKeyValueAsString(), 0, 16));
  80.     }
  82.     public function getInstance()/* : ?object */
  83.     {
  84.         return $this->instance;
  85.     }
  87.     public function getPrimaryKeyName(): ?string
  88.     {
  89.         return $this->primaryKeyName;
  90.     }
  92.     public function getPrimaryKeyValue(): mixed
  93.     {
  94.         if (null === $this->instance) {
  95.             return null;
  96.         }
  98.         if (null !== $this->primaryKeyValue) {
  99.             return $this->primaryKeyValue;
  100.         }
  102.         $propertyAccessor = PropertyAccess::createPropertyAccessorBuilder()
  103.             ->enableExceptionOnInvalidIndex()
  104.             ->getPropertyAccessor();
  106.         $primaryKeyValue = $propertyAccessor->getValue($this->instance, $this->primaryKeyName);
  108.         return $this->primaryKeyValue = $primaryKeyValue;
  109.     }
  111.     public function getPrimaryKeyValueAsString(): string
  112.     {
  113.         return (string) $this->getPrimaryKeyValue();
  114.     }
  116.     public function getPermission(): string|Expression|null
  117.     {
  118.         return $this->permission;
  119.     }
  121.     public function isAccessible(): bool
  122.     {
  123.         return $this->isAccessible;
  124.     }
  126.     public function markAsInaccessible(): void
  127.     {
  128.         $this->isAccessible = false;
  129.         $this->instance = null;
  130.         $this->fields = null;
  131.     }
  133.     public function getFields(): ?FieldCollection
  134.     {
  135.         return $this->fields;
  136.     }
  138.     public function setFields(FieldCollection $fields): void
  139.     {
  140.         $this->fields = $fields;
  141.     }
  143.     public function setActions(ActionCollection $actions): void
  144.     {
  145.         $this->actions = $actions;
  146.     }
  148.     public function getActions(): ActionCollection
  149.     {
  150.         return $this->actions;
  151.     }
  153.     /**
  154.      * Returns the names of all properties defined in the entity, no matter
  155.      * if they are used or not in the application.
  156.      */
  157.     public function getAllPropertyNames(): array
  158.     {
  159.         return $this->metadata->getFieldNames();
  160.     }
  162.     public function getPropertyMetadata(string $propertyName): KeyValueStore
  163.     {
  164.         if (\array_key_exists($propertyName, $this->metadata->fieldMappings)) {
  165.             /** @var FieldMapping|array $fieldMapping */
  166.             $fieldMapping = $this->metadata->fieldMappings[$propertyName];
  167.             // Doctrine ORM 2.x returns an array and Doctrine ORM 3.x returns a FieldMapping object
  168.             if ($fieldMapping instanceof FieldMapping) {
  169.                 $fieldMapping = (array) $fieldMapping;
  170.             }
  172.             return KeyValueStore::new($fieldMapping);
  173.         }
  175.         if (\array_key_exists($propertyName, $this->metadata->associationMappings)) {
  176.             /** @var OneToOneAssociationMapping|OneToManyAssociationMapping|ManyToOneAssociationMapping|ManyToManyAssociationMapping|array $associationMapping */
  177.             $associationMapping = $this->metadata->associationMappings[$propertyName];
  178.             // Doctrine ORM 2.x returns an array and Doctrine ORM 3.x returns one of the many *Mapping objects
  179.             // there's not a single interface implemented by all of them, so let's only check if it's an object
  180.             if (\is_object($associationMapping)) {
  181.                 // Doctrine ORM 3.x doesn't include the 'type' key that tells the type of association
  182.                 // recreate that key to keep the code compatible with both versions
  183.                 $associationType = match (true) {
  184.                     $associationMapping instanceof OneToOneAssociationMapping => ClassMetadata::ONE_TO_ONE,
  185.                     $associationMapping instanceof OneToManyAssociationMapping => ClassMetadata::ONE_TO_MANY,
  186.                     $associationMapping instanceof ManyToOneAssociationMapping => ClassMetadata::MANY_TO_ONE,
  187.                     $associationMapping instanceof ManyToManyAssociationMapping => ClassMetadata::MANY_TO_MANY,
  188.                     default => null,
  189.                 };
  191.                 $associationMapping = (array) $associationMapping;
  192.                 $associationMapping['type'] = $associationType;
  193.             }
  195.             return KeyValueStore::new($associationMapping);
  196.         }
  198.         throw new \InvalidArgumentException(sprintf('The "%s" field does not exist in the "%s" entity.', $propertyName, $this->getFqcn()));
  199.     }
  201.     public function getPropertyDataType(string $propertyName)
  202.     {
  203.         return $this->getPropertyMetadata($propertyName)->get('type');
  204.     }
  206.     public function hasProperty(string $propertyName): bool
  207.     {
  208.         return \array_key_exists($propertyName, $this->metadata->fieldMappings)
  209.             || \array_key_exists($propertyName, $this->metadata->associationMappings);
  210.     }
  212.     public function isAssociation(string $propertyName): bool
  213.     {
  214.         return \array_key_exists($propertyName, $this->metadata->associationMappings)
  215.             || (str_contains($propertyName, '.') && !$this->isEmbeddedClassProperty($propertyName));
  216.     }
  218.     public function isToOneAssociation(string $propertyName): bool
  219.     {
  220.         $associationType = $this->getPropertyMetadata($propertyName)->get('type');
  222.         return \in_array($associationType, [ClassMetadata::ONE_TO_ONE, ClassMetadata::MANY_TO_ONE], true);
  223.     }
  225.     public function isToManyAssociation(string $propertyName): bool
  226.     {
  227.         $associationType = $this->getPropertyMetadata($propertyName)->get('type');
  229.         return \in_array($associationType, [ClassMetadata::ONE_TO_MANY, ClassMetadata::MANY_TO_MANY], true);
  230.     }
  232.     public function isEmbeddedClassProperty(string $propertyName): bool
  233.     {
  234.         $propertyNameParts = explode('.', $propertyName, 2);
  236.         return \array_key_exists($propertyNameParts[0], $this->metadata->embeddedClasses);
  237.     }
  239.     public function setInstance(?object $newEntityInstance): void
  240.     {
  241.         if (null !== $this->instance && null !== $newEntityInstance && !$newEntityInstance instanceof $this->fqcn) {
  242.             throw new \InvalidArgumentException(sprintf('The new entity instance must be of the same type as the previous instance (original instance: "%s", new instance: "%s").', $this->fqcn, $newEntityInstance::class));
  243.         }
  245.         $this->instance = $newEntityInstance;
  246.         $this->primaryKeyValue = null;
  247.     }
  249.     public function newWithInstance(/* object */ $newEntityInstance): self
  250.     {
  251.         if (!\is_object($newEntityInstance)) {
  252.             trigger_deprecation(
  253.                 'easycorp/easyadmin-bundle',
  254.                 '4.0.5',
  255.                 'Argument "%s" for "%s" must be one of these types: %s. Passing type "%s" will cause an error in 5.0.0.',
  256.                 '$newEntityInstance',
  257.                 __METHOD__,
  258.                 '"object"',
  259.                 \gettype($newEntityInstance)
  260.             );
  261.         }
  263.         if (null !== $this->instance && !$newEntityInstance instanceof $this->fqcn) {
  264.             throw new \InvalidArgumentException(sprintf('The new entity instance must be of the same type as the previous instance (original instance: "%s", new instance: "%s").', $this->fqcn, $newEntityInstance::class));
  265.         }
  267.         return new self($this->fqcn, $this->metadata, $this->permission, $newEntityInstance);
  268.     }
  269. }