/**
* 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);
}
public function testResponseContentSetToResultIfNotEmpty()
{
$this->renderer->placeholder('article')->set('Article Content');
$this->renderer->placeholder('content')->set('Content');
$event = new ViewEvent();
$event->setResponse($this->response)->setRenderer($this->renderer)->setResult('Result Content');
$this->strategy->injectResponse($event);
$content = $this->response->getContent();
$this->assertEquals('Result Content', $content);
}
/**
* @param ViewEvent $e
*/
public function injectResponse(ViewEvent $e)
{
if (!$this->model instanceof ViewModel) {
return;
}
$response = $e->getResponse();
if (!method_exists($response, 'getHeaders')) {
return;
}
$headers = $response->getHeaders();
$headers->addHeaderLine('Content-Type', 'application/vnd.swagger+json');
}
/**
* @param ViewEvent $e
*/
public function injectResponse(ViewEvent $e)
{
if (!$this->model instanceof ApiBlueprintModel) {
return;
}
$response = $e->getResponse();
if (!method_exists($response, 'getHeaders')) {
return;
}
$headers = $response->getHeaders();
$headers->addHeaderLine('Content-Type', 'text/vnd.apiblueprint+markdown');
$response->setContent($e->getResult());
}
/**
* {@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 testProperlyFillViewModelHelperIfRendererIsSelected()
{
$model = new ResourceViewModel();
$viewEvent = new ViewEvent();
$viewEvent->setModel($model);
$viewModelHelper = $this->getMock(ViewModel::class, [], [], '', false);
$viewModelHelper->expects($this->once())->method('setRoot')->with($model);
$viewModelHelper->expects($this->once())->method('setCurrent')->with($model);
$helperManager = $this->getMock(HelperPluginManager::class, [], [], '', false);
$helperManager->expects($this->once())->method('setRenderer')->with($this->resourceRenderer);
$helperManager->expects($this->once())->method('get')->with('viewModel')->willReturn($viewModelHelper);
$this->resourceRenderer->expects($this->once())->method('getHelperPluginManager')->willReturn($helperManager);
$this->assertSame($this->resourceRenderer, $this->resourceStrategy->selectRenderer($viewEvent));
}
public function injectResponse(ViewEvent $e)
{
$model = $e->getModel();
if (!$model instanceof \Stjornvisi\View\Model\IcalModel) {
// no JsonModel; do nothing
return;
}
$result = $e->getResult();
// Populate response
$response = $e->getResponse();
$response->setContent($result);
$headers = $response->getHeaders();
$headers->addHeaderLine('content-type', 'text/calendar; charset=utf-8');
}
public function injectResponse(ViewEvent $e)
{
$model = $e->getModel();
if (!$model instanceof \Stjornvisi\View\Model\CsvModel) {
// no JsonModel; do nothing
return;
}
$csv = $model->getData();
$result = $e->getResult();
// Populate response
$response = $e->getResponse();
$response->setContent($result);
$headers = $response->getHeaders();
$headers->addHeaderLine('content-type', 'text/csv; charset=utf-8')->addHeaderLine('Content-Disposition', sprintf("attachment; filename=\"%s\"", $csv->getName()));
}
public function testReturnsNullWhenCannotSelectRenderer()
{
$model = new ViewModel();
$request = new HttpRequest();
$this->event->setModel($model);
$this->event->setRequest($request);
$this->assertNull($this->strategy->selectRenderer($this->event));
}
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');
}
