vendor/sensio/framework-extra-bundle/src/Request/ParamConverter/DoctrineParamConverter.php line 115

  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 Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter;
  14. use Doctrine\DBAL\Types\ConversionException;
  15. use Doctrine\ORM\EntityManagerInterface;
  16. use Doctrine\ORM\NoResultException;
  17. use Doctrine\Persistence\ManagerRegistry;
  18. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  19. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
  20. use Symfony\Component\ExpressionLanguage\SyntaxError;
  21. use Symfony\Component\HttpFoundation\Request;
  22. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  24. /**
  25.  * DoctrineParamConverter.
  26.  *
  27.  * @author Fabien Potencier <fabien@symfony.com>
  28.  */
  29. class DoctrineParamConverter implements ParamConverterInterface
  30. {
  31.     /**
  32.      * @var ManagerRegistry
  33.      */
  34.     private $registry;
  36.     /**
  37.      * @var ExpressionLanguage
  38.      */
  39.     private $language;
  41.     /**
  42.      * @var array
  43.      */
  44.     private $defaultOptions;
  46.     public function __construct(ManagerRegistry $registry = null, ExpressionLanguage $expressionLanguage = null, array $options = [])
  47.     {
  48.         $this->registry = $registry;
  49.         $this->language = $expressionLanguage;
  51.         $defaultValues = [
  52.             'entity_manager' => null,
  53.             'exclude' => [],
  54.             'mapping' => [],
  55.             'strip_null' => false,
  56.             'expr' => null,
  57.             'id' => null,
  58.             'repository_method' => null,
  59.             'map_method_signature' => false,
  60.             'evict_cache' => false,
  61.         ];
  63.         $this->defaultOptions = array_merge($defaultValues, $options);
  64.     }
  66.     /**
  67.      * {@inheritdoc}
  68.      *
  69.      * @throws \LogicException       When unable to guess how to get a Doctrine instance from the request information
  70.      * @throws NotFoundHttpException When object not found
  71.      */
  72.     public function apply(Request $request, ParamConverter $configuration)
  73.     {
  74.         $name = $configuration->getName();
  75.         $class = $configuration->getClass();
  76.         $options = $this->getOptions($configuration);
  78.         if (null === $request->attributes->get($name, false)) {
  79.             $configuration->setIsOptional(true);
  80.         }
  82.         $errorMessage = null;
  83.         if ($expr = $options['expr']) {
  84.             $object = $this->findViaExpression($class, $request, $expr, $options, $configuration);
  86.             if (null === $object) {
  87.                 $errorMessage = sprintf('The expression "%s" returned null', $expr);
  88.             }
  90.             // find by identifier?
  91.         } elseif (false === $object = $this->find($class, $request, $options, $name)) {
  92.             // find by criteria
  93.             if (false === $object = $this->findOneBy($class, $request, $options)) {
  94.                 if ($configuration->isOptional()) {
  95.                     $object = null;
  96.                 } else {
  97.                     throw new \LogicException(sprintf('Unable to guess how to get a Doctrine instance from the request information for parameter "%s".', $name));
  98.                 }
  99.             }
  100.         }
  102.         if (null === $object && false === $configuration->isOptional()) {
  103.             $message = sprintf('%s object not found by the @%s annotation.', $class, $this->getAnnotationName($configuration));
  104.             if ($errorMessage) {
  105.                 $message .= ' '.$errorMessage;
  106.             }
  107.             throw new NotFoundHttpException($message);
  108.         }
  110.         $request->attributes->set($name, $object);
  112.         return true;
  113.     }
  115.     private function find($class, Request $request, $options, $name)
  116.     {
  117.         if ($options['mapping'] || $options['exclude']) {
  118.             return false;
  119.         }
  121.         $id = $this->getIdentifier($request, $options, $name);
  123.         if (false === $id || null === $id) {
  124.             return false;
  125.         }
  127.         if ($options['repository_method']) {
  128.             $method = $options['repository_method'];
  129.         } else {
  130.             $method = 'find';
  131.         }
  133.         $om = $this->getManager($options['entity_manager'], $class);
  134.         if ($options['evict_cache'] && $om instanceof EntityManagerInterface) {
  135.             $cacheProvider = $om->getCache();
  136.             if ($cacheProvider && $cacheProvider->containsEntity($class, $id)) {
  137.                 $cacheProvider->evictEntity($class, $id);
  138.             }
  139.         }
  141.         try {
  142.             return $om->getRepository($class)->$method($id);
  143.         } catch (NoResultException $e) {
  144.             return;
  145.         } catch (ConversionException $e) {
  146.             return;
  147.         }
  148.     }
  150.     private function getIdentifier(Request $request, $options, $name)
  151.     {
  152.         if (null !== $options['id']) {
  153.             if (!\is_array($options['id'])) {
  154.                 $name = $options['id'];
  155.             } elseif (\is_array($options['id'])) {
  156.                 $id = [];
  157.                 foreach ($options['id'] as $field) {
  158.                     if (false !== strstr($field, '%s')) {
  159.                         // Convert "%s_uuid" to "foobar_uuid"
  160.                         $field = sprintf($field, $name);
  161.                     }
  162.                     $id[$field] = $request->attributes->get($field);
  163.                 }
  165.                 return $id;
  166.             }
  167.         }
  169.         if ($request->attributes->has($name)) {
  170.             return $request->attributes->get($name);
  171.         }
  173.         if ($request->attributes->has('id') && !$options['id']) {
  174.             return $request->attributes->get('id');
  175.         }
  177.         return false;
  178.     }
  180.     private function findOneBy($class, Request $request, $options)
  181.     {
  182.         if (!$options['mapping']) {
  183.             $keys = $request->attributes->keys();
  184.             $options['mapping'] = $keys ? array_combine($keys, $keys) : [];
  185.         }
  187.         foreach ($options['exclude'] as $exclude) {
  188.             unset($options['mapping'][$exclude]);
  189.         }
  191.         if (!$options['mapping']) {
  192.             return false;
  193.         }
  195.         // if a specific id has been defined in the options and there is no corresponding attribute
  196.         // return false in order to avoid a fallback to the id which might be of another object
  197.         if ($options['id'] && null === $request->attributes->get($options['id'])) {
  198.             return false;
  199.         }
  201.         $criteria = [];
  202.         $em = $this->getManager($options['entity_manager'], $class);
  203.         $metadata = $em->getClassMetadata($class);
  205.         $mapMethodSignature = $options['repository_method']
  206.             && $options['map_method_signature']
  207.             && true === $options['map_method_signature'];
  209.         foreach ($options['mapping'] as $attribute => $field) {
  210.             if ($metadata->hasField($field)
  211.                 || ($metadata->hasAssociation($field) && $metadata->isSingleValuedAssociation($field))
  212.                 || $mapMethodSignature) {
  213.                 $criteria[$field] = $request->attributes->get($attribute);
  214.             }
  215.         }
  217.         if ($options['strip_null']) {
  218.             $criteria = array_filter($criteria, function ($value) {
  219.                 return null !== $value;
  220.             });
  221.         }
  223.         if (!$criteria) {
  224.             return false;
  225.         }
  227.         if ($options['repository_method']) {
  228.             $repositoryMethod = $options['repository_method'];
  229.         } else {
  230.             $repositoryMethod = 'findOneBy';
  231.         }
  233.         try {
  234.             if ($mapMethodSignature) {
  235.                 return $this->findDataByMapMethodSignature($em, $class, $repositoryMethod, $criteria);
  236.             }
  238.             return $em->getRepository($class)->$repositoryMethod($criteria);
  239.         } catch (NoResultException $e) {
  240.             return;
  241.         } catch (ConversionException $e) {
  242.             return;
  243.         }
  244.     }
  246.     private function findDataByMapMethodSignature($em, $class, $repositoryMethod, $criteria)
  247.     {
  248.         $arguments = [];
  249.         $repository = $em->getRepository($class);
  250.         $ref = new \ReflectionMethod($repository, $repositoryMethod);
  251.         foreach ($ref->getParameters() as $parameter) {
  252.             if (\array_key_exists($parameter->name, $criteria)) {
  253.                 $arguments[] = $criteria[$parameter->name];
  254.             } elseif ($parameter->isDefaultValueAvailable()) {
  255.                 $arguments[] = $parameter->getDefaultValue();
  256.             } else {
  257.                 throw new \InvalidArgumentException(sprintf('Repository method "%s::%s" requires that you provide a value for the "$%s" argument.', \get_class($repository), $repositoryMethod, $parameter->name));
  258.             }
  259.         }
  261.         return $ref->invokeArgs($repository, $arguments);
  262.     }
  264.     private function findViaExpression($class, Request $request, $expression, $options, ParamConverter $configuration)
  265.     {
  266.         if (null === $this->language) {
  267.             throw new \LogicException(sprintf('To use the @%s tag with the "expr" option, you need to install the ExpressionLanguage component.', $this->getAnnotationName($configuration)));
  268.         }
  270.         $repository = $this->getManager($options['entity_manager'], $class)->getRepository($class);
  271.         $variables = array_merge($request->attributes->all(), ['repository' => $repository]);
  273.         try {
  274.             return $this->language->evaluate($expression, $variables);
  275.         } catch (NoResultException $e) {
  276.             return;
  277.         } catch (ConversionException $e) {
  278.             return;
  279.         } catch (SyntaxError $e) {
  280.             throw new \LogicException(sprintf('Error parsing expression -- "%s" -- (%s).', $expression, $e->getMessage()), 0, $e);
  281.         }
  282.     }
  284.     /**
  285.      * {@inheritdoc}
  286.      */
  287.     public function supports(ParamConverter $configuration)
  288.     {
  289.         // if there is no manager, this means that only Doctrine DBAL is configured
  290.         if (null === $this->registry || !\count($this->registry->getManagerNames())) {
  291.             return false;
  292.         }
  294.         if (null === $configuration->getClass()) {
  295.             return false;
  296.         }
  298.         $options = $this->getOptions($configuration, false);
  300.         // Doctrine Entity?
  301.         $em = $this->getManager($options['entity_manager'], $configuration->getClass());
  302.         if (null === $em) {
  303.             return false;
  304.         }
  306.         return !$em->getMetadataFactory()->isTransient($configuration->getClass());
  307.     }
  309.     private function getOptions(ParamConverter $configuration, $strict = true)
  310.     {
  311.         $passedOptions = $configuration->getOptions();
  313.         if (isset($passedOptions['repository_method'])) {
  314.             @trigger_error('The repository_method option of @ParamConverter is deprecated and will be removed in 6.0. Use the expr option or @Entity.', \E_USER_DEPRECATED);
  315.         }
  317.         if (isset($passedOptions['map_method_signature'])) {
  318.             @trigger_error('The map_method_signature option of @ParamConverter is deprecated and will be removed in 6.0. Use the expr option or @Entity.', \E_USER_DEPRECATED);
  319.         }
  321.         $extraKeys = array_diff(array_keys($passedOptions), array_keys($this->defaultOptions));
  322.         if ($extraKeys && $strict) {
  323.             throw new \InvalidArgumentException(sprintf('Invalid option(s) passed to @%s: "%s".', $this->getAnnotationName($configuration), implode(', ', $extraKeys)));
  324.         }
  326.         return array_replace($this->defaultOptions, $passedOptions);
  327.     }
  329.     private function getManager($name, $class)
  330.     {
  331.         if (null === $name) {
  332.             return $this->registry->getManagerForClass($class);
  333.         }
  335.         return $this->registry->getManager($name);
  336.     }
  338.     private function getAnnotationName(ParamConverter $configuration)
  339.     {
  340.         $r = new \ReflectionClass($configuration);
  342.         return $r->getShortName();
  343.     }
  344. }