Actualización

vendor/symfony/framework-bundle/Controller/Controller.php

@@ -0,0 +1,394 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\Controller;
+
+use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\DependencyInjection\ContainerAwareTrait;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\RedirectResponse;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+use Symfony\Component\Security\Core\Exception\AccessDeniedException;
+use Symfony\Component\Security\Csrf\CsrfToken;
+use Symfony\Component\Form\Extension\Core\Type\FormType;
+use Symfony\Component\Form\Form;
+use Symfony\Component\Form\FormBuilder;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+use Doctrine\Bundle\DoctrineBundle\Registry;
+
+/**
+ * Controller is a simple implementation of a Controller.
+ *
+ * It provides methods to common features needed in controllers.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+abstract class Controller implements ContainerAwareInterface
+{
+    use ContainerAwareTrait;
+
+    /**
+     * Generates a URL from the given parameters.
+     *
+     * @param string $route         The name of the route
+     * @param mixed  $parameters    An array of parameters
+     * @param int    $referenceType The type of reference (one of the constants in UrlGeneratorInterface)
+     *
+     * @return string The generated URL
+     *
+     * @see UrlGeneratorInterface
+     */
+    protected function generateUrl($route, $parameters = array(), $referenceType = UrlGeneratorInterface::ABSOLUTE_PATH)
+    {
+        return $this->container->get('router')->generate($route, $parameters, $referenceType);
+    }
+
+    /**
+     * Forwards the request to another controller.
+     *
+     * @param string $controller The controller name (a string like BlogBundle:Post:index)
+     * @param array  $path       An array of path parameters
+     * @param array  $query      An array of query parameters
+     *
+     * @return Response A Response instance
+     */
+    protected function forward($controller, array $path = array(), array $query = array())
+    {
+        $path['_controller'] = $controller;
+        $subRequest = $this->container->get('request_stack')->getCurrentRequest()->duplicate($query, null, $path);
+
+        return $this->container->get('http_kernel')->handle($subRequest, HttpKernelInterface::SUB_REQUEST);
+    }
+
+    /**
+     * Returns a RedirectResponse to the given URL.
+     *
+     * @param string $url    The URL to redirect to
+     * @param int    $status The status code to use for the Response
+     *
+     * @return RedirectResponse
+     */
+    protected function redirect($url, $status = 302)
+    {
+        return new RedirectResponse($url, $status);
+    }
+
+    /**
+     * Returns a RedirectResponse to the given route with the given parameters.
+     *
+     * @param string $route      The name of the route
+     * @param array  $parameters An array of parameters
+     * @param int    $status     The status code to use for the Response
+     *
+     * @return RedirectResponse
+     */
+    protected function redirectToRoute($route, array $parameters = array(), $status = 302)
+    {
+        return $this->redirect($this->generateUrl($route, $parameters), $status);
+    }
+
+    /**
+     * Adds a flash message to the current session for type.
+     *
+     * @param string $type    The type
+     * @param string $message The message
+     *
+     * @throws \LogicException
+     */
+    protected function addFlash($type, $message)
+    {
+        if (!$this->container->has('session')) {
+            throw new \LogicException('You can not use the addFlash method if sessions are disabled.');
+        }
+
+        $this->container->get('session')->getFlashBag()->add($type, $message);
+    }
+
+    /**
+     * Checks if the attributes are granted against the current authentication token and optionally supplied object.
+     *
+     * @param mixed $attributes The attributes
+     * @param mixed $object     The object
+     *
+     * @return bool
+     *
+     * @throws \LogicException
+     */
+    protected function isGranted($attributes, $object = null)
+    {
+        if (!$this->container->has('security.authorization_checker')) {
+            throw new \LogicException('The SecurityBundle is not registered in your application.');
+        }
+
+        return $this->container->get('security.authorization_checker')->isGranted($attributes, $object);
+    }
+
+    /**
+     * Throws an exception unless the attributes are granted against the current authentication token and optionally
+     * supplied object.
+     *
+     * @param mixed  $attributes The attributes
+     * @param mixed  $object     The object
+     * @param string $message    The message passed to the exception
+     *
+     * @throws AccessDeniedException
+     */
+    protected function denyAccessUnlessGranted($attributes, $object = null, $message = 'Access Denied.')
+    {
+        if (!$this->isGranted($attributes, $object)) {
+            throw $this->createAccessDeniedException($message);
+        }
+    }
+
+    /**
+     * Returns a rendered view.
+     *
+     * @param string $view       The view name
+     * @param array  $parameters An array of parameters to pass to the view
+     *
+     * @return string The rendered view
+     */
+    protected function renderView($view, array $parameters = array())
+    {
+        if ($this->container->has('templating')) {
+            return $this->container->get('templating')->render($view, $parameters);
+        }
+
+        if (!$this->container->has('twig')) {
+            throw new \LogicException('You can not use the "renderView" method if the Templating Component or the Twig Bundle are not available.');
+        }
+
+        return $this->container->get('twig')->render($view, $parameters);
+    }
+
+    /**
+     * Renders a view.
+     *
+     * @param string   $view       The view name
+     * @param array    $parameters An array of parameters to pass to the view
+     * @param Response $response   A response instance
+     *
+     * @return Response A Response instance
+     */
+    protected function render($view, array $parameters = array(), Response $response = null)
+    {
+        if ($this->container->has('templating')) {
+            return $this->container->get('templating')->renderResponse($view, $parameters, $response);
+        }
+
+        if (!$this->container->has('twig')) {
+            throw new \LogicException('You can not use the "render" method if the Templating Component or the Twig Bundle are not available.');
+        }
+
+        if (null === $response) {
+            $response = new Response();
+        }
+
+        $response->setContent($this->container->get('twig')->render($view, $parameters));
+
+        return $response;
+    }
+
+    /**
+     * Streams a view.
+     *
+     * @param string           $view       The view name
+     * @param array            $parameters An array of parameters to pass to the view
+     * @param StreamedResponse $response   A response instance
+     *
+     * @return StreamedResponse A StreamedResponse instance
+     */
+    protected function stream($view, array $parameters = array(), StreamedResponse $response = null)
+    {
+        if ($this->container->has('templating')) {
+            $templating = $this->container->get('templating');
+
+            $callback = function () use ($templating, $view, $parameters) {
+                $templating->stream($view, $parameters);
+            };
+        } elseif ($this->container->has('twig')) {
+            $twig = $this->container->get('twig');
+
+            $callback = function () use ($twig, $view, $parameters) {
+                $twig->display($view, $parameters);
+            };
+        } else {
+            throw new \LogicException('You can not use the "stream" method if the Templating Component or the Twig Bundle are not available.');
+        }
+
+        if (null === $response) {
+            return new StreamedResponse($callback);
+        }
+
+        $response->setCallback($callback);
+
+        return $response;
+    }
+
+    /**
+     * Returns a NotFoundHttpException.
+     *
+     * This will result in a 404 response code. Usage example:
+     *
+     *     throw $this->createNotFoundException('Page not found!');
+     *
+     * @param string          $message  A message
+     * @param \Exception|null $previous The previous exception
+     *
+     * @return NotFoundHttpException
+     */
+    protected function createNotFoundException($message = 'Not Found', \Exception $previous = null)
+    {
+        return new NotFoundHttpException($message, $previous);
+    }
+
+    /**
+     * Returns an AccessDeniedException.
+     *
+     * This will result in a 403 response code. Usage example:
+     *
+     *     throw $this->createAccessDeniedException('Unable to access this page!');
+     *
+     * @param string          $message  A message
+     * @param \Exception|null $previous The previous exception
+     *
+     * @return AccessDeniedException
+     */
+    protected function createAccessDeniedException($message = 'Access Denied.', \Exception $previous = null)
+    {
+        return new AccessDeniedException($message, $previous);
+    }
+
+    /**
+     * Creates and returns a Form instance from the type of the form.
+     *
+     * @param string $type    The fully qualified class name of the form type
+     * @param mixed  $data    The initial data for the form
+     * @param array  $options Options for the form
+     *
+     * @return Form
+     */
+    protected function createForm($type, $data = null, array $options = array())
+    {
+        return $this->container->get('form.factory')->create($type, $data, $options);
+    }
+
+    /**
+     * Creates and returns a form builder instance.
+     *
+     * @param mixed $data    The initial data for the form
+     * @param array $options Options for the form
+     *
+     * @return FormBuilder
+     */
+    protected function createFormBuilder($data = null, array $options = array())
+    {
+        return $this->container->get('form.factory')->createBuilder(FormType::class, $data, $options);
+    }
+
+    /**
+     * Shortcut to return the Doctrine Registry service.
+     *
+     * @return Registry
+     *
+     * @throws \LogicException If DoctrineBundle is not available
+     */
+    protected function getDoctrine()
+    {
+        if (!$this->container->has('doctrine')) {
+            throw new \LogicException('The DoctrineBundle is not registered in your application.');
+        }
+
+        return $this->container->get('doctrine');
+    }
+
+    /**
+     * Get a user from the Security Token Storage.
+     *
+     * @return mixed
+     *
+     * @throws \LogicException If SecurityBundle is not available
+     *
+     * @see TokenInterface::getUser()
+     */
+    protected function getUser()
+    {
+        if (!$this->container->has('security.token_storage')) {
+            throw new \LogicException('The SecurityBundle is not registered in your application.');
+        }
+
+        if (null === $token = $this->container->get('security.token_storage')->getToken()) {
+            return;
+        }
+
+        if (!is_object($user = $token->getUser())) {
+            // e.g. anonymous authentication
+            return;
+        }
+
+        return $user;
+    }
+
+    /**
+     * Returns true if the service id is defined.
+     *
+     * @param string $id The service id
+     *
+     * @return bool true if the service id is defined, false otherwise
+     */
+    protected function has($id)
+    {
+        return $this->container->has($id);
+    }
+
+    /**
+     * Gets a container service by its id.
+     *
+     * @param string $id The service id
+     *
+     * @return object The service
+     */
+    protected function get($id)
+    {
+        return $this->container->get($id);
+    }
+
+    /**
+     * Gets a container configuration parameter by its name.
+     *
+     * @param string $name The parameter name
+     *
+     * @return mixed
+     */
+    protected function getParameter($name)
+    {
+        return $this->container->getParameter($name);
+    }
+
+    /**
+     * Checks the validity of a CSRF token.
+     *
+     * @param string $id    The id used when generating the token
+     * @param string $token The actual token sent with the request that should be validated
+     *
+     * @return bool
+     */
+    protected function isCsrfTokenValid($id, $token)
+    {
+        if (!$this->container->has('security.csrf.token_manager')) {
+            throw new \LogicException('CSRF protection is not enabled in your application.');
+        }
+
+        return $this->container->get('security.csrf.token_manager')->isTokenValid(new CsrfToken($id, $token));
+    }
+}

vendor/symfony/framework-bundle/Controller/ControllerNameParser.php

@@ -0,0 +1,151 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\Controller;
+
+use Symfony\Component\HttpKernel\KernelInterface;
+
+/**
+ * ControllerNameParser converts controller from the short notation a:b:c
+ * (BlogBundle:Post:index) to a fully-qualified class::method string
+ * (Bundle\BlogBundle\Controller\PostController::indexAction).
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ControllerNameParser
+{
+    protected $kernel;
+
+    /**
+     * Constructor.
+     *
+     * @param KernelInterface $kernel A KernelInterface instance
+     */
+    public function __construct(KernelInterface $kernel)
+    {
+        $this->kernel = $kernel;
+    }
+
+    /**
+     * Converts a short notation a:b:c to a class::method.
+     *
+     * @param string $controller A short notation controller (a:b:c)
+     *
+     * @return string A string in the class::method notation
+     *
+     * @throws \InvalidArgumentException when the specified bundle is not enabled
+     *                                   or the controller cannot be found
+     */
+    public function parse($controller)
+    {
+        $originalController = $controller;
+        if (3 !== count($parts = explode(':', $controller))) {
+            throw new \InvalidArgumentException(sprintf('The "%s" controller is not a valid "a:b:c" controller string.', $controller));
+        }
+
+        list($bundle, $controller, $action) = $parts;
+        $controller = str_replace('/', '\\', $controller);
+        $bundles = array();
+
+        try {
+            // this throws an exception if there is no such bundle
+            $allBundles = $this->kernel->getBundle($bundle, false);
+        } catch (\InvalidArgumentException $e) {
+            $message = sprintf(
+                'The "%s" (from the _controller value "%s") does not exist or is not enabled in your kernel!',
+                $bundle,
+                $originalController
+            );
+
+            if ($alternative = $this->findAlternative($bundle)) {
+                $message .= sprintf(' Did you mean "%s:%s:%s"?', $alternative, $controller, $action);
+            }
+
+            throw new \InvalidArgumentException($message, 0, $e);
+        }
+
+        foreach ($allBundles as $b) {
+            $try = $b->getNamespace().'\\Controller\\'.$controller.'Controller';
+            if (class_exists($try)) {
+                return $try.'::'.$action.'Action';
+            }
+
+            $bundles[] = $b->getName();
+            $msg = sprintf('The _controller value "%s:%s:%s" maps to a "%s" class, but this class was not found. Create this class or check the spelling of the class and its namespace.', $bundle, $controller, $action, $try);
+        }
+
+        if (count($bundles) > 1) {
+            $msg = sprintf('Unable to find controller "%s:%s" in bundles %s.', $bundle, $controller, implode(', ', $bundles));
+        }
+
+        throw new \InvalidArgumentException($msg);
+    }
+
+    /**
+     * Converts a class::method notation to a short one (a:b:c).
+     *
+     * @param string $controller A string in the class::method notation
+     *
+     * @return string A short notation controller (a:b:c)
+     *
+     * @throws \InvalidArgumentException when the controller is not valid or cannot be found in any bundle
+     */
+    public function build($controller)
+    {
+        if (0 === preg_match('#^(.*?\\\\Controller\\\\(.+)Controller)::(.+)Action$#', $controller, $match)) {
+            throw new \InvalidArgumentException(sprintf('The "%s" controller is not a valid "class::method" string.', $controller));
+        }
+
+        $className = $match[1];
+        $controllerName = $match[2];
+        $actionName = $match[3];
+        foreach ($this->kernel->getBundles() as $name => $bundle) {
+            if (0 !== strpos($className, $bundle->getNamespace())) {
+                continue;
+            }
+
+            return sprintf('%s:%s:%s', $name, $controllerName, $actionName);
+        }
+
+        throw new \InvalidArgumentException(sprintf('Unable to find a bundle that defines controller "%s".', $controller));
+    }
+
+    /**
+     * Attempts to find a bundle that is *similar* to the given bundle name.
+     *
+     * @param string $nonExistentBundleName
+     *
+     * @return string
+     */
+    private function findAlternative($nonExistentBundleName)
+    {
+        $bundleNames = array_map(function ($b) {
+            return $b->getName();
+        }, $this->kernel->getBundles());
+
+        $alternative = null;
+        $shortest = null;
+        foreach ($bundleNames as $bundleName) {
+            // if there's a partial match, return it immediately
+            if (false !== strpos($bundleName, $nonExistentBundleName)) {
+                return $bundleName;
+            }
+
+            $lev = levenshtein($nonExistentBundleName, $bundleName);
+            if ($lev <= strlen($nonExistentBundleName) / 3 && ($alternative === null || $lev < $shortest)) {
+                $alternative = $bundleName;
+                $shortest = $lev;
+            }
+        }
+
+        return $alternative;
+    }
+}

vendor/symfony/framework-bundle/Controller/ControllerResolver.php

@@ -0,0 +1,93 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\Controller;
+
+use Psr\Log\LoggerInterface;
+use Symfony\Component\HttpKernel\Controller\ControllerResolver as BaseControllerResolver;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+
+/**
+ * ControllerResolver.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ControllerResolver extends BaseControllerResolver
+{
+    protected $container;
+    protected $parser;
+
+    /**
+     * Constructor.
+     *
+     * @param ContainerInterface   $container A ContainerInterface instance
+     * @param ControllerNameParser $parser    A ControllerNameParser instance
+     * @param LoggerInterface      $logger    A LoggerInterface instance
+     */
+    public function __construct(ContainerInterface $container, ControllerNameParser $parser, LoggerInterface $logger = null)
+    {
+        $this->container = $container;
+        $this->parser = $parser;
+
+        parent::__construct($logger);
+    }
+
+    /**
+     * Returns a callable for the given controller.
+     *
+     * @param string $controller A Controller string
+     *
+     * @return mixed A PHP callable
+     *
+     * @throws \LogicException           When the name could not be parsed
+     * @throws \InvalidArgumentException When the controller class does not exist
+     */
+    protected function createController($controller)
+    {
+        if (false === strpos($controller, '::')) {
+            $count = substr_count($controller, ':');
+            if (2 == $count) {
+                // controller in the a:b:c notation then
+                $controller = $this->parser->parse($controller);
+            } elseif (1 == $count) {
+                // controller in the service:method notation
+                list($service, $method) = explode(':', $controller, 2);
+
+                return array($this->container->get($service), $method);
+            } elseif ($this->container->has($controller) && method_exists($service = $this->container->get($controller), '__invoke')) {
+                return $service;
+            } else {
+                throw new \LogicException(sprintf('Unable to parse the controller name "%s".', $controller));
+            }
+        }
+
+        return parent::createController($controller);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function instantiateController($class)
+    {
+        if ($this->container->has($class)) {
+            return $this->container->get($class);
+        }
+
+        $controller = parent::instantiateController($class);
+
+        if ($controller instanceof ContainerAwareInterface) {
+            $controller->setContainer($this->container);
+        }
+
+        return $controller;
+    }
+}

vendor/symfony/framework-bundle/Controller/RedirectController.php

@@ -0,0 +1,144 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\Controller;
+
+use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\DependencyInjection\ContainerAwareTrait;
+use Symfony\Component\HttpFoundation\RedirectResponse;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\HttpException;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+
+/**
+ * Redirects a request to another URL.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class RedirectController implements ContainerAwareInterface
+{
+    use ContainerAwareTrait;
+
+    /**
+     * Redirects to another route with the given name.
+     *
+     * The response status code is 302 if the permanent parameter is false (default),
+     * and 301 if the redirection is permanent.
+     *
+     * In case the route name is empty, the status code will be 404 when permanent is false
+     * and 410 otherwise.
+     *
+     * @param Request    $request          The request instance
+     * @param string     $route            The route name to redirect to
+     * @param bool       $permanent        Whether the redirection is permanent
+     * @param bool|array $ignoreAttributes Whether to ignore attributes or an array of attributes to ignore
+     *
+     * @return Response A Response instance
+     *
+     * @throws HttpException In case the route name is empty
+     */
+    public function redirectAction(Request $request, $route, $permanent = false, $ignoreAttributes = false)
+    {
+        if ('' == $route) {
+            throw new HttpException($permanent ? 410 : 404);
+        }
+
+        $attributes = array();
+        if (false === $ignoreAttributes || is_array($ignoreAttributes)) {
+            $attributes = $request->attributes->get('_route_params');
+            unset($attributes['route'], $attributes['permanent'], $attributes['ignoreAttributes']);
+            if ($ignoreAttributes) {
+                $attributes = array_diff_key($attributes, array_flip($ignoreAttributes));
+            }
+        }
+
+        return new RedirectResponse($this->container->get('router')->generate($route, $attributes, UrlGeneratorInterface::ABSOLUTE_URL), $permanent ? 301 : 302);
+    }
+
+    /**
+     * Redirects to a URL.
+     *
+     * The response status code is 302 if the permanent parameter is false (default),
+     * and 301 if the redirection is permanent.
+     *
+     * In case the path is empty, the status code will be 404 when permanent is false
+     * and 410 otherwise.
+     *
+     * @param Request     $request   The request instance
+     * @param string      $path      The absolute path or URL to redirect to
+     * @param bool        $permanent Whether the redirect is permanent or not
+     * @param string|null $scheme    The URL scheme (null to keep the current one)
+     * @param int|null    $httpPort  The HTTP port (null to keep the current one for the same scheme or the configured port in the container)
+     * @param int|null    $httpsPort The HTTPS port (null to keep the current one for the same scheme or the configured port in the container)
+     *
+     * @return Response A Response instance
+     *
+     * @throws HttpException In case the path is empty
+     */
+    public function urlRedirectAction(Request $request, $path, $permanent = false, $scheme = null, $httpPort = null, $httpsPort = null)
+    {
+        if ('' == $path) {
+            throw new HttpException($permanent ? 410 : 404);
+        }
+
+        $statusCode = $permanent ? 301 : 302;
+
+        // redirect if the path is a full URL
+        if (parse_url($path, PHP_URL_SCHEME)) {
+            return new RedirectResponse($path, $statusCode);
+        }
+
+        if (null === $scheme) {
+            $scheme = $request->getScheme();
+        }
+
+        $qs = $request->getQueryString();
+        if ($qs) {
+            if (strpos($path, '?') === false) {
+                $qs = '?'.$qs;
+            } else {
+                $qs = '&'.$qs;
+            }
+        }
+
+        $port = '';
+        if ('http' === $scheme) {
+            if (null === $httpPort) {
+                if ('http' === $request->getScheme()) {
+                    $httpPort = $request->getPort();
+                } elseif ($this->container->hasParameter('request_listener.http_port')) {
+                    $httpPort = $this->container->getParameter('request_listener.http_port');
+                }
+            }
+
+            if (null !== $httpPort && 80 != $httpPort) {
+                $port = ":$httpPort";
+            }
+        } elseif ('https' === $scheme) {
+            if (null === $httpsPort) {
+                if ('https' === $request->getScheme()) {
+                    $httpsPort = $request->getPort();
+                } elseif ($this->container->hasParameter('request_listener.https_port')) {
+                    $httpsPort = $this->container->getParameter('request_listener.https_port');
+                }
+            }
+
+            if (null !== $httpsPort && 443 != $httpsPort) {
+                $port = ":$httpsPort";
+            }
+        }
+
+        $url = $scheme.'://'.$request->getHost().$port.$request->getBaseUrl().$path.$qs;
+
+        return new RedirectResponse($url, $statusCode);
+    }
+}

vendor/symfony/framework-bundle/Controller/TemplateController.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\Controller;
+
+use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\DependencyInjection\ContainerAwareTrait;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * TemplateController.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class TemplateController implements ContainerAwareInterface
+{
+    use ContainerAwareTrait;
+
+    /**
+     * Renders a template.
+     *
+     * @param string    $template  The template name
+     * @param int|null  $maxAge    Max age for client caching
+     * @param int|null  $sharedAge Max age for shared (proxy) caching
+     * @param bool|null $private   Whether or not caching should apply for client caches only
+     *
+     * @return Response A Response instance
+     */
+    public function templateAction($template, $maxAge = null, $sharedAge = null, $private = null)
+    {
+        /** @var $response \Symfony\Component\HttpFoundation\Response */
+        $response = $this->container->get('templating')->renderResponse($template);
+
+        if ($maxAge) {
+            $response->setMaxAge($maxAge);
+        }
+
+        if ($sharedAge) {
+            $response->setSharedMaxAge($sharedAge);
+        }
+
+        if ($private) {
+            $response->setPrivate();
+        } elseif ($private === false || (null === $private && ($maxAge || $sharedAge))) {
+            $response->setPublic();
+        }
+
+        return $response;
+    }
+}