Gets a list of content types acceptable by the client browser.
public getAcceptableContentTypes ( ) : array | ||
return | array | List of content types in preferable order |
/** * @return bool */ private function shouldHandleRequest() { if ($this->handleNonJsonRequests) { return true; } return in_array('application/json', $this->request->getAcceptableContentTypes()); }
/** * Extracts the requested media type from $request * @todo refactor, maybe to a REST Request with an accepts('content-type') method * * @return string */ protected function getMediaType() { foreach ($this->request->getAcceptableContentTypes() as $mimeType) { if (preg_match('(^([a-z0-9-/.]+)\\+.*$)', strtolower($mimeType), $matches)) { return $matches[1]; } } return 'unknown/unknown'; }
/** * @param ViewHandler $viewHandler * @param View $view * @param Request $request * @param string $format * * @return Response */ public function handleExtension(ViewHandler $handler, View $view, Request $request, $format) { if (in_array("application/vnd.bpi.api+xml", $request->getAcceptableContentTypes())) { $view->setHeader("Content-Type", "application/vnd.bpi.api+xml"); } return $handler->createResponse($view, $request, "xml"); }
/** * {@inheritdoc} */ public function filter(RouteCollection $collection, Request $request) { // Generates a list of Symfony formats matching the acceptable MIME types. // @todo replace by proper content negotiation library. $acceptable_mime_types = $request->getAcceptableContentTypes(); $acceptable_formats = array_filter(array_map(array($request, 'getFormat'), $acceptable_mime_types)); $primary_format = $request->getRequestFormat(); foreach ($collection as $name => $route) { // _format could be a |-delimited list of supported formats. $supported_formats = array_filter(explode('|', $route->getRequirement('_format'))); if (empty($supported_formats)) { // No format restriction on the route, so it always matches. Move it to // the end of the collection by re-adding it. $collection->add($name, $route); } elseif (in_array($primary_format, $supported_formats)) { // Perfect match, which will get a higher priority by leaving the route // on top of the list. } elseif (in_array('*/*', $acceptable_mime_types) || array_intersect($acceptable_formats, $supported_formats)) { // Move it to the end of the list. $collection->add($name, $route); } else { // Remove the route if it does not match at all. $collection->remove($name); } } if (count($collection)) { return $collection; } // We do not throw a // \Symfony\Component\Routing\Exception\ResourceNotFoundException here // because we don't want to return a 404 status code, but rather a 406. throw new NotAcceptableHttpException(SafeMarkup::format('No route found for the specified formats @formats.', array('@formats' => implode(' ', $acceptable_mime_types)))); }
/** * Gets the normalized type of a request. * * The normalized type is a short, lowercase version of the format, such as * 'html', 'json' or 'atom'. * * @param \Symfony\Component\HttpFoundation\Request $request * The request object from which to extract the content type. * * @return string * The normalized type of a given request. */ public function getContentType(Request $request) { // AJAX iframe uploads need special handling, because they contain a JSON // response wrapped in <textarea>. if ($request->get('ajax_iframe_upload', FALSE)) { return 'iframeupload'; } // Check all formats, if priority format is found return it. $first_found_format = FALSE; $priority = array('html', 'drupal_ajax', 'drupal_modal', 'drupal_dialog'); foreach ($request->getAcceptableContentTypes() as $mime_type) { $format = $request->getFormat($mime_type); if (in_array($format, $priority, TRUE)) { return $format; } if (!is_null($format) && !$first_found_format) { $first_found_format = $format; } } // No HTML found, return first found. if ($first_found_format) { return $first_found_format; } if ($request->isXmlHttpRequest()) { return 'ajax'; } // Do HTML last so that it always wins. return 'html'; }
/** * Exports the given data to a given format * * @Routing\Route("/api/export", defaults={"method" = "post","_format" = "json"}) * @View() * * @return array */ public function exportAction(Request $request) { $contentTypes = $request->getAcceptableContentTypes(); $exporter = false; $file = tempnam(sys_get_temp_dir(), "partkeepr_export"); unlink($file); foreach ($contentTypes as $contentType) { switch ($contentType) { case "text/comma-separated-values": $exporter = new CsvWriter($file, ',', '"', '\\', false); break; case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": $exporter = new XmlExcelWriter($file, false); break; } } if ($exporter === false) { throw new \Exception("No or invalid format specified"); } $content = json_decode($request->getContent(), true); $exporter->open(); foreach ($content as $item) { $exporter->write($item); } $exporter->close(); $exportData = file_get_contents($file); return new Response($exportData, 200); }
/** * Replaces the default controller action with one that provides data in one of the requested formats * * @param FilterControllerEvent $event */ public function onController(FilterControllerEvent $event) { $this->event = $event; $types = $this->request->getAcceptableContentTypes(); $controller = null; foreach ($types as $type) { if ($controller = $this->findControllerForContentType($type)) { $this->event->setController($controller); break; } } if (null === $controller) { header('HTTP/1.0 406 Not Acceptable'); die; } $controller = $event->getController(); $this->logger->debug('Chose controller action "' . array_pop($controller) . '"'); }
private function getFormatFromHeaders(Request $request) { foreach ($request->getAcceptableContentTypes() as $acceptableContentType) { foreach ($this->contentTypeMapping as $contentType => $format) { if ($acceptableContentType === $contentType) { return $format; } } } }
/** * Returns acceptance type based on given request. * * @param Request $request * * @return string */ public function checkAcceptHeader(Request $request) { $headers = $request->getAcceptableContentTypes(); if (array_intersect($headers, ['application/json', 'text/json'])) { return 'json'; } elseif (array_intersect($headers, ['application/xml', 'text/xml'])) { return 'xml'; } return $this->defaultAcceptType; }
/** * @param $request Request * * @return void */ protected function setTargetPath(Request $request) { // Do not save target path for non HTML requests // Note that non-GET requests are already ignored $acceptableContentTypes = array_map('strtolower', $request->getAcceptableContentTypes()); if (!in_array('text/html', $acceptableContentTypes) || $request->isXmlHttpRequest()) { return; } parent::setTargetPath($request); }
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true) { if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) { $data = json_decode($request->getContent(), true); $request->request->replace(is_array($data) ? $data : []); } if (in_array('application/json', $request->getAcceptableContentTypes())) { $request->setRequestFormat('json'); } return $response = $this->app->handle($request, $type, $catch); }
/** * @param Request $request The request * @param FlattenException $exception A FlattenException instance * @param DebugLoggerInterface $logger A DebugLoggerInterface instance * * @return Response */ public function showAction(Request $request, FlattenException $exception, DebugLoggerInterface $logger = null) { $status = $exception->getStatusCode(); $message = $exception->getMessage(); $previousUrl = $request->headers->get('referer'); if ($request->getFormat($request->getAcceptableContentTypes()[0]) == 'json') { return new JsonResponse(['status' => $status, 'message' => $message]); } else { return $this->render('exception/404.html.twig', ['status' => $status, 'message' => $message, 'previousUrl' => $previousUrl]); } }
public function createContexts(Request $request) { $map = array('request_method' => $request->getMethod(), 'request_uri' => $request->getRequestUri(), 'request_route' => $request->attributes->get('_route'), 'request_host' => $request->getHost(), 'request_port' => $request->getPort(), 'request_scheme' => $request->getScheme(), 'request_client_ip' => $request->getClientIp(), 'request_content_type' => $request->getContentType(), 'request_acceptable_content_types' => $request->getAcceptableContentTypes(), 'request_etags' => $request->getETags(), 'request_charsets' => $request->getCharsets(), 'request_languages' => $request->getLanguages(), 'request_locale' => $request->getLocale(), 'request_auth_user' => $request->getUser(), 'request_auth_has_password' => !is_null($request->getPassword())); // Attributes from newer versions. if (method_exists($request, 'getEncodings')) { $map['request_encodings'] = $request->getEncodings(); } if (method_exists($request, 'getClientIps')) { $map['request_client_ips'] = $request->getClientIps(); } return $map; }
/** * Dispatches a visitable result to the mapped visitor * * @param \Symfony\Component\HttpFoundation\Request $request * @param mixed $result * * @throws NowViewFoundException * * @return Response */ public function dispatch(Request $request, $result) { foreach ($request->getAcceptableContentTypes() as $mimeType) { /** @var \eZ\Publish\Core\REST\Common\Output\Visitor $visitor */ foreach ($this->mapping as $regexp => $visitor) { if (preg_match($regexp, $mimeType)) { return $visitor->visit($result); } } } throw new NowViewFoundException("No view mapping found."); }
protected function logRequest(Request $request) { $msg = 'Request "{request_method} {request_uri}"'; $map = array('request_method' => $request->getMethod(), 'request_uri' => $request->getRequestUri(), 'request_host' => $request->getHost(), 'request_port' => $request->getPort(), 'request_scheme' => $request->getScheme(), 'request_client_ip' => $request->getClientIp(), 'request_content_type' => $request->getContentType(), 'request_acceptable_content_types' => $request->getAcceptableContentTypes(), 'request_etags' => $request->getETags(), 'request_charsets' => $request->getCharsets(), 'request_languages' => $request->getLanguages(), 'request_locale' => $request->getLocale(), 'request_auth_user' => $request->getUser(), 'request_auth_has_password' => !is_null($request->getPassword())); // Attributes from newer versions. if (method_exists($request, 'getEncodings')) { $map['request_encodings'] = $request->getEncodings(); } if (method_exists($request, 'getClientIps')) { $map['request_client_ips'] = $request->getClientIps(); } $this->logger->log($this->logLevel, $msg, $map); }
public function setBaseRequestFormat() { // Check headers for Accept $acceptHeaders = $this->request->getAcceptableContentTypes(); foreach ($acceptHeaders as $header) { $baseFormt = $this->request->getFormat($header); if ($baseFormt == Format::FORMAT_JSON) { $this->request->setRequestFormat($baseFormt); } // Override base HTML format with JSON (default) if ($baseFormt == 'html') { $this->request->setRequestFormat(Format::FORMAT_JSON); } } }
private function getRendererFromRequest(Request $request) { if (null === ($contentType = $request->attributes->get('_content_type', null))) { $contentType = current($request->getAcceptableContentTypes()); } if (null !== ($name = $request->attributes->get('_renderer', null))) { return $this->getRendererFromName($name); } if (0 === count($this->contentTypes)) { return $this->getRendererFromContentType($contentType); } if (false === array_key_exists($contentType, $this->contentTypes)) { return $this->getRendererFromContentType($contentType); } return $this->getRendererFromName($this->contentTypes[$contentType]); }
private function parseResponseType() { if (trim($this->request->get('callback')) !== '') { return $this->responseType = self::FORMAT_JSONP; } $responseTypes = array_map('strtolower', $this->request->getAcceptableContentTypes()); if (in_array('application/json', $responseTypes)) { return $this->responseType = self::FORMAT_JSON; } if (in_array('application/yaml', $responseTypes)) { return $this->responseType = self::FORMAT_YAML; } if (in_array('text/yaml', $responseTypes)) { return $this->responseType = self::FORMAT_YAML; } return $this->responseType = self::FORMAT_JSON; }
public function locate(Request $request) { $pathInfo = $request->getPathInfo(); $matches = []; foreach ($this->resources as $path => $item) { if (preg_match($path, $pathInfo, $matches)) { $accepts = array_intersect($item->getContentTypes(), $request->getAcceptableContentTypes()); if (empty($accepts)) { throw new NotAcceptable(); } /** @var callable $factory */ $factory = $item->getFactory(); /** @var \RestArc\Http\Resource $resource */ $resource = $factory(); if (!$resource instanceof Resource) { throw new \DomainException('Cant handle non \\RestArc\\Http\\Resource'); } $resource->setPathParameters(array_slice($matches, 1)); return $resource; } } return null; }
/** * This before middleware validates whether the application will be able to * respond in a format that the client understands. * * @param Request $request * @throws NotAcceptableHttpException */ public function setRequestFormat(Request $request, Application $app) { // If there is no Accept header, do nothing if (!$request->headers->get("Accept")) { return; } // Check the Accept header for acceptable formats foreach ($request->getAcceptableContentTypes() as $contentType) { // If any format is acceptable, do nothing if ($contentType === "*/*") { return; } $format = $request->getFormat($contentType); if (in_array($format, $app["conneg.responseFormats"])) { // An acceptable format was found. Set it as the requestFormat // where it can be referenced later. $request->setRequestFormat($format); return; } } // No acceptable formats were found throw new NotAcceptableHttpException(); }
public function testGetAcceptableContentTypes() { $request = new Request(); $this->assertEquals(array(), $request->getAcceptableContentTypes()); $request->headers->set('Accept', 'application/vnd.wap.wmlscriptc, text/vnd.wap.wml, application/vnd.wap.xhtml+xml, application/xhtml+xml, text/html, multipart/mixed, */*'); $this->assertEquals(array(), $request->getAcceptableContentTypes()); // testing caching $request = new Request(); $request->headers->set('Accept', 'application/vnd.wap.wmlscriptc, text/vnd.wap.wml, application/vnd.wap.xhtml+xml, application/xhtml+xml, text/html, multipart/mixed, */*'); $this->assertEquals(array('application/vnd.wap.wmlscriptc', 'text/vnd.wap.wml', 'application/vnd.wap.xhtml+xml', 'application/xhtml+xml', 'text/html', 'multipart/mixed', '*/*'), $request->getAcceptableContentTypes()); }
/** * Get classcontent. * * @param string $type type of the class content (ex: Element/text) * @param string $uid identifier of the class content * * @return Symfony\Component\HttpFoundation\Response * * @Rest\QueryParam(name="mode", description="The render mode to use") * @Rest\QueryParam(name="page_uid", description="The page to set to application's renderer before rendering") * * @Rest\Security("is_fully_authenticated() & has_role('ROLE_API_USER')") */ public function getAction($type, $uid, Request $request) { $this->granted('VIEW', $content = $this->getClassContentByTypeAndUid($type, $uid, true)); $response = null; if (in_array('text/html', $request->getAcceptableContentTypes())) { if (false != ($pageUid = $request->query->get('page_uid'))) { if (null !== ($page = $this->getDoctrine()->getManager()->find('BackBee\\CoreDomain\\NestedNode\\Page', $pageUid))) { $this->get('renderer')->setCurrentPage($page); } } $mode = $request->query->get('mode', null); $response = $this->createResponse($this->get('renderer')->render($content, $mode), 200, 'text/html'); } else { $response = $this->createJsonResponse(); $response->setData($this->getClassContentManager()->jsonEncode($content, $this->getFormatParam())); } return $response; }
/** * Authorize application to use a grant password type. * * @param Application $app * @param Request $request * @param ApiApplication $application * * @return JsonResponse */ public function authorizeGrantPassword(Application $app, Request $request, ApiApplication $application) { if (!$request->isXmlHttpRequest() || !array_key_exists($request->getMimeType('json'), array_flip($request->getAcceptableContentTypes()))) { $app->abort(400, 'Bad request format, only JSON is allowed'); } $application->setGrantPassword((bool) $request->request->get('grant')); $app['manipulator.api-application']->update($application); return $app->json(['success' => true]); }
/** * Gets the error-relevant format from the request. * * @param \Symfony\Component\HttpFoundation\Request $request * The request object. * * @return string * The format as which to treat the exception. */ protected function getFormat(Request $request) { $format = $request->query->get(MainContentViewSubscriber::WRAPPER_FORMAT, $request->getRequestFormat()); // These are all JSON errors for our purposes. Any special handling for // them can/should happen in earlier listeners if desired. if (in_array($format, ['drupal_modal', 'drupal_dialog', 'drupal_ajax'])) { $format = 'json'; } // Make an educated guess that any Accept header type that includes "json" // can probably handle a generic JSON response for errors. As above, for // any format this doesn't catch or that wants custom handling should // register its own exception listener. foreach ($request->getAcceptableContentTypes() as $mime) { if (strpos($mime, 'html') === FALSE && strpos($mime, 'json') !== FALSE) { $format = 'json'; } } return $format; }
/** * @param \Symfony\Component\HttpFoundation\Request $request * @return bool */ protected function isJsonRequest(Request $request) { // If XmlHttpRequest, return true if ($request->isXmlHttpRequest()) { return true; } // Check if the request wants Json $acceptable = $request->getAcceptableContentTypes(); return isset($acceptable[0]) && $acceptable[0] == 'application/json'; }
public function deleteStatusBitAction(Request $request, $databox_id, $bit) { if (!$request->isXmlHttpRequest() || !array_key_exists($request->getMimeType('json'), array_flip($request->getAcceptableContentTypes()))) { $this->app->abort(400, $this->app->trans('Bad request format, only JSON is allowed')); } if (!$this->getAclForUser()->has_right_on_sbas($databox_id, 'bas_modify_struct')) { $this->app->abort(403); } $databox = $this->findDataboxById($databox_id); $error = false; try { $this->app['status.provider']->deleteStatus($databox->getStatusStructure(), $bit); } catch (\Exception $e) { $error = true; } return $this->app->json(['success' => !$error]); }
/** * Get classcontent. * * @param string $type type of the class content (ex: Element/text) * @param string $uid identifier of the class content * * @return Symfony\Component\HttpFoundation\Response * * @Rest\QueryParam(name="mode", description="The render mode to use") * @Rest\QueryParam(name="page_uid", description="The page to set to application's renderer before rendering") * * @Rest\ParamConverter( * name="page", id_name="page_uid", id_source="query", class="BackBee\NestedNode\Page", required=false * ) * * @Rest\Security("is_fully_authenticated() & has_role('ROLE_API_USER')") */ public function getAction($type, $uid, Request $request) { $this->granted('VIEW', $content = $this->getClassContentByTypeAndUid($type, $uid, true)); $response = null; if (in_array('text/html', $request->getAcceptableContentTypes())) { if (null !== ($page = $this->getEntityFromAttributes('page'))) { $this->getApplication()->getRenderer()->setCurrentPage($page); } $mode = $request->query->get('mode', null); $response = $this->createResponse($this->getApplication()->getRenderer()->render($content, $mode), 200, 'text/html'); } else { $response = $this->createJsonResponse(); $response->setData($this->getClassContentManager()->jsonEncode($content, $this->getFormatParam())); } return $response; }
protected function getWriter(Request $request) { $attribute = $request->attributes->get(Context::RESPONSE_FORMAT); $query = $request->query->get('format'); if (!empty($attribute)) { $writer = $this->writerFactory->getWriterByFormat($attribute); } elseif (!empty($query)) { $writer = $this->writerFactory->getWriterByFormat($query); } else { $writer = $this->writerFactory->getWriterByContentType(implode(', ', $request->getAcceptableContentTypes())); } if ($writer === null) { $writer = $this->writerFactory->getDefaultWriter(); } return $writer; }
/** * @param Request $request * @param Route $route * @return bool */ private function matchContentType(Request $request, Route $route) { return !$route->getPattern()->getContentType() || in_array($route->getPattern()->getContentType(), $request->getAcceptableContentTypes()); }
/** * @param Request $request * @throws HttpException */ private function assertJsonRequestFormat(Request $request) { if (!$request->isXmlHttpRequest() || !array_key_exists($request->getMimeType('json'), array_flip($request->getAcceptableContentTypes()))) { $this->app->abort(400, 'Bad request format, only JSON is allowed'); } }