Gets the mime type associated with the format.
| public getMimeType ( string $format ) : string | ||
| $format | string | The format |
| Résultat | string | The associated mime type (null if not found) |
protected function doKernelResponse(Request $request, Response $response)
{
if (!$response instanceof DataResponse) {
return;
}
$routeName = $request->attributes->get('_route');
$route = $this->routes->get($routeName);
if (!$route) {
return;
}
$acceptedFormat = $route->getOption(RouteOptions::ACCEPTED_FORMAT);
if (!$acceptedFormat) {
$response->setContent('');
$response->setStatusCode(406);
}
if ($this->encoder->supportsEncoding($acceptedFormat) && $acceptedFormat === 'json') {
$contentType = $request->getMimeType($acceptedFormat);
$jsonResponse = new JsonResponse($response->getContent());
$response->setContent($jsonResponse->getContent());
$response->headers->set('Content-Type', $contentType);
} elseif ($this->encoder->supportsEncoding($acceptedFormat)) {
$contentType = $request->getMimeType($acceptedFormat);
$content = $this->encoder->encode($response->getContent(), $acceptedFormat);
$response->setContent($content);
$response->headers->set('Content-Type', $contentType);
}
}
/**
* Detect the request format based on the priorities and the Accept header
*
* Note: Request "_format" parameter is considered the preferred Accept header
*
* @param Request $request The request
* @param array $priorities Ordered array of formats (highest priority first)
* @param Boolean $preferExtension If to consider the extension last or first
*
* @return void|string The format string
*/
public function getBestFormat(Request $request, array $priorities, $preferExtension = false)
{
$mimetypes = $request->splitHttpAcceptHeader($request->headers->get('Accept'));
$extension = $request->get('_format');
if (null !== $extension && $request->getMimeType($extension)) {
$mimetypes[$request->getMimeType($extension)] = $preferExtension ? reset($mimetypes) + 1 : end($mimetypes) - 1;
arsort($mimetypes);
}
if (empty($mimetypes)) {
return null;
}
$catchAllEnabled = in_array('*/*', $priorities);
return $this->getFormatByPriorities($request, $mimetypes, $priorities, $catchAllEnabled);
}
/**
* indexAction action.
*/
public function indexAction(Request $request, $_format)
{
if (version_compare(Kernel::VERSION, '2.1.0-dev', '<')) {
if (null !== ($session = $request->getSession())) {
// keep current flashes for one more request
$session->setFlashes($session->getFlashes());
}
} else {
$session = $request->getSession();
if (null !== $session && $session->getFlashBag() instanceof AutoExpireFlashBag) {
// keep current flashes for one more request if using AutoExpireFlashBag
$session->getFlashBag()->setAll($session->getFlashBag()->peekAll());
}
}
$cache = new ConfigCache($this->cacheDir . '/fosJsRouting.json', $this->debug);
if (!$cache->isFresh()) {
$content = $this->serializer->serialize(new RoutesResponse($this->exposedRoutesExtractor->getBaseUrl(), $this->exposedRoutesExtractor->getRoutes()), 'json');
$cache->write($content, $this->exposedRoutesExtractor->getResources());
}
$content = file_get_contents((string) $cache);
if ($callback = $request->query->get('callback')) {
$content = $callback . '(' . $content . ');';
}
return new Response($content, 200, array('Content-Type' => $request->getMimeType($_format)));
}
/**
* Action point for js translation resource
*
* @param Request $request
* @param string $_locale
* @return Response
*/
public function indexAction(Request $request, $_locale)
{
$domains = isset($this->options['domains']) ? $this->options['domains'] : [];
$debug = isset($this->options['debug']) ? (bool) $this->options['debug'] : false;
$content = $this->renderJsTranslationContent($domains, $_locale, $debug);
return new Response($content, 200, ['Content-Type' => $request->getMimeType('js')]);
}
function get(Request $req)
{
$resourceName = $req->get('resource');
if (!isset($this->module["resourceEntityMappings"][$resourceName])) {
throw new NotFoundHttpException();
}
$entityClass = $this->module["namespace"] . $this->module["resourceEntityMappings"][$resourceName];
// Filterer entities queried?
if ($req->getQueryString() != null) {
$querystring = $req->getQueryString();
$criteria = array();
$queryParts = \explode('&', $querystring);
foreach ($queryParts as $queryPart) {
$key_value = \explode('=', $queryPart);
$criteria[$key_value[0]] = urldecode($key_value[1]);
}
$entities = $this->em->getRepository($entityClass)->findBy($criteria);
// Single entity queried?
} elseif ($req->get('id') != null) {
$id = $req->get('id');
$entity = $this->em->getRepository($entityClass)->find($id);
$entities = array($entity);
} else {
$entities = $this->em->getRepository($entityClass)->findAll();
}
return new Response($this->serializer->serialize(array($resourceName => $entities), 'json'), 200, array('Content-Type' => $req->getMimeType('json')));
}
/**
* @param ApiResponse $apiResponse to convert to a Symfony Response.
* @param Request $request that needs this Response.
*
* @return Response
*/
public function toSymfonyResponse(ApiResponse $apiResponse, Request $request)
{
$format = $request->getRequestFormat($this->defaultResponseFormat);
$serialized = $this->serializer->serialize($apiResponse->getData(), $format);
$response = new Response($serialized, $apiResponse->getStatusCode(), $apiResponse->getHeaders());
$response->headers->set('Content-Type', $request->getMimeType($format));
return $response;
}
/**
* Deliver the result of the query.
*/
public function handle(RouteMatchInterface $route_match, Request $request)
{
$query = new RestEntityQuery($request, $this->container);
$serializer = $this->container->get('serializer');
$format = $request->getMimeType() ?: 'json';
$headers = ['Content-Type' => $format, 'Access-Control-Allow-Origin' => '*', 'Access-Control-Allow-Methods' => 'GET'];
$content = $query->execute();
if ($query->hasError()) {
return new Response($serializer->serialize($query->getLastError(), $format), 400, $headers);
}
return new Response($serializer->serialize($content, 'json'), 200, $headers);
}
/**
* indexAction action.
*/
public function indexAction(Request $request, $_format)
{
$cache = new ConfigCache($this->cacheDir . '/fosJsRouting.json', $this->debug);
if (!$cache->isFresh()) {
$content = $this->serializer->serialize(new RoutesResponse($this->exposedRoutesExtractor->getBaseUrl(), $this->exposedRoutesExtractor->getRoutes()), 'json');
$cache->write($content, $this->exposedRoutesExtractor->getResources());
}
$content = file_get_contents((string) $cache);
if ($callback = $request->query->get('callback')) {
$content = $callback . '(' . $content . ')';
}
return new Response($content, 200, array('Content-Type' => $request->getMimeType($_format)));
}
/**
* Detect the request format based on the priorities and the Accept header
*
* Note: Request "_format" parameter is considered the preferred Accept header
*
* @param Request $request The request
* @param array $priorities Ordered array of formats (highest priority first)
* @param Boolean $preferExtension If to consider the extension last or first
*
* @return void|string The format string
*/
public function getBestFormat(Request $request, array $priorities, $preferExtension = false)
{
// BC - Maintain this while 2.0 and 2.1 dont reach their end of life
// Note: Request::splitHttpAcceptHeader is deprecated since version 2.2, to be removed in 2.3.
if (class_exists('Symfony\\Component\\HttpFoundation\\AcceptHeader')) {
$mimetypes = array();
foreach (AcceptHeader::fromString($request->headers->get('Accept'))->all() as $item) {
$mimetypes[$item->getValue()] = $item->getQuality();
}
} else {
$mimetypes = $request->splitHttpAcceptHeader($request->headers->get('Accept'));
}
$extension = $request->get('_format');
if (null !== $extension && $request->getMimeType($extension)) {
$mimetypes[$request->getMimeType($extension)] = $preferExtension ? reset($mimetypes) + 1 : end($mimetypes) - 1;
arsort($mimetypes);
}
if (empty($mimetypes)) {
return null;
}
$catchAllEnabled = in_array('*/*', $priorities);
return $this->getFormatByPriorities($request, $mimetypes, $priorities, $catchAllEnabled);
}
/**
* Prepares the Response before it is sent to the client.
*
* This method tweaks the Response to ensure that it is
* compliant with RFC 2616. Most of the changes are based on
* the Request that is "associated" with this Response.
*
* @param Request $request A Request instance
*
* @return Response The current response.
*/
public function prepare(Request $request)
{
$headers = $this->headers;
if ($this->isInformational() || $this->isEmpty()) {
$this->setContent(null);
$headers->remove('Content-Type');
$headers->remove('Content-Length');
} else {
// Content-type based on the Request
if (!$headers->has('Content-Type')) {
$format = $request->getRequestFormat();
if (null !== $format && ($mimeType = $request->getMimeType($format))) {
$headers->set('Content-Type', $mimeType);
}
}
// Fix Content-Type
$charset = $this->charset ?: 'UTF-8';
if (!$headers->has('Content-Type')) {
$headers->set('Content-Type', 'text/html; charset=' . $charset);
} elseif (0 === stripos($headers->get('Content-Type'), 'text/') && false === stripos($headers->get('Content-Type'), 'charset')) {
// add the charset
$headers->set('Content-Type', $headers->get('Content-Type') . '; charset=' . $charset);
}
// Fix Content-Length
if ($headers->has('Transfer-Encoding')) {
$headers->remove('Content-Length');
}
if ($request->isMethod('HEAD')) {
// cf. RFC2616 14.13
$length = $headers->get('Content-Length');
$this->setContent(null);
if ($length) {
$headers->set('Content-Length', $length);
}
}
}
// Fix protocol
if ('HTTP/1.0' != $request->server->get('SERVER_PROTOCOL')) {
$this->setProtocolVersion('1.1');
}
// Check if we need to send extra expire info headers
if ('1.0' == $this->getProtocolVersion() && 'no-cache' == $this->headers->get('Cache-Control')) {
$this->headers->set('pragma', 'no-cache');
$this->headers->set('expires', -1);
}
$this->ensureIEOverSSLCompatibility($request);
return $this;
}
/**
* Returns a response containing the given image after applying the given filter on it.
*
* @uses FilterManager::applyFilterSet
*
* @param Request $request
* @param string $filter
* @param ImageInterface $image
* @param string $localPath
*
* @return Response
*/
public function get(Request $request, $filter, ImageInterface $image, $localPath)
{
$config = $this->getFilterConfiguration()->get($filter);
$image = $this->applyFilter($image, $filter);
if (empty($config['format'])) {
$format = pathinfo($localPath, PATHINFO_EXTENSION);
$format = $format ?: 'png';
} else {
$format = $config['format'];
}
$quality = empty($config['quality']) ? 100 : $config['quality'];
$image = $image->get($format, array('quality' => $quality));
$contentType = $request->getMimeType($format);
if (empty($contentType)) {
$contentType = 'image/' . $format;
}
return new Response($image, 200, array('Content-Type' => $contentType));
}
/**
* @Route("/js/filemanager.{_format}", name="novaway_filemanagement_routing_js", defaults={"_format"="js"})
*/
public function indexAction(Request $request, $_format)
{
$serviceManagerId = $request->get('service_manager');
if (empty($serviceManagerId)) {
throw new \RuntimeException('service_manager argument is missing.');
}
if (!$this->has($serviceManagerId)) {
throw new NotFoundHttpException(sprintf('The %s service does not exist.', $serviceManagerId));
}
/** @var \Novaway\Bundle\FileManagementBundle\Manager\BaseEntityWithImageManager $manager */
$manager = $this->get($serviceManagerId);
if (!$manager instanceof BaseEntityWithImageManager) {
throw new \RuntimeException('The manager must be an instance of BaseEntityWithImageManager.');
}
$content = json_encode(['webpath' => $manager->getWebPath(), 'image_formats' => $manager->getImageFormatChoices()]);
if (null !== ($jsManager = $request->query->get('manager'))) {
$content = "var {$jsManager} = new novaway.FileManager(); {$jsManager}.setData({$content});";
}
return new Response($content, 200, array('Content-Type' => $request->getMimeType($_format)));
}
/**
* Main action: renders the image cache and returns it to the browser
*
* @param Request $request
* @param string $format A format name defined in config or a string [width]x[height]
* @param string $path The path of the source file (@see Manager::downloadExternalImage for more info on external/remote images)
*
* @return Response
*/
public function indexAction(Request $request, $format, $path)
{
/** @var $im \Snowcap\ImBundle\Manager */
$im = $this->get("snowcap_im.manager");
if (strpos($path, "http/") === 0 || strpos($path, "https/") === 0) {
$newPath = $im->downloadExternalImage($format, $path);
$im->mogrify($format, $newPath);
} else {
$im->convert($format, $path);
}
if (!$im->cacheExists($format, $path)) {
throw new RuntimeException(sprintf("Caching of image failed for %s in %s format", $path, $format));
} else {
$extension = pathinfo($path, PATHINFO_EXTENSION);
$contentType = $request->getMimeType($extension);
if (empty($contentType)) {
$contentType = 'image/' . $extension;
}
return new Response($im->getCacheContent($format, $path), 200, array('Content-Type' => $contentType));
}
}
public function showAction(Request $request)
{
$showid = $request->query->get('showid');
$type = $request->query->get('type');
if ($type != 'json') {
$type = 'xml';
}
$repo = $this->getDoctrine()->getManager()->getRepository('ActsCamdramBundle:Show');
$show = $repo->findOneBySlug($showid);
if (!$show) {
if (is_numeric($showid)) {
$show = $repo->find($showid);
}
}
if (!$show) {
throw $this->createNotFoundException('That show does not exist.');
}
$apiShow = new ApiShow($show, $this->get('router'));
$serializer = $this->get('jms_serializer');
$response = new Response($serializer->serialize($apiShow, $type));
$response->headers->set('content-type', $request->getMimeType($type));
return $response;
}
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]);
}
/**
* exposeTranslationAction action.
*/
public function exposeTranslationAction(Request $request, $domain_name, $_locale, $_format)
{
$cache = new ConfigCache($this->cacheDir . '/' . $domain_name . '.' . $_locale . "." . $_format, $this->debug);
if (!$cache->isFresh()) {
$files = $this->translationFinder->getResources($domain_name, $_locale);
$resources = array();
$catalogues = array();
foreach (iterator_to_array($files) as $file) {
$extension = pathinfo($file->getFilename(), \PATHINFO_EXTENSION);
if (isset($this->loaders[$extension])) {
$resources[] = new FileResource($file->getPath());
$catalogues[] = $this->loaders[$extension]->load($file, $_locale, $domain_name);
}
}
$messages = array();
foreach ($catalogues as $catalogue) {
$messages = array_merge_recursive($messages, $catalogue->all());
}
$content = $this->engine->render('BazingaExposeTranslationBundle::exposeTranslation.' . $_format . '.twig', array('messages' => $messages, 'locale' => $_locale, 'defaultDomains' => $this->defaultDomains));
$cache->write($content, $resources);
}
$content = file_get_contents((string) $cache);
return new Response($content, 200, array('Content-Type' => $request->getMimeType($_format)));
}
/**
* Transform the format (json, html, ...) to their mimeType form (application/json, text/html, ...).
*
* @param Request $request
* @param array $priorities
*
* @return array formated priorities
*/
protected function normalizePriorities(Request $request, $priorities)
{
$priorities = $this->sanitize($priorities);
$mimeTypes = array();
foreach ($priorities as $priority) {
if (strpos($priority, '/')) {
$mimeTypes[] = $priority;
continue;
}
if (isset($this->mimeTypes[$priority])) {
foreach ($this->mimeTypes[$priority] as $mimeType) {
$mimeTypes[] = $mimeType;
}
} elseif (($mimeType = $request->getMimeType($priority)) !== null) {
$mimeTypes[] = $mimeType;
}
}
return $mimeTypes;
}
/**
* Display authorized applications that can access user information
*
* @param Request $request
* @param ApiApplication $application
*
* @return JsonResponse
*/
public function grantAccess(Request $request, ApiApplication $application)
{
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 (null === ($account = $this->getApiAccountRepository()->findByUserAndApplication($this->getAuthenticatedUser(), $application))) {
return $this->app->json(['success' => false]);
}
$manipulator = $this->getApiAccountManipulator();
if (false === (bool) $request->query->get('revoke')) {
$manipulator->authorizeAccess($account);
} else {
$manipulator->revokeAccess($account);
}
return $this->app->json(['success' => true]);
}
public function testGetMimeTypesFromInexistentFormat()
{
$request = new Request();
$this->assertNull($request->getMimeType('foo'));
$this->assertEquals(array(), Request::getMimeTypes('foo'));
}
/**
* Display authorized applications that can access user informations
*
* @param Application $app A Silex application where the controller is mounted on
* @param Request $request The current request
* @param Integer $application_id The application id
*
* @return JsonResponse
*/
public function grantAccess(Application $app, Request $request, $application_id)
{
if (!$request->isXmlHttpRequest() || !array_key_exists($request->getMimeType('json'), array_flip($request->getAcceptableContentTypes()))) {
$app->abort(400, $app->trans('Bad request format, only JSON is allowed'));
}
$error = false;
try {
$account = \API_OAuth2_Account::load_with_user($app, new \API_OAuth2_Application($app, $application_id), $app['authentication']->getUser());
$account->set_revoked((bool) $request->query->get('revoke'), false);
} catch (NotFoundHttpException $e) {
$error = true;
}
return $app->json(['success' => !$error]);
}
/**
* deleteId Autor
*
*/
public function deleteId(Application $app, Request $request, $id)
{
$em = $app['db.orm.em'];
$entity = $em->getRepository('Entity\\Autor')->find($id);
if (!$entity) {
$app->abort(404, 'No entity found for id ' . $id);
}
$em->remove($entity);
$em->flush();
return new Response($app['serializer']->serialize(['success' => true], 'json'), 200, array('Content-Type' => $request->getMimeType('json')));
}
/**
* @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');
}
}
/**
* @covers Symfony\Component\HttpFoundation\Request::getMimeType
* @dataProvider getFormatToMimeTypeMapProvider
*/
public function testGetMimeTypeFromFormat($format, $mimeTypes)
{
if (null !== $format) {
$request = new Request();
$this->assertEquals($mimeTypes[0], $request->getMimeType($format));
}
}
/**
* Handles creation of a Response using either redirection or the templating/serializer service.
*
* @param View $view
* @param Request $request
* @param string $format
*
* @return Response
*/
public function createResponse(View $view, Request $request, $format)
{
$route = $view->getRoute();
$location = $route ? $this->urlGenerator->generate($route, (array) $view->getRouteParameters(), UrlGeneratorInterface::ABSOLUTE_URL) : $view->getLocation();
if ($location) {
return $this->createRedirectResponse($view, $location, $format);
}
$response = $this->initResponse($view, $format);
if (!$response->headers->has('Content-Type')) {
$response->headers->set('Content-Type', $request->getMimeType($format));
}
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]);
}
/**
* Handles creation of a Response using either redirection or the templating/serializer service
*
* @param View $view
* @param Request $request
* @param string $format
*
* @return Response
*/
public function createResponse(View $view, Request $request, $format)
{
$headers = $view->getHeaders();
if (empty($headers['Content-Type'])) {
$view->setHeader('Content-Type', $request->getMimeType($format));
}
$route = $view->getRoute();
$location = $route ? $this->getRouter()->generate($route, (array) $view->getData(), true) : $view->getLocation();
if ($location) {
return $this->createRedirectResponse($view, $location, $format);
}
if ($this->isFormatTemplating($format)) {
$content = $this->renderTemplate($view, $format);
} else {
$serializer = $this->getSerializer($view);
$content = $serializer->serialize($view->getData(), $format);
}
return new Response($content, $this->getStatusCode($view), $view->getHeaders());
}
/**
* Handles a web API request.
*
* @param \Drupal\Core\Routing\RouteMatchInterface $route_match
* The route match.
* @param \Symfony\Component\HttpFoundation\Request $request
* The HTTP request object.
*
* @return \Symfony\Component\HttpFoundation\Response
* The response object.
*/
public function handle(RouteMatchInterface $route_match, Request $request)
{
$plugin = $route_match->getRouteObject()->getDefault('_plugin');
$method = strtolower($request->getMethod());
// Symfony is built to transparently map HEAD requests to a GET request. In
// the case of the REST module's RequestHandler though, we essentially have
// our own light-weight routing system on top of the Drupal/symfony routing
// system. So, we have to do the same as what the UrlMatcher does: map HEAD
// requests to the logic for GET. This also guarantees response headers for
// HEAD requests are identical to those for GET requests, because we just
// return a GET response. Response::prepare() will transform it to a HEAD
// response at the very last moment.
// @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.4
// @see \Symfony\Component\Routing\Matcher\UrlMatcher::matchCollection()
// @see \Symfony\Component\HttpFoundation\Response::prepare()
if ($method === 'head') {
$method = 'get';
}
$resource = $this->container->get('plugin.manager.rest')->getInstance(array('id' => $plugin));
// Deserialize incoming data if available.
$serializer = $this->container->get('serializer');
$received = $request->getContent();
$unserialized = NULL;
if (!empty($received)) {
$format = $request->getContentType();
// Only allow serialization formats that are explicitly configured. If no
// formats are configured allow all and hope that the serializer knows the
// format. If the serializer cannot handle it an exception will be thrown
// that bubbles up to the client.
$config = $this->container->get('config.factory')->get('rest.settings')->get('resources');
$method_settings = $config[$plugin][$request->getMethod()];
if (empty($method_settings['supported_formats']) || in_array($format, $method_settings['supported_formats'])) {
$definition = $resource->getPluginDefinition();
$class = $definition['serialization_class'];
try {
$unserialized = $serializer->deserialize($received, $class, $format, array('request_method' => $method));
} catch (UnexpectedValueException $e) {
$error['error'] = $e->getMessage();
$content = $serializer->serialize($error, $format);
return new Response($content, 400, array('Content-Type' => $request->getMimeType($format)));
}
} else {
throw new UnsupportedMediaTypeHttpException();
}
}
// Determine the request parameters that should be passed to the resource
// plugin.
$route_parameters = $route_match->getParameters();
$parameters = array();
// Filter out all internal parameters starting with "_".
foreach ($route_parameters as $key => $parameter) {
if ($key[0] !== '_') {
$parameters[] = $parameter;
}
}
// Invoke the operation on the resource plugin.
// All REST routes are restricted to exactly one format, so instead of
// parsing it out of the Accept headers again, we can simply retrieve the
// format requirement. If there is no format associated, just pick JSON.
$format = $route_match->getRouteObject()->getRequirement('_format') ?: 'json';
try {
$response = call_user_func_array(array($resource, $method), array_merge($parameters, array($unserialized, $request)));
} catch (HttpException $e) {
$error['error'] = $e->getMessage();
$content = $serializer->serialize($error, $format);
// Add the default content type, but only if the headers from the
// exception have not specified it already.
$headers = $e->getHeaders() + array('Content-Type' => $request->getMimeType($format));
return new Response($content, $e->getStatusCode(), $headers);
}
if ($response instanceof ResourceResponse) {
$data = $response->getResponseData();
// Serialization can invoke rendering (e.g., generating URLs), but the
// serialization API does not provide a mechanism to collect the
// bubbleable metadata associated with that (e.g., language and other
// contexts), so instead, allow those to "leak" and collect them here in
// a render context.
// @todo Add test coverage for language negotiation contexts in
// https://www.drupal.org/node/2135829.
$context = new RenderContext();
$output = $this->container->get('renderer')->executeInRenderContext($context, function () use($serializer, $data, $format) {
return $serializer->serialize($data, $format);
});
$response->setContent($output);
if (!$context->isEmpty()) {
$response->addCacheableDependency($context->pop());
}
$response->headers->set('Content-Type', $request->getMimeType($format));
// Add rest settings config's cache tags.
$response->addCacheableDependency($this->container->get('config.factory')->get('rest.settings'));
}
return $response;
}
/**
* Transform the format (json, html, ...) to their mimeType form (application/json, text/html, ...).
*
* @param Request $request
* @param string[] $priorities
*
* @return string[] formatted priorities
*/
private function normalizePriorities(Request $request, array $priorities)
{
$priorities = $this->sanitize($priorities);
$mimeTypes = array();
foreach ($priorities as $priority) {
if (strpos($priority, '/')) {
$mimeTypes[] = $priority;
continue;
}
if (method_exists(Request::class, 'getMimeTypes')) {
$mimeTypes = array_merge($mimeTypes, Request::getMimeTypes($priority));
} elseif (null !== $request->getMimeType($priority)) {
$class = new \ReflectionClass(Request::class);
$properties = $class->getStaticProperties();
$mimeTypes = array_merge($mimeTypes, $properties['formats'][$priority]);
}
if (isset($this->mimeTypes[$priority])) {
foreach ($this->mimeTypes[$priority] as $mimeType) {
$mimeTypes[] = $mimeType;
}
}
}
return $mimeTypes;
}
/**
* indexAction action.
*/
public function indexAction(Request $request, $_format)
{
$session = $request->getSession();
if ($request->hasPreviousSession() && $session->getFlashBag() instanceof AutoExpireFlashBag) {
// keep current flashes for one more request if using AutoExpireFlashBag
$session->getFlashBag()->setAll($session->getFlashBag()->peekAll());
}
$cache = new ConfigCache($this->exposedRoutesExtractor->getCachePath($request->getLocale()), $this->debug);
if (!$cache->isFresh()) {
$exposedRoutes = $this->exposedRoutesExtractor->getRoutes();
$serializedRoutes = $this->serializer->serialize($exposedRoutes, 'json');
$cache->write($serializedRoutes, $this->exposedRoutesExtractor->getResources());
} else {
$serializedRoutes = file_get_contents((string) $cache);
$exposedRoutes = $this->serializer->deserialize($serializedRoutes, 'Symfony\\Component\\Routing\\RouteCollection', 'json');
}
$routesResponse = new RoutesResponse($this->exposedRoutesExtractor->getBaseUrl(), $exposedRoutes, $this->exposedRoutesExtractor->getPrefix($request->getLocale()), $this->exposedRoutesExtractor->getHost(), $this->exposedRoutesExtractor->getScheme(), $request->getLocale());
$content = $this->serializer->serialize($routesResponse, 'json');
if (null !== ($callback = $request->query->get('callback'))) {
$validator = new \JsonpCallbackValidator();
if (!$validator->validate($callback)) {
throw new HttpException(400, 'Invalid JSONP callback value');
}
$content = $callback . '(' . $content . ');';
}
$response = new Response($content, 200, array('Content-Type' => $request->getMimeType($_format)));
$this->cacheControlConfig->apply($response);
return $response;
}
/**
* Handles creation of a Response using either redirection or the templating/serializer service
*
* @param View $view
* @param Request $request
* @param string $format
*
* @return Response
*/
public function createResponse(View $view, Request $request, $format)
{
$route = $view->getRoute();
$location = $route ? $this->getRouter()->generate($route, (array) $view->getData(), true) : $view->getLocation();
if ($location) {
return $this->createRedirectResponse($view, $location, $format);
}
$content = null;
if ($this->isFormatTemplating($format)) {
$content = $this->renderTemplate($view, $format);
} elseif ($this->serializeNull || null !== $view->getData()) {
$serializer = $this->getSerializer($view);
if ($serializer instanceof Serializer) {
$context = $this->getSerializationContext($view);
$content = $serializer->serialize($view->getData(), $format, $context);
} else {
$content = $serializer->serialize($view->getData(), $format);
}
}
$response = $view->getResponse();
$response->setStatusCode($this->getStatusCode($view, $content));
if (null !== $content) {
$response->setContent($content);
}
if (!$response->headers->has('Content-Type')) {
$response->headers->set('Content-Type', $request->getMimeType($format));
}
return $response;
}