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

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\DBAL\Types\Type as DBALType;
  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\MappingException as OrmMappingException;
  20. use Doctrine\Persistence\Mapping\ClassMetadataFactory;
  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;
  35.     private $classMetadataFactory;
  37.     private static $useDeprecatedConstants;
  39.     /**
  40.      * @param EntityManagerInterface $entityManager
  41.      */
  42.     public function __construct($entityManager)
  43.     {
  44.         if ($entityManager instanceof EntityManagerInterface) {
  45.             $this->entityManager = $entityManager;
  46.         } elseif ($entityManager instanceof ClassMetadataFactory) {
  47.             @trigger_error(sprintf('Injecting an instance of "%s" in "%s" is deprecated since Symfony 4.2, inject an instance of "%s" instead.', ClassMetadataFactory::class, __CLASS__, EntityManagerInterface::class), \E_USER_DEPRECATED);
  48.             $this->classMetadataFactory = $entityManager;
  49.         } else {
  50.             throw new \TypeError(sprintf('$entityManager must be an instance of "%s", "%s" given.', EntityManagerInterface::class, \is_object($entityManager) ? \get_class($entityManager) : \gettype($entityManager)));
  51.         }
  53.         if (null === self::$useDeprecatedConstants) {
  54.             self::$useDeprecatedConstants = !class_exists(Types::class);
  55.         }
  56.     }
  58.     /**
  59.      * {@inheritdoc}
  60.      */
  61.     public function getProperties($class, array $context = [])
  62.     {
  63.         if (null === $metadata = $this->getMetadata($class)) {
  64.             return null;
  65.         }
  67.         $properties = array_merge($metadata->getFieldNames(), $metadata->getAssociationNames());
  69.         if ($metadata instanceof ClassMetadataInfo && class_exists(\Doctrine\ORM\Mapping\Embedded::class) && $metadata->embeddedClasses) {
  70.             $properties = array_filter($properties, function ($property) {
  71.                 return !str_contains($property, '.');
  72.             });
  74.             $properties = array_merge($properties, array_keys($metadata->embeddedClasses));
  75.         }
  77.         return $properties;
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      */
  83.     public function getTypes($class, $property, array $context = [])
  84.     {
  85.         if (null === $metadata = $this->getMetadata($class)) {
  86.             return null;
  87.         }
  89.         if ($metadata->hasAssociation($property)) {
  90.             $class = $metadata->getAssociationTargetClass($property);
  92.             if ($metadata->isSingleValuedAssociation($property)) {
  93.                 if ($metadata instanceof ClassMetadataInfo) {
  94.                     $associationMapping = $metadata->getAssociationMapping($property);
  96.                     $nullable = $this->isAssociationNullable($associationMapping);
  97.                 } else {
  98.                     $nullable = false;
  99.                 }
  101.                 return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $class)];
  102.             }
  104.             $collectionKeyType = Type::BUILTIN_TYPE_INT;
  106.             if ($metadata instanceof ClassMetadataInfo) {
  107.                 $associationMapping = $metadata->getAssociationMapping($property);
  109.                 if (isset($associationMapping['indexBy'])) {
  110.                     /** @var ClassMetadataInfo $subMetadata */
  111.                     $subMetadata = $this->entityManager ? $this->entityManager->getClassMetadata($associationMapping['targetEntity']) : $this->classMetadataFactory->getMetadataFor($associationMapping['targetEntity']);
  113.                     // Check if indexBy value is a property
  114.                     $fieldName = $associationMapping['indexBy'];
  115.                     if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  116.                         $fieldName = $subMetadata->getFieldForColumn($associationMapping['indexBy']);
  117.                         //Not a property, maybe a column name?
  118.                         if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  119.                             //Maybe the column name is the association join column?
  120.                             $associationMapping = $subMetadata->getAssociationMapping($fieldName);
  122.                             /** @var ClassMetadataInfo $subMetadata */
  123.                             $indexProperty = $subMetadata->getSingleAssociationReferencedJoinColumnName($fieldName);
  124.                             $subMetadata = $this->entityManager ? $this->entityManager->getClassMetadata($associationMapping['targetEntity']) : $this->classMetadataFactory->getMetadataFor($associationMapping['targetEntity']);
  126.                             //Not a property, maybe a column name?
  127.                             if (null === ($typeOfField = $subMetadata->getTypeOfField($indexProperty))) {
  128.                                 $fieldName = $subMetadata->getFieldForColumn($indexProperty);
  129.                                 $typeOfField = $subMetadata->getTypeOfField($fieldName);
  130.                             }
  131.                         }
  132.                     }
  134.                     if (!$collectionKeyType = $this->getPhpType($typeOfField)) {
  135.                         return null;
  136.                     }
  137.                 }
  138.             }
  140.             return [new Type(
  141.                 Type::BUILTIN_TYPE_OBJECT,
  142.                 false,
  143.                 'Doctrine\Common\Collections\Collection',
  144.                 true,
  145.                 new Type($collectionKeyType),
  146.                 new Type(Type::BUILTIN_TYPE_OBJECT, false, $class)
  147.             )];
  148.         }
  150.         if ($metadata instanceof ClassMetadataInfo && class_exists(\Doctrine\ORM\Mapping\Embedded::class) && isset($metadata->embeddedClasses[$property])) {
  151.             return [new Type(Type::BUILTIN_TYPE_OBJECT, false, $metadata->embeddedClasses[$property]['class'])];
  152.         }
  154.         if ($metadata->hasField($property)) {
  155.             $typeOfField = $metadata->getTypeOfField($property);
  157.             if (!$builtinType = $this->getPhpType($typeOfField)) {
  158.                 return null;
  159.             }
  161.             $nullable = $metadata instanceof ClassMetadataInfo && $metadata->isNullable($property);
  162.             $enumType = null;
  163.             if (null !== $enumClass = $metadata->getFieldMapping($property)['enumType'] ?? null) {
  164.                 $enumType = new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $enumClass);
  165.             }
  167.             switch ($builtinType) {
  168.                 case Type::BUILTIN_TYPE_OBJECT:
  169.                     switch ($typeOfField) {
  170.                         case self::$useDeprecatedConstants ? DBALType::DATE : Types::DATE_MUTABLE:
  171.                         case self::$useDeprecatedConstants ? DBALType::DATETIME : Types::DATETIME_MUTABLE:
  172.                         case self::$useDeprecatedConstants ? DBALType::DATETIMETZ : Types::DATETIMETZ_MUTABLE:
  173.                         case 'vardatetime':
  174.                         case self::$useDeprecatedConstants ? DBALType::TIME : Types::TIME_MUTABLE:
  175.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')];
  177.                         case 'date_immutable':
  178.                         case 'datetime_immutable':
  179.                         case 'datetimetz_immutable':
  180.                         case 'time_immutable':
  181.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTimeImmutable')];
  183.                         case 'dateinterval':
  184.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateInterval')];
  185.                     }
  187.                     break;
  188.                 case Type::BUILTIN_TYPE_ARRAY:
  189.                     switch ($typeOfField) {
  190.                         case self::$useDeprecatedConstants ? DBALType::TARRAY : Types::ARRAY:
  191.                         case 'json_array':
  192.                             // return null if $enumType is set, because we can't determine if collectionKeyType is string or int
  193.                             if ($enumType) {
  194.                                 return null;
  195.                             }
  197.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)];
  199.                         case self::$useDeprecatedConstants ? DBALType::SIMPLE_ARRAY : Types::SIMPLE_ARRAY:
  200.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), $enumType ?? new Type(Type::BUILTIN_TYPE_STRING))];
  201.                     }
  202.                     break;
  203.                 case Type::BUILTIN_TYPE_INT:
  204.                 case Type::BUILTIN_TYPE_STRING:
  205.                     if ($enumType) {
  206.                         return [$enumType];
  207.                     }
  208.                     break;
  209.             }
  211.             return [new Type($builtinType, $nullable)];
  212.         }
  214.         return null;
  215.     }
  217.     /**
  218.      * {@inheritdoc}
  219.      */
  220.     public function isReadable($class, $property, array $context = [])
  221.     {
  222.         return null;
  223.     }
  225.     /**
  226.      * {@inheritdoc}
  227.      */
  228.     public function isWritable($class, $property, array $context = [])
  229.     {
  230.         if (
  231.             null === ($metadata = $this->getMetadata($class))
  232.             || ClassMetadata::GENERATOR_TYPE_NONE === $metadata->generatorType
  233.             || !\in_array($property, $metadata->getIdentifierFieldNames(), true)
  234.         ) {
  235.             return null;
  236.         }
  238.         return false;
  239.     }
  241.     private function getMetadata(string $class): ?ClassMetadata
  242.     {
  243.         try {
  244.             return $this->entityManager ? $this->entityManager->getClassMetadata($class) : $this->classMetadataFactory->getMetadataFor($class);
  245.         } catch (MappingException|OrmMappingException $exception) {
  246.             return null;
  247.         }
  248.     }
  250.     /**
  251.      * Determines whether an association is nullable.
  252.      *
  253.      * @see https://github.com/doctrine/doctrine2/blob/v2.5.4/lib/Doctrine/ORM/Tools/EntityGenerator.php#L1221-L1246
  254.      */
  255.     private function isAssociationNullable(array $associationMapping): bool
  256.     {
  257.         if (isset($associationMapping['id']) && $associationMapping['id']) {
  258.             return false;
  259.         }
  261.         if (!isset($associationMapping['joinColumns'])) {
  262.             return true;
  263.         }
  265.         $joinColumns = $associationMapping['joinColumns'];
  266.         foreach ($joinColumns as $joinColumn) {
  267.             if (isset($joinColumn['nullable']) && !$joinColumn['nullable']) {
  268.                 return false;
  269.             }
  270.         }
  272.         return true;
  273.     }
  275.     /**
  276.      * Gets the corresponding built-in PHP type.
  277.      */
  278.     private function getPhpType(string $doctrineType): ?string
  279.     {
  280.         switch ($doctrineType) {
  281.             case self::$useDeprecatedConstants ? DBALType::SMALLINT : Types::SMALLINT:
  282.             case self::$useDeprecatedConstants ? DBALType::INTEGER : Types::INTEGER:
  283.                 return Type::BUILTIN_TYPE_INT;
  285.             case self::$useDeprecatedConstants ? DBALType::FLOAT : Types::FLOAT:
  286.                 return Type::BUILTIN_TYPE_FLOAT;
  288.             case self::$useDeprecatedConstants ? DBALType::BIGINT : Types::BIGINT:
  289.             case self::$useDeprecatedConstants ? DBALType::STRING : Types::STRING:
  290.             case self::$useDeprecatedConstants ? DBALType::TEXT : Types::TEXT:
  291.             case self::$useDeprecatedConstants ? DBALType::GUID : Types::GUID:
  292.             case self::$useDeprecatedConstants ? DBALType::DECIMAL : Types::DECIMAL:
  293.                 return Type::BUILTIN_TYPE_STRING;
  295.             case self::$useDeprecatedConstants ? DBALType::BOOLEAN : Types::BOOLEAN:
  296.                 return Type::BUILTIN_TYPE_BOOL;
  298.             case self::$useDeprecatedConstants ? DBALType::BLOB : Types::BLOB:
  299.             case 'binary':
  300.                 return Type::BUILTIN_TYPE_RESOURCE;
  302.             case self::$useDeprecatedConstants ? DBALType::OBJECT : Types::OBJECT:
  303.             case self::$useDeprecatedConstants ? DBALType::DATE : Types::DATE_MUTABLE:
  304.             case self::$useDeprecatedConstants ? DBALType::DATETIME : Types::DATETIME_MUTABLE:
  305.             case self::$useDeprecatedConstants ? DBALType::DATETIMETZ : Types::DATETIMETZ_MUTABLE:
  306.             case 'vardatetime':
  307.             case self::$useDeprecatedConstants ? DBALType::TIME : Types::TIME_MUTABLE:
  308.             case 'date_immutable':
  309.             case 'datetime_immutable':
  310.             case 'datetimetz_immutable':
  311.             case 'time_immutable':
  312.             case 'dateinterval':
  313.                 return Type::BUILTIN_TYPE_OBJECT;
  315.             case self::$useDeprecatedConstants ? DBALType::TARRAY : Types::ARRAY:
  316.             case self::$useDeprecatedConstants ? DBALType::SIMPLE_ARRAY : Types::SIMPLE_ARRAY:
  317.             case 'json_array':
  318.                 return Type::BUILTIN_TYPE_ARRAY;
  319.         }
  321.         return null;
  322.     }
  323. }