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

Open in your IDE?
  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\Exception\UninitializedPropertyException;
  16. use Symfony\Component\PropertyAccess\PropertyAccess;
  18. /**
  19.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  20.  */
  21. final class EntityDto
  22. {
  23.     private bool $isAccessible = true;
  24.     private string $fqcn;
  25.     private ClassMetadata $metadata;
  26.     private $instance;
  27.     private $primaryKeyName;
  28.     private mixed $primaryKeyValue = null;
  29.     private string|Expression|null $permission;
  30.     private ?FieldCollection $fields = null;
  31.     private ?ActionCollection $actions = null;
  33.     public function __construct(string $entityFqcn, ClassMetadata $entityMetadata, string|Expression|null $entityPermission = null, /* ?object */ $entityInstance = null)
  34.     {
  35.         if (!\is_object($entityInstance)
  36.             && null !== $entityInstance) {
  37.             trigger_deprecation(
  38.                 'easycorp/easyadmin-bundle',
  39.                 '4.0.5',
  40.                 'Argument "%s" for "%s" must be one of these types: %s. Passing type "%s" will cause an error in 5.0.0.',
  41.                 '$entityInstance',
  42.                 __METHOD__,
  43.                 '"object" or "null"',
  44.                 \gettype($entityInstance)
  45.             );
  46.         }
  48.         $this->fqcn = $entityFqcn;
  49.         $this->metadata = $entityMetadata;
  50.         $this->instance = $entityInstance;
  51.         $this->primaryKeyName = $this->metadata->getIdentifierFieldNames()[0];
  52.         $this->permission = $entityPermission;
  53.     }
  55.     public function __toString(): string
  56.     {
  57.         return $this->toString();
  58.     }
  60.     public function getFqcn(): string
  61.     {
  62.         return $this->fqcn;
  63.     }
  65.     public function getName(): string
  66.     {
  67.         return basename(str_replace('\\', '/', $this->fqcn));
  68.     }
  70.     public function toString(): string
  71.     {
  72.         if (null === $this->instance) {
  73.             return '';
  74.         }
  76.         if (method_exists($this->instance, '__toString')) {
  77.             return (string) $this->instance;
  78.         }
  80.         return sprintf('%s #%s', $this->getName(), substr($this->getPrimaryKeyValueAsString(), 0, 16));
  81.     }
  83.     public function getInstance()/* : ?object */
  84.     {
  85.         return $this->instance;
  86.     }
  88.     public function getPrimaryKeyName(): ?string
  89.     {
  90.         return $this->primaryKeyName;
  91.     }
  93.     public function getPrimaryKeyValue(): mixed
  94.     {
  95.         if (null === $this->instance) {
  96.             return null;
  97.         }
  99.         if (null !== $this->primaryKeyValue) {
  100.             return $this->primaryKeyValue;
  101.         }
  103.         $propertyAccessor = PropertyAccess::createPropertyAccessorBuilder()
  104.             ->enableExceptionOnInvalidIndex()
  105.             ->getPropertyAccessor();
  107.         try {
  108.             $primaryKeyValue = $propertyAccessor->getValue($this->instance, $this->primaryKeyName);
  109.         } catch (UninitializedPropertyException $exception) {
  110.             $primaryKeyValue = null;
  111.         }
  113.         return $this->primaryKeyValue = $primaryKeyValue;
  114.     }
  116.     public function getPrimaryKeyValueAsString(): string
  117.     {
  118.         return (string) $this->getPrimaryKeyValue();
  119.     }
  121.     public function getPermission(): string|Expression|null
  122.     {
  123.         return $this->permission;
  124.     }
  126.     public function isAccessible(): bool
  127.     {
  128.         return $this->isAccessible;
  129.     }
  131.     public function markAsInaccessible(): void
  132.     {
  133.         $this->isAccessible = false;
  134.         $this->instance = null;
  135.         $this->fields = null;
  136.     }
  138.     public function getFields(): ?FieldCollection
  139.     {
  140.         return $this->fields;
  141.     }
  143.     public function setFields(FieldCollection $fields): void
  144.     {
  145.         $this->fields = $fields;
  146.     }
  148.     public function setActions(ActionCollection $actions): void
  149.     {
  150.         $this->actions = $actions;
  151.     }
  153.     public function getActions(): ActionCollection
  154.     {
  155.         return $this->actions;
  156.     }
  158.     /**
  159.      * Returns the names of all properties defined in the entity, no matter
  160.      * if they are used or not in the application.
  161.      */
  162.     public function getAllPropertyNames(): array
  163.     {
  164.         return $this->metadata->getFieldNames();
  165.     }
  167.     public function getPropertyMetadata(string $propertyName): KeyValueStore
  168.     {
  169.         if (\array_key_exists($propertyName, $this->metadata->fieldMappings)) {
  170.             /** @var FieldMapping|array $fieldMapping */
  171.             $fieldMapping = $this->metadata->fieldMappings[$propertyName];
  172.             // Doctrine ORM 2.x returns an array and Doctrine ORM 3.x returns a FieldMapping object
  173.             if ($fieldMapping instanceof FieldMapping) {
  174.                 $fieldMapping = (array) $fieldMapping;
  175.             }
  177.             return KeyValueStore::new($fieldMapping);
  178.         }
  180.         if (\array_key_exists($propertyName, $this->metadata->associationMappings)) {
  181.             /** @var OneToOneAssociationMapping|OneToManyAssociationMapping|ManyToOneAssociationMapping|ManyToManyAssociationMapping|array $associationMapping */
  182.             $associationMapping = $this->metadata->associationMappings[$propertyName];
  183.             // Doctrine ORM 2.x returns an array and Doctrine ORM 3.x returns one of the many *Mapping objects
  184.             // there's not a single interface implemented by all of them, so let's only check if it's an object
  185.             if (\is_object($associationMapping)) {
  186.                 // Doctrine ORM 3.x doesn't include the 'type' key that tells the type of association
  187.                 // recreate that key to keep the code compatible with both versions
  188.                 $associationType = match (true) {
  189.                     $associationMapping instanceof OneToOneAssociationMapping => ClassMetadata::ONE_TO_ONE,
  190.                     $associationMapping instanceof OneToManyAssociationMapping => ClassMetadata::ONE_TO_MANY,
  191.                     $associationMapping instanceof ManyToOneAssociationMapping => ClassMetadata::MANY_TO_ONE,
  192.                     $associationMapping instanceof ManyToManyAssociationMapping => ClassMetadata::MANY_TO_MANY,
  193.                     default => null,
  194.                 };
  196.                 $associationMapping = (array) $associationMapping;
  197.                 $associationMapping['type'] = $associationType;
  198.             }
  200.             return KeyValueStore::new($associationMapping);
  201.         }
  203.         throw new \InvalidArgumentException(sprintf('The "%s" field does not exist in the "%s" entity.', $propertyName, $this->getFqcn()));
  204.     }
  206.     public function getPropertyDataType(string $propertyName)
  207.     {
  208.         return $this->getPropertyMetadata($propertyName)->get('type');
  209.     }
  211.     public function hasProperty(string $propertyName): bool
  212.     {
  213.         return \array_key_exists($propertyName, $this->metadata->fieldMappings)
  214.             || \array_key_exists($propertyName, $this->metadata->associationMappings);
  215.     }
  217.     public function isAssociation(string $propertyName): bool
  218.     {
  219.         return \array_key_exists($propertyName, $this->metadata->associationMappings)
  220.             || (str_contains($propertyName, '.') && !$this->isEmbeddedClassProperty($propertyName));
  221.     }
  223.     public function isToOneAssociation(string $propertyName): bool
  224.     {
  225.         $associationType = $this->getPropertyMetadata($propertyName)->get('type');
  227.         return \in_array($associationType, [ClassMetadata::ONE_TO_ONE, ClassMetadata::MANY_TO_ONE], true);
  228.     }
  230.     public function isToManyAssociation(string $propertyName): bool
  231.     {
  232.         $associationType = $this->getPropertyMetadata($propertyName)->get('type');
  234.         return \in_array($associationType, [ClassMetadata::ONE_TO_MANY, ClassMetadata::MANY_TO_MANY], true);
  235.     }
  237.     public function isEmbeddedClassProperty(string $propertyName): bool
  238.     {
  239.         $propertyNameParts = explode('.', $propertyName, 2);
  241.         return \array_key_exists($propertyNameParts[0], $this->metadata->embeddedClasses);
  242.     }
  244.     public function setInstance(?object $newEntityInstance): void
  245.     {
  246.         if (null !== $this->instance && null !== $newEntityInstance && !$newEntityInstance instanceof $this->fqcn) {
  247.             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));
  248.         }
  250.         $this->instance = $newEntityInstance;
  251.         $this->primaryKeyValue = null;
  252.     }
  254.     public function newWithInstance(/* object */ $newEntityInstance): self
  255.     {
  256.         if (!\is_object($newEntityInstance)) {
  257.             trigger_deprecation(
  258.                 'easycorp/easyadmin-bundle',
  259.                 '4.0.5',
  260.                 'Argument "%s" for "%s" must be one of these types: %s. Passing type "%s" will cause an error in 5.0.0.',
  261.                 '$newEntityInstance',
  262.                 __METHOD__,
  263.                 '"object"',
  264.                 \gettype($newEntityInstance)
  265.             );
  266.         }
  268.         if (null !== $this->instance && !$newEntityInstance instanceof $this->fqcn) {
  269.             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));
  270.         }
  272.         return new self($this->fqcn, $this->metadata, $this->permission, $newEntityInstance);
  273.     }
  274. }