vendor/can/rest/src/Can/RestBundle/EventListener/RequestBodyListener.php line 52

Open in your IDE?
  1. <?php
  3. namespace Can\RestBundle\EventListener;
  5. use Can\RestBundle\CanRestBundle;
  6. use Can\RestBundle\Http\Exception\UnsupportedMediaTypeHttpException;
  7. use Can\RestBundle\Http\HttpConfiguration;
  8. use Can\RestBundle\Http\Method;
  9. use Can\RestBundle\Http\MethodSupport;
  11. use Symfony\Component\HttpFoundation\Request;
  12. use Symfony\Component\HttpKernel\Event\RequestEvent;
  13. use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
  15. use Exception;
  17. /**
  18.  * Some of the HTTP methods do not define request bodies. Servers MUST examine
  19.  * all requests for a body, even when a body was not expected. In cases where
  20.  * a request body is present but would be ignored by a server, the server MUST
  21.  * reject the request with 415 (Unsupported Media Type).
  22.  *
  23.  * This informs the client (which may have been attempting to use an extension)
  24.  * that the body could not be processed as the client intended.
  25.  *
  26.  * @group core
  27.  *
  28.  * @package can/rest-bundle
  29.  * @author lechecacharro <lechecacharro@gmail.com>
  30.  */
  31. class RequestBodyListener
  32. {
  34.     /**
  35.      * @var HttpConfiguration
  36.      */
  37.     protected $configuration;
  39.     /**
  40.      * RequiredBodyListener constructor.
  41.      *
  42.      * @param HttpConfiguration $configuration
  43.      */
  44.     public function __construct(HttpConfiguration $configuration)
  45.     {
  46.         $this->configuration = $configuration;
  47.     }
  49.     /**
  50.      * @param RequestEvent $event
  51.      */
  52.     public function onRequest(RequestEvent $event): void
  53.     {
  54.         // Skip any check if the configuration states that we should
  55.         // allow unexpected entities in the body of requests which have
  56.         // no semantic defined for such entity
  57.         if ($this->configuration->isAllowUnexpectedEntities()) {
  58.             return;
  59.         }
  61.         if (! $event->isMasterRequest()) {
  62.             return;
  63.         }
  65.         $request = $event->getRequest();
  67.         if (! $request->attributes->get(CanRestBundle::ATTR_SERVICE_ZONE)) {
  68.             return;
  69.         }
  71.         try {
  72.             $method = Method::getMethod($request->getMethod());
  73.         } catch (Exception $e) {
  74.             // This should not ever happen, as the RequestMethodListener
  75.             // should handle this case
  76.             throw new MethodNotAllowedHttpException(MethodSupport::getHttpMethods(0));
  77.         }
  79.         $hasContent = $this->hasContent($request);
  80.         $request->attributes->set(CanRestBundle::ATTR_REQUEST_CONTENT, $hasContent);
  82.         if ($hasContent && ! $method->mayHaveRequestBody()) {
  83.             throw new UnsupportedMediaTypeHttpException(sprintf(
  84.                 'No semantic defined for the request body entity of a %s request',
  85.                 $method->getName()
  86.             ));
  87.         }
  88.     }
  90.     /**
  91.      * @param Request $request
  92.      *
  93.      * @return bool
  94.      */
  95.     private function hasContent(Request $request): bool
  96.     {
  97.         // DO NOT use $request->getContent(), as in case of POST or PUT requests,
  98.         // it would read the php://input fully using file_get_contents(), which
  99.         // can be expensive if the request body is too large
  100.         $contentLength = $request->headers->get('Content-Length', 0);
  102.         if (is_array($contentLength)) {
  103.             $contentLength = (int) reset($contentLength);
  104.         }
  106.         return $contentLength > 0;
  107.     }
  109. }