Sets a new controller
| public setController ( callable $controller ) | ||
| $controller | callable | |
public function onKernelController(FilterControllerEvent $event)
{
$request = $event->getRequest();
if ('HealthCareAbroad\\SearchBundle\\Controller\\FrontendController::searchProcessAction' != $request->attributes->get('_controller')) {
return;
}
$controllerAndAction = $event->getController();
$controller = $controllerAndAction[0];
$requestParams = $request->request->all();
if (isset($requestParams['searchParameter']) && !empty($requestParams['searchParameter'])) {
$event->setController(array($controller, 'searchProcessNarrowAction'));
return;
}
$treatmentId = $request->get('treatment_id');
$destinationId = $request->get('destination_id') == '0-0' ? 0 : $request->get('destination_id');
$treatmentName = $request->get('sb_treatment');
$destinationName = $request->get('sb_destination');
//TODO: this will break if we are going to force the destination field in our search forms to always submit the ID
if (!$treatmentId && !$destinationId || !$treatmentId && $treatmentName || !$destinationId && $destinationName) {
$context = '';
if ($treatmentName && $destinationName) {
$context = 'combined';
} elseif ($treatmentName) {
$context = 'treatment';
} elseif ($destinationName) {
$context = 'destination';
}
$request->attributes->set('context', $context);
$event->setController(array($controller, 'searchProcessKeywordsAction'));
return;
}
}
/**
* @param FilterControllerEvent $event
*/
public function onKernelController(FilterControllerEvent $event)
{
/**
* @var $controller Controller
*/
$controller = $event->getController();
/*
* $controller passed can be either a class or a Closure.
* This is not usual in Symfony but it may happen.
* If it is a class, it comes in array format
*/
if (!is_array($controller)) {
return;
}
if ($controller[0] instanceof ProductControllerInterface) {
$user = $controller[0]->get('security.token_storage')->getToken()->getUser();
// Checks if an order belongs to user
$orderId = $event->getRequest()->get('orderId');
if ($orderId) {
$order = $this->entityManager->getRepository('IlluminatiOrderBundle:User_order')->findOneBy(['hostOrderId' => $orderId, 'usersId' => $user->getId(), 'deleted' => 0]);
if (!$order) {
throw new NotFoundHttpException('Order not found!');
}
$redirectUrl = $controller[0]->generateUrl('host_order_summary', ['id' => $orderId]);
$closeDate = $order->getHostOrderId()->getCloseDate();
$now = new \DateTime('now');
if ($closeDate < $now) {
$this->session->getFlashBag()->add('info', $this->translator->trans('product.order_expired'));
// redirect to summary if order is expired
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
// redirect to summary if order is closed or confirmed
if ($order->getHostOrderId()->getStateId() == 0) {
$this->session->getFlashBag()->add('info', $this->translator->trans('product.order_closed'));
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
}
// Load cart items from database
$cart = $controller[0]->get('cart.provider');
if ($cart->getStorage() === null) {
$cart->load($user->getId(), $orderId);
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
if (!is_array($controller)) {
return;
}
$session = $event->getRequest()->getSession();
/** @var BaseController $ctrl */
$ctrl = $controller[0];
if (!is_object($ctrl) || !$ctrl instanceof BaseController) {
return;
}
// no loop for you, also allow username checking
if ($ctrl instanceof ProfileController && ($controller[1] == 'updateUsernameAction' || $controller[1] == 'checkUsernameAction')) {
return;
}
/** @var User $user */
$user = $ctrl->getUser();
if ($user && $this->isGUID($user->getUsername())) {
$session->getFlashBag()->add('error', "We recently changed our username restrictions. Your previous username is no longer valid. Please create a new one.");
$url = $this->router->generate('reset_username');
$event->setController(function () use($url) {
return new RedirectResponse($url);
});
}
}
/**
* This event will fire during any controller call.
*
* @param FilterControllerEvent $event
*
* @return type
*
* @throws AccessDeniedHttpException
*/
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
//return if no controller
return;
}
$object = new \ReflectionObject($controller[0]);
// get controller
$method = $object->getMethod($controller[1]);
// get method
$configurations = $this->reader->getMethodAnnotations($method);
foreach ($configurations as $configuration) {
//Start of annotations reading
if (isset($configuration->grantType) && $controller[0] instanceof BaseProjectController) {
//Found our annotation
$controller[0]->setProjectGrantType($configuration->grantType);
$request = $controller[0]->get('request_stack')->getCurrentRequest();
$id = $request->get('id', false);
if ($id !== false) {
$redirectUrl = $controller[0]->initAction($id, $configuration->grantType);
if ($redirectUrl) {
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
}
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
$request = $event->getRequest();
$annotation = $this->findAnnotation($controller);
if (!$annotation) {
return;
}
$lastTouched = $annotation->calculateLastModified($this->metaQueryFactory);
if (!$lastTouched) {
return;
}
$this->lastTouchedResults[$request] = $lastTouched;
/*
* Für kernel.debug = 1 senden wir niemals
* 304-Responses, anstatt den Kernel auszuführen:
*
* Das Ergebnis hängt auch von vielen Dingen außerhalb
* wfd_meta ab (z. B. template-Code), die wir hier nicht
* berücksichtigen können.
*/
if ($this->debug) {
return;
}
$response = new Response();
$response->setLastModified($lastTouched);
if ($response->isNotModified($request)) {
$event->setController(function () use($response) {
return $response;
});
}
}
/**
* Handles HTTP validation headers.
*/
public function onKernelController(FilterControllerEvent $event)
{
$request = $event->getRequest();
if (!($configuration = $request->attributes->get('_cache'))) {
return;
}
$response = new Response();
$lastModifiedDate = '';
if ($configuration->getLastModified()) {
$lastModifiedDate = $this->getExpressionLanguage()->evaluate($configuration->getLastModified(), $request->attributes->all());
$response->setLastModified($lastModifiedDate);
}
$etag = '';
if ($configuration->getETag()) {
$etag = hash('sha256', $this->getExpressionLanguage()->evaluate($configuration->getETag(), $request->attributes->all()));
$response->setETag($etag);
}
if ($response->isNotModified($request)) {
$event->setController(function () use($response) {
return $response;
});
} else {
if ($etag) {
$this->etags[$request] = $etag;
}
if ($lastModifiedDate) {
$this->lastModifiedDates[$request] = $lastModifiedDate;
}
}
}
/**
* @param FilterControllerEvent $event
*/
public function onKernelController(FilterControllerEvent $event)
{
$request = $event->getRequest();
// Check if the event has a nodeTranslation, if not this method can be skipped
if (!$request->attributes->has('_nodeTranslation')) {
return;
}
$nodeTranslation = $request->attributes->get('_nodeTranslation');
if (!$nodeTranslation instanceof NodeTranslation) {
$nodeTranslation = $this->em->getRepository('KunstmaanNodeBundle:NodeTranslation')->find($nodeTranslation);
$request->attributes->set('_nodeTranslation', $nodeTranslation);
}
$entity = $nodeTranslation->getRef($this->em);
// If the entity is an instance of the SlugActionInterface, change the controller
if ($entity instanceof SlugActionInterface) {
$request->attributes->set('_entity', $entity);
// Do security check by firing an event that gets handled by the SlugSecurityListener
$securityEvent = new SlugSecurityEvent();
$securityEvent->setNode($nodeTranslation->getNode())->setEntity($entity)->setRequest($request)->setNodeTranslation($nodeTranslation);
$this->eventDispatcher->dispatch(Events::SLUG_SECURITY, $securityEvent);
// Set the right controller
$request->attributes->set('_controller', $entity->getControllerAction());
$event->setController($this->resolver->getController($request));
}
}
public function onKernelController(FilterControllerEvent $event)
{
if ($event->isMasterRequest()) {
$route = $event->getRequest()->get('_route');
if ($this->isExcludedRoute($route)) {
return;
}
if ($this->isAsset($_SERVER['REQUEST_URI'])) {
return;
}
$is_logged = $this->securityContext->isGranted('IS_AUTHENTICATED_FULLY');
if (!$is_logged && $route != 'fos_user_security_login') {
$redirectUrl = $this->router->generate('fos_user_security_login');
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
if (!$is_logged && $route == 'fos_user_security_login') {
return;
}
if (!$this->rolesProvider->hasRouteAccess($route)) {
throw new AccessDeniedException();
}
}
}
public function environmentSessionController(FilterControllerEvent $event)
{
$controller = $event->getController();
$session = new Session();
$environment = $session->get('environment');
// Validar si hay un environment cargado a la session de usuario
if (isset($environment)) {
// Validar si el controller es una instacia de InitController
if ($controller[0] instanceof InitController) {
// ****** if auth
// ****** redirect home
// ****** no
// ****** redirect login
return;
}
return;
} else {
// NO exite un environment cargado
// Validar si el controller NO es instacia de InitController
if (!$controller[0] instanceof InitController) {
//redireccion a init controller
$redirectUrl = '/init';
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
} else {
return;
}
}
}
public function it_set_controller_if_init_return_response(FilterControllerEvent $event, Request $request, SampleInitController $controller)
{
$event->getRequest()->willReturn($request);
$event->getController()->willReturn(array($controller));
$controller->init($request)->willReturn(new Response('http://example.com/'));
$event->setController(Argument::allOf(Argument::withEntry('0', Argument::type('Yavin\\Symfony\\Controller\\InitControllerSubscriber')), Argument::withEntry('1', 'responseAction')))->shouldBeCalled();
$this->onKernelController($event);
}
public function environmentSessionController(FilterControllerEvent $event)
{
$securityChecker = $this->container->get('security.authorization_checker');
$controller = $event->getController();
$session = new Session();
$environment = $session->get('environment');
$request = $event->getRequest();
/*
if ($request->get('_route') == '') {
$redirectInit = '/init';
$event->setController(function() use ($redirectInit) {
return new RedirectResponse($redirectInit);
});
}
*/
if (isset($environment)) {
if ($controller[0] instanceof InitController) {
if ($securityChecker->isGranted('IS_AUTHENTICATED_FULLY')) {
$redirectUrl = '/menu';
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
} else {
if ($controller[0] instanceof SecurityController) {
return;
} else {
$environment = $session->remove('environment');
$redirectUrl = '/init';
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
}
}
} else {
if (!$controller[0] instanceof InitController) {
$redirectUrl = '/init';
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
} else {
return;
}
}
}
protected function obtainScopes(array $scopes, FilterControllerEvent $event)
{
$request = $event->getRequest();
$url = $this->scopeManager->obtainScopeUrl($scopes, $request->getRequestUri());
// Set request parameter for redirect
$request->attributes->set('url', '/' . ltrim($url, '/'));
// Set controller to redirect controller instead
$event->setController(array(new RedirectController(), 'redirectAction'));
}
/**
* Replaces the default controller action with one that provides data in one of the requested formats
*
* @param FilterControllerEvent $event
*/
public function onController(FilterControllerEvent $event)
{
$this->event = $event;
$types = $this->request->getAcceptableContentTypes();
$controller = null;
foreach ($types as $type) {
if ($controller = $this->findControllerForContentType($type)) {
$this->event->setController($controller);
break;
}
}
if (null === $controller) {
header('HTTP/1.0 406 Not Acceptable');
die;
}
$controller = $event->getController();
$this->logger->debug('Chose controller action "' . array_pop($controller) . '"');
}
public function filter(FilterControllerEvent $event, Response $response)
{
if ($this->check($response)) {
$event->setController(function () use($response) {
return $response;
});
$event->stopPropagation();
}
}
/**
* Overriding response in Sandbox mode
*
* @param FilterControllerEvent $event
* @throws \Exception
*/
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
list($responseController, , , ) = $this->sandboxResponseManager->getResponseController($controller[0], $controller[1], $this->request->query, $this->request->request, $this->getStreamParams());
// Fall back to real controller if none has been found and force mode is false
if ($responseController === false) {
return;
}
$event->setController($responseController);
}
public function onKernelController(FilterControllerEvent $event)
{
$controller_data = $event->getController();
$controller_class = $controller_data[0];
// redirect to a new location if the specified controller has queued up a redirect url
if ($controller_class->getRedirectUrl()) {
$event->setController(function () use($controller_class) {
return new RedirectResponse($controller_class->getRedirectUrl());
});
}
}
public function onKernelController(FilterControllerEvent $event)
{
$controllerWrapper = $event->getController();
$controller = $controllerWrapper[0];
if ($controller instanceof CatchableController) {
$overwriteController = new RewrittenController();
$overwriteAction = 'capturedAction';
$overwriteWrapper = [$overwriteController, $overwriteAction];
$event->setController($overwriteWrapper);
}
}
/**
* {@inheritdoc}
*/
public function initialize(FilterControllerEvent $event)
{
$securityContext = $this->get('security.context');
//redirect user if they are already authenticated
if ($securityContext->isGranted('IS_AUTHENTICATED_FULLY') || $securityContext->isGranted('IS_AUTHENTICATED_REMEMBERED')) {
$redirectUrl = $this->generateUrl('mautic_dashboard_index');
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
}
/**
* @param FilterControllerEvent $event
*
* @throws \Throwable
* @throws \TypeError
*/
public function onKernelController(FilterControllerEvent $event)
{
$request = $event->getRequest();
$apiValidation = false;
if ($request->attributes->has('_api_bag')) {
$apiBagClass = $request->attributes->get('_api_bag');
$request->attributes->remove('_api_bag');
}
if ($request->attributes->has('_api_validation')) {
$apiValidation = (bool) $request->attributes->get('_api_validation');
$request->attributes->remove('_api_validation');
}
if ($request->attributes->has('_api_as')) {
$apiBagName = $request->attributes->get('_api_as');
$request->attributes->remove('_api_as');
}
if (is_array($controller = $event->getController())) {
$object = new \ReflectionObject($controller[0]);
$method = $object->getMethod($controller[1]);
foreach ($this->reader->getMethodAnnotations($method) as $configuration) {
if ($configuration instanceof ApiParameters) {
if (isset($configuration->bag)) {
$apiBagClass = $configuration->bag;
}
if (isset($configuration->as)) {
$apiBagName = $configuration->as;
}
if (isset($configuration->validation)) {
$apiValidation = (bool) $configuration->validation;
}
}
}
}
if (!empty($apiBagClass)) {
$apiParameterBag = class_exists($apiBagClass) ? new $apiBagClass() : new ApiParameterBag();
$apiParameterBag->populateFromRequest($request);
$request->attributes->set(isset($apiBagName) ? $apiBagName : 'api_parameters', $apiParameterBag);
if ($apiValidation) {
$errors = $this->validator->validate($apiParameterBag);
if (count($errors) > 0) {
$errorsList = array();
$accessor = PropertyAccess::createPropertyAccessor();
foreach ($errors as $error) {
$key = preg_replace('/parameters(\\[(.+)\\])+/', '$1', $error->getPropertyPath());
$accessor->setValue($errorsList, $key, $error->getMessage());
}
$request->attributes->set('_api_errors', $errorsList);
$controller = new ApiErrorController();
$event->setController(array($controller, 'validationErrorsAction'));
}
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
$request = $event->getRequest();
$controller = $event->getController();
$errorResponse = $this->requestBinder->bind($request, $controller);
if (null === $errorResponse) {
return;
}
$event->setController(function () use($errorResponse) {
return $errorResponse;
});
}
/**
* {@inheritdoc}
*/
public function initialize(FilterControllerEvent $event)
{
/** @var \Symfony\Component\Security\Core\Authorization\AuthorizationChecker $authChecker */
$authChecker = $this->get('security.authorization_checker');
//redirect user if they are already authenticated
if ($authChecker->isGranted('IS_AUTHENTICATED_FULLY') || $authChecker->isGranted('IS_AUTHENTICATED_REMEMBERED')) {
$redirectUrl = $this->generateUrl('mautic_dashboard_index');
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
}
public function checkRequestValidity(FilterControllerEvent $event)
{
$request = $event->getRequest();
$attributes = $request->attributes;
/** @var ConstraintViolationListInterface $violations */
$violations = $attributes->get('validationErrors');
if (!$violations) {
return;
}
if ($violations->count()) {
$event->setController(array($this->errorHandlerController, 'validationAction'));
}
}
public function onKernelController(FilterControllerEvent $event)
{
if ($this->getSecurityHelper()->isActiveFirewall('admin')) {
$route = $this->getRouterHelper()->getCurrentRoute();
if ($route->hasOption('require_admin_permission')) {
$name = $route->getOption('require_admin_permission');
$user = $this->getSecurityHelper()->getCurrentUser();
$permission = $this->getUserRepository()->getUserPermission($name, $user);
if (empty($permission)) {
$event->setController([$this->get('user.controller.admin'), 'accessDeniedAction']);
}
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
$user = $this->getUser();
if ($user instanceof UserInterface) {
$route = $this->getRouterHelper()->getCurrentRoute();
if ($route->hasOption('require_admin_permission')) {
$name = $route->getOption('require_admin_permission');
$permission = $this->getSecurityHelper()->getPermission($name, $user);
if (empty($permission)) {
$event->setController([$this->get('user.controller.admin'), 'accessDeniedAction']);
}
}
}
}
/**
* call controller init method if controller implements InitControllerInterface
*
* @param FilterControllerEvent $event
*/
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
if (empty($controller) || !is_array($controller)) {
// not a object but a different kind of callable. Do nothing
return;
}
$controllerObject = $controller[0];
if ($controllerObject instanceof InitControllerInterface) {
$this->response = $controllerObject->init($event->getRequest());
if ($this->response instanceof Response) {
$event->setController([$this, 'responseAction']);
}
}
}
/**
* Searches for sluggable objects in the route parameters and checks slugs if necessary.
*
* If an invalid slug is detected, then the user will be redirected to the URLs with the valid slug.
*
* @param FilterControllerEvent $event
*/
public function onKernelController(FilterControllerEvent $event)
{
$attributes = $event->getRequest()->attributes;
foreach ($attributes as $name => $value) {
if ($this->hasValidSlug($attributes, $name)) {
continue;
}
$event->stopPropagation();
// Invalid slug passed. Redirect to a URL with valid slug.
$event->setController(function () use($event, $name) {
return $this->createRedirectFor($event->getRequest(), $name);
});
break;
}
}
/**
* Listen kernel.controller event for find assigned annotation
*
* @param FilterControllerEvent $event
* @return null
*/
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
if (!is_array($controller)) {
return;
}
$action = new ReflectionMethod($controller[0], $controller[1]);
$annotation = $this->annotationReader->getMethodAnnotation($action, $this->annotationClass);
if (get_class($annotation) != $this->annotationClass) {
return;
}
$newController = $this->resolver->resolve($annotation);
if (!empty($newController)) {
$event->setController($newController);
}
}
/**
* Configures the View for eZ View controllers.
*
* @param FilterControllerEvent $event
*
* @throws \Symfony\Component\Security\Core\Exception\AccessDeniedException
*/
public function getController(FilterControllerEvent $event)
{
$request = $event->getRequest();
if (($viewBuilder = $this->viewBuilderRegistry->getFromRegistry($request->attributes->get('_controller'))) === null) {
return;
}
$parameterEvent = new FilterViewBuilderParametersEvent(clone $request);
$this->eventDispatcher->dispatch(ViewEvents::FILTER_BUILDER_PARAMETERS, $parameterEvent);
$view = $viewBuilder->buildView($parameterEvent->getParameters()->all());
$request->attributes->set('view', $view);
// View parameters are added as request attributes so that they are available as controller action parameters
$request->attributes->add($view->getParameters());
if (($controllerReference = $view->getControllerReference()) instanceof ControllerReference) {
$request->attributes->set('_controller', $controllerReference->controller);
$event->setController($this->controllerResolver->getController($request));
}
}
public function onCoreController(FilterControllerEvent $event)
{
if (HttpKernelInterface::MASTER_REQUEST === $event->getRequestType()) {
$_controller = $event->getController();
if (isset($_controller[0])) {
$controller = $_controller[0];
if (method_exists($controller, 'preExecute')) {
$redirectUrl = $controller->preExecute($event->getRequest());
if (!is_null($redirectUrl)) {
$event->setController(function () use($redirectUrl) {
return new RedirectResponse($redirectUrl);
});
}
}
}
}
}
/**
* @param \Symfony\Component\HttpKernel\Event\FilterControllerEvent $event
*
* @return callable|null
*/
public function onKernelController(FilterControllerEvent $event)
{
$currentController = $event->getController();
$controller = $currentController[0];
$action = $currentController[1];
if (!$controller instanceof AbstractGatewayController) {
return $currentController;
}
$newController = function () use($controller, $action) {
MessengerConfig::setMessageTray(MessengerConstants::IN_MEMORY_TRAY);
$requestTransfer = $this->getRequestTransfer($controller, $action);
$result = $controller->{$action}($requestTransfer->getTransfer(), $requestTransfer);
$response = $this->getResponse($controller, $result);
return TransferServer::getInstance()->setResponse($response)->send();
};
$event->setController($newController);
}
