vendor/symfony/doctrine-bridge/PropertyInfo/DoctrineExtractor.php line 211

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Bridge\Doctrine\PropertyInfo;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\DBAL\Types\Types;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use Doctrine\ORM\Mapping\ClassMetadata;
  18. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  19. use Doctrine\ORM\Mapping\Embedded;
  20. use Doctrine\ORM\Mapping\MappingException as OrmMappingException;
  21. use Doctrine\Persistence\Mapping\MappingException;
  22. use Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface;
  23. use Symfony\Component\PropertyInfo\PropertyListExtractorInterface;
  24. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  25. use Symfony\Component\PropertyInfo\Type;
  27. /**
  28.  * Extracts data using Doctrine ORM and ODM metadata.
  29.  *
  30.  * @author Kévin Dunglas <dunglas@gmail.com>
  31.  */
  32. class DoctrineExtractor implements PropertyListExtractorInterface, PropertyTypeExtractorInterface, PropertyAccessExtractorInterface
  33. {
  34.     private $entityManager;
  36.     public function __construct(EntityManagerInterface $entityManager)
  37.     {
  38.         $this->entityManager = $entityManager;
  39.     }
  41.     /**
  42.      * {@inheritdoc}
  43.      */
  44.     public function getProperties(string $class, array $context = [])
  45.     {
  46.         if (null === $metadata = $this->getMetadata($class)) {
  47.             return null;
  48.         }
  50.         $properties = array_merge($metadata->getFieldNames(), $metadata->getAssociationNames());
  52.         if ($metadata instanceof ClassMetadataInfo && class_exists(Embedded::class) && $metadata->embeddedClasses) {
  53.             $properties = array_filter($properties, function ($property) {
  54.                 return !str_contains($property, '.');
  55.             });
  57.             $properties = array_merge($properties, array_keys($metadata->embeddedClasses));
  58.         }
  60.         return $properties;
  61.     }
  63.     /**
  64.      * {@inheritdoc}
  65.      */
  66.     public function getTypes(string $class, string $property, array $context = [])
  67.     {
  68.         if (null === $metadata = $this->getMetadata($class)) {
  69.             return null;
  70.         }
  72.         if ($metadata->hasAssociation($property)) {
  73.             $class = $metadata->getAssociationTargetClass($property);
  75.             if ($metadata->isSingleValuedAssociation($property)) {
  76.                 if ($metadata instanceof ClassMetadataInfo) {
  77.                     $associationMapping = $metadata->getAssociationMapping($property);
  79.                     $nullable = $this->isAssociationNullable($associationMapping);
  80.                 } else {
  81.                     $nullable = false;
  82.                 }
  84.                 return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $class)];
  85.             }
  87.             $collectionKeyType = Type::BUILTIN_TYPE_INT;
  89.             if ($metadata instanceof ClassMetadataInfo) {
  90.                 $associationMapping = $metadata->getAssociationMapping($property);
  92.                 if (isset($associationMapping['indexBy'])) {
  93.                     /** @var ClassMetadataInfo $subMetadata */
  94.                     $subMetadata = $this->entityManager->getClassMetadata($associationMapping['targetEntity']);
  96.                     // Check if indexBy value is a property
  97.                     $fieldName = $associationMapping['indexBy'];
  98.                     if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  99.                         $fieldName = $subMetadata->getFieldForColumn($associationMapping['indexBy']);
  100.                         //Not a property, maybe a column name?
  101.                         if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  102.                             //Maybe the column name is the association join column?
  103.                             $associationMapping = $subMetadata->getAssociationMapping($fieldName);
  105.                             /** @var ClassMetadataInfo $subMetadata */
  106.                             $indexProperty = $subMetadata->getSingleAssociationReferencedJoinColumnName($fieldName);
  107.                             $subMetadata = $this->entityManager->getClassMetadata($associationMapping['targetEntity']);
  109.                             //Not a property, maybe a column name?
  110.                             if (null === ($typeOfField = $subMetadata->getTypeOfField($indexProperty))) {
  111.                                 $fieldName = $subMetadata->getFieldForColumn($indexProperty);
  112.                                 $typeOfField = $subMetadata->getTypeOfField($fieldName);
  113.                             }
  114.                         }
  115.                     }
  117.                     if (!$collectionKeyType = $this->getPhpType($typeOfField)) {
  118.                         return null;
  119.                     }
  120.                 }
  121.             }
  123.             return [new Type(
  124.                 Type::BUILTIN_TYPE_OBJECT,
  125.                 false,
  126.                 Collection::class,
  127.                 true,
  128.                 new Type($collectionKeyType),
  129.                 new Type(Type::BUILTIN_TYPE_OBJECT, false, $class)
  130.             )];
  131.         }
  133.         if ($metadata instanceof ClassMetadataInfo && class_exists(Embedded::class) && isset($metadata->embeddedClasses[$property])) {
  134.             return [new Type(Type::BUILTIN_TYPE_OBJECT, false, $metadata->embeddedClasses[$property]['class'])];
  135.         }
  137.         if ($metadata->hasField($property)) {
  138.             $nullable = $metadata instanceof ClassMetadataInfo && $metadata->isNullable($property);
  139.             if (null !== $enumClass = $metadata->getFieldMapping($property)['enumType'] ?? null) {
  140.                 return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $enumClass)];
  141.             }
  143.             $typeOfField = $metadata->getTypeOfField($property);
  145.             if (!$builtinType = $this->getPhpType($typeOfField)) {
  146.                 return null;
  147.             }
  149.             switch ($builtinType) {
  150.                 case Type::BUILTIN_TYPE_OBJECT:
  151.                     switch ($typeOfField) {
  152.                         case Types::DATE_MUTABLE:
  153.                         case Types::DATETIME_MUTABLE:
  154.                         case Types::DATETIMETZ_MUTABLE:
  155.                         case 'vardatetime':
  156.                         case Types::TIME_MUTABLE:
  157.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')];
  159.                         case Types::DATE_IMMUTABLE:
  160.                         case Types::DATETIME_IMMUTABLE:
  161.                         case Types::DATETIMETZ_IMMUTABLE:
  162.                         case Types::TIME_IMMUTABLE:
  163.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTimeImmutable')];
  165.                         case Types::DATEINTERVAL:
  166.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateInterval')];
  167.                     }
  169.                     break;
  170.                 case Type::BUILTIN_TYPE_ARRAY:
  171.                     switch ($typeOfField) {
  172.                         case Types::ARRAY:
  173.                         case 'json_array':
  174.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)];
  176.                         case Types::SIMPLE_ARRAY:
  177.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), new Type(Type::BUILTIN_TYPE_STRING))];
  178.                     }
  179.             }
  181.             return [new Type($builtinType, $nullable)];
  182.         }
  184.         return null;
  185.     }
  187.     /**
  188.      * {@inheritdoc}
  189.      */
  190.     public function isReadable(string $class, string $property, array $context = [])
  191.     {
  192.         return null;
  193.     }
  195.     /**
  196.      * {@inheritdoc}
  197.      */
  198.     public function isWritable(string $class, string $property, array $context = [])
  199.     {
  200.         if (
  201.             null === ($metadata = $this->getMetadata($class))
  202.             || ClassMetadata::GENERATOR_TYPE_NONE === $metadata->generatorType
  203.             || !\in_array($property, $metadata->getIdentifierFieldNames(), true)
  204.         ) {
  205.             return null;
  206.         }
  208.         return false;
  209.     }
  211.     private function getMetadata(string $class): ?ClassMetadata
  212.     {
  213.         try {
  214.             return $this->entityManager->getClassMetadata($class);
  215.         } catch (MappingException|OrmMappingException $exception) {
  216.             return null;
  217.         }
  218.     }
  220.     /**
  221.      * Determines whether an association is nullable.
  222.      *
  223.      * @see https://github.com/doctrine/doctrine2/blob/v2.5.4/lib/Doctrine/ORM/Tools/EntityGenerator.php#L1221-L1246
  224.      */
  225.     private function isAssociationNullable(array $associationMapping): bool
  226.     {
  227.         if (isset($associationMapping['id']) && $associationMapping['id']) {
  228.             return false;
  229.         }
  231.         if (!isset($associationMapping['joinColumns'])) {
  232.             return true;
  233.         }
  235.         $joinColumns = $associationMapping['joinColumns'];
  236.         foreach ($joinColumns as $joinColumn) {
  237.             if (isset($joinColumn['nullable']) && !$joinColumn['nullable']) {
  238.                 return false;
  239.             }
  240.         }
  242.         return true;
  243.     }
  245.     /**
  246.      * Gets the corresponding built-in PHP type.
  247.      */
  248.     private function getPhpType(string $doctrineType): ?string
  249.     {
  250.         switch ($doctrineType) {
  251.             case Types::SMALLINT:
  252.             case Types::INTEGER:
  253.                 return Type::BUILTIN_TYPE_INT;
  255.             case Types::FLOAT:
  256.                 return Type::BUILTIN_TYPE_FLOAT;
  258.             case Types::BIGINT:
  259.             case Types::STRING:
  260.             case Types::TEXT:
  261.             case Types::GUID:
  262.             case Types::DECIMAL:
  263.                 return Type::BUILTIN_TYPE_STRING;
  265.             case Types::BOOLEAN:
  266.                 return Type::BUILTIN_TYPE_BOOL;
  268.             case Types::BLOB:
  269.             case Types::BINARY:
  270.                 return Type::BUILTIN_TYPE_RESOURCE;
  272.             case Types::OBJECT:
  273.             case Types::DATE_MUTABLE:
  274.             case Types::DATETIME_MUTABLE:
  275.             case Types::DATETIMETZ_MUTABLE:
  276.             case 'vardatetime':
  277.             case Types::TIME_MUTABLE:
  278.             case Types::DATE_IMMUTABLE:
  279.             case Types::DATETIME_IMMUTABLE:
  280.             case Types::DATETIMETZ_IMMUTABLE:
  281.             case Types::TIME_IMMUTABLE:
  282.             case Types::DATEINTERVAL:
  283.                 return Type::BUILTIN_TYPE_OBJECT;
  285.             case Types::ARRAY:
  286.             case Types::SIMPLE_ARRAY:
  287.             case 'json_array':
  288.                 return Type::BUILTIN_TYPE_ARRAY;
  289.         }
  291.         return null;
  292.     }
  293. }