php Zend-View-ViewEvent类(方法)实例源码

/**
  * 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 testSelectRendererReturnsNullWhenApiBlueprintViewModelIsNotPresentInEvent()
 {
     $event = new ViewEvent();
     $event->setName(ViewEvent::EVENT_RENDERER);
     $this->assertNull($this->strategy->selectRenderer($event));
     return $event;
 }

/**
  * 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);
 }

/**
  * 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);
 }

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 $e
  *
  * @return null
  *
  * @throws \Zend\Config\Exception\RuntimeException
  * @throws \Zend\Http\Exception\InvalidArgumentException
  */
 public function injectResponse(ViewEvent $e)
 {
     $model = $e->getModel();
     if (!$model instanceof ApiProblemModel) {
         // Model is not an ApiProblemModel; we cannot handle it here
         return null;
     }
     /** @var Request $request */
     $request = $e->getRequest();
     /** @var Accept $accept */
     $accept = $request->getHeader('Accept');
     if (!($accept instanceof Accept && $accept->hasMediaType('text/xml'))) {
         return null;
     }
     $problem = $model->getApiProblem();
     $statusCode = $this->getStatusCodeFromApiProblem($problem);
     $contentType = 'text/xml';
     /** @var Response $response */
     $response = $e->getResponse();
     $problemData = $problem->toArray();
     $xmlWriter = new XmlWriter();
     $output = $xmlWriter->processConfig($problemData);
     $response->setStatusCode($statusCode);
     $response->setContent($output);
     $headers = $response->getHeaders();
     $headers->addHeaderLine('Content-Type', $contentType);
 }

/**
  * 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);
     }
 }

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

/**
  * 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 testSelectRendererWithExtension()
 {
     $model = $this->getMock('Zend\\View\\Model\\ModelInterface');
     $model->expects($this->at(0))->method('getTemplate')->will($this->returnValue('test.md'));
     $event = new ViewEvent();
     $event->setModel($model);
     $result = $this->strategy->selectRenderer($event);
     $this->assertInstanceOf('Netorare\\View\\Renderer\\MarkdownRenderer', $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());
     }
 }

public function testSelectRendererWhenTemplateFound()
 {
     $model = $this->getMock('Zend\\View\\Model\\ModelInterface');
     $model->expects($this->at(0))->method('getTemplate')->will($this->returnValue('key1'));
     $event = new ViewEvent();
     $event->setModel($model);
     $result = $this->strategy->selectRenderer($event);
     $this->assertSame($this->renderer, $result);
 }

/**
  * Check for not authorized and redirect to the login page on 401.
  *
  * @param ViewEvent $event Zend MVC Event object
  *
  * @return null
  */
 public function processRcmResponses(ViewEvent $event)
 {
     $response = $event->getResponse();
     if (!$response instanceof RcmResponse) {
         return null;
     }
     $this->responseHandler->processResponse($response);
     return null;
 }

/**
  * Detect if we should use the ResourceJsonRenderer based on model type
  *
  * @param ViewEvent $e
  * @return null|ResourceJsonRenderer|\Zend\View\Renderer\JsonRenderer
  */
 public function selectRenderer(ViewEvent $e)
 {
     $model = $e->getModel();
     if (!$model instanceof ResourceJsonModel) {
         // Not a Resource Json Model
         return;
     }
     return $this->renderer;
 }

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

/**
  * Sets the response based on image returned by the renderer
  *
  * @param  ViewEvent $e
  * @return void
  */
 public function injectResponse(ViewEvent $e)
 {
     $model = $e->getModel();
     if ($model instanceof ImageModel) {
         $result = $e->getResult();
         $response = $e->getResponse();
         $response->setContent($result);
         $response->getHeaders()->addHeaderLine('Content-type', $this->getMimeType($model->getFormat()));
     }
 }

/**
  * Detect if we should use the UploaderRenderer based on model type and/or
  * Accept header
  *
  * @param  ViewEvent $e
  * @return null | RendererInterface
  */
 public function selectRenderer(ViewEvent $e)
 {
     $model = $e->getModel();
     if (!$model instanceof UploaderModelInterface) {
         return null;
     }
     $this->renderer = $this->rendererFactory->createRenderer($e->getRequest()->getQuery());
     // JsonModel found
     return $this->renderer;
 }

public function selectRenderer(ViewEvent $event)
 {
     $model = $event->getModel();
     if (!$model instanceof JsonModel) {
         // no JsonModel; do nothing
         return null;
     }
     // JsonModel found
     return $this->renderer;
 }

/**
  * 
  * @param ModelInterface $model
  * @return string
  */
 public function render(ModelInterface $model)
 {
     $event = new ViewEvent();
     $event->setName(ViewEvent::EVENT_RENDERER);
     $event->setModel($model);
     $renderers = $this->view->getEventManager()->triggerEventUntil(function ($result) {
         return $result instanceof RendererInterface;
     }, $event);
     return $renderers->last()->render($model);
 }