/**
* @param GetResponseForControllerResultEvent $event The event to handle
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
/**
* Anytime we don't find what we're looking for, return and let other
* listeners handle things
*/
$response = $event->getControllerResult();
if (!is_array($response)) {
return;
}
$request = $event->getRequest();
$routeName = $request->attributes->get('_route');
if (!($route = $this->app['routes']->get($routeName))) {
return;
}
if (!($args = $route->getOption('_view'))) {
return;
}
$template = $args['template'];
$callable = $args['callable'];
if ($callable) {
$response = $callable($response, $request);
}
if ($response instanceof Response) {
$event->setResponse($response);
return;
}
if (null !== $template) {
$output = $this->render($template, $response);
$event->setResponse(new Response($output));
}
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
$request = $event->getRequest();
if ('json' !== $request->getRequestFormat()) {
return;
}
$result = $event->getControllerResult();
if (null === $result) {
$event->setResponse(new JsonResponse(null, 204));
return;
}
if ($result instanceof Response) {
return;
}
$response = new JsonResponse();
if ($request->isMethod('POST')) {
$response->setStatusCode(201);
}
if (!is_scalar($result)) {
$result = $this->getSerializer()->normalize($result, null, ['groups' => $this->options['serialization_default_groups']]);
}
$response->setData($result);
$event->setResponse($response);
}
/**
* Handle converting the result into a valid JSON Response object back to the caller.
*
* @param GetResponseForControllerResultEvent $event The event to handle
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$response = $event->getControllerResult();
if ($response instanceof Response) {
$event->setResponse($response);
}
if (is_null($response)) {
$event->setResponse(new Response('', 404, $this->getResponseHeaders()));
return;
}
// we allow the response object that come back to be encoded by our default handler
// or decorator if need be.
if (is_object($response)) {
$decorator = $this->getDecorator();
if ($decorator) {
$decorator->setObject($response);
$event->setResponse(new Response($decorator->getResult(), 200, $this->getResponseHeaders()));
return;
}
if (is_callable($response, "toJson")) {
$event->setResponse(new Response($response->toJson(), 200, $this->getResponseHeaders()));
return;
}
}
$event->setResponse(new JsonResponse($response));
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
$templating = $this->templating;
$parameters = $event->getControllerResult();
if (null === $parameters) {
if (!($vars = $request->attributes->get('_template_vars'))) {
if (!($vars = $request->attributes->get('_template_default_vars'))) {
return;
}
}
$parameters = array();
foreach ($vars as $var) {
$parameters[$var] = $request->attributes->get($var);
}
}
$routeParams = $request->attributes->get('_route_params');
// get injected layout entity from annotation and add it to the paramaters
if (isset($routeParams['rootLayout'])) {
$parameters['rootLayout'] = $routeParams['rootLayout'];
}
if (!($template = $request->attributes->get('_template'))) {
return $parameters;
}
// wrap all parameters in params array
$parameters['params'] = $parameters;
if (!$request->attributes->get('_template_streamable')) {
$event->setResponse($templating->renderResponse($template, $parameters));
} else {
$callback = function () use($templating, $template, $parameters) {
return $templating->stream($template, $parameters);
};
$event->setResponse(new StreamedResponse($callback));
}
}
/**
* Sets a response given a TestDomainObject instance.
*
* @param \Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent $event
* The event to process.
*/
public function onViewTestDomainObject(GetResponseForControllerResultEvent $event)
{
$result = $event->getControllerResult();
if ($result instanceof TestDomainObject) {
if ($result instanceof AttachmentsTestDomainObject) {
$event->setResponse(new AttachmentsTestResponse('AttachmentsTestDomainObject'));
} elseif ($result instanceof CacheableTestDomainObject) {
$event->setResponse(new CacheableTestResponse('CacheableTestDomainObject'));
} else {
$event->setResponse(new Response('TestDomainObject'));
}
}
}
/**
* Transform data from controller to json.
*
* @param GetResponseForControllerResultEvent $event
*/
public function onView(GetResponseForControllerResultEvent $event)
{
$controllerResult = $event->getControllerResult();
if (is_string($controllerResult)) {
if (null === json_decode($controllerResult)) {
$event->setResponse(new Response($controllerResult));
return;
}
} else {
$controllerResult = $this->serializer->serialize($controllerResult, 'json');
}
$response = new JsonResponse();
$response->setJsonData($controllerResult);
$event->setResponse($response);
}
/**
* Transform data from controller to json.
*
* @param GetResponseForControllerResultEvent $event
*/
public function onView(GetResponseForControllerResultEvent $event)
{
$controllerResult = $event->getControllerResult();
$response = new JsonResponse();
$response->setJsonData($this->serializer->serialize($controllerResult, 'json'));
$event->setResponse($response);
}
/**
* @param \Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent $e
*/
public function onKernelView(GetResponseForControllerResultEvent $e)
{
$queryset = $e->getControllerResult();
$routeName = $e->getRequest()->attributes->get('_route');
$route = $this->routes->get($routeName);
if (!$route) {
return;
}
$interface = 'SDispatcher\\Common\\PaginatorInterface';
$paginatorClass = $route->getOption(RouteOptions::PAGINATOR_CLASS);
if (!$paginatorClass || !is_subclass_of($paginatorClass, $interface)) {
return;
}
try {
/* @var \SDispatcher\Common\PaginatorInterface $paginator */
$paginator = new $paginatorClass();
if (!$paginator->supports($queryset)) {
return;
}
list($headers, $data) = $paginator->paginate($e->getRequest(), $queryset, 0, $route->getOption(RouteOptions::PAGE_LIMIT), $route->getOption(RouteOptions::PAGINATED_META_CONTAINER_NAME), $route->getOption(RouteOptions::PAGINATED_DATA_CONTAINER_NAME));
} catch (\Exception $ex) {
list($headers, $data) = array(array(), array());
}
$response = new DataResponse($data);
$response->headers->add($headers);
$e->setResponse($response);
}
/**
* In an API context, converts any data to a XML response.
*
* @param GetResponseForControllerResultEvent $event
*
* @return Response|mixed
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$controllerResult = $event->getControllerResult();
if ($controllerResult instanceof Response) {
return $controllerResult;
}
$request = $event->getRequest();
$format = $request->attributes->get('_api_format');
if (self::FORMAT !== $format) {
return $controllerResult;
}
switch ($request->getMethod()) {
case Request::METHOD_POST:
$status = 201;
break;
case Request::METHOD_DELETE:
$status = 204;
break;
default:
$status = 200;
break;
}
$resourceType = $request->attributes->get('_resource_type');
$response = new Response($this->serializer->serialize($controllerResult, self::FORMAT, $resourceType->getNormalizationContext()), $status, ['Content-Type' => 'application/xml']);
$event->setResponse($response);
}
/**
* @param GetResponseForControllerResultEvent $event
*/
public function onControllerView(GetResponseForControllerResultEvent $event)
{
if (!$event->getControllerResult() instanceof XmlRpcResponse) {
return;
}
$event->setResponse($this->responseGenerator->fromXmlRpcResponse($event->getControllerResult()));
}
/**
* Renders the layout and initializes the content of a new response object
* with the rendered layout.
*
* @param GetResponseForControllerResultEvent $event
*
* @throws LogicException if @Layout annotation is used in incorrect way
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
/** @var LayoutAnnotation|null $layoutAnnotation */
$layoutAnnotation = $request->attributes->get('_layout');
if (!$layoutAnnotation) {
return;
}
if ($request->attributes->get('_template')) {
throw new LogicException('The @Template() annotation cannot be used together with the @Layout() annotation.');
}
$parameters = $event->getControllerResult();
if (is_array($parameters)) {
$context = new LayoutContext();
foreach ($parameters as $key => $value) {
$context->set($key, $value);
}
$this->configureContext($context, $layoutAnnotation);
$layout = $this->getLayout($context, $layoutAnnotation);
} elseif ($parameters instanceof ContextInterface) {
$this->configureContext($parameters, $layoutAnnotation);
$layout = $this->getLayout($parameters, $layoutAnnotation);
} elseif ($parameters instanceof Layout) {
if (!$layoutAnnotation->isEmpty()) {
throw new LogicException('The empty @Layout() annotation must be used when ' . 'the controller returns an instance of "Oro\\Component\\Layout\\Layout".');
}
$layout = $parameters;
} else {
return;
}
$response = new Response();
$response->setContent($layout->render());
$event->setResponse($response);
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$response = $event->getResponse();
if ($response && $response->headers->get('Content-type') == 'application/json') {
return;
}
$controllerResult = $event->getControllerResult();
$response = new Response();
$response->setStatusCode(200);
$response->headers->add(array('Content-type' => 'application/json'));
list($controllerObject, $controllerMethod) = explode('::', $event->getRequest()->get('_controller'));
$method = new \ReflectionMethod($controllerObject, $controllerMethod);
$annotations = $this->reader->getMethodAnnotations($method);
$full = false;
foreach ($annotations as $annotation) {
if ($annotation instanceof \Hyper\AdsBundle\Api\Json) {
$full = $annotation->full;
}
}
if (is_object($controllerResult)) {
$content = json_encode($this->serializer->toJson($controllerResult, $full));
} elseif (is_array($controllerResult) && !empty($controllerResult) && is_object(current($controllerResult))) {
$content = json_encode($this->serializer->toJsonArray($controllerResult));
} else {
$content = json_encode($controllerResult);
}
$response->setContent($content);
$event->setResponse($response);
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$response = $event->getControllerResult();
if (!$response instanceof Response) {
$event->setResponse(new Response($response));
}
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$hal = $event->getControllerResult();
if ($hal instanceof Hal) {
$event->setResponse(new HalResponse($hal, 200, [], $this->prettyPrint));
}
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$response = $event->getControllerResult();
if (is_object($response) && !$response instanceof Response || is_array($response)) {
$event->setResponse(new Response(serialize($response)));
}
}
/**
* Processes a successful controller into an HTTP 200 response.
*
* Some controllers may not return a response object but simply the body of
* one. The VIEW event is called in that case, to allow us to mutate that
* body into a Response object. In particular we assume that the return
* from an JSON-type response is a JSON string, so just wrap it into a
* Response object.
*
* @param Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent $event
* The Event to process.
*/
public function onView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
// For a master request, we process the result and wrap it as needed.
// For a subrequest, all we want is the string value. We assume that
// is just an HTML string from a controller, so wrap that into a response
// object. The subrequest's response will get dissected and placed into
// the larger page as needed.
if ($event->getRequestType() == HttpKernelInterface::MASTER_REQUEST) {
$method = 'on' . $this->negotiation->getContentType($request);
if (method_exists($this, $method)) {
$event->setResponse($this->{$method}($event));
} else {
$event->setResponse(new Response('Not Acceptable', 406));
}
} else {
// This is a new-style Symfony-esque subrequest, which means we assume
// the body is not supposed to be a complete page but just a page
// fragment.
$page_result = $event->getControllerResult();
if ($page_result instanceof HtmlPage || $page_result instanceof Response) {
return $page_result;
}
if (!is_array($page_result)) {
$page_result = array('#markup' => $page_result);
}
// If no title was returned fall back to one defined in the route.
if (!isset($page_result['#title'])) {
$page_result['#title'] = $this->titleResolver->getTitle($request, $request->attributes->get(RouteObjectInterface::ROUTE_OBJECT));
}
$event->setResponse(new Response(drupal_render_root($page_result)));
}
}
/**
* Dumps the statstable
* @param GetResponseForControllerResultEvent $event
* @throws \RuntimeException
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$configuration = $event->getRequest()->attributes->get('_statstable');
if (!$configuration instanceof Configuration\StatsTableResult) {
return;
}
$types = $this->getTypes();
$format = $configuration->getFormat();
$formatConfiguration = array();
foreach ($types as $type) {
if (in_array($format, $type['formats'])) {
$formatConfiguration = $type;
break;
}
}
if (0 === count($formatConfiguration)) {
throw new \RuntimeException('Invalid format : "' . $format . '" given.');
}
$statsTable = $event->getControllerResult();
if (!$statsTable instanceof \IgraalOSL\StatsTable\StatsTable) {
throw new \RuntimeException('Controller result must be an instance of \\IgraalOSL\\StatsTable\\StatsTable');
}
$response = $event->getResponse();
if (!$response) {
$response = new Response();
}
$event->setResponse($response);
/** @var \IgraalOSB\StatsTable\Dumper\DumperInterface $dumper */
$dumper = new $formatConfiguration['class']();
$stResponse = new StatsTableResponse($statsTable, $dumper);
$response->headers->set('Content-type', $stResponse->headers->get('content-type'));
$response->setContent($stResponse->getContent());
unset($stResponse);
}
/**
* Converts a PSR-7 response to a Symfony response.
*
* @param \Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent $event
* The Event to process.
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$controller_result = $event->getControllerResult();
if ($controller_result instanceof ResponseInterface) {
$event->setResponse($this->httpFoundationFactory->createResponse($controller_result));
}
}
/**
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
$nodeTranslation = $request->attributes->get('_nodeTranslation');
if ($nodeTranslation) {
$entity = $request->attributes->get('_entity');
$url = $request->attributes->get('url');
$nodeMenu = $request->attributes->get('_nodeMenu');
$parameters = $request->attributes->get('_renderContext');
if ($request->get('preview') == true) {
$version = $request->get('version');
if (!empty($version) && is_numeric($version)) {
$nodeVersion = $this->em->getRepository('KunstmaanNodeBundle:NodeVersion')->find($version);
if (!is_null($nodeVersion)) {
$entity = $nodeVersion->getRef($this->em);
}
}
}
$renderContext = array('nodetranslation' => $nodeTranslation, 'slug' => $url, 'page' => $entity, 'resource' => $entity, 'nodemenu' => $nodeMenu);
if (is_array($parameters) || $parameters instanceof \ArrayObject) {
$parameters = array_merge($renderContext, (array) $parameters);
} else {
$parameters = $renderContext;
}
// Sent the response here, another option is to let the symfony kernel.view listener handle it
$event->setResponse($this->templating->renderResponse($entity->getDefaultView(), $parameters));
}
}
public function onView(GetResponseForControllerResultEvent $event)
{
$response = $event->getControllerResult();
if (is_string($response)) {
$event->setResponse(new Response($response));
}
}
/**
* In an API context, converts any data to a JSON-LD response.
*
* @param GetResponseForControllerResultEvent $event
*
* @return JsonLdResponse|mixed
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$controllerResult = $event->getControllerResult();
if ($controllerResult instanceof Response) {
return;
}
$request = $event->getRequest();
$format = $request->attributes->get('_api_format');
if (self::FORMAT !== $format) {
return;
}
switch ($request->getMethod()) {
case Request::METHOD_POST:
$status = 201;
break;
case Request::METHOD_DELETE:
$status = 204;
break;
default:
$status = 200;
break;
}
$resourceType = $request->attributes->get('_resource_type');
$response = new JsonLdResponse($resourceType ? $this->normalizer->normalize($controllerResult, self::FORMAT, $resourceType->getNormalizationContext() + ['request_uri' => $request->getRequestUri()]) : $controllerResult, $status);
$event->setResponse($response);
}
/**
* Handles string responses.
*
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$result = $event->getControllerResult();
if (!(null === $result || is_array($result) || $result instanceof Response || is_object($result) && !method_exists($result, '__toString'))) {
$event->setResponse(new Response((string) $result));
}
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$response = $event->getControllerResult();
if (null !== ($response = $this->view->render($response))) {
$event->setResponse($response);
}
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
if (!$this->enabled) {
return;
}
$response = $event->getControllerResult();
if ($response !== null) {
return;
}
$request = $event->getRequest();
$routeName = $request->attributes->get('_route');
if (!($route = $this->routes->get($routeName))) {
return;
}
if (!($args = $route->getOption('_redirect'))) {
return;
}
$uri = isset($args['uri']) ? $args['uri'] : null;
if (isset($args['callable'])) {
$arguments = $this->resolver->getArguments($request, $args['callable']);
$resolved = call_user_func_array($args['callable'], $arguments);
if (null == $uri) {
$uri = $resolved;
} else {
if (null === $this->urlGenerator) {
throw new \InvalidArgumentException("The UrlGeneratorServiceProvider must be registered to use named routes");
}
$uri = $this->urlGenerator->generate($uri, $resolved);
}
}
if (!is_string($uri)) {
throw new \InvalidArgumentException("Could not resolve uri for redirect");
}
$event->setResponse(new RedirectResponse($uri));
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$data = array('status' => 200, 'data' => $event->getControllerResult());
$response = new Response();
$response->setContent(json_encode($data, JSON_PRETTY_PRINT));
$response->headers->set('Content-Type', 'application/json');
$event->setResponse($response);
}
/**
* Handles responses in JSON format.
*
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
$result = $event->getControllerResult();
if (strtolower($request->attributes->get('_response[value]', '', true)) == 'json') {
$event->setResponse(new JsonResponse($result));
}
}
/**
* @param \Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent $event
*/
public function onKernelResultView(GetResponseForControllerResultEvent $event)
{
if (!$event->getRequest()->attributes->get('is_rest_request')) {
return;
}
$event->setResponse($this->viewDispatcher->dispatch($event->getRequest(), $event->getControllerResult()));
$event->stopPropagation();
}
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$result = $event->getControllerResult();
if (true === is_array($result)) {
$response = new JsonResponse($result);
$event->setResponse($response);
}
}
public function onView(GetResponseForControllerResultEvent $event)
{
if (null === ($renderer = $this->getRendererFromRequest($event->getRequest()))) {
throw new NotAcceptableHttpException();
}
$result = $event->getControllerResult();
$event->setResponse($renderer->renderResponse($result));
}
/**
* Sets a response given a (main content) render array.
*
* @param \Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent $event
* The event to process.
*/
public function onViewRenderArray(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
$result = $event->getControllerResult();
$format = $request->getRequestFormat();
// Render the controller result into a response if it's a render array.
if (is_array($result)) {
if (isset($this->mainContentRenderers[$format])) {
$renderer = $this->classResolver->getInstanceFromDefinition($this->mainContentRenderers[$format]);
$event->setResponse($renderer->renderResponse($result, $request, $this->routeMatch));
} else {
$supported_formats = array_keys($this->mainContentRenderers);
$supported_mimetypes = array_map([$request, 'getMimeType'], $supported_formats);
$event->setResponse(new JsonResponse(['message' => 'Not Acceptable.', 'supported_mime_types' => $supported_mimetypes], 406));
}
}
}
