if (!is_dir(Config::get('concrete.cache.page.directory'))) {
            @mkdir(Config::get('concrete.cache.page.directory'));
            @touch(Config::get('concrete.cache.page.directory') . '/index.html');
        }
        $lifetime = $c->getCollectionFullPageCachingLifetimeValue();
        $file = $this->getCacheFile($c);
        if ($file) {
            $response = new PageCacheRecord($c, $content, $lifetime);
            if ($content) {
                file_put_contents($file, serialize($response));
            }
        }
    }
}
 

 
        $event = new \Symfony\Component\EventDispatcher\GenericEvent();
        $event->setArgument('contents', $contents);
        Events::dispatch('on_page_output', $event);
        $contents = $event->getArgument('contents');
 
        $cache = PageCache::getLibrary();
        $shouldAddToCache = $cache->shouldAddToCache($this);
        if ($shouldAddToCache) {
            $cache->set($this->c, $contents);
        }
 
        return $contents;
    }
 
    /**
     * @deprecated
     */
    public function getCollectionObject()
    {

        if ($this instanceof View) {
            $this->setRequestInstance($this);
        }
        $this->start($state);
        $this->setupRender();
        $this->startRender();
        $scopeItems = $this->getScopeItems();
        $contents = $this->renderViewContents($scopeItems);
        $contents = $this->postProcessViewContents($contents);
        $response = $this->finishRender($contents);
        if ($this instanceof View) {
            $this->revertRequestInstance();
        }
 
        return $response;
    }
 
    public function renderViewContents($scopeItems)
    {
        if (file_exists($this->template)) {

     * @inheritdoc
     */
    public function view(View $view, $code = Response::HTTP_OK, $headers = array())
    {
        $changeContext = $this->shouldChangeContext();
        if ($changeContext) {
            $this->localization->pushActiveContext('site');
        }
 
        $contents = $view->render();
        if ($changeContext) {
            $this->localization->popActiveContext();
        }
 
        return $this->create($contents, $code, $headers);
    }
 
    /**
     * @inheritdoc
     */

            if ($md->isMobile()) {
                $mobileTheme = Theme::getByID(Config::get('concrete.misc.mobile_theme_id'));
                if ($mobileTheme instanceof Theme) {
                    $view->setViewTheme($mobileTheme);
                    $controller->setTheme($mobileTheme);
                }
            }
        }
 
        return $this->view($view, $code, $headers);
    }
 
    /**
     * @inheritdoc
     */
    public function collection(Collection $collection, $code = Response::HTTP_OK, $headers = array())
    {
        if (!$this->app) {
            throw new \RuntimeException('Cannot resolve collections without a reference to the application');
        }

        $item = new RelationListItem();
        $menu = $this->app->make('helper/concrete/ui/menu');
        $menu->addMenuItem($item);
 
        $controller = $collection->getPageController();
 
        // we update the current page with the one bound to this controller.
        $collection->setController($controller);
 
        return $this->controller($controller);
    }
 
    private function collectionNotFound(Collection $collection, Request $request, array $headers)
    {
        // if we don't have a path and we're doing cID, then this automatically fires a 404.
        if (!$request->getPath() && $request->get('cID')) {
            return $this->notFound('', Response::HTTP_NOT_FOUND, $headers);
        }
 
        // let's test to see if this is, in fact, the home page,

    {
        parent::__construct($callback);
        $this->factory = $factory;
    }
 
    public function execute(Request $request, Route $route = null, $parameters = [])
    {
        // figure out where we need to go
        $c = Page::getFromRequest($request);
        return $this->factory->collection($c);
    }
 
    public static function getRouteAttributes($callback)
    {
        $callback = \Core::make(self::class, [$callback]);
        return ['callback' => $callback];
    }
 
    /**
     * @deprecated Use CollectionResponseFactory

        try {
            $request->attributes->add($matcher->match($path));
            $matched = $matcher->match($path);
            $route = $collection->get($matched['_route']);
 
            $this->router->setRequest($request);
            $response = $this->router->execute($route, $matched);
        } catch (ResourceNotFoundException $e) {
            $callback = $this->app->make(DispatcherRouteCallback::class, ['dispatcher']);
            $response = $callback->execute($request);
        }
 
        return $response;
    }
}
 

            substr($path, 0, 3) == '..\\' || substr($path, -3) == '\\..' || strpos($path, '\\..\\')) {
            throw new \RuntimeException(t('Invalid path traversal. Please make this request with a valid HTTP client.'));
        }
 
        $response = null;
        if ($this->app->isInstalled()) {
            $response = $this->getEarlyDispatchResponse();
        }
        if ($response === null) {
            $response = $this->handleDispatch($request);
        }
 
        return $response;
    }
 
    private function getEarlyDispatchResponse()
    {
        $session = $this->app['session'];
 
        if (!$session->has('uID')) {

 
    /**
     * Dispatch the next available middleware and return the response.
     *
     * @param Request $request
     * @return Response
     */
    public function next(Request $request)
    {
        return $this->dispatcher->dispatch($request);
    }
 
}
 

            }
        }
        
        $session = $this->app->make('session');
        $session->set('multilingual_default_locale', $locale);    

        $loc = Localization::getInstance();
        $loc->setLocale($locale); 
        
        return $frame->next($request);
    }
    
    private function cookieManager($locale){
        setcookie("current_language", "", time() - 3600);
        setcookie("current_language", $locale, time()+((3600 * 24) * 30), "/");
    }
    
    private function toIsoDate($lang){
        switch ($lang){
            case 'it':

 
    /**
     * Dispatch the next available middleware and return the response.
     *
     * @param Request $request
     * @return Response
     */
    public function next(Request $request)
    {
        return $this->middleware->process($request, $this->nextDelegate);
    }
 
}
 

     * Process the request and return a response.
     *
     * @param \Symfony\Component\HttpFoundation\Request $request
     * @param DelegateInterface $frame
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function process(Request $request, DelegateInterface $frame)
    {
        $response = $frame->next($request);
 
        if ($this->app->isInstalled()) {
            if ($response->getStatusCode() == 200) {
                /* @var Connection $database */
                try {
                    $database = $this->getConnection();
                } catch (\InvalidArgumentException $e) {
                    // Don't die here if there's no available database connection
                    $database = null;
                }

 
    /**
     * Dispatch the next available middleware and return the response.
     *
     * @param Request $request
     * @return Response
     */
    public function next(Request $request)
    {
        return $this->middleware->process($request, $this->nextDelegate);
    }
 
}
 

        $this->stringValidator = $stringValidator;
    }
 
    /**
     * @param \Concrete\Core\Http\Middleware\DelegateInterface $frame
     * @return Response
     */
    public function process(Request $request, DelegateInterface $frame)
    {
        $response = $frame->next($request);
 
        if ($response->headers->has('X-Frame-Options') === false) {
            $x_frame_options = $this->config->get('concrete.security.misc.x_frame_options');
            if ($this->stringValidator->notempty($x_frame_options)) {
                $response->headers->set('X-Frame-Options', $x_frame_options);
            }
        }
 
        return $response;
    }

 
    /**
     * Dispatch the next available middleware and return the response.
     *
     * @param Request $request
     * @return Response
     */
    public function next(Request $request)
    {
        return $this->middleware->process($request, $this->nextDelegate);
    }
 
}
 

     * @param Request $request
     * @param \Concrete\Core\Http\Middleware\DelegateInterface $frame
     * @return Response
     */
    public function process(Request $request, DelegateInterface $frame)
    {
        $this->cookies->setRequest($request);
 
        /** @var Response $response */
        $response = $frame->next($request);
 
        $cleared = $this->cookies->getClearedCookies();
        foreach ($cleared as $cookie) {
            $response->headers->clearCookie($cookie);
        }
 
        $cookies = $this->cookies->getCookies();
        foreach ($cookies as $cookie) {
            $response->headers->setCookie($cookie);
        }

 
    /**
     * Dispatch the next available middleware and return the response.
     *
     * @param Request $request
     * @return Response
     */
    public function next(Request $request)
    {
        return $this->middleware->process($request, $this->nextDelegate);
    }
 
}
 

     * @param \Symfony\Component\HttpFoundation\Request $request
     * @param \Concrete\Core\Http\Middleware\DelegateInterface $frame
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function process(Request $request, DelegateInterface $frame)
    {
        \Concrete\Core\Http\Request::setInstance($request);
        $this->app->instance('Concrete\Core\Http\Request', $request);
 
        return $frame->next($request);
    }
 
}
 

 
    /**
     * Dispatch the next available middleware and return the response.
     *
     * @param Request $request
     * @return Response
     */
    public function next(Request $request)
    {
        return $this->middleware->process($request, $this->nextDelegate);
    }
 
}
 

        return $stack;
    }
 
    /**
     * @inheritdoc
     */
    public function process(Request $request)
    {
        $stack = $this->getStack();
        return $stack->next($request);
    }
 
    /**
     * Reduce middleware into a stack of functions that each call the next
     * @return callable
     */
    private function getStack()
    {
        $processed = [];
 

     * @return SymfonyResponse
     */
    public function handleRequest(SymfonyRequest $request)
    {
        $stack = $this->stack;
        if ($stack instanceof MiddlewareStack) {
            $stack = $stack->withDispatcher($this->app->make(DispatcherDelegate::class, [$this->dispatcher]));
        }
 
        return $stack->process($request);
    }
 
}
 

 
        /*
         * ----------------------------------------------------------------------------
         * Fire an event for intercepting the dispatch
         * ----------------------------------------------------------------------------
         */
        Events::dispatch('on_before_dispatch');
 
        $request = Request::createFromGlobals();
        return $this->server->handleRequest($request);
    }
 
    /**
     * @param Repository $config
     * @param Application $app
     */
    private function initializeLegacyURLDefinitions(Application $app)
    {
        if (!defined('BASE_URL')) {
            try {

            case self::STATUS_ENDED:
                // We've already ended, lets just return
                return;
 
            case self::STATUS_INACTIVE:
                throw new \RuntimeException('Runtime has not yet booted.');
        }
 
        $runner = $this->getRunner();
        $response = $runner->run();
 
        if ($response) {
            $this->sendResponse($response);
        }
 
        return $response;
    }
 
    /**
     * The method that handles properly sending a response.

/** @var \Concrete\Core\Application\Application $cms */
$cms = require $__DIR__ . '/bootstrap/start.php';
 
/*
 * ----------------------------------------------------------------------------
 * Run the runtime.
 * ----------------------------------------------------------------------------
 */
$runtime = $cms->getRuntime();
if ($response = $runtime->run()) {
 
    /*
     * ------------------------------------------------------------------------
     * Shut it down.
     * ------------------------------------------------------------------------
     */
    $cms->shutdown();
} else {
    return $cms;
}

<?php
 
require 'concrete/dispatcher.php';