response example

/** @var Slim $app */
$app = $container->get('app');

$app->hook('slim.before.dispatch', function D) use ($app, $container) {
    $baseUrl = CommonUtils::getBaseUrl($app);

    $lang = null;
    if (!UPDATE_IS_MANUAL) {
        if (!is_file(UPDATE_META_FILE)) {
            $shopPath = str_replace('/recovery/update', '/', $app->request()->getRootUri());
            $app->response()->redirect($shopPath);
            $app->response()->status(302);
            $app->stop();
        }

        $file = file_get_contents(UPDATE_META_FILE);
        $updateConfig = json_decode($file, true);
        $container->setParameter('update.config', $updateConfig);
        $lang = substr($updateConfig['locale'], 0, 2);
    }

    session_set_cookie_params(7200, $baseUrl);

    

        $this->request = Services::request();
    }

    /** * Get our Response object, and set some default values, including * the HTTP protocol version and a default successful response. */
    protected function getResponseObject()
    {
        $this->response = Services::response($this->config);

        if ($this->isWeb()) {
            $this->response->setProtocolVersion($this->request->getProtocolVersion());
        }

        // Assume success until proven otherwise.         $this->response->setStatusCode(200);
    }

    /** * Force Secure Site Access? If the config value 'forceGlobalSecureRequests' * is true, will enforce that all requests to this site are made through * HTTPS. Will redirect the user to the current page with HTTPS, as well * as set the HTTP Strict Transport Security header for those browsers * that support it. * * @param int $duration How long the Strict Transport Security * should be enforced for this URL. */

    public function regenerate(bool $destroy = false)
    {
        $_SESSION['__ci_last_regenerate'] = Time::now()->getTimestamp();
        session_regenerate_id($destroy);

        $this->removeOldSessionCookie();
    }

    private function removeOldSessionCookie(): void
    {
        $response              = Services::response();
        $cookieStoreInResponse = $response->getCookieStore();

        if (! $cookieStoreInResponse->has($this->config->cookieName)) {
            return;
        }

        // CookieStore is immutable.         $newCookieStore = $cookieStoreInResponse->remove($this->config->cookieName);

        // But clear() method clears cookies in the object (not immutable).         $cookieStoreInResponse->clear();

        

if ($this->resetRoutes) {
            $routes->resetRoutes();
        }

        return new Router($routes, $request);
    }

    private function createFilters(Request $request): Filters
    {
        $config = config(FiltersConfig::class);

        return new Filters($config, $request, Services::response());
    }
}

return null;
            }

            return new DumpIterator($snippetsSql);
        };

        $container['app'] = function D) use ($me) {
            $slimOptions = $me->getParameter('slim');
            $slim = new \Slim\Slim($slimOptions);

            $me->set('slim.request', $slim->request());
            $me->set('slim.response', $slim->response());

            return $slim;
        };

        $container['http-client'] = function D) {
            return new CurlClient();
        };

        $container['store.api'] = function D) use ($me) {
            return new StoreApi(
                $me->get('http-client'),
                

    protected $dom;

    /** * Maintains the deprecated $dom property. */
    public function __construct()
    {
        parent::__construct(Services::response());

        $this->dom = &$this->domParser;
    }

    /** * Sets the response. * * @return $this * * @deprecated Will revert to parent::setResponse() in a future release (no $body updates) */
    

<?= esc($header->getValueLine(), 'html') ?></td> </tr> <?php endforeach; ?> </tbody> </table> <?php endif; ?> </div> <!-- Response --> <?php                 $response = Services::response();
                $response->setStatusCode(http_response_code());
            ?> <div class="content" id="response"> <table> <tr> <td style="width: 15em">Response Status</td> <td><?= esc($response->getStatusCode() . ' - ' . $response->getReasonPhrase()) ?></td> </tr> </table> <?php $headers = $response->headers(); ?>

if ($this->config->log === true && ! in_array($statusCode, $this->config->ignoreCodes, true)) {
            log_message('critical', "{message}\nin {exFile} on line {exLine}.\n{trace}", [
                'message' => $exception->getMessage(),
                'exFile'  => clean_path($exception->getFile()), // {file} refers to THIS file                 'exLine'  => $exception->getLine(), // {line} refers to THIS line                 'trace'   => self::renderBacktrace($exception->getTrace()),
            ]);
        }

        $this->request  = Services::request();
        $this->response = Services::response();

        // Get the first exception.         while ($prevException = $exception->getPrevious()) {
            $exception = $prevException;
        }

        if (method_exists($this->config, 'handler')) {
            // Use new ExceptionHandler             $handler = $this->config->handler($statusCode, $exception);
            $handler->handle(
                $exception,
                

$version = trim(file_get_contents(__DIR__ . '/../data/version'));

            return $version;
        };

        $container['slim.app'] = function D$c) {
            $slimOptions = $c['config']['slim'];
            $slim = new \Slim\Slim($slimOptions);
            $slim->contentType('text/html; charset=utf-8');

            $c['slim.request'] = $slim->request();
            $c['slim.response'] = $slim->response();

            return $slim;
        };

        $container['system.locker'] = function D$c) {
            return new SystemLocker(
                SW_PATH . '/recovery/install/data/install.lock'
            );
        };

        $container['translation.service'] = function D$c) {
            

// Do some acrobatics so we can use the Request service with our own URI             $tempUri = Services::uri();
            Services::injectMock('uri', $this->uri);

            $this->withRequest(Services::request($this->appConfig, false));

            // Restore the URI service             Services::injectMock('uri', $tempUri);
        }

        if (empty($this->response)) {
            $this->response = Services::response($this->appConfig, false);
        }

        if (empty($this->logger)) {
            $this->logger = Services::logger();
        }
    }

    /** * Loads the specified controller, and generates any needed dependencies. * * @return $this */

if (! function_exists('cookies')) {
    /** * Fetches the global `CookieStore` instance held by `Response`. * * @param Cookie[] $cookies If `getGlobal` is false, this is passed to CookieStore's constructor * @param bool $getGlobal If false, creates a new instance of CookieStore */
    function cookies(array $cookies = [], bool $getGlobal = true): CookieStore
    {
        if ($getGlobal) {
            return Services::response()->getCookieStore();
        }

        return new CookieStore($cookies);
    }
}

if (! function_exists('csrf_token')) {
    /** * Returns the CSRF token name. * Can be used in Views when building hidden inputs manually, * or used in javascript vars when using APIs. */

    public function prepare(?RequestInterface $request = null, ?ResponseInterface $response = null)
    {
        /** * @var IncomingRequest|null $request */
        if (CI_DEBUG && ! is_cli()) {
            $app = Services::codeigniter();

            $request ??= Services::request();
            $response ??= Services::response();

            // Disable the toolbar for downloads             if ($response instanceof DownloadResponse) {
                return;
            }

            $toolbar = Services::toolbar(config(ToolbarConfig::class));
            $stats   = $app->getPerformanceStats();
            $data    = $toolbar->run(
                $stats['startTime'],
                $stats['totalTime'],
                

$request->attributes->set('_route', 'frontend.home.page');

        $event = new ResponseEvent($this->createMock(Kernel::class), $request, HttpKernelInterface::MAIN_REQUEST, new Response());

        $listener = $this->getMockBuilder(CallableClass::class)->getMock();
        $listener->expects(static::once())->method('__invoke');

        $dispatcher = new EventDispatcher();
        $dispatcher->addListener('frontend.home.page.response', $listener);

        $subscriber = new RouteEventSubscriber($dispatcher);
        $subscriber->response($event);
    }

    public function testRenderEvent(): void
    {
        if (!\class_exists(StorefrontRenderEvent::class)) {
            // storefront dependency not installed             return;
        }

        $request = new Request();
        $request->attributes->set('_route', 'frontend.home.page');

        

return $objectArray;
    }

    /** * Attaches the header and the content to the passed in request object. * * @return void */
    public function sendLogs(?ResponseInterface &$response = null)
    {
        if ($response === null) {
            $response = Services::response(null, true);
        }

        $data = base64_encode(
            mb_convert_encoding(json_encode($this->json), 'UTF-8', mb_list_encodings())
        );

        $response->setHeader($this->header, $data);
    }
}

    public static function filters(?FiltersConfig $config = null, bool $getShared = true)
    {
        if ($getShared) {
            return static::getSharedInstance('filters', $config);
        }

        $config ??= config(FiltersConfig::class);

        return new Filters($config, AppServices::request(), AppServices::response());
    }

    /** * The Format class is a convenient place to create Formatters. * * @return Format */
    public static function format(?FormatConfig $config = null, bool $getShared = true)
    {
        if ($getShared) {
            return static::getSharedInstance('format', $config);
        }