PHP ViewEvent::getRenderer方法代码示例

 /**
  * Inject the response
  *
  * Injects the response with the rendered content, and sets the content
  * type based on the detection that occurred during renderer selection.
  *
  * @param  ViewEvent $e
  */
 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     $result = $e->getResult();
     if (!is_string($result)) {
         // We don't have a string, and thus, no JSON
         return;
     }
     $model = $e->getModel();
     $contentType = $this->contentType;
     $response = $e->getResponse();
     if ($model instanceof ApiProblemModel) {
         $contentType = 'application/problem+json';
     } elseif ($model instanceof HalJsonModel && ($model->isCollection() || $model->isEntity())) {
         $contentType = 'application/hal+json';
     }
     /** @var Response $response */
     $response->setContent($result);
     $headers = $response->getHeaders();
     $headers->addHeaderLine('content-type', $contentType);
 }

 /**
  * Inject the response with the PDF payload and appropriate Content-Type header
  *
  * @param  ViewEvent $e
  * @return void
  */
 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     $result = $e->getResult();
     if (!is_string($result)) {
         // @todo Potentially throw an exception here since we should *always* get back a result.
         return;
     }
     $response = $e->getResponse();
     $response->setContent($result);
     $response->getHeaders()->addHeaderLine('content-type', 'application/pdf');
     /* @var PdfOptions $pdfOptions */
     $pdfOptions = $e->getModel()->getPdfOptions();
     $fileName = $pdfOptions->getFileName();
     if (isset($fileName)) {
         if (substr($fileName, -4) != '.pdf') {
             $fileName .= '.pdf';
         }
         $response->getHeaders()->addHeaderLine('Content-Disposition', 'attachment; filename=' . $fileName);
     }
 }

 /**
  * Inject the response with the feed payload and appropriate Content-Type header
  *
  * @param  ViewEvent $e
  * @return void
  */
 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     $result = $e->getResult();
     if (!is_string($result) && !$result instanceof Feed) {
         // We don't have a string, and thus, no feed
         return;
     }
     // If the result is a feed, export it
     if ($result instanceof Feed) {
         $result = $result->export($renderer->getFeedType());
     }
     // Get the content-type header based on feed type
     $feedType = $renderer->getFeedType();
     $feedType = 'rss' == $feedType ? 'application/rss+xml' : 'application/atom+xml';
     $model = $e->getModel();
     $charset = '';
     if ($model instanceof Model\FeedModel) {
         $feed = $model->getFeed();
         $charset = '; charset=' . $feed->getEncoding() . ';';
     }
     // Populate response
     $response = $e->getResponse();
     $response->setContent($result);
     $headers = $response->getHeaders();
     $headers->addHeaderLine('content-type', $feedType . $charset);
 }

 /**
  * Inject the response
  *
  * Injects the response with the rendered content, and sets the content
  * type based on the detection that occurred during renderer selection.
  *
  * @param  ViewEvent $e
  */
 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     $result = $e->getResult();
     if (!is_string($result)) {
         // We don't have a string, and thus, no JSON
         return;
     }
     $model = $e->getModel();
     $contentType = $this->contentType;
     $response = $e->getResponse();
     if ($this->renderer->isApiProblem()) {
         $contentType = 'application/api-problem+json';
         $statusCode = $this->getStatusCodeFromApiProblem($this->renderer->getApiProblem());
         $response->setStatusCode($statusCode);
     } elseif ($model instanceof RestfulJsonModel && $model->isApiProblem()) {
         $contentType = 'application/api-problem+json';
         $statusCode = $this->getStatusCodeFromApiProblem($model->getPayload());
         $response->setStatusCode($statusCode);
     } elseif ($model instanceof RestfulJsonModel && ($model->isHalCollection() || $model->isHalResource())) {
         $contentType = 'application/hal+json';
     }
     // Populate response
     $response->setContent($result);
     $headers = $response->getHeaders();
     $headers->addHeaderLine('content-type', $contentType);
 }

 /**
  * Populate the response object from the View
  *
  * Populates the content of the response object from the view rendering
  * results.
  *
  * @param  ViewEvent $e
  * @return void
  */
 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         return;
     }
 }

 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     $result = $e->getResult();
     if (!is_string($result)) {
         // We don't have a string, and thus, no yaml
         return;
     }
     // Populate response
     /** @var Http\Response $response */
     $response = $e->getResponse();
     $response->setContent($result);
     /** @var Headers $headers */
     $headers = $response->getHeaders();
     $contentType = sprintf('application/x-yaml; charset=%s', $this->charset);
     $headers->addHeaderLine('content-type', $contentType);
     // Add content-transfer-encoding header in charset is multibyte
     if (in_array(strtoupper($this->charset), $this->multibyteCharsets)) {
         $headers->addHeaderLine('content-transfer-encoding', 'BINARY');
     }
 }

 /**
  * @param ViewEvent $ev
  * @return void
  */
 public function injectResponse(ViewEvent $ev)
 {
     if ($ev->getRenderer() === $this->renderer) {
         $result = $ev->getResult();
         $response = $ev->getResponse();
         $response->setContent($result);
     }
 }

 public function response(ViewEvent $event)
 {
     $renderer = $event->getRenderer();
     if ($renderer instanceof IcalendarRenderer) {
         $response = $event->getResponse();
         $response->getHeaders()->addHeaderLine('Content-type', 'text/calendar; charset=utf-8');
         $response->setContent($event->getResult());
     }
 }

 /**
  * Populate the response object from the view
  *
  * Populates the content of the response object from the view rendering
  * results.
  *
  * @param ViewEvent $event
  * @return void
  */
 public function injectResponse(ViewEvent $event)
 {
     if ($event->getRenderer() !== $this->renderer) {
         return;
     }
     $result = $event->getResult();
     $response = $event->getResponse();
     $response->setContent($result);
 }

 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         return false;
     }
     $result = $e->getResult();
     $response = $e->getResponse();
     $response->setContent($result);
 }

 /**
  * {@inheritDoc}
  */
 public function injectResponse(ViewEvent $e)
 {
     // Test this again here to avoid running our extra code for non-API
     // requests.
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     parent::injectResponse($e);
     $model = $e->getModel();
     $e->getResponse()->setStatusCode($this->getResponseStatusCode($model));
 }

 /**
  * Inject the response with the feed payload and appropriate Content-Type header
  *
  * @param  ViewEvent $e
  * @return void
  * @throws \Zend\Http\Exception\InvalidArgumentException
  */
 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         return;
     }
     $result = $e->getResult();
     /** @var HttpResponse $response */
     $response = $e->getResponse();
     $response->setContent($result);
     $headers = $response->getHeaders();
     //$headers->addHeaderLine('Content-length', strlen($result));
     $headers->addHeaderLine('content-type', 'text/xml');
 }

 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     $result = $e->getResult();
     if (!is_string($result)) {
         // We don't have a string, and thus, no YAML
         return;
     }
     // Populate response
     $response = $e->getResponse();
     $response->setContent($result);
     $headers = $response->getHeaders();
     $headers->addHeaderLine('content-type', 'text/yaml');
 }

 /**
  * Inject the response
  *
  * Injects the response with the rendered content, and sets the content
  * type based on the detection that occurred during renderer selection.
  *
  * @param  ViewEvent $e
  */
 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     $result = $e->getResult();
     if (!is_string($result)) {
         // We don't have a string, and thus, no JSON
         return;
     }
     $model = $e->getModel();
     $response = $e->getResponse();
     $response->setContent($result);
     $headers = $response->getHeaders();
     $headers->addHeaderLine('content-type', $this->getContentTypeFromModel($model));
 }

 /**
  * Inject the response with the JSON payload and appropriate Content-Type header
  *
  * @param  \Zend\View\ViewEvent $e
  * @return void
  */
 public function injectResponse(ViewEvent $e)
 {
     $renderer = $e->getRenderer();
     if ($renderer !== $this->renderer) {
         // Discovered renderer is not ours; do nothing
         return;
     }
     $result = $e->getResult();
     if (!$result instanceof NegotiatedResult) {
         // not a NegotiatedResult, we can't go on here
         return;
     }
     // Populate response
     $response = $e->getResponse();
     $response->setContent($result->content);
     $headers = $response->getHeaders();
     $headers->addHeaderLine('content-type', $result->contentType);
 }