Returns the current controller
| public getController ( ) : callable | ||
| return | callable | |
/**
* Modifies the Request object to apply configuration information found in
* controllers annotations like the template to render or HTTP caching
* configuration.
*
* @param FilterControllerEvent $event A FilterControllerEvent instance
*/
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$className = class_exists('Doctrine\\Common\\Util\\ClassUtils') ? ClassUtils::getClass($controller[0]) : get_class($controller[0]);
$object = new \ReflectionClass($className);
$method = $object->getMethod($controller[1]);
$classConfigurations = $this->getConfigurations($this->reader->getClassAnnotations($object));
$methodConfigurations = $this->getConfigurations($this->reader->getMethodAnnotations($method));
$configurations = array();
foreach (array_merge(array_keys($classConfigurations), array_keys($methodConfigurations)) as $key) {
if (!array_key_exists($key, $classConfigurations)) {
$configurations[$key] = $methodConfigurations[$key];
} elseif (!array_key_exists($key, $methodConfigurations)) {
$configurations[$key] = $classConfigurations[$key];
} else {
if (is_array($classConfigurations[$key])) {
if (!is_array($methodConfigurations[$key])) {
throw new \UnexpectedValueException('Configurations should both be an array or both not be an array');
}
$configurations[$key] = array_merge($classConfigurations[$key], $methodConfigurations[$key]);
} else {
// method configuration overrides class configuration
$configurations[$key] = $methodConfigurations[$key];
}
}
}
$request = $event->getRequest();
foreach ($configurations as $key => $attributes) {
$request->attributes->set($key, $attributes);
}
}
public function onControllerFound(FilterControllerEvent $event)
{
if (!is_array($controllerData = $event->getController())) {
return;
}
$controllerData = $event->getController();
if ($controllerData[0] === null) {
return;
}
$method = new \ReflectionMethod($controllerData[0], $controllerData[1]);
//First we check for an automatic optim
$annotations = $this->annotationReader->getMethodAnnotations($method);
if (!empty($annotations)) {
foreach ($annotations as $annotation) {
if ($annotation instanceof SEOAnnotation\MetaTag) {
$request = $controllerData[0]->getRequest();
$controller = $request->get('_controller');
$object = $request->attributes->get($annotation->value);
if (empty($object)) {
continue;
}
$class = new \ReflectionClass($object);
$exists = $this->doctrine->getManager()->getRepository('SEOBundle:MetaTagPattern')->findOneBy(['controller' => $controller, 'entityClass' => $class->getName()]);
if (!is_null($exists)) {
$title = $this->getMeta('title', $object);
if ($title !== '') {
$this->sonataSEO->setTitle($title);
}
$meta = $this->getMeta('description', $object);
if ($meta !== '') {
$this->sonataSEO->addMeta('name', 'description', $meta);
}
$meta = $this->getMeta('keywords', $object);
if ($meta !== '') {
$this->sonataSEO->addMeta('name', 'keywords', $meta);
}
}
}
}
}
//Then we check an override with a manual optimisation
$path = $event->getRequest()->getPathinfo();
if (preg_match('@\\.[js|css]@', $path)) {
return;
}
$optim = $this->doctrine->getManager()->getRepository('SEOBundle:MetaTag')->findOneBy(['url' => $path]);
if ($optim !== null) {
if ($optim->getMetaTitle() !== null) {
$this->sonataSEO->setTitle($optim->getMetaTitle());
}
if ($optim->getMetaDescription() !== null) {
$this->sonataSEO->addMeta('name', 'description', $optim->getMetaDescription());
}
if ($optim->getMetaKeywords() !== null) {
$this->sonataSEO->addMeta('name', 'keywords', $optim->getMetaKeywords());
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
$this->controllers[$event->getRequest()] = $event->getController();
if ($parentRequestAttributes = $event->getRequest()->attributes->get('_forwarded')) {
if ($parentRequestAttributes instanceof ParameterBag) {
$parentRequestAttributes->set('_forward_controller', $event->getController());
}
}
}
/**
* kernel.controller listener method
*
* @param FilterControllerEvent $event
*/
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
$request = $event->getRequest();
$routeName = $request->get('_route');
if (!ListFilterFactory::isValidRouteName($routeName)) {
return;
}
$controller[0]->filteredResult = array();
$listFilter = ListFilterFactory::create($routeName, $this->doctrine);
foreach ($listFilter->getServiceDependencies() as $serviceId) {
$listFilter->injectDependency($serviceId, $controller[0]->get($serviceId));
}
$params = array_merge($request->get('_route_params'), $request->query->all());
if ($listFilter) {
// client admin filter
if (\preg_match('/^$routeName/', $routeName)) {
$params['institutionId'] = $request->getSession()->get('institutionId', 0);
$params['isInstitutionContext'] = true;
}
$listFilter->prepare($params);
$controller[0]->pager = $listFilter->getPager();
$controller[0]->filteredResult = $listFilter->getFilteredResult();
$listFilters = $this->twig->render('HelperBundle:Default:filters.html.twig', array('filters' => $listFilter->getFilterOptions(), 'url' => $this->router->generate($routeName, $request->get('_route_params'))));
$this->twig->addGlobal('listFilters', $listFilters);
$this->twig->addGlobal('pager', $controller[0]->pager);
}
}
/**
* Mark request with flag if handled with rest controller
*
* @param FilterControllerEvent $event
*/
public function onKernelController(FilterControllerEvent $event)
{
$callable = $event->getController();
if (is_array($callable) && count($callable) === 2 && $callable[0] instanceof RestController) {
$event->getRequest()->attributes->set('__is_rest', true);
}
}
/**
* http://api.symfony.com/2.4/Symfony/Component/HttpKernel/Event/FilterControllerEvent.html
*
* @param \Symfony\Component\HttpKernel\Event\FilterControllerEvent $event
* @return type
*/
public function onKernelController(FilterControllerEvent $event)
{
$request = $event->getRequest();
// Request object
$seesion = $request->getSession();
$container = $this->container;
if (!is_array($controller = $event->getController())) {
return;
}
//if ($request->get('id') || $request->get('keyword')) {
$entity = new Tracking();
$entity->setController(get_class($controller[0]));
// controller Formation\Bundle\Controller\PageController
$entity->setAction($controller[1]);
// getNextPageAction getPreviousPageAction
$entity->setHttpMethod($request->getMethod());
$entity->setIpRequest($request->getClientIp());
$entity->setIdRequest($request->get('id'));
$entity->setLang($seesion->get('_locale'));
$entity->setPageRequest($request->get('page'));
$entity->setKeywordRequest($request->get('keyword'));
$entity->setUriRequest($request->getUri());
$entity->setQueryRequest($request->getQueryString());
$entity->setPathInfo($request->getPathInfo());
$date = new \DateTime('now');
$entity->setCreated($date);
$em = $container->get('doctrine')->getManager();
if ($container->get('security.context')->getToken() && $container->get('security.context')->getToken()->getUser()) {
if (is_object($container->get('security.context')->getToken()->getUser())) {
$user_id = $container->get('security.context')->getToken()->getUser()->getId();
$user = $em->getRepository('UserBundle:User')->find($user_id);
$entity->setUser($user);
$last_acces = $em->getRepository('TrackingBundle:Tracking')->getLastAccess($user_id);
// update last access duration
if (is_object($last_acces)) {
//exit(\Doctrine\Common\Util\Debug::dump($last_acces->getCreated()));
$now = new \DateTime('now');
$diff = $now->getTimestamp() - $last_acces->getCreated()->getTimestamp();
$interval = new \DateTime();
$interval->setTimestamp($diff);
$tracking_id = $last_acces->getId();
$tracking = $em->getRepository('TrackingBundle:Tracking')->find($tracking_id);
$tracking->setDuration($interval);
//exit(\Doctrine\Common\Util\Debug::dump(strtotime($last_acces->getCreated()->format("Y-m-d H:i:s"))));
//$em->flush();
}
// update formation progression
// case 1 : Formation\Bundle\Controller\ChapterController && action=showAction && id_request
// get total formation page, get fos_user_formation percent, update percent
// case 2 : Formation\Bundle\Controller\PageController && action=getNextPageAction or action=getPreviousPageAction && id_request
// get total formation page
}
}
$em->persist($entity);
$em->flush();
//var_dump($last_acces->getCreated());
//var_dump($now);
//exit(\Doctrine\Common\Util\Debug::dump($interval));
//}
}
/**
* Modifies the ParamConverterManager instance.
*
* @param FilterControllerEvent $event A FilterControllerEvent instance
*/
public function onCoreController(FilterControllerEvent $event)
{
$controller = $event->getController();
$request = $event->getRequest();
$configurations = array();
if ($configuration = $request->attributes->get('_converters')) {
$configurations = is_array($configuration) ? $configuration : array($configuration);
}
if (is_array($controller)) {
$r = new \ReflectionMethod($controller[0], $controller[1]);
} else {
$r = new \ReflectionFunction($controller);
}
// automatically apply conversion for non-configured objects
foreach ($r->getParameters() as $param) {
if ($param->getClass() && !$request->attributes->get($param->getName())) {
$configuration = new ParamConverter(array());
$configuration->setName($param->getName());
$configuration->setClass($param->getClass()->getName());
$configuration->setIsOptional($param->isOptional());
$configurations[] = $configuration;
}
}
$this->manager->apply($request, $configurations);
}
/**
* Core controller handler.
*
* @param FilterControllerEvent $event
*
* @throws \InvalidArgumentException
*/
public function onKernelController(FilterControllerEvent $event)
{
$request = $event->getRequest();
if (!$request->attributes->get(FOSRestBundle::ZONE_ATTRIBUTE, true)) {
return;
}
$paramFetcher = $this->container->get('fos_rest.request.param_fetcher');
$controller = $event->getController();
if (is_callable($controller) && method_exists($controller, '__invoke')) {
$controller = [$controller, '__invoke'];
}
$paramFetcher->setController($controller);
$attributeName = $this->getAttributeName($controller);
$request->attributes->set($attributeName, $paramFetcher);
if ($this->setParamsAsAttributes) {
$params = $paramFetcher->all();
foreach ($params as $name => $param) {
if ($request->attributes->has($name) && null !== $request->attributes->get($name)) {
$msg = sprintf("ParamFetcher parameter conflicts with a path parameter '{$name}' for route '%s'", $request->attributes->get('_route'));
throw new \InvalidArgumentException($msg);
}
$request->attributes->set($name, $param);
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
$instance = $controller[0];
if (!$instance instanceof \Dinnovos\Amazonas\Controllers\InstallController) {
$instance->settings = \Settings::prepareSettings();
$instance->addMethod(function ($label, $default = -1) use($instance) {
if (isset($instance->settings[$label])) {
return $instance->settings[$label];
}
return $default === -1 ? null : $default;
}, "getSetting");
}
$instance->addMethod(function () use($instance) {
return $instance->forward('Dinnovos\\Amazonas:Errors:error402');
}, "responseError402");
$instance->addMethod(function () use($instance) {
return $instance->forward('Dinnovos\\Amazonas:Errors:error404');
}, "responseError404");
$instance->addMethod(function () use($instance) {
return $instance->forward('Dinnovos\\Amazonas:Errors:error405');
}, "responseError402");
$instance->addMethod(function () use($instance) {
return $instance->forward('Dinnovos\\Amazonas:Errors:error423');
}, "responseError423");
}
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$object = new \ReflectionObject($controller[0]);
$method = $object->getMethod($controller[1]);
$classConfigurations = $this->reader->getClassAnnotations($object);
$methodConfigurations = $this->reader->getMethodAnnotations($method);
foreach (array_merge($classConfigurations, $methodConfigurations) as $configuration) {
if ($configuration instanceof OAuth2) {
$token = $this->token_storage->getToken();
// If no access token is found by the firewall, then returns an authentication error
if (!$token instanceof OAuth2Token) {
$this->createAuthenticationException($event, 'OAuth2 authentication required');
return;
}
foreach ($this->getCheckers() as $checker) {
$result = $checker->check($token, $configuration);
if (null !== $result) {
$this->createAccessDeniedException($event, $result);
return;
}
}
}
}
}
/**
* Guesses the template name to render and its variables and adds them to
* the request object.
*
* @param FilterControllerEvent $event A FilterControllerEvent instance
*/
public function onCoreController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$request = $event->getRequest();
if (!$configuration = $request->attributes->get('_tal')) {
//echo "PAS DE _TAL";
return;
}
if (!$configuration->getTemplate()) {
$configuration->setTemplate($this->guessTemplateName($controller, $request, $configuration->getExtension() ));
}
$request->attributes->set('_tal', $configuration->getTemplate());
$request->attributes->set('_tal_vars', $configuration->getVars());
//$request->attributes->set('_tal_extension', $configuration->getExtension());
// all controller method arguments
if (!$configuration->getVars()) {
$r = new \ReflectionObject($controller[0]);
$vars = array();
foreach ($r->getMethod($controller[1])->getParameters() as $param) {
$vars[] = $param->getName();
}
$request->attributes->set('_tal_vars', $vars);
}
}
public function onKernelController(FilterControllerEvent $event)
{
if (!$this->securityContext->getToken()) {
return true;
}
$controller = $event->getController();
list($object, $method) = $controller;
$className = ClassUtils::getRealClass($object);
$reflectionClass = new \ReflectionClass($className);
$reflectionMethod = $reflectionClass->getMethod($method);
$classAnnotations = $this->annotationReader->getClassAnnotations($reflectionClass);
$methodsAnnotations = $this->annotationReader->getMethodAnnotations($reflectionMethod);
$allAnnotations = array_merge($classAnnotations, $methodsAnnotations);
$ruleAnnotations = array_filter($allAnnotations, function ($annotation) {
return $annotation instanceof Rule;
});
foreach ($ruleAnnotations as $ruleAnnotation) {
if (is_array($ruleAnnotation->rules)) {
$rules = $ruleAnnotation->rules;
} else {
$rules = explode(',', $ruleAnnotation->rules);
}
foreach ($rules as $rule) {
$rule = trim($rule);
if (empty($rule)) {
continue;
}
if ($this->securityContext->isGranted($rule)) {
return true;
}
}
}
throw new AccessDeniedException('The current user has no permissions on this action.');
}
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 onKernelController(FilterControllerEvent $event)
{
$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;
}
$request = $event->getRequest();
$url = $request->getBaseUrl();
if (in_array($url, self::$skipAuthentification)) {
return;
}
$content = $request->getContent();
$input = json_decode($content, true);
// check authentification
$account = $this->em->getRepository('AppBundle:Account')->getAccount($input['username'], $input['password']);
if ($account == null) {
throw new ApiAuthentificationFailureException("Ce compte n'existe pas");
} else {
if (in_array($url, self::$adminUrls) && $account->getUsername() != "admin") {
throw new ApiAuthentificationFailureException("Ce compte n'est pas administrateur");
}
// mettre ces variables déjà calculées à disposition de tous les controlleurs
$request->apiAccount = $account;
$request->decodedBody = $input;
}
}
/**
* Handles the @Njax() annotation for the found controller action.
*
* @param FilterControllerEvent $event Event called.
*/
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$request = $event->getRequest();
$njax = $this->container->get('njax');
// force @Njax() annotation for *all* NJAX requests
if (!($njaxConfiguration = $request->attributes->get('_njax'))) {
if (!$njax->isNjax()) {
return;
}
$njaxConfiguration = new NjaxAnnotation(array());
$request->attributes->set('_njax', $njaxConfiguration);
}
// force every @Njax() annotation to also trigger @Template() (if not defined)
if (!($templateConfiguration = $request->attributes->get('_template'))) {
$templateAnnotation = new Template(array());
// if there is @Njax default template set then use this
if ($njaxConfiguration->getDefaultTemplate()) {
$templateConfiguration = $njaxConfiguration->getDefaultTemplate();
} else {
// if not, then try to guess the template name (just like @Template() would do)
$guesser = $this->container->get('sensio_framework_extra.view.guesser');
$templateConfiguration = $guesser->guessTemplateName($controller, $request);
}
$request->attributes->set('_template', $templateConfiguration);
}
if (!$njaxConfiguration->getDefaultTemplate()) {
$njaxConfiguration->setDefaultTemplate($templateConfiguration);
}
}
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
if (isset($controller[0]) && is_object($controller[0])) {
$controller[0]->preAction();
}
}
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;
});
}
}
/**
* Creates the method needed from the class- and method name
*
* @param FilterControllerEvent $event
*
* @return \ReflectionMethod
*/
private function getCalledMethod(FilterControllerEvent $event)
{
list($object, $method) = $event->getController();
$className = get_class($object);
$reflectionClass = new \ReflectionClass($className);
return $reflectionClass->getMethod($method);
}
/**
* Guesses the template name to render and its variables and adds them to
* the request object.
*
* @param FilterControllerEvent $event A FilterControllerEvent instance
*/
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$request = $event->getRequest();
if (!($configuration = $request->attributes->get('_template'))) {
return;
}
if (!$configuration->getTemplate()) {
$guesser = $this->container->get('sensio_framework_extra.view.guesser');
$configuration->setTemplate($guesser->guessTemplateName($controller, $request, $configuration->getEngine()));
}
$request->attributes->set('_template', $configuration->getTemplate());
$request->attributes->set('_template_vars', $configuration->getVars());
$request->attributes->set('_template_streamable', $configuration->isStreamable());
// all controller method arguments
if (!$configuration->getVars()) {
$r = new \ReflectionObject($controller[0]);
$vars = array();
foreach ($r->getMethod($controller[1])->getParameters() as $param) {
$vars[] = $param->getName();
}
$request->attributes->set('_template_default_vars', $vars);
}
}
public function apply(FilterControllerEvent $event)
{
$controller = $event->getController();
$request = $event->getRequest();
if (is_array($controller)) {
$reflected = new ReflectionMethod($controller[0], $controller[1]);
} elseif (is_object($controller) && is_callable($controller, '__invoke')) {
$reflected = new ReflectionMethod($controller, '__invoke');
} else {
$reflected = new ReflectionFunction($controller);
}
foreach ($reflected->getParameters() as $param) {
// Ignore non-classes or the request instance
if ($param->getClass() && !$param->getClass()->isInstance($request)) {
$value = null;
$class = $param->getClass()->getName();
if ($class === 'Backpack\\Controller\\Request\\FormRequestInterface') {
$value = new FormRequest($request, $this->container->get('form.factory'));
}
if ($value !== null) {
$request->attributes->set($param->getName(), $value);
}
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$className = class_exists('Doctrine\\Common\\Util\\ClassUtils') ? ClassUtils::getClass($controller[0]) : get_class($controller[0]);
$object = new \ReflectionClass($className);
$method = $object->getMethod($controller[1]);
/**
* @var UserType\UserTypeInterface[] $requiredUserTypes
*/
$requiredUserTypes = array_merge($this->getConfigurations($this->reader->getClassAnnotations($object)), $this->getConfigurations($this->reader->getMethodAnnotations($method)));
if (count($requiredUserTypes) === 0) {
return;
}
$token = $this->securityContext->getToken();
if (null === $token) {
throw new AccessDeniedException(sprintf("You are not authenticated, a known user type is required for access."));
}
$user = $token->getUser();
foreach ($requiredUserTypes as $userType) {
$userClass = $userType->getUserClass();
if (!interface_exists($userClass) && !class_exists($userClass)) {
throw new RuntimeException(sprintf("The user type class '%s' does not exist", $userClass));
}
if (!$user instanceof $userClass) {
throw new AccessDeniedException(sprintf("You do not have the required user type. A user type of '%s' is required.", $userClass));
}
unset($userType, $userClass);
}
}
public function onKernelController(FilterControllerEvent $event)
{
if (!$this->isTrackingEnabled) {
return;
}
$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
* @link http://symfony.com/doc/current/event_dispatcher/before_after_filters.html#creating-an-event-listener
*/
if (!is_array($controller)) {
return;
}
$controller = $controller[0];
if ($controller instanceof Controller) {
$request = $event->getRequest();
$path = $request->getRequestUri();
$host = $request->getHost();
$title = get_class($controller);
$data = ['dh' => $host, 'dp' => $path, 'dt' => $title];
try {
$this->tracker->send($data, 'pageview');
} catch (\Exception $e) {
$this->logger->error('Failed to send tracking data.', ['exception' => $e]);
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
list($ctrl, $action) = $controller;
$ref = new \ReflectionClass($ctrl);
$annotations = $this->reader->getMethodAnnotations($ref->getMethod($action));
$acl = current(array_filter($annotations, function ($annotation) {
return $annotation instanceof ACL;
}));
if ($acl) {
if (strlen($acl->value)) {
$parts = explode('.', $acl->value);
$action = array_pop($parts);
$resource = implode('.', $parts);
} else {
$resource = Util::classToResource($ctrl);
$action = Util::underscore(preg_replace('/Action$/', '', $action));
}
if (!($allowed = $this->dm->isGranted($action, $resource))) {
throw new AccessDeniedHttpException("User is not allowed to \"{$action}\" resource: \"{$resource}\"");
}
}
}
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);
});
}
}
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$request = $event->getRequest();
if (!($configuration = $request->attributes->get('_acl_permission'))) {
return;
}
$refl = new \ReflectionMethod($controller[0], $controller[1]);
foreach ($refl->getParameters() as $param) {
if (!$param->getClass() || $param->getClass()->isInstance($request)) {
continue;
}
$name = $param->getName();
$object = $request->get($name);
if (is_null($object)) {
continue;
}
$mask = null;
foreach ($configuration as $config) {
if (!is_null($mask = $config->getEntry($name))) {
continue;
}
}
if (is_null($mask)) {
continue;
}
if (!$this->manager->isGranted($mask, $object)) {
throw new AccessDeniedException('Acl permission for this object is not granted.');
}
}
}
public function onCoreController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$method = new \ReflectionMethod($controller[0], $controller[1]);
if (!($annotations = $this->reader->getMethodAnnotations($method))) {
return;
}
foreach ($annotations as $annotation) {
if ($annotation instanceof LayoutAnnotation) {
if ($annotation->getPosition()) {
$root = $this->em->getRepository('TemplateDesignerLayoutBundle:Layout')->findLayoutWitOptions($annotation->getName(), $annotation->getPosition());
} else {
$root = $this->em->getRepository('TemplateDesignerLayoutBundle:Layout')->findOneBy(array('name' => $annotation->getName()));
}
if (!$annotation->getPosition() && !$annotation->getName()) {
throw new \Exception("Parameter missing in layout annotation", 1);
}
if (!$root) {
throw new NotFoundHttpException('Layout not found');
}
$route_params = $event->getRequest()->attributes->get('_route_params');
$route_params['rootLayout'] = $root;
$event->getRequest()->attributes->set('_route_params', $route_params);
}
}
}
/**
* Modifies the Request object to apply configuration information found in
* controllers annotations like the template to render or HTTP caching
* configuration.
*
* @param FilterControllerEvent $event A FilterControllerEvent instance
*
* @return void
*/
public function onKernelController(FilterControllerEvent $event)
{
if (!is_array($controller = $event->getController())) {
return;
}
$className = class_exists('Doctrine\\Common\\Util\\ClassUtils') ? ClassUtils::getClass($controller[0]) : get_class($controller[0]);
$object = new \ReflectionClass($className);
$transactional = $this->reader->getClassAnnotation($object, Transactional::NAME);
if (!$transactional instanceof Transactional) {
return;
}
$avoidTransaction = $this->reader->getMethodAnnotation($object->getMethod($controller[1]), AvoidTransaction::NAME);
if (!is_null($avoidTransaction)) {
return;
}
$request = $event->getRequest();
$modelName = $transactional->model;
$model = new $modelName();
$this->transactionBuilder->setRequestMethod($request->getRealMethod());
$this->transactionBuilder->setRequestSource(Transaction::SOURCE_REST);
$this->transactionBuilder->setRelatedRoute($transactional->relatedRoute);
$ids = [];
foreach ($model->getIds() as $field => $value) {
$ids[$field] = $request->attributes->get($field);
}
$this->transactionBuilder->setRelatedIds($ids);
$this->transactionBuilder->setModel($transactional->model);
$transaction = $this->transactionBuilder->build();
$request->attributes->set('transaction', $transaction);
}
/**
* Modifies the ParamConverterManager instance.
*
* @param FilterControllerEvent $event A FilterControllerEvent instance
*/
public function onKernelController(FilterControllerEvent $event)
{
$controller = $event->getController();
$request = $event->getRequest();
$configurations = array();
if ($configuration = $request->attributes->get('_converters')) {
foreach (is_array($configuration) ? $configuration : array($configuration) as $configuration) {
$configurations[$configuration->getName()] = $configuration;
}
}
if (is_array($controller)) {
$r = new \ReflectionMethod($controller[0], $controller[1]);
} else {
$r = new \ReflectionFunction($controller);
}
// automatically apply conversion for non-configured objects
foreach ($r->getParameters() as $param) {
if (!$param->getClass() || $param->getClass()->isInstance($request)) {
continue;
}
$name = $param->getName();
if (!isset($configurations[$name])) {
$configuration = new ParamConverter(array());
$configuration->setName($name);
$configuration->setClass($param->getClass()->getName());
$configurations[$name] = $configuration;
} elseif (null === $configurations[$name]->getClass()) {
$configurations[$name]->setClass($param->getClass()->getName());
}
$configurations[$name]->setIsOptional($param->isOptional());
}
$this->manager->apply($request, $configurations);
}
public function onKernelRequest(FilterControllerEvent $event)
{
if (HttpKernel::MASTER_REQUEST != $event->getRequestType() || $this->securityContext->getToken() === null) {
// don't do anything if it's not the master request
return;
}
$controller = $event->getController()[0];
// We know we'll build the board list eventually so we get all of them
$this->boardService->getBoards();
$board = null;
if ($event->getRequest()->attributes->get('boardSlug') !== null && method_exists($controller, 'setBoard') === true) {
$board = $this->pathService->getCurrentBoard();
if ($board === null) {
throw $controller->createNotFoundException();
}
}
if ($event->getRequest()->attributes->get('topicSlug') !== null && method_exists($controller, 'setTopic') === true && $board !== null) {
$topic = $this->pathService->getCurrentTopic();
if ($topic === null) {
throw $controller->createNotFoundException();
}
}
if ($event->getRequest()->attributes->get('messageId') !== null && method_exists($controller, 'setMessage') === true) {
$message = $this->pathService->getCurrentMessage();
if ($message === null) {
throw $controller->createNotFoundException();
}
}
}
public function onKernelController(FilterControllerEvent $event)
{
$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 AccountAccessInterface) {
$accountName = $event->getRequest()->attributes->get('accountName');
$accounts = $controller[0]->getUser()->getAccounts();
$hasAccount = false;
foreach ($accounts as $account) {
if ($account->getName() == $accountName) {
$hasAccount = true;
break;
}
}
if (!$hasAccount) {
throw new AccessDeniedHttpException('Access denied.');
}
$filter = $this->entityManager->getFilters()->enable('account_check_filter');
$filter->setParameter('account', $account->getId());
$event->getRequest()->attributes->set('accountTitle', $account->getTitle());
$router = $controller[0]->get('router');
$routeCollection = $router->getRouteCollection();
foreach ($routeCollection as $route) {
$route->setDefault('accountName', $accountName);
}
}
}
