vendor/symfony/doctrine-bridge/Validator/Constraints/UniqueEntityValidator.php line 43

  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\Constraints;
  14. use Doctrine\Persistence\ManagerRegistry;
  15. use Doctrine\Persistence\Mapping\ClassMetadata;
  16. use Doctrine\Persistence\ObjectManager;
  17. use Symfony\Component\Validator\Constraint;
  18. use Symfony\Component\Validator\ConstraintValidator;
  19. use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
  20. use Symfony\Component\Validator\Exception\UnexpectedTypeException;
  21. use Symfony\Component\Validator\Exception\UnexpectedValueException;
  23. /**
  24.  * Unique Entity Validator checks if one or a set of fields contain unique values.
  25.  *
  26.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  27.  */
  28. class UniqueEntityValidator extends ConstraintValidator
  29. {
  30.     private ManagerRegistry $registry;
  32.     public function __construct(ManagerRegistry $registry)
  33.     {
  34.         $this->registry = $registry;
  35.     }
  37.     /**
  38.      * @param object $entity
  39.      *
  40.      * @throws UnexpectedTypeException
  41.      * @throws ConstraintDefinitionException
  42.      */
  43.     public function validate(mixed $entity, Constraint $constraint)
  44.     {
  45.         if (!$constraint instanceof UniqueEntity) {
  46.             throw new UnexpectedTypeException($constraint, UniqueEntity::class);
  47.         }
  49.         if (!\is_array($constraint->fields) && !\is_string($constraint->fields)) {
  50.             throw new UnexpectedTypeException($constraint->fields, 'array');
  51.         }
  53.         if (null !== $constraint->errorPath && !\is_string($constraint->errorPath)) {
  54.             throw new UnexpectedTypeException($constraint->errorPath, 'string or null');
  55.         }
  57.         $fields = (array) $constraint->fields;
  59.         if (0 === \count($fields)) {
  60.             throw new ConstraintDefinitionException('At least one field has to be specified.');
  61.         }
  63.         if (null === $entity) {
  64.             return;
  65.         }
  67.         if (!\is_object($entity)) {
  68.             throw new UnexpectedValueException($entity, 'object');
  69.         }
  71.         if ($constraint->em) {
  72.             $em = $this->registry->getManager($constraint->em);
  74.             if (!$em) {
  75.                 throw new ConstraintDefinitionException(sprintf('Object manager "%s" does not exist.', $constraint->em));
  76.             }
  77.         } else {
  78.             $em = $this->registry->getManagerForClass($entity::class);
  80.             if (!$em) {
  81.                 throw new ConstraintDefinitionException(sprintf('Unable to find the object manager associated with an entity of class "%s".', get_debug_type($entity)));
  82.             }
  83.         }
  85.         $class = $em->getClassMetadata($entity::class);
  87.         $criteria = [];
  88.         $hasNullValue = false;
  90.         foreach ($fields as $fieldName) {
  91.             if (!$class->hasField($fieldName) && !$class->hasAssociation($fieldName)) {
  92.                 throw new ConstraintDefinitionException(sprintf('The field "%s" is not mapped by Doctrine, so it cannot be validated for uniqueness.', $fieldName));
  93.             }
  95.             $fieldValue = $class->reflFields[$fieldName]->getValue($entity);
  97.             if (null === $fieldValue) {
  98.                 $hasNullValue = true;
  99.             }
  101.             if ($constraint->ignoreNull && null === $fieldValue) {
  102.                 continue;
  103.             }
  105.             $criteria[$fieldName] = $fieldValue;
  107.             if (null !== $criteria[$fieldName] && $class->hasAssociation($fieldName)) {
  108.                 /* Ensure the Proxy is initialized before using reflection to
  109.                  * read its identifiers. This is necessary because the wrapped
  110.                  * getter methods in the Proxy are being bypassed.
  111.                  */
  112.                 $em->initializeObject($criteria[$fieldName]);
  113.             }
  114.         }
  116.         // validation doesn't fail if one of the fields is null and if null values should be ignored
  117.         if ($hasNullValue && $constraint->ignoreNull) {
  118.             return;
  119.         }
  121.         // skip validation if there are no criteria (this can happen when the
  122.         // "ignoreNull" option is enabled and fields to be checked are null
  123.         if (empty($criteria)) {
  124.             return;
  125.         }
  127.         if (null !== $constraint->entityClass) {
  128.             /* Retrieve repository from given entity name.
  129.              * We ensure the retrieved repository can handle the entity
  130.              * by checking the entity is the same, or subclass of the supported entity.
  131.              */
  132.             $repository = $em->getRepository($constraint->entityClass);
  133.             $supportedClass = $repository->getClassName();
  135.             if (!$entity instanceof $supportedClass) {
  136.                 throw new ConstraintDefinitionException(sprintf('The "%s" entity repository does not support the "%s" entity. The entity should be an instance of or extend "%s".', $constraint->entityClass, $class->getName(), $supportedClass));
  137.             }
  138.         } else {
  139.             $repository = $em->getRepository($entity::class);
  140.         }
  142.         $arguments = [$criteria];
  144.         /* If the default repository method is used, it is always enough to retrieve at most two entities because:
  145.          * - No entity returned, the current entity is definitely unique.
  146.          * - More than one entity returned, the current entity cannot be unique.
  147.          * - One entity returned the uniqueness depends on the current entity.
  148.          */
  149.         if ('findBy' === $constraint->repositoryMethod) {
  150.             $arguments = [$criteria, null, 2];
  151.         }
  153.         $result = $repository->{$constraint->repositoryMethod}(...$arguments);
  155.         if ($result instanceof \IteratorAggregate) {
  156.             $result = $result->getIterator();
  157.         }
  159.         /* If the result is a MongoCursor, it must be advanced to the first
  160.          * element. Rewinding should have no ill effect if $result is another
  161.          * iterator implementation.
  162.          */
  163.         if ($result instanceof \Iterator) {
  164.             $result->rewind();
  165.             if ($result instanceof \Countable && 1 < \count($result)) {
  166.                 $result = [$result->current(), $result->current()];
  167.             } else {
  168.                 $result = $result->valid() && null !== $result->current() ? [$result->current()] : [];
  169.             }
  170.         } elseif (\is_array($result)) {
  171.             reset($result);
  172.         } else {
  173.             $result = null === $result ? [] : [$result];
  174.         }
  176.         /* If no entity matched the query criteria or a single entity matched,
  177.          * which is the same as the entity being validated, the criteria is
  178.          * unique.
  179.          */
  180.         if (!$result || (1 === \count($result) && current($result) === $entity)) {
  181.             return;
  182.         }
  184.         $errorPath = $constraint->errorPath ?? $fields[0];
  185.         $invalidValue = $criteria[$errorPath] ?? $criteria[$fields[0]];
  187.         $this->context->buildViolation($constraint->message)
  188.             ->atPath($errorPath)
  189.             ->setParameter('{{ value }}', $this->formatWithIdentifiers($em, $class, $invalidValue))
  190.             ->setInvalidValue($invalidValue)
  191.             ->setCode(UniqueEntity::NOT_UNIQUE_ERROR)
  192.             ->setCause($result)
  193.             ->addViolation();
  194.     }
  196.     private function formatWithIdentifiers(ObjectManager $em, ClassMetadata $class, mixed $value)
  197.     {
  198.         if (!\is_object($value) || $value instanceof \DateTimeInterface) {
  199.             return $this->formatValue($value, self::PRETTY_DATE);
  200.         }
  202.         if ($value instanceof \Stringable) {
  203.             return (string) $value;
  204.         }
  206.         if ($class->getName() !== $idClass = $value::class) {
  207.             // non unique value might be a composite PK that consists of other entity objects
  208.             if ($em->getMetadataFactory()->hasMetadataFor($idClass)) {
  209.                 $identifiers = $em->getClassMetadata($idClass)->getIdentifierValues($value);
  210.             } else {
  211.                 // this case might happen if the non unique column has a custom doctrine type and its value is an object
  212.                 // in which case we cannot get any identifiers for it
  213.                 $identifiers = [];
  214.             }
  215.         } else {
  216.             $identifiers = $class->getIdentifierValues($value);
  217.         }
  219.         if (!$identifiers) {
  220.             return sprintf('object("%s")', $idClass);
  221.         }
  223.         array_walk($identifiers, function (&$id, $field) {
  224.             if (!\is_object($id) || $id instanceof \DateTimeInterface) {
  225.                 $idAsString = $this->formatValue($id, self::PRETTY_DATE);
  226.             } else {
  227.                 $idAsString = sprintf('object("%s")', $id::class);
  228.             }
  230.             $id = sprintf('%s => %s', $field, $idAsString);
  231.         });
  233.         return sprintf('object("%s") identified by (%s)', $idClass, implode(', ', $identifiers));
  234.     }
  235. }