vendor/symfony/doctrine-bridge/ArgumentResolver/EntityValueResolver.php line 76

  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\ArgumentResolver;
  14. use Doctrine\DBAL\Types\ConversionException;
  15. use Doctrine\ORM\EntityManagerInterface;
  16. use Doctrine\ORM\NoResultException;
  17. use Doctrine\Persistence\ManagerRegistry;
  18. use Doctrine\Persistence\ObjectManager;
  19. use Symfony\Bridge\Doctrine\Attribute\MapEntity;
  20. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
  21. use Symfony\Component\HttpFoundation\Request;
  22. use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
  23. use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
  24. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  26. /**
  27.  * Yields the entity matching the criteria provided in the route.
  28.  *
  29.  * @author Fabien Potencier <fabien@symfony.com>
  30.  * @author Jérémy Derussé <jeremy@derusse.com>
  31.  */
  32. final class EntityValueResolver implements ValueResolverInterface
  33. {
  34.     public function __construct(
  35.         private ManagerRegistry $registry,
  36.         private ?ExpressionLanguage $expressionLanguage = null,
  37.         private MapEntity $defaults = new MapEntity(),
  38.     ) {
  39.     }
  41.     public function resolve(Request $request, ArgumentMetadata $argument): array
  42.     {
  43.         if (\is_object($request->attributes->get($argument->getName()))) {
  44.             return [];
  45.         }
  47.         $options = $argument->getAttributes(MapEntity::class, ArgumentMetadata::IS_INSTANCEOF);
  48.         $options = ($options[0] ?? $this->defaults)->withDefaults($this->defaults, $argument->getType());
  50.         if (!$options->class || $options->disabled) {
  51.             return [];
  52.         }
  53.         if (!$manager = $this->getManager($options->objectManager, $options->class)) {
  54.             return [];
  55.         }
  57.         $message = '';
  58.         if (null !== $options->expr) {
  59.             if (null === $object = $this->findViaExpression($manager, $request, $options)) {
  60.                 $message = sprintf(' The expression "%s" returned null.', $options->expr);
  61.             }
  62.         // find by identifier?
  63.         } elseif (false === $object = $this->find($manager, $request, $options, $argument->getName())) {
  64.             // find by criteria
  65.             if (!$criteria = $this->getCriteria($request, $options, $manager)) {
  66.                 return [];
  67.             }
  68.             try {
  69.                 $object = $manager->getRepository($options->class)->findOneBy($criteria);
  70.             } catch (NoResultException|ConversionException) {
  71.                 $object = null;
  72.             }
  73.         }
  75.         if (null === $object && !$argument->isNullable()) {
  76.             throw new NotFoundHttpException(sprintf('"%s" object not found by "%s".', $options->class, self::class).$message);
  77.         }
  79.         return [$object];
  80.     }
  82.     private function getManager(?string $name, string $class): ?ObjectManager
  83.     {
  84.         if (null === $name) {
  85.             return $this->registry->getManagerForClass($class);
  86.         }
  88.         try {
  89.             $manager = $this->registry->getManager($name);
  90.         } catch (\InvalidArgumentException) {
  91.             return null;
  92.         }
  94.         return $manager->getMetadataFactory()->isTransient($class) ? null : $manager;
  95.     }
  97.     private function find(ObjectManager $manager, Request $request, MapEntity $options, string $name): false|object|null
  98.     {
  99.         if ($options->mapping || $options->exclude) {
  100.             return false;
  101.         }
  103.         $id = $this->getIdentifier($request, $options, $name);
  104.         if (false === $id || null === $id) {
  105.             return $id;
  106.         }
  108.         if ($options->evictCache && $manager instanceof EntityManagerInterface) {
  109.             $cacheProvider = $manager->getCache();
  110.             if ($cacheProvider && $cacheProvider->containsEntity($options->class, $id)) {
  111.                 $cacheProvider->evictEntity($options->class, $id);
  112.             }
  113.         }
  115.         try {
  116.             return $manager->getRepository($options->class)->find($id);
  117.         } catch (NoResultException|ConversionException) {
  118.             return null;
  119.         }
  120.     }
  122.     private function getIdentifier(Request $request, MapEntity $options, string $name): mixed
  123.     {
  124.         if (\is_array($options->id)) {
  125.             $id = [];
  126.             foreach ($options->id as $field) {
  127.                 // Convert "%s_uuid" to "foobar_uuid"
  128.                 if (str_contains($field, '%s')) {
  129.                     $field = sprintf($field, $name);
  130.                 }
  132.                 $id[$field] = $request->attributes->get($field);
  133.             }
  135.             return $id;
  136.         }
  138.         if (null !== $options->id) {
  139.             $name = $options->id;
  140.         }
  142.         if ($request->attributes->has($name)) {
  143.             return $request->attributes->get($name) ?? ($options->stripNull ? false : null);
  144.         }
  146.         if (!$options->id && $request->attributes->has('id')) {
  147.             return $request->attributes->get('id') ?? ($options->stripNull ? false : null);
  148.         }
  150.         return false;
  151.     }
  153.     private function getCriteria(Request $request, MapEntity $options, ObjectManager $manager): array
  154.     {
  155.         if (null === $mapping = $options->mapping) {
  156.             $mapping = $request->attributes->keys();
  157.         }
  159.         if ($mapping && \is_array($mapping) && array_is_list($mapping)) {
  160.             $mapping = array_combine($mapping, $mapping);
  161.         }
  163.         foreach ($options->exclude as $exclude) {
  164.             unset($mapping[$exclude]);
  165.         }
  167.         if (!$mapping) {
  168.             return [];
  169.         }
  171.         // if a specific id has been defined in the options and there is no corresponding attribute
  172.         // return false in order to avoid a fallback to the id which might be of another object
  173.         if (\is_string($options->id) && null === $request->attributes->get($options->id)) {
  174.             return [];
  175.         }
  177.         $criteria = [];
  178.         $metadata = $manager->getClassMetadata($options->class);
  180.         foreach ($mapping as $attribute => $field) {
  181.             if (!$metadata->hasField($field) && (!$metadata->hasAssociation($field) || !$metadata->isSingleValuedAssociation($field))) {
  182.                 continue;
  183.             }
  185.             $criteria[$field] = $request->attributes->get($attribute);
  186.         }
  188.         if ($options->stripNull) {
  189.             $criteria = array_filter($criteria, static fn ($value) => null !== $value);
  190.         }
  192.         return $criteria;
  193.     }
  195.     private function findViaExpression(ObjectManager $manager, Request $request, MapEntity $options): ?object
  196.     {
  197.         if (!$this->expressionLanguage) {
  198.             throw new \LogicException(sprintf('You cannot use the "%s" if the ExpressionLanguage component is not available. Try running "composer require symfony/expression-language".', __CLASS__));
  199.         }
  201.         $repository = $manager->getRepository($options->class);
  202.         $variables = array_merge($request->attributes->all(), ['repository' => $repository]);
  204.         try {
  205.             return $this->expressionLanguage->evaluate($options->expr, $variables);
  206.         } catch (NoResultException|ConversionException) {
  207.             return null;
  208.         }
  209.     }
  210. }