public function __invoke(Request $request, Response $response, $arguments) { $response->write('this is just the beginning of my application'); foreach ($arguments as $argument) { $response->write("\n {$argument}"); } }
public function render(Response $response, $template = "", $data = []) { extract($data); ob_start(); include $this->templatePath . $template; $output = ob_get_clean(); return $response->write($output); }
/** * @param \swoole_http_request $request * @param \swoole_http_response $response * @throws \Exception */ public function __invoke($request, $response) { $this->app->getContainer()['environment'] = $this->app->getContainer()->factory(function () { return new Environment($_SERVER); }); $this->app->getContainer()['request'] = $this->app->getContainer()->factory(function ($container) { return Request::createFromEnvironment($container['environment']); }); $this->app->getContainer()['response'] = $this->app->getContainer()->factory(function ($container) { $headers = new Headers(['Content-Type' => 'text/html']); $response = new Response(200, $headers); return $response->withProtocolVersion($container->get('settings')['httpVersion']); }); /** * @var ResponseInterface $appResponse */ $appResponse = $this->app->run(true); // set http header foreach ($appResponse->getHeaders() as $key => $value) { $filter_header = function ($header) { $filtered = str_replace('-', ' ', $header); $filtered = ucwords($filtered); return str_replace(' ', '-', $filtered); }; $name = $filter_header($key); foreach ($value as $v) { $response->header($name, $v); } } // set http status $response->status($appResponse->getStatusCode()); // send response to browser if (!$this->isEmptyResponse($appResponse)) { $body = $appResponse->getBody(); if ($body->isSeekable()) { $body->rewind(); } $settings = $this->app->getContainer()->get('settings'); $chunkSize = $settings['responseChunkSize']; $contentLength = $appResponse->getHeaderLine('Content-Length'); if (!$contentLength) { $contentLength = $body->getSize(); } $totalChunks = ceil($contentLength / $chunkSize); $lastChunkSize = $contentLength % $chunkSize; $currentChunk = 0; while (!$body->eof() && $currentChunk < $totalChunks) { if (++$currentChunk == $totalChunks && $lastChunkSize > 0) { $chunkSize = $lastChunkSize; } $response->write($body->read($chunkSize)); if (connection_status() != CONNECTION_NORMAL) { break; } } $response->end(); } }
/** * Error Handler * * This method defines or invokes the application-wide Error handler. * There are two contexts in which this method may be invoked: * * 1. When declaring the handler: * * If the $argument parameter is callable, this * method will register the callable to be invoked when an uncaught * Exception is detected, or when otherwise explicitly invoked. * The handler WILL NOT be invoked in this context. * * 2. When invoking the handler: * * If the $argument parameter is not callable, Slim assumes you want * to invoke an already-registered handler. If the handler has been * registered and is callable, it is invoked and passed the caught Exception * as its one and only argument. The error handler's output is captured * into an output buffer and sent as the body of a 500 HTTP Response. * * @param mixed $argument Callable|\Exception */ public function error($argument = null) { if (is_callable($argument)) { //Register error handler $this->router->error($argument); } else { //Invoke error handler $this->response->status(500); $this->response->body(''); $this->response->write($this->callErrorHandler($argument)); $this->stop(); } }
public function __invoke(Request $request, Response $response) { $data = ['uri' => $request->getUri()->getPath(), 'contact' => $this->container->router->pathFor('contact')]; // We need a new response body $headers = new Headers(['Content-Type' => 'text/html; charset=UTF-8']); $res = new Response(404, $headers); // Start buffering ob_start(); $view = new View($res); $view->setTemplate('errors.404'); $view->render($data); // Get the buffer output $content = ob_get_clean(); return $res->write($content); }
/** * __invoke magical method * * @param ServerRequestInterface $request A valid PSR-7 Request object that inherits the `ServerRequestInterface` interface * @param ResponseInterface $response A valid PSR-7 Response object that inherits `ResponseInterface` interface * @param Exception $exception Exception to be handled * @return ResponseInterface object */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, Exception $exception) { // We need a new response body $headers = new Headers(['Content-Type' => 'text/html; charset=UTF-8']); $res = new Response(500, $headers); $handler = new Handler($exception); // Start buffering ob_start(); // Create a new View instance just for this page $view = new View($res); $view->setTemplate('errors.exhan'); $view->render($handler->getExceptionData()); // Get the buffer output $content = ob_get_clean(); return $res->write($content); }
public function testGetRequest() { $request = m::mock('\\swoole_http_request'); $response = m::mock('\\swoole_http_response'); $container = new Container(); $app = m::mock(App::class); $handler = new RequestHandler($app); $mockResponse = new Response(200, new Headers(['Content-Type' => 'text/html', 'Content-Length' => 5])); $mockResponse->write('hello'); $app->shouldReceive('getContainer')->andReturn($container); $app->shouldReceive('run')->once()->andReturn($mockResponse); $response->shouldReceive('header')->twice(); $response->shouldReceive('status')->once()->withArgs([200]); $response->shouldReceive('write')->once()->withArgs(['hello']); $response->shouldReceive('end')->once(); $handler($request, $response); }
/** * We wrap the base * @param Response $response * @param array $data * @param bool $merge * @return Response */ public function response(Response $response, $data = [], $merge = false) { return $response->write($this->render($data, $merge)); }
public function testInvokeWithPimpleCallable() { // Prepare request and response objects $env = Environment::mock(['SCRIPT_NAME' => '/index.php', 'REQUEST_URI' => '/foo', 'REQUEST_METHOD' => 'GET']); $uri = Uri::createFromEnvironment($env); $headers = Headers::createFromEnvironment($env); $cookies = []; $serverParams = $env->all(); $body = new RequestBody(); $req = new Request('GET', $uri, $headers, $cookies, $serverParams, $body); $res = new Response(); $mock = $this->getMock('StdClass', ['bar']); $app = new App(); $container = $app->getContainer(); $container['foo'] = function () use($mock, $res) { $mock->method('bar')->willReturn($res->write('Hello')); return $mock; }; $app->get('/foo', 'foo:bar'); // Invoke app $resOut = $app($req, $res); $this->assertInstanceOf('\\Psr\\Http\\Message\\ResponseInterface', $resOut); $this->assertEquals('Hello', (string) $res->getBody()); }
public function testFinalize() { $method = new \ReflectionMethod('Slim\\App', 'finalize'); $method->setAccessible(true); $response = new Response(); $response->write('foo'); $response = $method->invoke(new App(), $response); $this->assertTrue($response->hasHeader('Content-Length')); $this->assertEquals('3', $response->getHeaderLine('Content-Length')); }
/** * Dispatch request and build response * * This method will route the provided Request object against all available * application routes. The provided response will reflect the status, header, and body * set by the invoked matching route. * * The provided Request and Response objects are updated by reference. There is no * value returned by this method. * * @param \Slim\Http\Request The request instance * @param \Slim\Http\Response The response instance */ protected function dispatchRequest(\Slim\Http\Request $request, \Slim\Http\Response $response) { try { $this->applyHook('slim.before'); ob_start(); $this->applyHook('slim.before.router'); $dispatched = false; $matchedRoutes = $this['router']->getMatchedRoutes($request->getMethod(), $request->getPathInfo(), false); foreach ($matchedRoutes as $route) { try { $this->applyHook('slim.before.dispatch'); $dispatched = $route->dispatch(); $this->applyHook('slim.after.dispatch'); if ($dispatched) { break; } } catch (\Slim\Exception\Pass $e) { continue; } } if (!$dispatched) { $this->notFound(); } $this->applyHook('slim.after.router'); } catch (\Slim\Exception\Stop $e) { } $response->write(ob_get_clean()); $this->applyHook('slim.after'); }
/** * Integration test IpRestrictMiddleware::_invoke() when the given IP is allowed. */ public function testIpAllow() { // Prepare the Request and the application. $app = new App(); // Setup a demo environment $env = Environment::mock(['SCRIPT_NAME' => '/index.php', 'REQUEST_URI' => '/foo', 'REQUEST_METHOD' => 'GET', 'REMOTE_ADDR' => '127.0.0.2']); $uri = Uri::createFromEnvironment($env); $headers = Headers::createFromEnvironment($env); $headers->set('Accept', 'text/html'); $cookies = []; $serverParams = $env->all(); $body = new Body(fopen('php://temp', 'r+')); $req = new Request('GET', $uri, $headers, $cookies, $serverParams, $body); $res = new Response(); $app->getContainer()['request'] = $req; $app->getContainer()['response'] = $res; // Set the options value. $this->options = ['error_code' => 403, 'exception_message' => 'NOT ALLOWED']; $app->add(new IpRestrictMiddleware($this->ipSet, false, $this->options)); $appMessage = 'I am In'; $app->get('/foo', function ($req, $res) use($appMessage) { $res->write($appMessage); return $res; }); $resOut = $app->run(); $body = (string) $resOut->getBody(); $this->assertEquals($appMessage, $body, 'The client is allowed to access the application.'); }
public function renderAjax($view, $params = []) { $render = $this->getView()->render($view, $params); return $this->response->write($render); }