Subida del módulo y tema de PrestaShop

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

@@ -0,0 +1,103 @@
+<?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>
+ */
+#[\Attribute(\Attribute::TARGET_CLASS | \Attribute::IS_REPEATABLE)]
+class UniqueEntity extends Constraint
+{
+    public const NOT_UNIQUE_ERROR = '23bd9dbf-6b9b-41cd-a99e-4844bcf3077f';
+
+    protected const ERROR_NAMES = [
+        self::NOT_UNIQUE_ERROR => 'NOT_UNIQUE_ERROR',
+    ];
+
+    public $message = 'This value is already used.';
+    public $service = 'doctrine.orm.validator.unique';
+    public $em;
+    public $entityClass;
+    public $repositoryMethod = 'findBy';
+    public $fields = [];
+    public $errorPath;
+    public $ignoreNull = true;
+
+    /**
+     * @deprecated since Symfony 6.1, use const ERROR_NAMES instead
+     */
+    protected static $errorNames = self::ERROR_NAMES;
+
+    /**
+     * @param array|string      $fields     The combination of fields that must contain unique values or a set of options
+     * @param bool|array|string $ignoreNull The combination of fields that ignore null values
+     */
+    public function __construct(
+        $fields,
+        ?string $message = null,
+        ?string $service = null,
+        ?string $em = null,
+        ?string $entityClass = null,
+        ?string $repositoryMethod = null,
+        ?string $errorPath = null,
+        bool|string|array|null $ignoreNull = null,
+        ?array $groups = null,
+        $payload = null,
+        array $options = [],
+    ) {
+        if (\is_array($fields) && \is_string(key($fields))) {
+            $options = array_merge($fields, $options);
+        } elseif (null !== $fields) {
+            $options['fields'] = $fields;
+        }
+
+        parent::__construct($options, $groups, $payload);
+
+        $this->message = $message ?? $this->message;
+        $this->service = $service ?? $this->service;
+        $this->em = $em ?? $this->em;
+        $this->entityClass = $entityClass ?? $this->entityClass;
+        $this->repositoryMethod = $repositoryMethod ?? $this->repositoryMethod;
+        $this->errorPath = $errorPath ?? $this->errorPath;
+        $this->ignoreNull = $ignoreNull ?? $this->ignoreNull;
+    }
+
+    public function getRequiredOptions(): array
+    {
+        return ['fields'];
+    }
+
+    /**
+     * The validator must be defined as a service with this name.
+     */
+    public function validatedBy(): string
+    {
+        return $this->service;
+    }
+
+    public function getTargets(): string|array
+    {
+        return self::CLASS_CONSTRAINT;
+    }
+
+    public function getDefaultOption(): ?string
+    {
+        return 'fields';
+    }
+}

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

@@ -0,0 +1,246 @@
+<?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\Persistence\ManagerRegistry;
+use Doctrine\Persistence\Mapping\ClassMetadata;
+use Doctrine\Persistence\ObjectManager;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
+use Symfony\Component\Validator\Exception\UnexpectedTypeException;
+use Symfony\Component\Validator\Exception\UnexpectedValueException;
+
+/**
+ * Unique Entity Validator checks if one or a set of fields contain unique values.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class UniqueEntityValidator extends ConstraintValidator
+{
+    public function __construct(
+        private readonly ManagerRegistry $registry,
+    ) {
+    }
+
+    /**
+     * @param object $entity
+     *
+     * @return void
+     *
+     * @throws UnexpectedTypeException
+     * @throws ConstraintDefinitionException
+     */
+    public function validate(mixed $entity, Constraint $constraint)
+    {
+        if (!$constraint instanceof UniqueEntity) {
+            throw new UnexpectedTypeException($constraint, UniqueEntity::class);
+        }
+
+        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 (!\is_object($entity)) {
+            throw new UnexpectedValueException($entity, 'object');
+        }
+
+        if ($constraint->em) {
+            try {
+                $em = $this->registry->getManager($constraint->em);
+            } catch (\InvalidArgumentException $e) {
+                throw new ConstraintDefinitionException(\sprintf('Object manager "%s" does not exist.', $constraint->em), 0, $e);
+            }
+        } else {
+            $em = $this->registry->getManagerForClass($entity::class);
+
+            if (!$em) {
+                throw new ConstraintDefinitionException(\sprintf('Unable to find the object manager associated with an entity of class "%s".', get_debug_type($entity)));
+            }
+        }
+
+        $class = $em->getClassMetadata($entity::class);
+
+        $criteria = [];
+        $hasIgnorableNullValue = 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));
+            }
+
+            if (property_exists($class, 'propertyAccessors')) {
+                $fieldValue = $class->propertyAccessors[$fieldName]->getValue($entity);
+            } else {
+                $fieldValue = $class->reflFields[$fieldName]->getValue($entity);
+            }
+
+            if (null === $fieldValue && $this->ignoreNullForField($constraint, $fieldName)) {
+                $hasIgnorableNullValue = true;
+
+                continue;
+            }
+
+            $criteria[$fieldName] = $fieldValue;
+
+            if (\is_object($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 ($hasIgnorableNullValue) {
+            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;
+        }
+
+        if (null !== $constraint->entityClass) {
+            /* Retrieve repository from given entity name.
+             * We ensure the retrieved repository can handle the entity
+             * by checking the entity is the same, or subclass of the supported entity.
+             */
+            $repository = $em->getRepository($constraint->entityClass);
+            $supportedClass = $repository->getClassName();
+
+            if (!$entity instanceof $supportedClass) {
+                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));
+            }
+        } else {
+            $repository = $em->getRepository($entity::class);
+        }
+
+        $arguments = [$criteria];
+
+        /* If the default repository method is used, it is always enough to retrieve at most two entities because:
+         * - No entity returned, the current entity is definitely unique.
+         * - More than one entity returned, the current entity cannot be unique.
+         * - One entity returned the uniqueness depends on the current entity.
+         */
+        if ('findBy' === $constraint->repositoryMethod) {
+            $arguments = [$criteria, null, 2];
+        }
+
+        $result = $repository->{$constraint->repositoryMethod}(...$arguments);
+
+        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 = [$result->current(), $result->current()];
+            } else {
+                $result = $result->valid() && null !== $result->current() ? [$result->current()] : [];
+            }
+        } elseif (\is_array($result)) {
+            reset($result);
+        } else {
+            $result = null === $result ? [] : [$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 = $constraint->errorPath ?? $fields[0];
+        $invalidValue = $criteria[$errorPath] ?? $criteria[$fields[0]];
+
+        $this->context->buildViolation($constraint->message)
+            ->atPath($errorPath)
+            ->setParameter('{{ value }}', $this->formatWithIdentifiers($em, $class, $invalidValue))
+            ->setInvalidValue($invalidValue)
+            ->setCode(UniqueEntity::NOT_UNIQUE_ERROR)
+            ->setCause($result)
+            ->addViolation();
+    }
+
+    private function ignoreNullForField(UniqueEntity $constraint, string $fieldName): bool
+    {
+        if (\is_bool($constraint->ignoreNull)) {
+            return $constraint->ignoreNull;
+        }
+
+        return \in_array($fieldName, (array) $constraint->ignoreNull, true);
+    }
+
+    private function formatWithIdentifiers(ObjectManager $em, ClassMetadata $class, mixed $value): string
+    {
+        if (!\is_object($value) || $value instanceof \DateTimeInterface) {
+            return $this->formatValue($value, self::PRETTY_DATE);
+        }
+
+        if ($value instanceof \Stringable) {
+            return (string) $value;
+        }
+
+        if ($class->getName() !== $idClass = $value::class) {
+            // non unique value might be a composite PK that consists of other entity objects
+            if ($em->getMetadataFactory()->hasMetadataFor($idClass)) {
+                $identifiers = $em->getClassMetadata($idClass)->getIdentifierValues($value);
+            } else {
+                // this case might happen if the non unique column has a custom doctrine type and its value is an object
+                // in which case we cannot get any identifiers for it
+                $identifiers = [];
+            }
+        } else {
+            $identifiers = $class->getIdentifierValues($value);
+        }
+
+        if (!$identifiers) {
+            return \sprintf('object("%s")', $idClass);
+        }
+
+        array_walk($identifiers, function (&$id, $field) {
+            if (!\is_object($id) || $id instanceof \DateTimeInterface) {
+                $idAsString = $this->formatValue($id, self::PRETTY_DATE);
+            } else {
+                $idAsString = \sprintf('object("%s")', $id::class);
+            }
+
+            $id = \sprintf('%s => %s', $field, $idAsString);
+        });
+
+        return \sprintf('object("%s") identified by (%s)', $idClass, implode(', ', $identifiers));
+    }
+}

vendor/symfony/doctrine-bridge/Validator/DoctrineInitializer.php

@@ -0,0 +1,38 @@
+<?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;
+
+use Doctrine\Persistence\ManagerRegistry;
+use Symfony\Component\Validator\ObjectInitializerInterface;
+
+/**
+ * Automatically loads proxy object before validation.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class DoctrineInitializer implements ObjectInitializerInterface
+{
+    protected $registry;
+
+    public function __construct(ManagerRegistry $registry)
+    {
+        $this->registry = $registry;
+    }
+
+    /**
+     * @return void
+     */
+    public function initialize(object $object)
+    {
+        $this->registry->getManagerForClass($object::class)?->initializeObject($object);
+    }
+}

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

@@ -0,0 +1,145 @@
+<?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;
+
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\ClassMetadata as OrmClassMetadata;
+use Doctrine\ORM\Mapping\FieldMapping;
+use Doctrine\ORM\Mapping\MappingException as OrmMappingException;
+use Doctrine\Persistence\Mapping\MappingException;
+use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
+use Symfony\Component\PropertyInfo\Type;
+use Symfony\Component\Validator\Constraints\Length;
+use Symfony\Component\Validator\Constraints\Valid;
+use Symfony\Component\Validator\Mapping\AutoMappingStrategy;
+use Symfony\Component\Validator\Mapping\ClassMetadata;
+use Symfony\Component\Validator\Mapping\Loader\AutoMappingTrait;
+use Symfony\Component\Validator\Mapping\Loader\LoaderInterface;
+
+/**
+ * Guesses and loads the appropriate constraints using Doctrine's metadata.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+final class DoctrineLoader implements LoaderInterface
+{
+    use AutoMappingTrait;
+
+    public function __construct(
+        private readonly EntityManagerInterface $entityManager,
+        private readonly ?string $classValidatorRegexp = null,
+    ) {
+    }
+
+    public function loadClassMetadata(ClassMetadata $metadata): bool
+    {
+        $className = $metadata->getClassName();
+        try {
+            $doctrineMetadata = $this->entityManager->getClassMetadata($className);
+        } catch (MappingException|OrmMappingException) {
+            return false;
+        }
+
+        if (!$doctrineMetadata instanceof OrmClassMetadata) {
+            return false;
+        }
+
+        $loaded = false;
+        $enabledForClass = $this->isAutoMappingEnabledForClass($metadata, $this->classValidatorRegexp);
+
+        /* Available keys:
+           - type
+           - scale
+           - length
+           - unique
+           - nullable
+           - precision
+         */
+        $existingUniqueFields = $this->getExistingUniqueFields($metadata);
+
+        // Type and nullable aren't handled here, use the PropertyInfo Loader instead.
+        foreach ($doctrineMetadata->fieldMappings as $mapping) {
+            $enabledForProperty = $enabledForClass;
+            $lengthConstraint = null;
+            foreach ($metadata->getPropertyMetadata(self::getFieldMappingValue($mapping, 'fieldName')) as $propertyMetadata) {
+                // Enabling or disabling auto-mapping explicitly always takes precedence
+                if (AutoMappingStrategy::DISABLED === $propertyMetadata->getAutoMappingStrategy()) {
+                    continue 2;
+                }
+                if (AutoMappingStrategy::ENABLED === $propertyMetadata->getAutoMappingStrategy()) {
+                    $enabledForProperty = true;
+                }
+
+                foreach ($propertyMetadata->getConstraints() as $constraint) {
+                    if ($constraint instanceof Length) {
+                        $lengthConstraint = $constraint;
+                    }
+                }
+            }
+
+            if (!$enabledForProperty) {
+                continue;
+            }
+
+            if (true === (self::getFieldMappingValue($mapping, 'unique') ?? false) && !isset($existingUniqueFields[self::getFieldMappingValue($mapping, 'fieldName')])) {
+                $metadata->addConstraint(new UniqueEntity(['fields' => self::getFieldMappingValue($mapping, 'fieldName')]));
+                $loaded = true;
+            }
+
+            if (null === (self::getFieldMappingValue($mapping, 'length') ?? null) || null !== (self::getFieldMappingValue($mapping, 'enumType') ?? null) || !\in_array(self::getFieldMappingValue($mapping, 'type'), ['string', 'text'], true)) {
+                continue;
+            }
+
+            if (null === $lengthConstraint) {
+                if (self::getFieldMappingValue($mapping, 'originalClass') && !str_contains(self::getFieldMappingValue($mapping, 'declaredField'), '.')) {
+                    $metadata->addPropertyConstraint(self::getFieldMappingValue($mapping, 'declaredField'), new Valid());
+                    $loaded = true;
+                } elseif (property_exists($className, self::getFieldMappingValue($mapping, 'fieldName')) && (!$doctrineMetadata->isMappedSuperclass || $metadata->getReflectionClass()->getProperty(self::getFieldMappingValue($mapping, 'fieldName'))->isPrivate())) {
+                    $metadata->addPropertyConstraint(self::getFieldMappingValue($mapping, 'fieldName'), new Length(['max' => self::getFieldMappingValue($mapping, 'length')]));
+                    $loaded = true;
+                }
+            } elseif (null === $lengthConstraint->max) {
+                // If a Length constraint exists and no max length has been explicitly defined, set it
+                $lengthConstraint->max = self::getFieldMappingValue($mapping, 'length');
+            }
+        }
+
+        return $loaded;
+    }
+
+    private function getExistingUniqueFields(ClassMetadata $metadata): array
+    {
+        $fields = [];
+        foreach ($metadata->getConstraints() as $constraint) {
+            if (!$constraint instanceof UniqueEntity) {
+                continue;
+            }
+
+            if (\is_string($constraint->fields)) {
+                $fields[$constraint->fields] = true;
+            } elseif (\is_array($constraint->fields) && 1 === \count($constraint->fields)) {
+                $fields[$constraint->fields[0]] = true;
+            }
+        }
+
+        return $fields;
+    }
+
+    private static function getFieldMappingValue(array|FieldMapping $mapping, string $key): mixed
+    {
+        if ($mapping instanceof FieldMapping) {
+            return $mapping->$key ?? null;
+        }
+
+        return $mapping[$key] ?? null;
+    }
+}