Actualización

vendor/symfony/doctrine-bridge/Validator/Constraints/UniqueEntity.php

@@ -0,0 +1,67 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bridge\Doctrine\Validator\Constraints;
+
+use Symfony\Component\Validator\Constraint;
+
+/**
+ * Constraint for the Unique Entity validator.
+ *
+ * @Annotation
+ * @Target({"CLASS", "ANNOTATION"})
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class UniqueEntity extends Constraint
+{
+    const NOT_UNIQUE_ERROR = '23bd9dbf-6b9b-41cd-a99e-4844bcf3077f';
+
+    public $message = 'This value is already used.';
+    public $service = 'doctrine.orm.validator.unique';
+    public $em = null;
+    public $repositoryMethod = 'findBy';
+    public $fields = array();
+    public $errorPath = null;
+    public $ignoreNull = true;
+
+    protected static $errorNames = array(
+        self::NOT_UNIQUE_ERROR => 'NOT_UNIQUE_ERROR',
+    );
+
+    public function getRequiredOptions()
+    {
+        return array('fields');
+    }
+
+    /**
+     * The validator must be defined as a service with this name.
+     *
+     * @return string
+     */
+    public function validatedBy()
+    {
+        return $this->service;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getTargets()
+    {
+        return self::CLASS_CONSTRAINT;
+    }
+
+    public function getDefaultOption()
+    {
+        return 'fields';
+    }
+}

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

@@ -0,0 +1,173 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bridge\Doctrine\Validator\Constraints;
+
+use Doctrine\Common\Persistence\ManagerRegistry;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
+use Symfony\Component\Validator\Exception\UnexpectedTypeException;
+
+/**
+ * Unique Entity Validator checks if one or a set of fields contain unique values.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class UniqueEntityValidator extends ConstraintValidator
+{
+    private $registry;
+
+    public function __construct(ManagerRegistry $registry)
+    {
+        $this->registry = $registry;
+    }
+
+    /**
+     * @param object     $entity
+     * @param Constraint $constraint
+     *
+     * @throws UnexpectedTypeException
+     * @throws ConstraintDefinitionException
+     */
+    public function validate($entity, Constraint $constraint)
+    {
+        if (!$constraint instanceof UniqueEntity) {
+            throw new UnexpectedTypeException($constraint, __NAMESPACE__.'\UniqueEntity');
+        }
+
+        if (!\is_array($constraint->fields) && !\is_string($constraint->fields)) {
+            throw new UnexpectedTypeException($constraint->fields, 'array');
+        }
+
+        if (null !== $constraint->errorPath && !\is_string($constraint->errorPath)) {
+            throw new UnexpectedTypeException($constraint->errorPath, 'string or null');
+        }
+
+        $fields = (array) $constraint->fields;
+
+        if (0 === \count($fields)) {
+            throw new ConstraintDefinitionException('At least one field has to be specified.');
+        }
+
+        if (null === $entity) {
+            return;
+        }
+
+        if ($constraint->em) {
+            $em = $this->registry->getManager($constraint->em);
+
+            if (!$em) {
+                throw new ConstraintDefinitionException(sprintf('Object manager "%s" does not exist.', $constraint->em));
+            }
+        } else {
+            $em = $this->registry->getManagerForClass(\get_class($entity));
+
+            if (!$em) {
+                throw new ConstraintDefinitionException(sprintf('Unable to find the object manager associated with an entity of class "%s".', \get_class($entity)));
+            }
+        }
+
+        $class = $em->getClassMetadata(\get_class($entity));
+        /* @var $class \Doctrine\Common\Persistence\Mapping\ClassMetadata */
+
+        $criteria = array();
+        $hasNullValue = false;
+
+        foreach ($fields as $fieldName) {
+            if (!$class->hasField($fieldName) && !$class->hasAssociation($fieldName)) {
+                throw new ConstraintDefinitionException(sprintf('The field "%s" is not mapped by Doctrine, so it cannot be validated for uniqueness.', $fieldName));
+            }
+
+            $fieldValue = $class->reflFields[$fieldName]->getValue($entity);
+
+            if (null === $fieldValue) {
+                $hasNullValue = true;
+            }
+
+            if ($constraint->ignoreNull && null === $fieldValue) {
+                continue;
+            }
+
+            $criteria[$fieldName] = $fieldValue;
+
+            if (null !== $criteria[$fieldName] && $class->hasAssociation($fieldName)) {
+                /* Ensure the Proxy is initialized before using reflection to
+                 * read its identifiers. This is necessary because the wrapped
+                 * getter methods in the Proxy are being bypassed.
+                 */
+                $em->initializeObject($criteria[$fieldName]);
+            }
+        }
+
+        // validation doesn't fail if one of the fields is null and if null values should be ignored
+        if ($hasNullValue && $constraint->ignoreNull) {
+            return;
+        }
+
+        // skip validation if there are no criteria (this can happen when the
+        // "ignoreNull" option is enabled and fields to be checked are null
+        if (empty($criteria)) {
+            return;
+        }
+
+        $repository = $em->getRepository(\get_class($entity));
+        $result = $repository->{$constraint->repositoryMethod}($criteria);
+
+        if ($result instanceof \IteratorAggregate) {
+            $result = $result->getIterator();
+        }
+
+        /* If the result is a MongoCursor, it must be advanced to the first
+         * element. Rewinding should have no ill effect if $result is another
+         * iterator implementation.
+         */
+        if ($result instanceof \Iterator) {
+            $result->rewind();
+            if ($result instanceof \Countable && 1 < \count($result)) {
+                $result = array($result->current(), $result->current());
+            } else {
+                $result = $result->current();
+                $result = null === $result ? array() : array($result);
+            }
+        } elseif (\is_array($result)) {
+            reset($result);
+        } else {
+            $result = null === $result ? array() : array($result);
+        }
+
+        /* If no entity matched the query criteria or a single entity matched,
+         * which is the same as the entity being validated, the criteria is
+         * unique.
+         */
+        if (!$result || (1 === \count($result) && current($result) === $entity)) {
+            return;
+        }
+
+        $errorPath = null !== $constraint->errorPath ? $constraint->errorPath : $fields[0];
+        $invalidValue = isset($criteria[$errorPath]) ? $criteria[$errorPath] : $criteria[$fields[0]];
+
+        if ($this->context instanceof ExecutionContextInterface) {
+            $this->context->buildViolation($constraint->message)
+                ->atPath($errorPath)
+                ->setInvalidValue($invalidValue)
+                ->setCode(UniqueEntity::NOT_UNIQUE_ERROR)
+                ->addViolation();
+        } else {
+            $this->buildViolation($constraint->message)
+                ->atPath($errorPath)
+                ->setInvalidValue($invalidValue)
+                ->setCode(UniqueEntity::NOT_UNIQUE_ERROR)
+                ->addViolation();
+        }
+    }
+}