public static function init()
{
$url = $_SERVER['REQUEST_URI'];
$isCustom = false;
if (count(self::$rules)) {
foreach (self::$rules as $ruleKey => $ruleData) {
$params = self::ruleMatch($ruleKey, $url);
if ($params) {
self::$controller = $ruleData['controller'];
self::$action = $ruleData['action'];
self::$params = $params;
$isCustom = true;
break;
}
}
}
if (!$isCustom) {
self::defaultRoutes($url);
}
if (!strlen(self::$controller)) {
self::$controller = 'site';
}
if (!strlen(self::$action)) {
self::$action = '';
}
if (self::$action == ':site') {
self::$action = self::getParam("site");
}
}
static function parse_url()
{
if (Router::$controller) {
return;
}
// Work around problems with the CGI sapi by enforcing our default path
if ($_SERVER["SCRIPT_NAME"] && "/" . Router::$current_uri == $_SERVER["SCRIPT_NAME"]) {
Router::$controller_path = MODPATH . "gallery/controllers/albums.php";
Router::$controller = "albums";
Router::$method = 1;
return;
}
$current_uri = html_entity_decode(Router::$current_uri, ENT_QUOTES);
$item = ORM::factory("item")->where("relative_path_cache", $current_uri)->find();
if (!$item->loaded) {
// It's possible that the relative path cache for the item we're looking for is out of date,
// so find it the hard way.
$count = count(Router::$segments);
foreach (ORM::factory("item")->where("name", html_entity_decode(Router::$segments[$count - 1], ENT_QUOTES))->where("level", $count + 1)->find_all() as $match) {
if ($match->relative_path() == $current_uri) {
$item = $match;
}
}
}
if ($item && $item->loaded) {
Router::$controller = "{$item->type}s";
Router::$controller_path = MODPATH . "gallery/controllers/{$item->type}s.php";
Router::$method = $item->id;
}
}
/**
* @param $url
* @throws Exception
*/
public static function parse($url)
{
$arr = explode('?', $url);
$url = rtrim($arr[0], '/');
if (!$url) {
self::$controller = 'IndexController';
self::$action = 'indexAction';
return;
}
foreach (self::$routes as $route => $item) {
$regex = $item['pattern'];
foreach ($item['params'] as $k => $v) {
$regex = str_replace('{' . $k . '}', '(' . $v . ')', $regex);
}
if (preg_match('@^' . $regex . '$@', $url, $matches)) {
array_shift($matches);
if ($matches) {
foreach ($item as $k1 => $v1) {
$matches = array_combine(array_keys($item['params']), $matches);
}
}
self::$controller = $item['controller'] . 'Controller';
self::$action = $item['action'] . 'Action';
$_GET = $matches + $_GET;
break;
}
}
if (is_null(self::$controller) || is_null(self::$action)) {
throw new Exception('Page not found', 404);
}
}
/**
* @param $url
* @throws Exception
* Метод для парсинга урла
*/
public static function parse($url)
{
$arr = explode('?', $url);
$url = rtrim($arr[0], '/');
// если пусто - то на главную
if (!$url) {
self::$controller = 'IndexController';
self::$action = 'indexAction';
return;
}
// перебор роутов на предмет совпадения решулярки с урлом
foreach (self::$routes as $route => $item) {
$regex = $item['pattern'];
foreach ($item['params'] as $k => $v) {
$regex = str_replace('{' . $k . '}', '(' . $v . ')', $regex);
}
// если совпало
if (preg_match('@^' . $regex . '$@', $url, $matches)) {
array_shift($matches);
if ($matches) {
foreach ($item as $k1 => $v1) {
$matches = array_combine(array_keys($item['params']), $matches);
}
}
// определяем названия класса/метода контроллера
self::$controller = $item['controller'] . 'Controller';
self::$action = $item['action'] . 'Action';
$_GET = $matches + $_GET;
break;
}
}
if (is_null(self::$controller) || is_null(self::$action)) {
throw new Exception('Page not found', 404);
}
}
private function init()
{
//get user requested route
if (isset($_GET['node'])) {
//define route without parameters (helps with showing base URI request)
$route = $_GET['node'];
self::$route = $route;
//break requested route into chunks in array
$route_chunks = explode("/", $route);
//define controller
$controller = $route_chunks[0];
self::$controller = $controller;
//define controller directory
$controller_dir = CONTROLLER_DIR . $controller;
self::$controller_dir = $controller_dir;
//define format
if (!empty($route_chunks[1])) {
$format = $route_chunks[1];
self::$format = $format;
}
//define parameters - get full url etc and extract all strings after &..
global $settings;
$request_uri = $settings['request_uri'];
//break requested route into chunks in array
$route_params = explode("&", $request_uri);
//remove first value from array & return $route_params as just parameters
$params_shift = array_shift($route_params);
//update $params array
foreach ($route_params as $val) {
$param_chunks = explode("=", $val);
$params[$param_chunks[0]] = $param_chunks[1];
}
self::$params = $params;
}
}
static function route_controller($applicationName)
{
$url = parse_url($_SERVER['REQUEST_URI']);
$path = explode('/', trim($url['path'], '/'));
if (!isset($path[1])) {
self::$controller = 'index';
self::$action = 'index';
} else {
array_shift($path);
$dir = $applicationName . '/controllers/';
foreach ($path as $p) {
if (!is_dir($dir . $p . '/')) {
break;
} else {
$dir .= $p . '/';
array_shift($path);
}
}
self::$dir = $dir;
//if (isset($path[0]) and $path[0] == 'index.php')
self::$controller = array_shift($path);
self::$action = array_shift($path);
if (empty(self::$action)) {
self::$action = 'index';
}
}
foreach ($path as $k => $v) {
self::$params[$k] = $v;
}
return array(self::$controller, self::$action, self::$params);
}
function call_fallback_page()
{
if (Router::$controller === NULL) {
Router::$controller = 'fallback_page';
Router::$method = 'find_view';
Router::$controller_path = APPPATH . 'controllers/fallback_page.php';
}
}
public function getController()
{
if (isset(self::$segments[0])) {
self::$controller = self::$segments[0];
} else {
self::$controller = 'index';
}
}
/**
* If Gallery is in maintenance mode, then force all non-admins to get routed to a "This site is
* down for maintenance" page.
*/
static function maintenance_mode()
{
$maintenance_mode = Kohana::config("core.maintenance_mode", false, false);
if (Router::$controller != "login" && !empty($maintenance_mode) && !user::active()->admin) {
Router::$controller = "maintenance";
Router::$controller_path = MODPATH . "gallery/controllers/maintenance.php";
Router::$method = "index";
}
}
public static function pareUrl()
{
if (isset($_GET['r'])) {
$query_string = $_GET['r'];
$query_string = explode('/', $query_string);
self::$controller = $query_string[0];
self::$action = $query_string[1];
}
}
/**
* Add the chroot path at the begining of the requested URI
*/
static function parse_url()
{
if (user_chroot::album()) {
if (Router::$controller == 'albums' && Router::$current_uri == '') {
// Root album requested
Router::$controller = null;
Router::$current_uri = trim(user_chroot::album()->relative_url() . '/' . Router::$current_uri, '/');
} else {
if (is_null(Router::$controller) && Router::$current_uri != '') {
// Non-root album requested
Router::$current_uri = trim(user_chroot::album()->relative_url() . '/' . Router::$current_uri, '/');
}
}
}
return parent::parse_url();
}
static function parse_url()
{
if (Router::$controller) {
return;
}
$count = count(Router::$segments);
foreach (ORM::factory("item")->where("name", Router::$segments[$count - 1])->where("level", $count + 1)->find_all() as $match) {
if ($match->relative_path() == Router::$current_uri) {
$item = $match;
}
}
if (!empty($item)) {
Router::$controller = "{$item->type}s";
Router::$controller_path = APPPATH . "controllers/{$item->type}s.php";
Router::$method = $item->id;
}
}
protected function setUp()
{
// Save config
$this->kohana_config['core.url_suffix'] = Kohana_Config::instance()->get('core.url_suffix');
// Save Server API
$this->kohana_server_api = Kohana::$server_api;
// Save Router members
$this->router_vars = array('complete_uri' => Router::$complete_uri, 'controller' => Router::$controller, 'current_uri' => Router::$current_uri, 'query_string' => Router::$query_string, 'rsegments' => Router::$rsegments, 'routed_uri' => Router::$routed_uri, 'segments' => Router::$segments, 'url_suffix' => Router::$url_suffix);
// Reset Router members
Router::$complete_uri = '';
Router::$controller = NULL;
Router::$current_uri = '';
Router::$query_string = '';
Router::$rsegments = NULL;
Router::$routed_uri = '';
Router::$segments = NULL;
Router::$url_suffix = '';
}
static function parse_url()
{
if (Router::$controller) {
return;
}
// Work around problems with the CGI sapi by enforcing our default path
if ($_SERVER["SCRIPT_NAME"] && "/" . Router::$current_uri == $_SERVER["SCRIPT_NAME"]) {
Router::$controller_path = MODPATH . "gallery/controllers/albums.php";
Router::$controller = "albums";
Router::$method = 1;
return;
}
$item = self::get_item_from_uri(Router::$current_uri);
if ($item && $item->loaded) {
Router::$controller = "{$item->type}s";
Router::$controller_path = MODPATH . "gallery/controllers/{$item->type}s.php";
Router::$method = $item->id;
}
}
static function parse_url()
{
if (Router::$controller) {
return;
}
// Work around problems with the CGI sapi by enforcing our default path
if ($_SERVER["SCRIPT_NAME"] && "/" . Router::$current_uri == $_SERVER["SCRIPT_NAME"]) {
Router::$controller_path = MODPATH . "gallery/controllers/albums.php";
Router::$controller = "albums";
Router::$method = 1;
return;
}
$item = item::find_by_relative_url(html_entity_decode(Router::$current_uri, ENT_QUOTES));
if ($item && $item->loaded()) {
Router::$controller = "{$item->type}s";
Router::$controller_path = MODPATH . "gallery/controllers/{$item->type}s.php";
Router::$method = "show";
Router::$arguments = array($item);
}
}
public static function operation()
{
$filepath = Router::controller('filepath');
$classname = Router::controller('classname');
$method = Router::method();
$arguments = Router::arguments();
//加载controller
if (file_exists($filepath)) {
Zotop::load($filepath);
}
if (class_exists($classname, false)) {
$controller = new $classname();
if (method_exists($controller, $method) && $method[0] != '_') {
call_user_func_array(array($controller, $method), $arguments);
} else {
//Zotop::run('system.status.404');
//当方法不存在时，默认调用类的_empty()函数，改函数默认显示一个404错误，你可以在控制器中重写此方法
call_user_func_array(array($controller, '_empty'), $arguments);
}
} else {
Zotop::run('system.status.404');
}
}
private function _init()
{
$route = $this->_set_route();
$route = substr($route, -1, 1) == "/" ? substr($route, 0, -1) : $route;
$route = $route ? explode("/", $route) : null;
// define the controller directory
if (isset(self::$config_route['controller_dir_in_route']) && self::$config_route['controller_dir_in_route'] === true) {
if (is_array($route) && count($route)) {
self::$controller_dir = array_shift($route);
} elseif (isset(self::$config_route["default_controller_dir"])) {
self::$config_route["default_controller_dir"];
} else {
trigger_error("ROUTER: DEFAULT CONTROLLER DIR NOT SET");
}
}
// define the controller
if (is_array($route) && count($route)) {
self::$controller = array_shift($route);
} elseif (isset(self::$config_route['default_controller'])) {
self::$controller = self::$config_route["default_controller"];
} else {
trigger_error("ROUTER: DEFAULT CONTROLLER NOT SET");
}
// define action
if (is_array($route) && count($route)) {
self::$action = array_shift($route);
} elseif (isset(self::$config_route['default_action'])) {
self::$action = self::$config_route['default_action'];
} else {
trigger_error("ROUTER: DEFAULT ACTION NOT SET");
}
// define the parameters
if ($route) {
self::$params = $route;
}
}
/**
* If the gallery is only available to registered users and the user is not logged in, present
* the login page.
*/
static function private_gallery()
{
if (identity::active_user()->guest && !access::user_can(identity::guest(), "view", item::root()) && php_sapi_name() != "cli") {
try {
$class = new ReflectionClass(ucfirst(Router::$controller) . '_Controller');
$allowed = $class->getConstant("ALLOW_PRIVATE_GALLERY") === true;
} catch (ReflectionClass $e) {
$allowed = false;
}
if (!$allowed) {
if (Router::$controller == "admin") {
// At this point we're in the admin theme and it doesn't have a themed login page, so
// we can't just swap in the login controller and have it work. So redirect back to the
// root item where we'll run this code again with the site theme.
url::redirect(item::root()->abs_url());
} else {
Session::instance()->set("continue_url", url::abs_current());
Router::$controller = "login";
Router::$controller_path = MODPATH . "gallery/controllers/login.php";
Router::$method = "html";
}
}
}
}
public static function setController($str)
{
self::$controller = $str;
}
/**
* Setup routine.
* Automatically called during the core initialization process.
* @return bool
* @throws Exception_Exido
* @throws Exception_Exido_404
*/
public static function initialize()
{
if (self::$_routes === null) {
// Load routes
self::$_routes = Exido::config('route');
}
// Debug log
if (Exido::$log_debug) {
Exido::$log->add('EXIDO_DEBUG_LOG', __('Initialize routing'));
}
$default_route = false;
if (self::$current_uri == Exido::config('global.core.index_file')) {
self::$current_uri = '';
}
if (!isset(self::$_routes['default_method'])) {
self::$_routes['default_method'] = self::$method;
}
// Remove web-root directory
if (WEB_ROOT != '') {
self::$web_root = trim(WEB_ROOT, '/');
// Remove the suffix from the URL if needed
self::$current_uri = trim(preg_replace("|^" . self::$web_root . "|", "", self::$current_uri), '/');
}
if (self::$current_uri == '') {
// If default controller is not set
if (!isset(self::$_routes['default_controller']) or self::$_routes['default_controller'] == '') {
self::$_routes['default_controller'] = self::$default;
}
// Use the default route when no segments exist
self::$current_uri = self::$_routes['default_controller'];
// Default route is in use
$default_route = true;
}
if ($default_route == false) {
// Remove the suffix from the URL if needed
self::$current_uri = preg_replace("|" . preg_quote(Exido::config('global.core.url_suffix')) . "\$|", "", self::$current_uri);
// Strip arguments
if ($argspos = strpos(self::$current_uri, '?')) {
self::$current_uri = substr(self::$current_uri, 0, $argspos);
}
// Explode the segments by slashes
foreach (explode("/", preg_replace("|/*(.+?)/*\$|", "\\1", self::$current_uri)) as $val) {
$val = trim($val);
// Check for allowed characters
if (Exido::config('global.core.permitted_uri_chars') != '' and $val != '') {
// preg_quote() in PHP 5.3 escapes -, so the str_replace() and addition of - to preg_quote() is to maintain backwards
// compatibility as many are unaware of how characters in the permitted_uri_chars will be parsed as a regex pattern
if (!preg_match("|^[" . str_replace(array('\\-', '\\-'), '-', preg_quote(Exido::config('global.core.permitted_uri_chars'), '-')) . "]+\$|i", $val)) {
throw new Exception_Exido('The requested URL %s has a disallowed characters', array($val));
}
}
if ($val != '') {
self::$segments[] = self::$rsegments[] = $val;
}
}
// Custom routing
if (count(self::$_routes) > 0) {
self::$rsegments = self::_getRouted(self::$segments);
}
//array_merge(self::_getRouted(self::$segments), self::$segments);
}
if ($default_route == true) {
self::$rsegments[] = self::$current_uri;
}
// Prepare to find the controller
$controller_path = '';
$method_segment = null;
$controller_name = array();
// Paths to search
$paths = Exido::getIncludePaths();
foreach (self::$rsegments as $key => $segment) {
// Add the segment to the search path
$controller_path .= $segment;
$found = false;
// Set segment into controller name
$controller_name[] = ucfirst($segment);
foreach ($paths as $dir) {
// Search within controllers only
$dir .= 'controller/';
if (is_dir($dir . $controller_path) or is_file($dir . $controller_path . '.php')) {
// Valid path
$found = true;
// The controller must be a file that exists with the search path
if ($c = realpath($dir . $controller_path . '.php') and is_file($c)) {
// Set the controller name
self::$controller = ucfirst(strtolower(EXIDO_ENVIRONMENT_NAME)) . '_Controller_' . implode('_', $controller_name);
self::$controller_view = $controller_path;
// Set the controller path
self::$controller_path = $c;
// Set the method
$method_segment = $key + 1;
// Stop searching
break;
}
}
}
if ($found === false) {
// Maximum depth has been reached, stop searching
break;
}
// Add another slash
$controller_path .= '/';
}
if ($method_segment !== null and isset(self::$rsegments[$method_segment])) {
// Set method
if (isset(self::$rsegments[$method_segment])) {
self::$method = self::$rsegments[$method_segment];
}
if (isset(self::$rsegments[$method_segment])) {
// Set arguments
self::$arguments = array_slice(self::$rsegments, $method_segment + 1);
}
}
// If controller does not found
// We throw the 404 page
if (self::$controller === null) {
throw new Exception_Exido_404('Undefined controller %s.', array(self::$current_uri));
}
return true;
}
/**
* Invokes method $method (with arguments $arguments) of the wrapped Controller, optionally replacing
* $_GET and $_POST contents before making the call.
* @param $method The name of the method to invoke.
* @param $arguments The arguments to pass.
* @param $get The array that should replace $_GET.
* @param $post The array that should replace $_POST.
* @param $capture If true (default) any output generated by the method is captured and returned,
* otherwise the method's return value itself is returned.
* @return The called method's output or its return value, depending on $capture.
*/
public function method($method, $arguments = null, $get = null, $post = null, $capture = true)
{
// If method does not exist, call the "__call" magic method
// This can be made faster by catching an exception in the switch statement below
if (!method_exists($this->controller, $method)) {
$arguments = array($method, $arguments);
$method = '__call';
}
// Change Router state to reflect call
//Router::$current_route = '';
//Router::$current_uri = '';
//Router::$complete_uri = '';
Router::$controller = $this->router_controller;
Router::$method = $method;
if ($arguments === null) {
Router::$arguments = array();
} else {
Router::$arguments = $arguments;
}
// If get or post parameters are passed, alter $_GET, $_POST and Router::$query_string accordingly
// NOTE: Should we alter $_SERVER['QUERY_STRING'] too?
if ($get !== null) {
$old_get = $_GET;
$_GET = $get;
Router::$query_string = '?' . http_build_query($get);
}
if ($post !== null) {
$old_post = $_POST;
$_POST = $post;
}
// Start output capture
if ($capture) {
ob_implicit_flush(0);
ob_start();
}
if (is_string($arguments)) {
$arguments = array($arguments);
}
// Invoke method
switch (count($arguments)) {
case 1:
$result = $this->controller->{$method}($arguments[0]);
break;
case 2:
$result = $this->controller->{$method}($arguments[0], $arguments[1]);
break;
case 3:
$result = $this->controller->{$method}($arguments[0], $arguments[1], $arguments[2]);
break;
case 4:
$result = $this->controller->{$method}($arguments[0], $arguments[1], $arguments[2], $arguments[3]);
break;
default:
// Resort to using call_user_func_array for many arguments (slower)
$result = call_user_func_array(array($this->controller, $method), $arguments);
break;
}
// Run system.post_controller
Event::run('dispatch.post_controller');
// Stop output capture
if ($capture) {
$result = ob_get_contents();
ob_end_clean();
}
// Revert $_GET and $_POST changes
if ($get !== null) {
$_GET = $old_get;
}
if ($post !== null) {
$_POST = $old_post;
}
// Revert Router state
//Router::$current_route = $this->router_state_backup['current_route'];
//Router::$current_uri = $this->router_state_backup['current_uri'];
//Router::$complete_uri = $this->router_state_backup['complete_uri'];
Router::$query_string = $this->router_state_backup['query_string'];
Router::$controller = $this->router_state_backup['controller'];
Router::$method = $this->router_state_backup['method'];
Router::$arguments = $this->router_state_backup['arguments'];
return $result;
}
public static function init()
{
// find URI
$uri = self::uri();
// remove query string from URI
if (($query = strpos($uri, '?')) !== FALSE) {
// split URI on question mark
list($uri, $query) = explode('?', $uri, 2);
// parse the query string into $_GET if using CLI
// warning: converts spaces and dots to underscores
if (PHP_SAPI === 'cli') {
parse_str($query, $_GET);
}
}
// store requested URI on first run only
if (self::$current_uri === NULL) {
self::$current_uri = trim($uri, '/');
}
// matches a defined route
$matched = FALSE;
// match URI against route
foreach (self::$routes as $route => $callback) {
// trim slashes
$route = trim($route, '/');
$callback = trim($callback, '/');
if (preg_match('#^' . $route . '$#u', self::$current_uri)) {
if (strpos($callback, '$') !== FALSE) {
// use regex routing
self::$routed_uri = preg_replace('#^' . $route . '$#u', $callback, self::$current_uri);
} else {
// standard routing
self::$routed_uri = $callback;
}
// valid route has been found
$matched = TRUE;
break;
}
}
// no route matches found, use actual uri
if (!$matched) {
self::$routed_uri = self::$current_uri;
}
// use default route if requesting /
if (empty(self::$routed_uri)) {
self::$routed_uri = self::$routes['_default'];
}
// decipher controller/method
$segments = explode('/', self::$routed_uri);
// controller is first segment
self::$controller = $segments[0];
// use default method if none specified
self::$method = isset($segments[1]) ? $segments[1] : self::$method;
// remaining arguments
self::$arguments = array_slice($segments, 2);
// instatiate controller
self::execute();
}
public function error($role = false)
{
require CONTROLLER_PATH . 'Error.php';
Router::$controller = 'error';
$controller = new Error();
if ($role == true) {
$controller->exePermission();
} else {
$controller->exeDefault();
}
return false;
}
public static function parse($uri)
{
self::$action = Config::get('default_action');
self::$controller = Config::get('default_controller');
self::$language = Config::get('default_language');
self::$id = Config::get('default_id');
$uri_elements = self::url_to_array($uri);
if (count($uri_elements)) {
//if (strtolower(current($uri_elements) != 'admiin')) {
if (in_array(strtolower(current($uri_elements)), Config::get('languages'))) {
self::$language = strtolower(current($uri_elements));
array_shift($uri_elements);
}
//}else {
// array_shift($uri_elements);
//}
$url = implode('/', $uri_elements);
self::find_alias($url);
/**
if(current($uri_elements)){
self::$controller = ucfirst(strtolower(current($uri_elements)));
array_shift($uri_elements);
}
if(current($uri_elements)){
self::$action = strtolower(current($uri_elements));
array_shift($uri_elements);
}
if(current($uri_elements)){
self::$params = $uri_elements;
}
**/
}
}
/**
* Determines the appropriate controller, method, and arguments
* from the current URI request.
* Where necessary, defaults will be employed.
* Values are stored in local static members for use by the core.
*/
public static function current()
{
$current = self::getRequestPath();
// Are we being run from command line?
if (PHP_SAPI === 'cli') {
// $argv and $argc are disabled by default in some configurations.
$argc = isset($argc) ? $argc : $_SERVER['argc'];
if ($argc > 0) {
$args = isset($argv) ? $argv : $_SERVER['argv'];
// Merge all cli arguments as if they were in a uri from web context.
$current = implode('/', $args);
} else {
$current = self::getRequestPath();
}
}
// Remove dot paths
$current = preg_replace('#\\.[\\s./]*/#', '', $current);
// Remove leading slash
$current = ltrim($current, '/');
// Reduce multiple slashes
$current = preg_replace('#//+#', '/', $current);
// Remove front controller from URI if present (depends on variable used)
$frontController = \Config::get('core.front_controller') . FILE_EXTENSION;
if (substr($current, 0, strlen($frontController)) == $frontController) {
$current = substr($current, strlen($frontController));
}
// Remove any remaining leading/trailing slashes
$current = trim($current, '/');
// Check for rewrites matching configuration values.
$matched = $current;
$rewrites = \Config::get('rewrites');
if (!empty($rewrites)) {
foreach ($rewrites as $match => $replace) {
$match = trim($match, '/');
// Exact match?
if ($match == $current) {
$matched = $replace;
} elseif (preg_match('#^' . $match . '$#u', $current)) {
if (strpos($replace, '$')) {
// Replacement requires arguments that were parsed during match.
$matched = preg_replace('#^' . $match . '$#u', $replace, $current);
} else {
// Found match, no parsed arguments required.
$matched = $replace;
}
}
}
}
$current = $matched;
$parts = array();
if (strlen($current) > 0) {
$parts = explode('/', $current);
}
if (empty($parts)) {
self::$controller = \Config::get('core.default_controller');
} else {
$controller = '';
while (count($parts)) {
$controller .= array_shift($parts);
if (Loader::search('controller' . DIRECTORY_SEPARATOR . $controller)) {
self::$controller = $controller;
if (count($parts)) {
self::$method = array_shift($parts);
}
if (count($parts)) {
self::$arguments = $parts;
}
} else {
$controller .= DIRECTORY_SEPARATOR;
}
}
}
if (empty(self::$method)) {
self::$method = \Config::get('core.default_controller_method');
}
}
/**
* Router setup routine. Automatically called during Kohana setup process.
*
* @return void
*/
public static function setup()
{
if (!empty($_SERVER['QUERY_STRING'])) {
// Set the query string to the current query string
Router::$query_string = '?' . trim($_SERVER['QUERY_STRING'], '&/');
}
if (Router::$routes === NULL) {
// Load routes
Router::$routes = Kohana::config('routes');
}
// Default route status
$default_route = FALSE;
if (Router::$current_uri === '') {
// Make sure the default route is set
if (!isset(Router::$routes['_default'])) {
throw new Kohana_Exception('core.no_default_route');
}
// Use the default route when no segments exist
Router::$current_uri = Router::$routes['_default'];
// Default route is in use
$default_route = TRUE;
}
// Make sure the URL is not tainted with HTML characters
Router::$current_uri = html::specialchars(Router::$current_uri, FALSE);
// Remove all dot-paths from the URI, they are not valid
Router::$current_uri = preg_replace('#\\.[\\s./]*/#', '', Router::$current_uri);
// At this point segments, rsegments, and current URI are all the same
Router::$segments = Router::$rsegments = Router::$current_uri = trim(Router::$current_uri, '/');
// Set the complete URI
Router::$complete_uri = Router::$current_uri . Router::$query_string;
// Explode the segments by slashes
Router::$segments = ($default_route === TRUE or Router::$segments === '') ? array() : explode('/', Router::$segments);
if ($default_route === FALSE and count(Router::$routes) > 1) {
// Custom routing
Router::$rsegments = Router::routed_uri(Router::$current_uri);
}
// The routed URI is now complete
Router::$routed_uri = Router::$rsegments;
// Routed segments will never be empty
Router::$rsegments = explode('/', Router::$rsegments);
// Prepare to find the controller
$controller_path = '';
$method_segment = NULL;
// Paths to search
$paths = Kohana::include_paths();
foreach (Router::$rsegments as $key => $segment) {
// Add the segment to the search path
$controller_path .= $segment;
$found = FALSE;
foreach ($paths as $dir) {
// Search within controllers only
$dir .= 'controllers/';
if (is_dir($dir . $controller_path) or is_file($dir . $controller_path . EXT)) {
// Valid path
$found = TRUE;
// The controller must be a file that exists with the search path
if ($c = str_replace('\\', '/', realpath($dir . $controller_path . EXT)) and is_file($c) and strpos($c, $dir) === 0) {
// Set controller name
Router::$controller = $segment;
// Change controller path
Router::$controller_path = $c;
// Set the method segment
$method_segment = $key + 1;
// Stop searching
break;
}
}
}
if ($found === FALSE) {
// Maximum depth has been reached, stop searching
break;
}
// Add another slash
$controller_path .= '/';
}
if ($method_segment !== NULL and isset(Router::$rsegments[$method_segment])) {
// Set method
Router::$method = Router::$rsegments[$method_segment];
if (isset(Router::$rsegments[$method_segment + 1])) {
// Set arguments
Router::$arguments = array_slice(Router::$rsegments, $method_segment + 1);
}
}
// Last chance to set routing before a 404 is triggered
Event::run('system.post_routing');
if (Router::$controller === NULL) {
// No controller was found, so no page can be rendered
Event::run('system.404');
}
}
/**
* Determines the appropriate controller, method, and arguments
* from the current URI request.
* Where necessary, defaults will be employed.
* Values are stored in local static members for use by the core.
*/
public static function current()
{
$current = $_SERVER['PHP_SELF'];
// Are we being run from command line?
if (PHP_SAPI === 'cli') {
// $argv and $argc are disabled by default in some configurations.
$argc = isset($argc) ? $argc : $_SERVER['argc'];
if ($argc > 0) {
$args = isset($argv) ? $argv : $_SERVER['argv'];
// Merge all cli arguments as if they were in a uri from web context.
$current = implode('/', $args);
} else {
$current = $_SERVER['PHP_SELF'];
}
}
// Remove dot paths
$current = preg_replace('#\\.[\\s./]*/#', '', $current);
// Remove leading slash
$current = ltrim($current, '/');
// Reduce multiple slashes
$current = preg_replace('#//+#', '/', $current);
// Remove front controller from URI
$current = ltrim($current, Registry::$config['core']['front_controller'] . FILE_EXTENSION);
// Remove any remaining leading/trailing slashes
$current = trim($current, '/');
$parts = array();
if (strlen($current) > 0) {
$parts = explode('/', $current);
}
/**
* The controller is expected to be the first part.
* If not supplied, we'll assume the default controller
* defined in config.
*
* The method, if supplied, is expected to be the second part.
* If not supplied, we'll assume that the default method defined
* in config is the intended method.
*
* Any remaining parts are presumed to be arguments to the
* method and will be treated as such.
*/
if (count($parts)) {
self::$controller = array_shift($parts);
} else {
self::$controller = Registry::$config['core']['default_controller'];
}
if (count($parts)) {
self::$method = array_shift($parts);
} else {
self::$method = Registry::$config['core']['default_controller_method'];
}
if (count($parts)) {
self::$arguments = $parts;
}
}
<?php
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);
require 'init.php';
if ($ctrl = Router::controller()) {
include $ctrl;
} else {
header('HTTP/1.1 404 Not Found');
echo "Page not found!";
}
//}}}
private function loadPageContent($pag)
{
Debug::log("Router - loadPageContent() ", __LINE__, __FUNCTION__, __CLASS__, __FILE__);
$class = ucwords(str_replace("-", "_", $pag)) . "Controller";
$method = isset(self::$levels[$this->level_to_load_method]) ? self::$levels[$this->level_to_load_method] : "index";
$method = $this->checkFullUrlExist($class, $method);
//Debug::p($class, $method);
//echo "CHECK $class, $method :".method_exists($class,$method);
//exit;
if (class_exists($class)) {
self::$controller = new $class();
//Debug::print_r("acceptNextIndexUnknownLevels: ".self::$controller->acceptNextIndexUnknownLevels);
}
if (class_exists($class) && method_exists($class, $method)) {
for ($i = self::$levelRef + 2; $i < self::$levelRef; $i++) {
$this->{$params}[$i - (self::$levelRef + 2)] = self::$levels[$i];
}
Debug::log("Router->loadPageContent : Chamando metodo {$method} para a URL. (control/" . $pag . "_control.php) - {$class}");
Action::registerAccess();
Run::$ajaxMethod->start();
if (!isset(self::$controller->autoLoadMethod) || self::$controller->autoLoadMethod !== false) {
Run::$benchmark->writeMark("startRouter/Inicio", "loadPageContent/if/controller/method");
self::$controller->{$method}();
}
} else {
if ((int) self::$controller->acceptNextIndexUnknownLevels > 0) {
if (!isset(self::$controller->autoLoadMethod) || self::$controller->autoLoadMethod !== false) {
$method = "index";
Debug::log("Router->loadPageContent : Chamando metodo index/{self::{$controller->acceptNextIndexUnknownLevels}} para a URL. (control/" . $pag . "_control.php) - {$class}");
Action::registerAccess();
Run::$benchmark->writeMark("startRouter/Inicio", "loadPageContent/else/controller/method");
if (method_exists($class, $method)) {
self::$controller->{$method}();
} else {
Error::show(8, "Router->loadPageContent: Metodo <b>{$method}</b> não existe. {self::{$controller->acceptNextUnknownLevels}} (control/" . $pag . "_control.php).", __FILE__, __LINE__);
$this->load("404");
}
}
} else {
if (!class_exists($class)) {
Error::show(8, "Router->loadPageContent: Classe <b>{$class}</b> não existe. (control/" . $pag . "_control.php).", __FILE__, __LINE__);
} else {
Error::show(8, "Router->loadPageContent: Metodo <b>{$method}</b> não existe. {self::{$controller->acceptNextUnknownLevels}} (control/" . $pag . "_control.php).", __FILE__, __LINE__);
}
echo "<!-- {$class} ou {$method} não existe -->";
$this->load("404");
}
}
$this->flush();
//Run::$benchmark->writeMark("loadPageContent1", "loadPageContent2");
}
