private function doRequest($URI, $data = []) { Input::$input = $data; Laravel\Routing\Filter::register(require APP_PATH . 'filters' . EXT); $loader = new Laravel\Routing\Loader(APP_PATH, ROUTE_PATH); $router = new Laravel\Routing\Router($loader, CONTROLLER_PATH); IoC::instance('laravel.routing.router', $router); Laravel\Request::$route = $router->route(Laravel\Request::method(), Laravel\URI::current()); if (!is_null(Request::$route)) { $response = Request::$route->call(); } else { Laravel\Routing\Filter::run(['before'], [], true); $response = Laravel\Response::json(['msg' => 'Not found'], 404); \Laravel\Routing\Filter::run(['after'], [$response], true); } ob_start(); $response->send(); $output = ob_get_contents(); ob_end_clean(); return $output; }
/** * Register a route filter. * * @param string $name * @param mixed $callback * @return void */ public static function filter($name, $callback) { Filter::register($name, $callback); }
/** * Execute a controller method with the given parameters. * * @param string $method * @param array $parameters * @return Response */ public function execute($method, $parameters = array()) { $filters = $this->filters('before', $method); // Again, as was the case with route closures, if the controller "before" // filters return a response, it will be considered the response to the // request and the controller method will not be used. $response = Filter::run($filters, array(), true); if (is_null($response)) { $this->before(); $response = $this->response($method, $parameters); } $response = Response::prepare($response); // The "after" function on the controller is simply a convenient hook // so the developer can work on the response before it's returned to // the browser. This is useful for templating, etc. $this->after($response); Filter::run($this->filters('after', $method), array($response)); return $response; }
/** * Call a given route and return the route's response. * * @return Response */ public function call() { // Since "before" filters can halt the request cycle, we will return // any response from the before filters. Allowing filters to halt the // request cycle makes tasks like authorization convenient. // // The route is responsible for running the global filters, and any // filters defined on the route itself. Since all incoming requests // come through a route (either defined or ad-hoc), it makes sense // to let the route handle the global filters. If the route uses // a controller, the controller will only call its own filters. $before = array_merge(array('before'), $this->filters('before')); $response = Filter::run($before, array(), true); if (is_null($response) and !is_null($response = $this->response())) { if ($response instanceof Delegate) { $response = Controller::call($response->destination, $this->parameters); } } if (!$response instanceof Response) { $response = new Response($response); } // Stringify the response. We need to force the response to be // stringed before closing the session, since the developer may // be using the session within their views, so we cannot age // the session data until the view is rendered. $response->content = $response->render(); $filters = array_merge($this->filters('after'), array('after')); Filter::run($filters, array($response)); return $response; }
*/ unset($input[Request::spoofer]); Input::$input = $input; //Compatibility hack set_log4php_env('ls_log_file', \Config::get('env.log_path') . '/content.log'); \Logger::configure(\Config::get('log4php')); /** * Route the request to the proper route in the application. If a * route is found, the route will be called with the current request * instance. If no route is found, the 404 response will be returned * to the browser. */ Routing\Filter::register(require APP_PATH . 'filters' . EXT); $loader = new Routing\Loader(APP_PATH, ROUTE_PATH); $router = new Routing\Router($loader, CONTROLLER_PATH); IoC::instance('laravel.routing.router', $router); Request::$route = $router->route(Request::method(), URI::current()); if (!is_null(Request::$route)) { $new_relic->name_transaction(Request::$route->key); try { $response = Request::$route->call(); } catch (\Exception $e) { $handler($e); } } else { $new_relic->name_transaction('404'); \Laravel\Routing\Filter::run(array('before'), array(), true); $response = \Response::json(['msg' => 'Not found'], 404); \Laravel\Routing\Filter::run(array('after'), array($response), true); } $response->send();
/** * Execute a controller method with the given parameters. * * @param string $method * @param array $parameters * @return Response */ public function execute($method, $parameters = array()) { // Again, as was the case with route closures, if the controller // "before" filters return a response, it will be considered the // response to the request and the controller method will not be // used to handle the request to the application. $response = Filter::run($this->filters('before', $method), array(), true); if (is_null($response)) { // The developer may mark the controller as being "RESTful" which // indicates that the controller actions are prefixed with the // HTTP verb they respond to rather than the word "action". if ($this->restful) { $action = strtolower(Request::method()) . '_' . $method; } else { $action = "action_{$method}"; } $response = call_user_func_array(array($this, $action), $parameters); // If the controller has specified a layout view. The response // returned by the controller method will be bound to that view // and the layout will be considered the response. if (is_null($response) and !is_null($this->layout)) { $response = $this->layout; } } if (!$response instanceof Response) { $response = new Response($response); } // Stringify the response. We need to force the response to be // stringed before closing the session, since the developer may // be using the session within their views, so we cannot age // the session data until the view is rendered. $response->content = $response->render(); Filter::run($this->filters('after', $method), array($response)); return $response; }
/** * Create a new filter collection instance. * * @param string|array $filters * @param mixed $parameters * @return void */ public function __construct($filters, $parameters = null) { $this->parameters = $parameters; $this->filters = Filter::parse($filters); }
/** * Create a new filter collection instance. * * @param string $name * @param string|array $filters */ public function __construct($name, $filters) { $this->name = $name; $this->filters = Filter::parse($filters); }