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);
}
