/**
* @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);
}
/**
* @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)
{
$this->logger->debug('Response builder listener: catch kernel.request event');
// If this is not a master request, skip handling
if (!$event->isMasterRequest()) {
$this->logger->debug('Response builder listener: this is not master request, skip');
return;
}
// If content already prepared
if ($event->hasResponse()) {
$this->logger->debug('Response builder listener: event already has response, skip');
return;
}
// Getting controller result
$result = $event->getControllerResult();
// If result is Response instance
if ($result instanceof Response) {
$this->logger->debug('Response builder listener: controller result is already an instance of Response, skip');
return;
}
// Getting action
$apiServerAction = $event->getRequest()->attributes->get('apiAction');
/* @var $apiServerAction ApiServerAction */
// Something wrong
if (!$apiServerAction) {
$this->logger->error('Response parser listener: request has no apiAction attribute, throwing access denied exception');
throw new AccessDeniedHttpException();
}
// Getting api server interface
$apiServerInterface = $apiServerAction->getApiServerInterface();
// Getting connection
$apiServerConnection = $event->getRequest()->attributes->get('apiConnection');
/* @var $apiServerConnection ApiServerConnection */
// Something wrong
if (!$apiServerConnection) {
$this->logger->error('Response parser listener: request has no apiConnection attribute, throwing access denied exception');
throw new AccessDeniedHttpException();
}
// Creating api response
try {
$apiResponse = $apiServerInterface->getApiResponse($result);
$newApiUserToken = $apiServerConnection->getNewApiUserToken();
if ($newApiUserToken) {
$this->logger->debug('Response builder listener: applying new api user token to response');
$apiResponse->setUserToken($newApiUserToken);
}
} catch (\Exception $e) {
$this->logger->error(sprintf('Response parser listener: problem with building response ("%s"), sending exception response', $e->getMessage()));
$apiResponse = $apiServerInterface->getExceptionResponse($e->getMessage());
}
// Setting response
$event->setResponse(new JsonResponse($apiResponse->export()));
$this->logger->debug('Response builder listener: response built');
}
/**
* Validates data returned by the controller if applicable.
*
* @param GetResponseForControllerResultEvent $event
*
* @return mixed
*
* @throws ValidationException
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$resourceType = $event->getRequest()->attributes->get('_resource_type');
if (!$resourceType || !in_array($event->getRequest()->getMethod(), [Request::METHOD_POST, Request::METHOD_PUT])) {
return;
}
$violations = $this->validator->validate($event->getControllerResult(), null, $resourceType->getValidationGroups());
if (0 !== count($violations)) {
throw new ValidationException($violations);
}
}
/**
* Renders the template and initializes a new response object with the
* rendered template content.
*
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
/* @var Template $template */
$request = $event->getRequest();
$template = $request->attributes->get('_template');
if (null === $template) {
return;
}
$parameters = $event->getControllerResult();
$owner = $template->getOwner();
list($controller, $action) = $owner;
// when the annotation declares no default vars and the action returns
// null, all action method arguments are used as default vars
if (null === $parameters) {
$parameters = $this->resolveDefaultParameters($request, $template, $controller, $action);
}
// attempt to render the actual response
$templating = $this->container->get('templating');
if ($template->isStreamable()) {
$callback = function () use($templating, $template, $parameters) {
return $templating->stream($template->getTemplate(), $parameters);
};
$event->setResponse(new StreamedResponse($callback));
}
// make sure the owner (controller+dependencies) is not cached or stored elsewhere
$template->setOwner(array());
$event->setResponse($templating->renderResponse($template->getTemplate(), $parameters));
}
/**
* 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);
}
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));
}
}
/**
* 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);
}
/**
* Validates data returned by the controller if applicable.
*
* @param GetResponseForControllerResultEvent $event
*
* @throws ValidationException
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
try {
$attributes = RequestAttributesExtractor::extractAttributes($request);
} catch (RuntimeException $e) {
return;
}
if ($request->isMethodSafe() || $request->isMethod(Request::METHOD_DELETE)) {
return;
}
$data = $event->getControllerResult();
$resourceMetadata = $this->resourceMetadataFactory->create($attributes['resource_class']);
if (isset($attributes['collection_operation_name'])) {
$validationGroups = $resourceMetadata->getCollectionOperationAttribute($attributes['collection_operation_name'], 'validation_groups');
} else {
$validationGroups = $resourceMetadata->getItemOperationAttribute($attributes['item_operation_name'], 'validation_groups');
}
if (!$validationGroups) {
// Fallback to the resource
$validationGroups = $resourceMetadata->getAttributes()['validation_groups'] ?? null;
}
if (is_callable($validationGroups)) {
$validationGroups = call_user_func_array($validationGroups, [$data]);
}
$violations = $this->validator->validate($data, null, $validationGroups);
if (0 !== count($violations)) {
throw new ValidationException($violations);
}
}
/**
* Renders the template and initializes a new response object with the
* rendered template content.
*
* @param GetResponseForControllerResultEvent $event A GetResponseForControllerResultEvent instance
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
$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);
}
}
if (!is_array($parameters)) {
return $parameters;
}
if (!($template = $request->attributes->get('_template'))) {
return $parameters;
}
$templating = $this->container->get('templating');
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));
}
}
public function onKernelView(GetResponseForControllerResultEvent $e)
{
if (!$this->isRestRoute($e->getRequest())) {
return;
}
$e->getDispatcher()->dispatch('sdispatcher.rest_view', $e);
}
/**
* @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));
}
}
/**
* @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));
}
}
/**
* 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);
}
/**
* Persists, updates or delete data return by the controller if applicable.
*
* @param GetResponseForControllerResultEvent $event
*
* @return mixed
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
$request = $event->getRequest();
if (!in_array($request->getMethod(), [Request::METHOD_POST, Request::METHOD_PUT, Request::METHOD_DELETE])) {
return;
}
$resourceType = $request->attributes->get('_resource_type');
if (!$resourceType) {
return;
}
$controllerResult = $event->getControllerResult();
if (null === ($objectManager = $this->getManager($resourceType, $controllerResult))) {
return $controllerResult;
}
switch ($request->getMethod()) {
case Request::METHOD_POST:
$objectManager->persist($controllerResult);
break;
case Request::METHOD_DELETE:
$objectManager->remove($controllerResult);
$event->setControllerResult(null);
break;
}
$objectManager->flush();
}
/**
* 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);
}
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));
}
/**
* 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)));
}
}
/**
* Renders the template and initializes a new response object with the
* rendered template content.
*
* @param GetResponseForControllerResultEvent $event A GetResponseForControllerResultEvent instance
*/
public function onCoreView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
$parameters = $event->getControllerResult();
if (null === $parameters) {
if (!$vars = $request->attributes->get('_tal_vars')) {
if (!$vars = $request->attributes->get('_tal_default_vars')) {
return;
}
}
$parameters = array();
foreach ($vars as $var) {
$parameters[$var] = $request->attributes->get($var);
}
}
if (!is_array($parameters)) {
return $parameters;
}
if (!$template = $request->attributes->get('_tal')) {
return $parameters;
}
$event->setResponse(new Response($this->container->get('templating')->render($template, $parameters)));
}
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);
}
/**
* Persists, updates or delete data return by the controller if applicable.
*
* @param GetResponseForControllerResultEvent $event
*
* @return mixed
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
if ($request->isMethodSafe()) {
return;
}
$resourceClass = $request->attributes->get('_api_resource_class');
if (null === $resourceClass) {
return;
}
$controllerResult = $event->getControllerResult();
if (null === ($objectManager = $this->getManager($resourceClass, $controllerResult))) {
return;
}
switch ($request->getMethod()) {
case Request::METHOD_POST:
$objectManager->persist($controllerResult);
break;
case Request::METHOD_DELETE:
$objectManager->remove($controllerResult);
$event->setControllerResult(null);
break;
}
$objectManager->flush();
}
/**
* Renders the template and initializes a new response object with the
* rendered template content.
*
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
/* @var Template $template */
$request = $event->getRequest();
$template = $request->attributes->get('_template');
if (null === $template) {
return;
}
$parameters = $event->getControllerResult();
$owner = $template->getOwner();
list($controller, $action) = $owner;
// when no template has been given, try to resolve it based on the controller
if (null === $template->getTemplate()) {
if ($action === '__invoke') {
throw new \InvalidArgumentException(sprintf('Cannot guess a template name for "%s::%s", please provide a template name.', get_class($controller), $action));
}
$guesser = $this->container->get('sensio_framework_extra.view.guesser');
$template->setTemplate($guesser->guessTemplateName($owner, $request, $template->getEngine()));
}
// when the annotation declares no default vars and the action returns
// null, all action method arguments are used as default vars
if (null === $parameters) {
$parameters = $this->resolveDefaultParameters($request, $template, $controller, $action);
}
// attempt to render the actual response
$templating = $this->container->get('templating');
if ($template->isStreamable()) {
$callback = function () use($templating, $template, $parameters) {
return $templating->stream($template->getTemplate(), $parameters);
};
$event->setResponse(new StreamedResponse($callback));
}
$event->setResponse($templating->renderResponse($template->getTemplate(), $parameters));
}
public function onView(GetResponseForControllerResultEvent $event)
{
if (null === ($renderer = $this->getRendererFromRequest($event->getRequest()))) {
throw new NotAcceptableHttpException();
}
$result = $event->getControllerResult();
$event->setResponse($renderer->renderResponse($result));
}
/**
* 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));
}
}
/**
* Handles Kernel View events
*
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
$response = $event->getResponse();
$parameters = $event->getControllerResult();
if (!$response instanceof Response && ($template = $request->attributes->get('_template'))) {
return $event->setControllerResult($this->templating->render($template, $parameters));
}
}
/**
* Creates a Response to send to the client according to the requested format.
*
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$controllerResult = $event->getControllerResult();
$request = $event->getRequest();
if ($controllerResult instanceof Response || !$request->attributes->get('_api_respond')) {
return;
}
$event->setResponse(new Response($controllerResult, self::METHOD_TO_CODE[$request->getMethod()] ?? Response::HTTP_OK, ['Content-Type' => sprintf('%s; charset=utf-8', $request->getMimeType($request->getRequestFormat())), 'Vary' => 'Accept', 'X-Content-Type-Options' => 'nosniff', 'X-Frame-Options' => 'deny']));
}
/**
* Setting embedded serialization groups for current response
*
* @param GetResponseForControllerResultEvent $event
*
* @return void
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$view = $event->getControllerResult();
if (!$view instanceof View) {
return;
}
$groups = $this->embeddedManager->generateGroups($event->getRequest());
$view->getSerializationContext()->setGroups($groups);
}
/**
* Set the controller result in SoapResponse.
*
* @param GetResponseForControllerResultEvent $event A GetResponseForControllerResultEvent instance
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
if (!$request instanceof SoapRequest) {
return;
}
$this->response->setReturnValue($event->getControllerResult());
$event->setResponse($this->response);
}
/**
* Auto-convert to JsonResponse whether the controller result is a ProgressBar instance.
*
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
$request = $event->getRequest();
$result = $event->getControllerResult();
if (!$event->isMasterRequest() || !$request->isXmlHttpRequest() || !$result instanceof ProgressBar) {
return;
}
$event->setResponse($this->createResponse($result));
}
