/** * A route returning a CacheableResponse object. * * @return \Drupal\Core\Cache\CacheableResponseInterface * A CacheableResponseInterface object. */ public function cacheableResponse() { $user = User::load(1); $response = new CacheableResponse($user->label()); $response->addCacheableDependency($user); return $response; }
/** * Returns the whole sitemap, a requested sitemap chunk, or the sitemap index file. * * @param int $chunk_id * Optional ID of the sitemap chunk. If none provided, the first chunk or * the sitemap index is fetched. * * @throws NotFoundHttpException * * @return object * Returns an XML response. */ public function getSitemap($chunk_id = NULL) { $output = $this->generator->getSitemap($chunk_id); if (!$output) { throw new NotFoundHttpException(); } // Display sitemap with correct xml header. $response = new CacheableResponse($output, Response::HTTP_OK, ['content-type' => 'application/xml']); $meta_data = $response->getCacheableMetadata(); $meta_data->addCacheTags(['simple_sitemap']); return $response; }
/** * {@inheritdoc} */ public static function buildResponse($view_id, $display_id, array $args = []) { $build = static::buildBasicRenderable($view_id, $display_id, $args); // Set up an empty response, so for example RSS can set the proper // Content-Type header. $response = new CacheableResponse('', 200); $build['#response'] = $response; /** @var \Drupal\Core\Render\RendererInterface $renderer */ $renderer = \Drupal::service('renderer'); $output = (string) $renderer->renderRoot($build); if (empty($output)) { throw new NotFoundHttpException(); } $response->setContent($output); $cache_metadata = CacheableMetadata::createFromRenderArray($build); $response->addCacheableDependency($cache_metadata); return $response; }
/** * Sets a header. */ public function setHeader(Request $request) { $query = $request->query->all(); $response = new CacheableResponse(); $response->headers->set($query['name'], $query['value']); $response->getCacheableMetadata()->addCacheContexts(['url.query_args:name', 'url.query_args:value']); $response->setContent($this->t('The following header was set: %name: %value', array('%name' => $query['name'], '%value' => $query['value']))); return $response; }
/** * {@inheritdoc} */ public static function buildResponse($view_id, $display_id, array $args = []) { $build = static::buildBasicRenderable($view_id, $display_id, $args); /** @var \Drupal\Core\Render\RendererInterface $renderer */ $renderer = \Drupal::service('renderer'); $output = $renderer->renderRoot($build); $response = new CacheableResponse($output, 200); $cache_metadata = CacheableMetadata::createFromRenderArray($build); $response->addCacheableDependency($cache_metadata); $response->headers->set('Content-type', $build['#content_type']); return $response; }
/** * {@inheritdoc} */ public function execute() { parent::execute(); $output = $this->view->render(); $header = []; $header['Content-type'] = $this->getMimeType(); $response = new CacheableResponse($this->renderer->renderRoot($output), 200); $cache_metadata = CacheableMetadata::createFromRenderArray($output); $response->addCacheableDependency($cache_metadata); return $response; }
/** * {@inheritdoc} */ public static function buildResponse($view_id, $display_id, array $args = []) { $build = static::buildBasicRenderable($view_id, $display_id, $args); $build['#cache']['contexts'][] = "url.query_args:callback"; /** @var \Drupal\Core\Render\RendererInterface $renderer */ $renderer = \Drupal::service('renderer'); $output = $renderer->renderRoot($build); if (isset($build['#jsonp_callback'])) { $response = new CacheableJsonResponse($output, 200); $response->setCallback($build['#jsonp_callback']); } else { $response = new CacheableResponse($output, 200); } $cache_metadata = CacheableMetadata::createFromRenderArray($build); $response->addCacheableDependency($cache_metadata); $response->headers->set('Content-type', $build['#content_type']); return $response; }
/** * {@inheritdoc} * * The entire HTML: takes a #type 'page' and wraps it in a #type 'html'. */ public function renderResponse(array $main_content, Request $request, RouteMatchInterface $route_match) { list($page, $title) = $this->prepare($main_content, $request, $route_match); if (!isset($page['#type']) || $page['#type'] !== 'page') { throw new \LogicException('Must be #type page'); } $page['#title'] = $title; // Now render the rendered page.html.twig template inside the html.html.twig // template, and use the bubbled #attached metadata from $page to ensure we // load all attached assets. $html = ['#type' => 'html', 'page' => $page]; // The special page regions will appear directly in html.html.twig, not in // page.html.twig, hence add them here, just before rendering html.html.twig. $this->buildPageTopAndBottom($html); // The three parts of rendered markup in html.html.twig (page_top, page and // page_bottom) must be rendered with drupal_render_root(), so that their // #post_render_cache callbacks are executed (which may attach additional // assets). // html.html.twig must be able to render the final list of attached assets, // and hence may not execute any #post_render_cache_callbacks (because they // might add yet more assets to be attached), and therefore it must be // rendered with drupal_render(), not drupal_render_root(). $this->renderer->render($html['page'], TRUE); if (isset($html['page_top'])) { $this->renderer->render($html['page_top'], TRUE); } if (isset($html['page_bottom'])) { $this->renderer->render($html['page_bottom'], TRUE); } $content = $this->renderer->render($html); // Set the generator in the HTTP header. list($version) = explode('.', \Drupal::VERSION, 2); $response = new CacheableResponse($content, 200, ['Content-Type' => 'text/html; charset=UTF-8', 'X-Generator' => 'Drupal ' . $version . ' (https://www.drupal.org)']); // Bubble the cacheability metadata associated with the rendered render // arrays to the response. foreach (['page_top', 'page', 'page_bottom'] as $region) { if (isset($html[$region])) { $response->addCacheableDependency(CacheableMetadata::createFromRenderArray($html[$region])); } } // Also associate the "rendered" cache tag. This allows us to invalidate the // entire render cache, regardless of the cache bin. $default = new CacheableMetadata(); $default->setCacheTags(['rendered']); $response->addCacheableDependency($default); return $response; }
/** * Processing the API request. */ public function processRequest(Request $request, RouteMatchInterface $route_match, $service_endpoint_id, $service_definition_id) { /** @var $service_endpoint \Drupal\services\ServiceEndpointInterface */ $service_endpoint = $this->entityManager()->getStorage('service_endpoint')->load($service_endpoint_id); //TODO - pull in settings from service API and alter response /** @var $service_def \Drupal\services\ServiceDefinitionInterface */ $service_def = $this->serviceDefinitionManager->createInstance($service_definition_id, []); /** * Iterate over any contexts defined for this plugin and extract them from * the request defaults if the naming is identical. This means that a * context named 'node' would match to a url parameter {node} or a route * default named 'node'. */ foreach ($service_def->getContextDefinitions() as $context_id => $context_definition) { if ($request->attributes->has($context_id)) { $context = new Context($context_definition, $request->attributes->get($context_id)); $service_def->setContext($context_id, $context); } } // Get the data from the plugin. $data = $service_def->processRequest($request, $route_match, $this->serializer); $code = $service_def->getPluginDefinition()['response_code']; $headers = []; $messages = drupal_get_messages(); if ($messages) { foreach ($messages as $type => $type_message) { $headers["X-Drupal-Services-Messages-{$type}"] = implode("; ", $type_message); } } // Find the request format to determin how we're going to serialize this data $format = $request->getRequestFormat(); $data = $this->serializer->serialize($data, $format); /** * Create a new Cacheable Response object with our serialized data, set its * Content-Type to match the format of our Request and add the service * definition plugin as a cacheable dependency. * * This last step will extract the cache context, tags and max-ages from * any context the plugin required to operate. */ $response = new CacheableResponse($data, $code, $headers); $response->headers->add(['Content-Type' => $request->getMimeType($format)]); $response->addCacheableDependency($service_def); // Be explicit about the caching needs of this response. $response->setVary('Accept'); $service_def->processResponse($response); return $response; }
/** * {@inheritdoc} */ public static function buildResponse($view_id, $display_id, array $args = []) { $build = static::buildBasicRenderable($view_id, $display_id, $args); // Setup an empty response so headers can be added as needed during views // rendering and processing. $response = new CacheableResponse('', 200); $build['#response'] = $response; /** @var \Drupal\Core\Render\RendererInterface $renderer */ $renderer = \Drupal::service('renderer'); $output = (string) $renderer->renderRoot($build); $response->setContent($output); $cache_metadata = CacheableMetadata::createFromRenderArray($build); $response->addCacheableDependency($cache_metadata); $response->headers->set('Content-type', $build['#content_type']); return $response; }