vendor/can/rest/src/Can/RestBundle/EventListener/RequestFormatListener.php line 65

Open in your IDE?
  1. <?php
  3. namespace Can\RestBundle\EventListener;
  5. use Can\RestBundle\CanRestBundle;
  6. use Can\RestBundle\Http\Exception\UnsupportedRequestFormatHttpException;
  7. use Can\RestBundle\Http\Method;
  8. use Can\RestBundle\Ingest\IngestConfiguration;
  9. use Can\RestBundle\Negotiation\Format;
  10. use Can\RestBundle\Negotiation\FormatGuesserInterface;
  11. use Can\RestBundle\Negotiation\NegotiationConfiguration;
  13. use Can\RestBundle\Negotiation\NoContentTypeException;
  14. use Symfony\Component\HttpFoundation\Request;
  15. use Symfony\Component\HttpKernel\Event\RequestEvent;
  16. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  17. use Symfony\Component\HttpKernel\Exception\UnsupportedMediaTypeHttpException;
  19. /**
  20.  * A content-negotiation listener which returns a 400 (Bad Request) error
  21.  * response if the request format is not supported.
  22.  *
  23.  * @group http
  24.  *
  25.  * @package can/rest-bundle
  26.  * @author lechecacharro <lechecacharro@gmail.com>
  27.  */
  28. class RequestFormatListener
  29. {
  31.     /**
  32.      * @var IngestConfiguration
  33.      */
  34.     protected $ingestConfiguration;
  36.     /**
  37.      * @var NegotiationConfiguration
  38.      */
  39.     protected $negotiationConfiguration;
  41.     /**
  42.      * @var FormatGuesserInterface
  43.      */
  44.     protected $formatGuesser;
  46.     /**
  47.      * RequestFormatListener constructor.
  48.      *
  49.      * @param IngestConfiguration      $ingestConfiguration
  50.      * @param NegotiationConfiguration $negotiationConfiguration
  51.      * @param FormatGuesserInterface   $formatGuesser
  52.      */
  53.     public function __construct(IngestConfiguration $ingestConfiguration, NegotiationConfiguration $negotiationConfiguration, FormatGuesserInterface $formatGuesser)
  54.     {
  55.         $this->ingestConfiguration = $ingestConfiguration;
  56.         $this->negotiationConfiguration = $negotiationConfiguration;
  57.         $this->formatGuesser = $formatGuesser;
  58.     }
  60.     /**
  61.      * @param RequestEvent $event
  62.      *
  63.      * @throws BadRequestHttpException on malformed Content-Type
  64.      */
  65.     public function onRequest(RequestEvent $event): void
  66.     {
  67.         if (! $event->isMasterRequest()) {
  68.             return;
  69.         }
  71.         $request = $event->getRequest();
  73.         // Skip if not in the REST zone, or if the request has no content
  74.         if (! $request->attributes->get(CanRestBundle::ATTR_SERVICE_ZONE) ||
  75.             ! $request->attributes->get(CanRestBundle::ATTR_REQUEST_CONTENT)) {
  76.             return;
  77.         }
  79.         $format = null;
  81.         try {
  82.             // Try to guess the request format from the request (most probably
  83.             // based on the Content-Type header, but maybe the guesser supports
  84.             // sniffing the request payload)
  85.             $format = $this->formatGuesser->guess($request);
  87.         } catch (NoContentTypeException $e) {
  89.             // If the request format could not be figured out for some reason
  90.             // (e.g., no Content-Type header),either fail (if the no Content-Type
  91.             // policy is STRICT) or fall-through and use the default media type
  92.             if ($this->negotiationConfiguration->isStrictNoContentTypePolicy()) {
  93.                 throw new UnsupportedMediaTypeHttpException();
  94.             }
  96.             // Fall-through
  97.         }
  99.         if (null === $format) {
  100.             $format = $this->formatGuesser->getDefaultFormat();
  101.         }
  103.         $request->attributes->set(CanRestBundle::ATTR_REQUEST_FORMAT, $format);
  104.         $request->attributes->set(CanRestBundle::ATTR_REQUEST_MEDIATYPE, $format->getMediaType());
  106.         if (! $this->isSupportedFormat($request, $format)) {
  107.             $request->attributes->set(CanRestBundle::ATTR_REQUEST_SUPPORTED, false);
  109.             throw new UnsupportedRequestFormatHttpException($format->getName(), $format->getMediaType());
  110.         }
  112.         $request->attributes->set(CanRestBundle::ATTR_REQUEST_SUPPORTED, true);
  113.     }
  115.     /**
  116.      * Figures out whether the specified format is supported. Note that the
  117.      * support for some formats (e.g. support for patch formats, or support
  118.      * for ingest formats may be allowed only for some particular kinds of
  119.      * requests).
  120.      *
  121.      * @param Request $request
  122.      * @param Format  $format
  123.      *
  124.      * @return bool
  125.      */
  126.     protected function isSupportedFormat(Request $request, Format $format): bool
  127.     {
  128.         $name = $format->getName();
  130.         if ($this->negotiationConfiguration->isSupportedFormat($name)) {
  131.             return true;
  132.         }
  134.         $method = $request->getMethod();
  136.         if (Method::PATCH === $method && $this->negotiationConfiguration->isSupportedPatchFormat($name)) {
  137.             return true;
  138.         }
  140.         if ($this->ingestConfiguration->isMethodAllowed($method) &&
  141.             $this->ingestConfiguration->isMediaTypeAllowed($format->getMediaType())) {
  142.             return true;
  143.         }
  145.         return false;
  146.     }
  148. }