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

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\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 $entityManager;
  37.     private $classValidatorRegexp;
  39.     public function __construct(EntityManagerInterface $entityManager, string $classValidatorRegexp = null)
  40.     {
  41.         $this->entityManager = $entityManager;
  42.         $this->classValidatorRegexp = $classValidatorRegexp;
  43.     }
  45.     /**
  46.      * {@inheritdoc}
  47.      */
  48.     public function loadClassMetadata(ClassMetadata $metadata): bool
  49.     {
  50.         $className = $metadata->getClassName();
  51.         try {
  52.             $doctrineMetadata = $this->entityManager->getClassMetadata($className);
  53.         } catch (MappingException|OrmMappingException $exception) {
  54.             return false;
  55.         }
  57.         if (!$doctrineMetadata instanceof ClassMetadataInfo) {
  58.             return false;
  59.         }
  61.         $loaded = false;
  62.         $enabledForClass = $this->isAutoMappingEnabledForClass($metadata, $this->classValidatorRegexp);
  64.         /* Available keys:
  65.            - type
  66.            - scale
  67.            - length
  68.            - unique
  69.            - nullable
  70.            - precision
  71.          */
  72.         $existingUniqueFields = $this->getExistingUniqueFields($metadata);
  74.         // Type and nullable aren't handled here, use the PropertyInfo Loader instead.
  75.         foreach ($doctrineMetadata->fieldMappings as $mapping) {
  76.             $enabledForProperty = $enabledForClass;
  77.             $lengthConstraint = null;
  78.             foreach ($metadata->getPropertyMetadata($mapping['fieldName']) as $propertyMetadata) {
  79.                 // Enabling or disabling auto-mapping explicitly always takes precedence
  80.                 if (AutoMappingStrategy::DISABLED === $propertyMetadata->getAutoMappingStrategy()) {
  81.                     continue 2;
  82.                 }
  83.                 if (AutoMappingStrategy::ENABLED === $propertyMetadata->getAutoMappingStrategy()) {
  84.                     $enabledForProperty = true;
  85.                 }
  87.                 foreach ($propertyMetadata->getConstraints() as $constraint) {
  88.                     if ($constraint instanceof Length) {
  89.                         $lengthConstraint = $constraint;
  90.                     }
  91.                 }
  92.             }
  94.             if (!$enabledForProperty) {
  95.                 continue;
  96.             }
  98.             if (true === ($mapping['unique'] ?? false) && !isset($existingUniqueFields[$mapping['fieldName']])) {
  99.                 $metadata->addConstraint(new UniqueEntity(['fields' => $mapping['fieldName']]));
  100.                 $loaded = true;
  101.             }
  103.             if (null === ($mapping['length'] ?? null) || null !== ($mapping['enumType'] ?? null) || !\in_array($mapping['type'], ['string', 'text'], true)) {
  104.                 continue;
  105.             }
  107.             if (null === $lengthConstraint) {
  108.                 if (isset($mapping['originalClass']) && !str_contains($mapping['declaredField'], '.')) {
  109.                     $metadata->addPropertyConstraint($mapping['declaredField'], new Valid());
  110.                     $loaded = true;
  111.                 } elseif (property_exists($className, $mapping['fieldName'])) {
  112.                     $metadata->addPropertyConstraint($mapping['fieldName'], new Length(['max' => $mapping['length']]));
  113.                     $loaded = true;
  114.                 }
  115.             } elseif (null === $lengthConstraint->max) {
  116.                 // If a Length constraint exists and no max length has been explicitly defined, set it
  117.                 $lengthConstraint->max = $mapping['length'];
  118.             }
  119.         }
  121.         return $loaded;
  122.     }
  124.     private function getExistingUniqueFields(ClassMetadata $metadata): array
  125.     {
  126.         $fields = [];
  127.         foreach ($metadata->getConstraints() as $constraint) {
  128.             if (!$constraint instanceof UniqueEntity) {
  129.                 continue;
  130.             }
  132.             if (\is_string($constraint->fields)) {
  133.                 $fields[$constraint->fields] = true;
  134.             } elseif (\is_array($constraint->fields) && 1 === \count($constraint->fields)) {
  135.                 $fields[$constraint->fields[0]] = true;
  136.             }
  137.         }
  139.         return $fields;
  140.     }
  141. }