PHP Response::setPrivate方法代码示例

 public function indexAction(Request $request)
 {
     $response = new Response();
     $response->setPrivate();
     $response->setContent($this->twig->render('www/Index.twig', array()));
     return $response;
 }

 /**
  * Update a valid non cacheable Response with http cache headers
  *
  * @see http://symfony.com/fr/doc/current/book/http_cache.html
  */
 public function handleResponse(Response $response)
 {
     // do not handle invalid response
     if (!$response->isOk()) {
         return $response;
     }
     // do not handle response with http cache headers
     if ($response->isCacheable()) {
         return $response;
     }
     // seek for optional configuration
     $this->readRoutingConfiguration();
     // mark the response as private
     $response->setPrivate();
     // set the private or shared max age
     $response->setMaxAge($this->duration);
     $response->setSharedMaxAge($this->duration);
     // set expires
     $date = new \DateTime();
     $date->modify(sprintf('+%d seconds', $this->duration));
     $response->setExpires($date);
     // set a custom Cache-Control directive
     $response->headers->addCacheControlDirective('must-revalidate', true);
     return $response;
 }

 /**
  * {@inheritdoc}
  */
 public function render(BlockInterface $block, Response $response = null)
 {
     if ($this->logger) {
         $this->logger->info(sprintf('[cms::renderBlock] block.id=%d, block.type=%s ', $block->getId(), $block->getType()));
     }
     try {
         $service = $this->blockServiceManager->get($block);
         $service->load($block);
         // load the block
         $response = $service->execute($block, $response);
         if (!$response instanceof Response) {
             throw new \RuntimeException('A block service must return a Response object');
         }
     } catch (\Exception $e) {
         if ($this->logger) {
             $this->logger->crit(sprintf('[cms::renderBlock] block.id=%d - error while rendering block - %s', $block->getId(), $e->getMessage()));
         }
         if ($this->debug) {
             throw $e;
         }
         $response = new Response();
         $response->setPrivate();
     }
     return $response;
 }

 /**
  * Set response status
  * 
  * @param Response $response
  * @param string   $status
  */
 protected function setResponseStatus(Response $response, $status)
 {
     if (CacheableInterface::CACHE_PUBLIC == $status) {
         $response->setPublic();
     } else {
         $response->setPrivate();
     }
 }

 /**
  * {@inheritdoc}
  */
 public function after(Request $request, Response $response)
 {
     if ($this->session()->isStarted()) {
         $response->setPrivate();
     } else {
         $sharedMaxAge = $this->getOption('general/caching/duration', 10) * 60;
         $response->setPublic()->setSharedMaxAge($sharedMaxAge);
     }
 }

 /**
  * @param Request $request
  * @param Response $response
  * @return Response
  */
 public function setCacheHeaders(Request $request, Response $response)
 {
     $response->setMaxAge($this->defaultMaxAge);
     if ($this->isLoggedIn($request) || $this->isWordpressAdminPage($request)) {
         $response->setPrivate();
     } else {
         $response->setPublic();
     }
     return $response;
 }

 /**
  * @param Request $request
  *
  * @return \Symfony\Component\HttpFoundation\Response
  */
 public function embedAction(Request $request)
 {
     $response = new Response();
     $response->setPrivate();
     $response->setMaxAge(0);
     $response->setSharedMaxAge(0);
     $response->headers->addCacheControlDirective('must-revalidate', true);
     $response->headers->addCacheControlDirective('no-store', true);
     $response->headers->set(HttpCache::HEADER_REVERSE_PROXY_TTL, 0);
     return $this->render($this->getTemplate(Configuration::TYPE_LOGIN, Configuration::TEMPLATE_FORM_EMBED), ['user' => $this->getUser()], $response);
 }

 /**
  * @param Response $response
  * @param Request $request
  *
  * @return ResponseConfigurator
  */
 protected function setPrivateCache(Response $response, Request $request)
 {
     if (!$response->headers->hasCacheControlDirective('private')) {
         $response->setPublic();
         foreach ($this->private_headers as $private_header) {
             if ($request->headers->has($private_header)) {
                 $response->setPrivate();
                 break;
             }
         }
     }
     return $this;
 }

 /**
  * /token/event.pixel
  *
  * @param string $token Event
  * @param string $event Token
  *
  * @return Response Empty response
  */
 public function addEntryAction($token, $event)
 {
     $requestQuery = $this->requestStack->getCurrentRequest()->query;
     $value = $requestQuery->get('i', 0);
     $type = (int) $requestQuery->get('t', ElcodiMetricTypes::TYPE_BEACON_ALL);
     $this->metricManager->addEntry($token, $event, $value, $type, $this->dateTimeFactory->create());
     $content = base64_decode(self::IMAGE_CONTENT);
     $response = new Response($content);
     $response->setPrivate();
     $response->headers->addCacheControlDirective('no-cache', true);
     $response->headers->addCacheControlDirective('must-revalidate', true);
     $response->headers->set('Content-Type', 'image/png');
     return $response;
 }

 /**
  * @return Response
  */
 public function getResponse()
 {
     if (null !== $this->response) {
         $this->response->setPublic();
         $this->response->setPrivate();
         $this->response->setMaxAge($this->configuration->getTtl());
         $this->response->setSharedMaxAge($this->configuration->getTtl());
         $this->response->setCharset('UTF-8');
         $this->response->prepare($this->request);
         return $this->response;
     } else {
         throw new \RuntimeException("Request had not been handled. Use handle() method before getResponse()", 1);
     }
 }

 public function testIsPrivate()
 {
     $response = new Response();
     $response->headers->set('Cache-Control', 'max-age=100');
     $response->setPrivate();
     $this->assertEquals(100, $response->headers->getCacheControlDirective('max-age'), '->isPrivate() adds the private Cache-Control directive when set to true');
     $this->assertTrue($response->headers->getCacheControlDirective('private'), '->isPrivate() adds the private Cache-Control directive when set to true');
     $response = new Response();
     $response->headers->set('Cache-Control', 'public, max-age=100');
     $response->setPrivate();
     $this->assertEquals(100, $response->headers->getCacheControlDirective('max-age'), '->isPrivate() adds the private Cache-Control directive when set to true');
     $this->assertTrue($response->headers->getCacheControlDirective('private'), '->isPrivate() adds the private Cache-Control directive when set to true');
     $this->assertFalse($response->headers->hasCacheControlDirective('public'), '->isPrivate() removes the public Cache-Control directive');
 }

 /**
  * @param $id
  * @param $size
  * @return Response
  */
 public function getImagePreviewAction($id, $size)
 {
     /**
      * @var Piece $piece
      */
     $piece = $this->get('jahller.artlas.repository.piece')->find($id);
     /**
      * @var Image $image
      */
     $image = $piece->getImage();
     $content = $this->get('jahller.attachment.manager.image')->getPreview($image, $size);
     $response = new Response($content, 202, array('Content-type' => 'image/png'));
     $response->setPrivate();
     /* 1 month = 2.628.000 seconds */
     $response->setMaxAge(2628000);
     return $response;
 }

 /**
  * This action applies a given filter to a given image, saves the image and
  * outputs it to the browser at the same time
  *
  * @param string $path
  * @param string $filter
  *
  * @return Response
  *
  * @throws Exception
  */
 public function filterAction($path, $filter)
 {
     $baseUrl = $this->request->getBaseUrl();
     try {
         try {
             $cachedPath = $this->cacheManager->cacheImage($baseUrl, $path, $filter);
         } catch (RuntimeException $e) {
             if (!isset($this->notFoundImages[$filter])) {
                 throw $e;
             }
             $path = $this->notFoundImages[$filter];
             $cachedPath = $this->cacheManager->cacheImage($baseUrl, $path, $filter);
         }
     } catch (RouteNotFoundException $e) {
         throw new NotFoundHttpException('Filter doesn\'t exist.');
     }
     // if cache path cannot be determined, return 404
     if (null === $cachedPath) {
         throw new NotFoundHttpException('Image doesn\'t exist');
     }
     try {
         // Using File instead of Imagine::open(), because i.e. image/x-icon is not widely supported.
         $file = new ImageFile($cachedPath, false);
         // TODO: add more media headers
         $headers = ['content-type' => $file->getMimeType(), 'content-length' => $file->getSize()];
         $response = new Response($file->getContents(), 201, $headers);
         // Cache
         if (!($cacheType = $this->filterManager->getOption($filter, 'cache_type', false))) {
             return $response;
         }
         $cacheType === 'public' ? $response->setPublic() : $response->setPrivate();
         $cacheExpires = $this->filterManager->getOption($filter, 'cache_expires', '1 day');
         $expirationDate = new DateTime('+' . $cacheExpires);
         $maxAge = $expirationDate->format('U') - time();
         if ($maxAge < 0) {
             throw new InvalidArgumentException('Invalid cache expiration date');
         }
         $response->setExpires($expirationDate);
         $response->setMaxAge($maxAge);
         return $response;
     } catch (Exception $e) {
         throw $e;
     }
 }

 public function infoAction(Request $request)
 {
     $jsonp = $request->query->get('jsonp');
     $locale = $request->query->get('_locale');
     if (isset($locale)) {
         $request->setLocale($locale);
     }
     $locale = $request->getLocale();
     $decklist_id = $request->query->get('decklist_id');
     $content = null;
     /* @var $user \Netrunnerdb\UserBundle\Entity\User */
     $user = $this->getUser();
     if ($user) {
         $user_id = $user->getId();
         $public_profile_url = $this->get('router')->generate('user_profile_view', array('_locale' => $this->getRequest()->getLocale(), 'user_id' => $user_id, 'user_name' => urlencode($user->getUsername())));
         $content = array('public_profile_url' => $public_profile_url, 'id' => $user_id, 'name' => $user->getUsername(), 'faction' => $user->getFaction(), 'locale' => $locale);
         if (isset($decklist_id)) {
             /* @var $em \Doctrine\ORM\EntityManager */
             $em = $this->get('doctrine')->getManager();
             /* @var $decklist \Netrunnerdb\BuilderBundle\Entity\Decklist */
             $decklist = $em->getRepository('NetrunnerdbBuilderBundle:Decklist')->find($decklist_id);
             if ($decklist) {
                 $decklist_id = $decklist->getId();
                 $dbh = $this->get('doctrine')->getConnection();
                 $content['is_liked'] = (bool) $dbh->executeQuery("SELECT\n        \t\t\t\tcount(*)\n        \t\t\t\tfrom decklist d\n        \t\t\t\tjoin vote v on v.decklist_id=d.id\n        \t\t\t\twhere v.user_id=?\n        \t\t\t\tand d.id=?", array($user_id, $decklist_id))->fetch(\PDO::FETCH_NUM)[0];
                 $content['is_favorite'] = (bool) $dbh->executeQuery("SELECT\n        \t\t\t\tcount(*)\n        \t\t\t\tfrom decklist d\n        \t\t\t\tjoin favorite f on f.decklist_id=d.id\n        \t\t\t\twhere f.user_id=?\n        \t\t\t\tand d.id=?", array($user_id, $decklist_id))->fetch(\PDO::FETCH_NUM)[0];
                 $content['is_author'] = $user_id == $decklist->getUser()->getId();
                 $content['can_delete'] = $decklist->getNbcomments() == 0 && $decklist->getNbfavorites() == 0 && $decklist->getNbvotes() == 0;
             }
         }
     }
     $content = json_encode($content);
     $response = new Response();
     $response->setPrivate();
     if (isset($jsonp)) {
         $content = "{$jsonp}({$content})";
         $response->headers->set('Content-Type', 'application/javascript');
     } else {
         $response->headers->set('Content-Type', 'application/json');
     }
     $response->setContent($content);
     return $response;
 }

 /**
  * @param Response $response
  */
 public function apply(Response $response)
 {
     if (empty($this->parameters['enabled'])) {
         return;
     }
     $this->parameters['public'] ? $response->setPublic() : $response->setPrivate();
     if (is_integer($this->parameters['maxage'])) {
         $response->setMaxAge($this->parameters['maxage']);
     }
     if (is_integer($this->parameters['smaxage'])) {
         $response->setSharedMaxAge($this->parameters['smaxage']);
     }
     if ($this->parameters['expires'] !== null) {
         $response->setExpires(new \DateTime($this->parameters['expires']));
     }
     if (!empty($this->parameters['vary'])) {
         $response->setVary($this->parameters['vary']);
     }
 }