vendor\symfony\doctrine-bridge\PropertyInfo\DoctrineExtractor.php line 227

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  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 <[email protected]>
  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.             $typeOfField = $metadata->getTypeOfField($property);
  140.             if (!$builtinType = $this->getPhpType($typeOfField)) {
  141.                 return null;
  142.             }
  144.             $nullable = $metadata instanceof ClassMetadataInfo && $metadata->isNullable($property);
  145.             $enumType = null;
  146.             if (null !== $enumClass = $metadata->getFieldMapping($property)['enumType'] ?? null) {
  147.                 $enumType = new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $enumClass);
  148.             }
  150.             switch ($builtinType) {
  151.                 case Type::BUILTIN_TYPE_OBJECT:
  152.                     switch ($typeOfField) {
  153.                         case Types::DATE_MUTABLE:
  154.                         case Types::DATETIME_MUTABLE:
  155.                         case Types::DATETIMETZ_MUTABLE:
  156.                         case 'vardatetime':
  157.                         case Types::TIME_MUTABLE:
  158.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')];
  160.                         case Types::DATE_IMMUTABLE:
  161.                         case Types::DATETIME_IMMUTABLE:
  162.                         case Types::DATETIMETZ_IMMUTABLE:
  163.                         case Types::TIME_IMMUTABLE:
  164.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTimeImmutable')];
  166.                         case Types::DATEINTERVAL:
  167.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateInterval')];
  168.                     }
  170.                     break;
  171.                 case Type::BUILTIN_TYPE_ARRAY:
  172.                     switch ($typeOfField) {
  173.                         case Types::ARRAY:
  174.                         case 'json_array':
  175.                             // return null if $enumType is set, because we can't determine if collectionKeyType is string or int
  176.                             if ($enumType) {
  177.                                 return null;
  178.                             }
  180.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)];
  182.                         case Types::SIMPLE_ARRAY:
  183.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), $enumType ?? new Type(Type::BUILTIN_TYPE_STRING))];
  184.                     }
  185.                     break;
  186.                 case Type::BUILTIN_TYPE_INT:
  187.                 case Type::BUILTIN_TYPE_STRING:
  188.                     if ($enumType) {
  189.                         return [$enumType];
  190.                     }
  191.                     break;
  192.             }
  194.             return [new Type($builtinType, $nullable)];
  195.         }
  197.         return null;
  198.     }
  200.     /**
  201.      * {@inheritdoc}
  202.      */
  203.     public function isReadable(string $class, string $property, array $context = [])
  204.     {
  205.         return null;
  206.     }
  208.     /**
  209.      * {@inheritdoc}
  210.      */
  211.     public function isWritable(string $class, string $property, array $context = [])
  212.     {
  213.         if (
  214.             null === ($metadata = $this->getMetadata($class))
  215.             || ClassMetadata::GENERATOR_TYPE_NONE === $metadata->generatorType
  216.             || !\in_array($property, $metadata->getIdentifierFieldNames(), true)
  217.         ) {
  218.             return null;
  219.         }
  221.         return false;
  222.     }
  224.     private function getMetadata(string $class): ?ClassMetadata
  225.     {
  226.         try {
  227.             return $this->entityManager->getClassMetadata($class);
  228.         } catch (MappingException|OrmMappingException $exception) {
  229.             return null;
  230.         }
  231.     }
  233.     /**
  234.      * Determines whether an association is nullable.
  235.      *
  236.      * @see https://github.com/doctrine/doctrine2/blob/v2.5.4/lib/Doctrine/ORM/Tools/EntityGenerator.php#L1221-L1246
  237.      */
  238.     private function isAssociationNullable(array $associationMapping): bool
  239.     {
  240.         if (isset($associationMapping['id']) && $associationMapping['id']) {
  241.             return false;
  242.         }
  244.         if (!isset($associationMapping['joinColumns'])) {
  245.             return true;
  246.         }
  248.         $joinColumns = $associationMapping['joinColumns'];
  249.         foreach ($joinColumns as $joinColumn) {
  250.             if (isset($joinColumn['nullable']) && !$joinColumn['nullable']) {
  251.                 return false;
  252.             }
  253.         }
  255.         return true;
  256.     }
  258.     /**
  259.      * Gets the corresponding built-in PHP type.
  260.      */
  261.     private function getPhpType(string $doctrineType): ?string
  262.     {
  263.         switch ($doctrineType) {
  264.             case Types::SMALLINT:
  265.             case Types::INTEGER:
  266.                 return Type::BUILTIN_TYPE_INT;
  268.             case Types::FLOAT:
  269.                 return Type::BUILTIN_TYPE_FLOAT;
  271.             case Types::BIGINT:
  272.             case Types::STRING:
  273.             case Types::TEXT:
  274.             case Types::GUID:
  275.             case Types::DECIMAL:
  276.                 return Type::BUILTIN_TYPE_STRING;
  278.             case Types::BOOLEAN:
  279.                 return Type::BUILTIN_TYPE_BOOL;
  281.             case Types::BLOB:
  282.             case Types::BINARY:
  283.                 return Type::BUILTIN_TYPE_RESOURCE;
  285.             case Types::OBJECT:
  286.             case Types::DATE_MUTABLE:
  287.             case Types::DATETIME_MUTABLE:
  288.             case Types::DATETIMETZ_MUTABLE:
  289.             case 'vardatetime':
  290.             case Types::TIME_MUTABLE:
  291.             case Types::DATE_IMMUTABLE:
  292.             case Types::DATETIME_IMMUTABLE:
  293.             case Types::DATETIMETZ_IMMUTABLE:
  294.             case Types::TIME_IMMUTABLE:
  295.             case Types::DATEINTERVAL:
  296.                 return Type::BUILTIN_TYPE_OBJECT;
  298.             case Types::ARRAY:
  299.             case Types::SIMPLE_ARRAY:
  300.             case 'json_array':
  301.                 return Type::BUILTIN_TYPE_ARRAY;
  302.         }
  304.         return null;
  305.     }
  306. }