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

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\MappingException;
  21. use Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface;
  22. use Symfony\Component\PropertyInfo\PropertyListExtractorInterface;
  23. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  24. use Symfony\Component\PropertyInfo\Type;
  26. /**
  27.  * Extracts data using Doctrine ORM and ODM metadata.
  28.  *
  29.  * @author Kévin Dunglas <dunglas@gmail.com>
  30.  */
  31. class DoctrineExtractor implements PropertyListExtractorInterface, PropertyTypeExtractorInterface, PropertyAccessExtractorInterface
  32. {
  33.     private $entityManager;
  34.     private $classMetadataFactory;
  35.     private static $useDeprecatedConstants;
  37.     public function __construct(EntityManagerInterface $entityManager)
  38.     {
  39.         $this->entityManager = $entityManager;
  41.         if (null === self::$useDeprecatedConstants) {
  42.             self::$useDeprecatedConstants = !class_exists(Types::class);
  43.         }
  44.     }
  46.     /**
  47.      * {@inheritdoc}
  48.      */
  49.     public function getProperties(string $class, array $context = [])
  50.     {
  51.         if (null === $metadata = $this->getMetadata($class)) {
  52.             return null;
  53.         }
  55.         $properties = array_merge($metadata->getFieldNames(), $metadata->getAssociationNames());
  57.         if ($metadata instanceof ClassMetadataInfo && class_exists('Doctrine\ORM\Mapping\Embedded') && $metadata->embeddedClasses) {
  58.             $properties = array_filter($properties, function ($property) {
  59.                 return false === strpos($property, '.');
  60.             });
  62.             $properties = array_merge($properties, array_keys($metadata->embeddedClasses));
  63.         }
  65.         return $properties;
  66.     }
  68.     /**
  69.      * {@inheritdoc}
  70.      */
  71.     public function getTypes(string $class, string $property, array $context = [])
  72.     {
  73.         if (null === $metadata = $this->getMetadata($class)) {
  74.             return null;
  75.         }
  77.         if ($metadata->hasAssociation($property)) {
  78.             $class = $metadata->getAssociationTargetClass($property);
  80.             if ($metadata->isSingleValuedAssociation($property)) {
  81.                 if ($metadata instanceof ClassMetadataInfo) {
  82.                     $associationMapping = $metadata->getAssociationMapping($property);
  84.                     $nullable = $this->isAssociationNullable($associationMapping);
  85.                 } else {
  86.                     $nullable = false;
  87.                 }
  89.                 return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $class)];
  90.             }
  92.             $collectionKeyType = Type::BUILTIN_TYPE_INT;
  94.             if ($metadata instanceof ClassMetadataInfo) {
  95.                 $associationMapping = $metadata->getAssociationMapping($property);
  97.                 if (isset($associationMapping['indexBy'])) {
  98.                     $indexProperty = $associationMapping['indexBy'];
  99.                     /** @var ClassMetadataInfo $subMetadata */
  100.                     $subMetadata = $this->entityManager ? $this->entityManager->getClassMetadata($associationMapping['targetEntity']) : $this->classMetadataFactory->getMetadataFor($associationMapping['targetEntity']);
  101.                     $typeOfField = $subMetadata->getTypeOfField($indexProperty);
  103.                     if (null === $typeOfField) {
  104.                         $associationMapping = $subMetadata->getAssociationMapping($indexProperty);
  106.                         /** @var ClassMetadataInfo $subMetadata */
  107.                         $indexProperty = $subMetadata->getSingleAssociationReferencedJoinColumnName($indexProperty);
  108.                         $subMetadata = $this->entityManager ? $this->entityManager->getClassMetadata($associationMapping['targetEntity']) : $this->classMetadataFactory->getMetadataFor($associationMapping['targetEntity']);
  109.                         $typeOfField = $subMetadata->getTypeOfField($indexProperty);
  110.                     }
  112.                     if (!$collectionKeyType = $this->getPhpType($typeOfField)) {
  113.                         return null;
  114.                     }
  115.                 }
  116.             }
  118.             return [new Type(
  119.                 Type::BUILTIN_TYPE_OBJECT,
  120.                 false,
  121.                 'Doctrine\Common\Collections\Collection',
  122.                 true,
  123.                 new Type($collectionKeyType),
  124.                 new Type(Type::BUILTIN_TYPE_OBJECT, false, $class)
  125.             )];
  126.         }
  128.         if ($metadata instanceof ClassMetadataInfo && class_exists('Doctrine\ORM\Mapping\Embedded') && isset($metadata->embeddedClasses[$property])) {
  129.             return [new Type(Type::BUILTIN_TYPE_OBJECT, false, $metadata->embeddedClasses[$property]['class'])];
  130.         }
  132.         if ($metadata->hasField($property)) {
  133.             $typeOfField = $metadata->getTypeOfField($property);
  135.             if (!$builtinType = $this->getPhpType($typeOfField)) {
  136.                 return null;
  137.             }
  139.             $nullable = $metadata instanceof ClassMetadataInfo && $metadata->isNullable($property);
  141.             switch ($builtinType) {
  142.                 case Type::BUILTIN_TYPE_OBJECT:
  143.                     switch ($typeOfField) {
  144.                         case self::$useDeprecatedConstants ? DBALType::DATE : Types::DATE_MUTABLE:
  145.                         case self::$useDeprecatedConstants ? DBALType::DATETIME : Types::DATETIME_MUTABLE:
  146.                         case self::$useDeprecatedConstants ? DBALType::DATETIMETZ : Types::DATETIMETZ_MUTABLE:
  147.                         case 'vardatetime':
  148.                         case self::$useDeprecatedConstants ? DBALType::TIME : Types::TIME_MUTABLE:
  149.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')];
  151.                         case 'date_immutable':
  152.                         case 'datetime_immutable':
  153.                         case 'datetimetz_immutable':
  154.                         case 'time_immutable':
  155.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTimeImmutable')];
  157.                         case 'dateinterval':
  158.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateInterval')];
  159.                     }
  161.                     break;
  162.                 case Type::BUILTIN_TYPE_ARRAY:
  163.                     switch ($typeOfField) {
  164.                         case self::$useDeprecatedConstants ? DBALType::TARRAY : Types::ARRAY:
  165.                         case 'json_array':
  166.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)];
  168.                         case self::$useDeprecatedConstants ? DBALType::SIMPLE_ARRAY : Types::SIMPLE_ARRAY:
  169.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), new Type(Type::BUILTIN_TYPE_STRING))];
  170.                     }
  171.             }
  173.             return [new Type($builtinType, $nullable)];
  174.         }
  176.         return null;
  177.     }
  179.     /**
  180.      * {@inheritdoc}
  181.      */
  182.     public function isReadable(string $class, string $property, array $context = [])
  183.     {
  184.         return null;
  185.     }
  187.     /**
  188.      * {@inheritdoc}
  189.      */
  190.     public function isWritable(string $class, string $property, array $context = [])
  191.     {
  192.         if (
  193.             null === ($metadata = $this->getMetadata($class))
  194.             || ClassMetadata::GENERATOR_TYPE_NONE === $metadata->generatorType
  195.             || !\in_array($property, $metadata->getIdentifierFieldNames(), true)
  196.         ) {
  197.             return null;
  198.         }
  200.         return false;
  201.     }
  203.     private function getMetadata(string $class): ?ClassMetadata
  204.     {
  205.         try {
  206.             return $this->entityManager ? $this->entityManager->getClassMetadata($class) : $this->classMetadataFactory->getMetadataFor($class);
  207.         } catch (MappingException | OrmMappingException $exception) {
  208.             return null;
  209.         }
  210.     }
  212.     /**
  213.      * Determines whether an association is nullable.
  214.      *
  215.      * @see https://github.com/doctrine/doctrine2/blob/v2.5.4/lib/Doctrine/ORM/Tools/EntityGenerator.php#L1221-L1246
  216.      */
  217.     private function isAssociationNullable(array $associationMapping): bool
  218.     {
  219.         if (isset($associationMapping['id']) && $associationMapping['id']) {
  220.             return false;
  221.         }
  223.         if (!isset($associationMapping['joinColumns'])) {
  224.             return true;
  225.         }
  227.         $joinColumns = $associationMapping['joinColumns'];
  228.         foreach ($joinColumns as $joinColumn) {
  229.             if (isset($joinColumn['nullable']) && !$joinColumn['nullable']) {
  230.                 return false;
  231.             }
  232.         }
  234.         return true;
  235.     }
  237.     /**
  238.      * Gets the corresponding built-in PHP type.
  239.      */
  240.     private function getPhpType(string $doctrineType): ?string
  241.     {
  242.         switch ($doctrineType) {
  243.             case self::$useDeprecatedConstants ? DBALType::SMALLINT : Types::SMALLINT:
  244.             case self::$useDeprecatedConstants ? DBALType::INTEGER : Types::INTEGER:
  245.                 return Type::BUILTIN_TYPE_INT;
  247.             case self::$useDeprecatedConstants ? DBALType::FLOAT : Types::FLOAT:
  248.                 return Type::BUILTIN_TYPE_FLOAT;
  250.             case self::$useDeprecatedConstants ? DBALType::BIGINT : Types::BIGINT:
  251.             case self::$useDeprecatedConstants ? DBALType::STRING : Types::STRING:
  252.             case self::$useDeprecatedConstants ? DBALType::TEXT : Types::TEXT:
  253.             case self::$useDeprecatedConstants ? DBALType::GUID : Types::GUID:
  254.             case self::$useDeprecatedConstants ? DBALType::DECIMAL : Types::DECIMAL:
  255.                 return Type::BUILTIN_TYPE_STRING;
  257.             case self::$useDeprecatedConstants ? DBALType::BOOLEAN : Types::BOOLEAN:
  258.                 return Type::BUILTIN_TYPE_BOOL;
  260.             case self::$useDeprecatedConstants ? DBALType::BLOB : Types::BLOB:
  261.             case 'binary':
  262.                 return Type::BUILTIN_TYPE_RESOURCE;
  264.             case self::$useDeprecatedConstants ? DBALType::OBJECT : Types::OBJECT:
  265.             case self::$useDeprecatedConstants ? DBALType::DATE : Types::DATE_MUTABLE:
  266.             case self::$useDeprecatedConstants ? DBALType::DATETIME : Types::DATETIME_MUTABLE:
  267.             case self::$useDeprecatedConstants ? DBALType::DATETIMETZ : Types::DATETIMETZ_MUTABLE:
  268.             case 'vardatetime':
  269.             case self::$useDeprecatedConstants ? DBALType::TIME : Types::TIME_MUTABLE:
  270.             case 'date_immutable':
  271.             case 'datetime_immutable':
  272.             case 'datetimetz_immutable':
  273.             case 'time_immutable':
  274.             case 'dateinterval':
  275.                 return Type::BUILTIN_TYPE_OBJECT;
  277.             case self::$useDeprecatedConstants ? DBALType::TARRAY : Types::ARRAY:
  278.             case self::$useDeprecatedConstants ? DBALType::SIMPLE_ARRAY : Types::SIMPLE_ARRAY:
  279.             case 'json_array':
  280.                 return Type::BUILTIN_TYPE_ARRAY;
  281.         }
  283.         return null;
  284.     }
  285. }