vendor/symfony/doctrine-bridge/Validator/DoctrineLoader.php line 39

  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\Validator;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  16. use Doctrine\ORM\Mapping\MappingException as OrmMappingException;
  17. use Doctrine\Persistence\Mapping\MappingException;
  18. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  19. use Symfony\Component\PropertyInfo\Type;
  20. use Symfony\Component\Validator\Constraints\Length;
  21. use Symfony\Component\Validator\Constraints\Valid;
  22. use Symfony\Component\Validator\Mapping\AutoMappingStrategy;
  23. use Symfony\Component\Validator\Mapping\ClassMetadata;
  24. use Symfony\Component\Validator\Mapping\Loader\AutoMappingTrait;
  25. use Symfony\Component\Validator\Mapping\Loader\LoaderInterface;
  27. /**
  28.  * Guesses and loads the appropriate constraints using Doctrine's metadata.
  29.  *
  30.  * @author Kévin Dunglas <dunglas@gmail.com>
  31.  */
  32. final class DoctrineLoader implements LoaderInterface
  33. {
  34.     use AutoMappingTrait;
  36.     private EntityManagerInterface $entityManager;
  37.     private ?string $classValidatorRegexp;
  39.     public function __construct(EntityManagerInterface $entityManager, string $classValidatorRegexp = null)
  40.     {
  41.         $this->entityManager = $entityManager;
  42.         $this->classValidatorRegexp = $classValidatorRegexp;
  43.     }
  45.     public function loadClassMetadata(ClassMetadata $metadata): bool
  46.     {
  47.         $className = $metadata->getClassName();
  48.         try {
  49.             $doctrineMetadata = $this->entityManager->getClassMetadata($className);
  50.         } catch (MappingException|OrmMappingException) {
  51.             return false;
  52.         }
  54.         if (!$doctrineMetadata instanceof ClassMetadataInfo) {
  55.             return false;
  56.         }
  58.         $loaded = false;
  59.         $enabledForClass = $this->isAutoMappingEnabledForClass($metadata, $this->classValidatorRegexp);
  61.         /* Available keys:
  62.            - type
  63.            - scale
  64.            - length
  65.            - unique
  66.            - nullable
  67.            - precision
  68.          */
  69.         $existingUniqueFields = $this->getExistingUniqueFields($metadata);
  71.         // Type and nullable aren't handled here, use the PropertyInfo Loader instead.
  72.         foreach ($doctrineMetadata->fieldMappings as $mapping) {
  73.             $enabledForProperty = $enabledForClass;
  74.             $lengthConstraint = null;
  75.             foreach ($metadata->getPropertyMetadata($mapping['fieldName']) as $propertyMetadata) {
  76.                 // Enabling or disabling auto-mapping explicitly always takes precedence
  77.                 if (AutoMappingStrategy::DISABLED === $propertyMetadata->getAutoMappingStrategy()) {
  78.                     continue 2;
  79.                 }
  80.                 if (AutoMappingStrategy::ENABLED === $propertyMetadata->getAutoMappingStrategy()) {
  81.                     $enabledForProperty = true;
  82.                 }
  84.                 foreach ($propertyMetadata->getConstraints() as $constraint) {
  85.                     if ($constraint instanceof Length) {
  86.                         $lengthConstraint = $constraint;
  87.                     }
  88.                 }
  89.             }
  91.             if (!$enabledForProperty) {
  92.                 continue;
  93.             }
  95.             if (true === ($mapping['unique'] ?? false) && !isset($existingUniqueFields[$mapping['fieldName']])) {
  96.                 $metadata->addConstraint(new UniqueEntity(['fields' => $mapping['fieldName']]));
  97.                 $loaded = true;
  98.             }
  100.             if (null === ($mapping['length'] ?? null) || null !== ($mapping['enumType'] ?? null) || !\in_array($mapping['type'], ['string', 'text'], true)) {
  101.                 continue;
  102.             }
  104.             if (null === $lengthConstraint) {
  105.                 if (isset($mapping['originalClass']) && !str_contains($mapping['declaredField'], '.')) {
  106.                     $metadata->addPropertyConstraint($mapping['declaredField'], new Valid());
  107.                     $loaded = true;
  108.                 } elseif (property_exists($className, $mapping['fieldName'])) {
  109.                     $metadata->addPropertyConstraint($mapping['fieldName'], new Length(['max' => $mapping['length']]));
  110.                     $loaded = true;
  111.                 }
  112.             } elseif (null === $lengthConstraint->max) {
  113.                 // If a Length constraint exists and no max length has been explicitly defined, set it
  114.                 $lengthConstraint->max = $mapping['length'];
  115.             }
  116.         }
  118.         return $loaded;
  119.     }
  121.     private function getExistingUniqueFields(ClassMetadata $metadata): array
  122.     {
  123.         $fields = [];
  124.         foreach ($metadata->getConstraints() as $constraint) {
  125.             if (!$constraint instanceof UniqueEntity) {
  126.                 continue;
  127.             }
  129.             if (\is_string($constraint->fields)) {
  130.                 $fields[$constraint->fields] = true;
  131.             } elseif (\is_array($constraint->fields) && 1 === \count($constraint->fields)) {
  132.                 $fields[$constraint->fields[0]] = true;
  133.             }
  134.         }
  136.         return $fields;
  137.     }
  138. }