vendor/friendsofsymfony/rest-bundle/Request/ParamFetcher.php line 36

  1. <?php
  3. /*
  4.  * This file is part of the FOSRestBundle package.
  5.  *
  6.  * (c) FriendsOfSymfony <http://friendsofsymfony.github.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 FOS\RestBundle\Request;
  14. use FOS\RestBundle\Controller\Annotations\ParamInterface;
  15. use FOS\RestBundle\Exception\InvalidParameterException;
  16. use FOS\RestBundle\Util\ResolverTrait;
  17. use FOS\RestBundle\Validator\Constraints\ResolvableConstraintInterface;
  18. use Symfony\Component\DependencyInjection\ContainerInterface;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpFoundation\RequestStack;
  21. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  22. use Symfony\Component\Validator\Constraint;
  23. use Symfony\Component\Validator\ConstraintViolationList;
  24. use Symfony\Component\Validator\Validator\ValidatorInterface;
  25. use Symfony\Component\Validator\Exception\ValidatorException;
  26. use Symfony\Component\Validator\ConstraintViolation;
  28. /**
  29.  * Helper to validate parameters of the active request.
  30.  *
  31.  * @author Alexander <iam.asm89@gmail.com>
  32.  * @author Lukas Kahwe Smith <smith@pooteeweet.org>
  33.  * @author Jordi Boggiano <j.boggiano@seld.be>
  34.  * @author Boris Guéry <guery.b@gmail.com>
  35.  */
  36. final class ParamFetcher implements ParamFetcherInterface
  37. {
  38.     use ResolverTrait;
  40.     private $container;
  41.     private $parameterBag;
  42.     private $requestStack;
  43.     private $validator;
  45.     public function __construct(ContainerInterface $container, ParamReaderInterface $paramReader, RequestStack $requestStack, ValidatorInterface $validator)
  46.     {
  47.         $this->container = $container;
  48.         $this->requestStack = $requestStack;
  49.         $this->validator = $validator;
  51.         $this->parameterBag = new ParameterBag($paramReader);
  52.     }
  54.     /**
  55.      * {@inheritdoc}
  56.      */
  57.     public function setController(callable $controller): void
  58.     {
  59.         $this->parameterBag->setController($this->getRequest(), $controller);
  60.     }
  62.     /**
  63.      * Add additional params to the ParamFetcher during runtime.
  64.      *
  65.      * Note that adding a param that has the same name as an existing param will override that param.
  66.      */
  67.     public function addParam(ParamInterface $param): void
  68.     {
  69.         $this->parameterBag->addParam($this->getRequest(), $param);
  70.     }
  72.     /**
  73.      * @return ParamInterface[]
  74.      */
  75.     public function getParams(): array
  76.     {
  77.         return $this->parameterBag->getParams($this->getRequest());
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      */
  83.     public function get(string $name, ?bool $strict = null)
  84.     {
  85.         $params = $this->getParams();
  87.         if (!array_key_exists($name, $params)) {
  88.             throw new \InvalidArgumentException(sprintf("No @ParamInterface configuration for parameter '%s'.", $name));
  89.         }
  91.         /** @var ParamInterface $param */
  92.         $param = $params[$name];
  93.         $default = $param->getDefault();
  94.         $default = $this->resolveValue($this->container, $default);
  95.         $strict = (null !== $strict ? $strict : $param->isStrict());
  97.         $paramValue = $param->getValue($this->getRequest(), $default);
  99.         return $this->cleanParamWithRequirements($param, $paramValue, $strict, $default);
  100.     }
  102.     private function cleanParamWithRequirements(ParamInterface $param, $paramValue, bool $strict, $default)
  103.     {
  104.         $this->checkNotIncompatibleParams($param);
  105.         if (null !== $default && $default === $paramValue) {
  106.             return $paramValue;
  107.         }
  109.         $constraints = $param->getConstraints();
  110.         $this->resolveConstraints($constraints);
  111.         if (empty($constraints)) {
  112.             return $paramValue;
  113.         }
  115.         try {
  116.             $errors = $this->validator->validate($paramValue, $constraints);
  117.         } catch (ValidatorException $e) {
  118.             $violation = new ConstraintViolation(
  119.                 $e->getMessage(),
  120.                 $e->getMessage(),
  121.                 [],
  122.                 $paramValue,
  123.                 '',
  124.                 null,
  125.                 null,
  126.                 $e->getCode()
  127.             );
  128.             $errors = new ConstraintViolationList([$violation]);
  129.         }
  131.         if (0 < count($errors)) {
  132.             if ($strict) {
  133.                 throw InvalidParameterException::withViolations($param, $errors);
  134.             }
  136.             return null === $default ? '' : $default;
  137.         }
  139.         return $paramValue;
  140.     }
  142.     /**
  143.      * {@inheritdoc}
  144.      */
  145.     public function all(?bool $strict = null): array
  146.     {
  147.         $configuredParams = $this->getParams();
  149.         $params = [];
  150.         foreach ($configuredParams as $name => $param) {
  151.             $params[$name] = $this->get($name, $strict);
  152.         }
  154.         return $params;
  155.     }
  157.     private function checkNotIncompatibleParams(ParamInterface $param): void
  158.     {
  159.         if (null === $param->getValue($this->getRequest(), null)) {
  160.             return;
  161.         }
  163.         $params = $this->getParams();
  164.         foreach ($param->getIncompatibilities() as $incompatibleParamName) {
  165.             if (!array_key_exists($incompatibleParamName, $params)) {
  166.                 throw new \InvalidArgumentException(sprintf("No @ParamInterface configuration for parameter '%s'.", $incompatibleParamName));
  167.             }
  168.             $incompatibleParam = $params[$incompatibleParamName];
  170.             if (null !== $incompatibleParam->getValue($this->getRequest(), null)) {
  171.                 $exceptionMessage = sprintf(
  172.                     '"%s" param is incompatible with %s param.',
  173.                     $param->getName(),
  174.                     $incompatibleParam->getName()
  175.                 );
  177.                 throw new BadRequestHttpException($exceptionMessage);
  178.             }
  179.         }
  180.     }
  182.     /**
  183.      * @param Constraint[] $constraints
  184.      */
  185.     private function resolveConstraints(array $constraints): void
  186.     {
  187.         foreach ($constraints as $constraint) {
  188.             if ($constraint instanceof ResolvableConstraintInterface) {
  189.                 $constraint->resolve($this->container);
  190.             }
  191.         }
  192.     }
  194.     private function getRequest(): Request
  195.     {
  196.         $request = $this->requestStack->getCurrentRequest();
  197.         if (null === $request) {
  198.             throw new \RuntimeException('There is no current request.');
  199.         }
  201.         return $request;
  202.     }
  203. }