public static function find($type, $path = false, $keys = null)
{
self::current();
if (!array_key_exists($type, self::$files)) {
return false;
}
// If no keys are specfied, use the page URI
if (empty($keys)) {
$keys = array_keys(Uri::get());
} elseif (is_string($keys)) {
$keys = explode('_', $keys);
}
// Add the first section, if its not listed
if (!array_key_exists($type, $keys)) {
array_unshift($keys, $type);
}
$total = count($keys);
for ($i = 0; $i < $total; $i++) {
$name = implode($keys, '_');
$file = self::exists($type, $name);
// if ($file) return $file;
if ($file) {
if ($path) {
return $file;
} else {
return self::capitalize($name);
}
}
// Remove the last section on each pass
array_pop($keys);
}
}
public function start()
{
$uri = Uri::get();
if (isset($uri['module'])) {
$this->_module = $uri['module'];
}
if (isset($uri['page'])) {
$this->_page = $uri['page'];
}
if (isset($uri['act'])) {
$this->_act = $uri['act'];
}
$this->_params = $uri['params'];
if (!file_exists(BASE_DIR . '/module/' . $this->_module . '.php')) {
$this->_module = 'home';
$this->_page = '404';
}
$this->reqFile();
}
public function __construct($archive = null, $option = array())
{
$this->config =& Config::current();
if (isset($option['per_page'])) {
$this->page = (int) $option['per_page'];
} else {
$this->per_page = (int) $this->config->per_page;
}
if (isset($option['page'])) {
$this->page = (int) $option['page'];
} elseif (Uri::get('page')) {
$this->page = (int) Uri::get('page');
}
if (is_object($archive)) {
$this->_posts =& $archive;
} else {
$this->posts($archive);
}
if (empty($this->_posts)) {
return false;
}
// Everything worked!
$this->success = true;
}
public function activationComplete()
{
// ------------------------------------------------------------------------------
// CONFIG/USER.PHP AYARLARI
// Config/User.php dosyasında belirtilmiş ayarlar alınıyor.
// ------------------------------------------------------------------------------
$userConfig = $this->config;
$tableName = $userConfig['tableName'];
$usernameColumn = $userConfig['usernameColumn'];
$passwordColumn = $userConfig['passwordColumn'];
$activationColumn = $userConfig['activationColumn'];
// ------------------------------------------------------------------------------
// Aktivasyon dönüş linkinde yer alan segmentler -------------------------------
$user = Uri::get('user');
$pass = Uri::get('pass');
// ------------------------------------------------------------------------------
if (!empty($user) && !empty($pass)) {
$db = uselib('DB');
$row = $db->where($usernameColumn . ' =', $user, 'and')->where($passwordColumn . ' =', $pass)->get($tableName)->row();
if (!empty($row)) {
$db->where($usernameColumn . ' =', $user)->update($tableName, array($activationColumn => '1'));
$this->success = lang('User', 'activationComplete');
return true;
} else {
$this->error = lang('User', 'activationCompleteError');
return Error::set($this->error);
}
} else {
$this->error = lang('User', 'activationCompleteError');
return Error::set($this->error);
}
}
/**
* Creates the new Request object by getting a new URI object, then parsing
* the uri with the Route class.
*
* Usage:
*
* $request = new Request('foo/bar');
*
* @param string the uri string
* @param bool whether or not to route the URI
* @param string request method
* @return void
*/
public function __construct($uri, $route = true, $method = null)
{
$this->uri = new \Uri($uri);
$this->method = $method;
logger(\Fuel::L_INFO, 'Creating a new Request with URI = "' . $this->uri->get() . '"', __METHOD__);
// check if a module was requested
if (count($this->uri->get_segments()) and $module_path = \Module::exists($this->uri->get_segment(1))) {
// check if the module has routes
if (is_file($module_path .= 'config/routes.php')) {
$module = $this->uri->get_segment(1);
// load and add the module routes
$module_routes = \Fuel::load($module_path);
$prepped_routes = array();
foreach ($module_routes as $name => $_route) {
if ($name === '_root_') {
$name = $module;
} elseif (strpos($name, $module . '/') !== 0 and $name != $module and $name !== '_404_') {
$name = $module . '/' . $name;
}
$prepped_routes[$name] = $_route;
}
// update the loaded list of routes
\Router::add($prepped_routes, null, true);
}
}
$this->route = \Router::process($this, $route);
if (!$this->route) {
return;
}
$this->module = $this->route->module;
$this->controller = $this->route->controller;
$this->action = $this->route->action;
$this->method_params = $this->route->method_params;
$this->named_params = $this->route->named_params;
if ($this->route->module !== null) {
$this->add_path(\Module::exists($this->module));
}
}
error_reporting(0);
}
// Production
define('APPPATH', realpath(dirname(__FILE__)) . '/');
define('CACHEPATH', realpath(dirname(__FILE__) . '/../cache') . '/');
define('CONTENTPATH', realpath(dirname(__FILE__) . '/../content') . '/');
// Load Helper & Config
require_once APPPATH . 'classes/class_helper.php';
require_once APPPATH . 'classes/class_error.php';
require_once APPPATH . 'classes/class_config.php';
// By setting the include path, templates can simply call include('header.php');
// and it will include the template header file.
set_include_path(CONTENTPATH . 'templates/' . Config::current()->template . '/' . PATH_SEPARATOR . APPPATH);
// Initialize Autoloader
require_once 'classes/class_loader.php';
spl_autoload_register(array('Loader', 'autoload'));
// Search directories:
Loader::scan();
// Load default page, if no page is specified
if (count(Uri::get()) < 1) {
Uri::set(strtolower(Config::current()->default));
}
// Set the default time zone
date_default_timezone_set(Config::current()->timezone);
DB::init(Config::current()->db_type);
// Find and initialize the controller
$controller = Loader::find('controller');
$controller = new $controller();
// Display Page
echo $controller->indexAction(Uri::get());
/**
* This executes the request and sets the output to be used later.
*
* Usage:
*
* $request = Request::forge('hello/world')->execute();
*
* @param array|null $method_params An array of parameters to pass to the method being executed
* @return Request This request object
*/
public function execute($method_params = null)
{
// fire any request started events
\Event::instance()->has_events('request_started') and \Event::instance()->trigger('request_started', '', 'none');
if (\Fuel::$profiling) {
\Profiler::mark(__METHOD__ . ': Start of ' . $this->uri->get());
}
logger(\Fuel::L_INFO, 'Called', __METHOD__);
// Make the current request active
static::$active = $this;
// First request called is also the main request
if (!static::$main) {
logger(\Fuel::L_INFO, 'Setting main Request', __METHOD__);
static::$main = $this;
}
if (!$this->route) {
static::reset_request();
throw new \HttpNotFoundException();
}
// save the current language so we can restore it after the call
$current_language = \Config::get('language', 'en');
try {
if ($this->route->callable !== null) {
$response = call_fuel_func_array($this->route->callable, array($this));
if (!$response instanceof Response) {
$response = new \Response($response);
}
} else {
$method_prefix = $this->method . '_';
$class = $this->controller;
// Allow override of method params from execute
if (is_array($method_params)) {
$this->method_params = array_merge($this->method_params, $method_params);
}
// If the class doesn't exist then 404
if (!class_exists($class)) {
throw new \HttpNotFoundException();
}
// Load the controller using reflection
$class = new \ReflectionClass($class);
if ($class->isAbstract()) {
throw new \HttpNotFoundException();
}
// Create a new instance of the controller
$this->controller_instance = $class->newInstance($this);
$this->action = $this->action ?: ($class->hasProperty('default_action') ? $class->getProperty('default_action')->getValue($this->controller_instance) : 'index');
$method = $method_prefix . $this->action;
// Allow to do in controller routing if method router(action, params) exists
if ($class->hasMethod('router')) {
$method = 'router';
$this->method_params = array($this->action, $this->method_params);
}
if (!$class->hasMethod($method)) {
// If they call user, go to $this->post_user();
$method = strtolower(\Input::method()) . '_' . $this->action;
// Fall back to action_ if no HTTP request method based method exists
if (!$class->hasMethod($method)) {
$method = 'action_' . $this->action;
}
}
if ($class->hasMethod($method)) {
$action = $class->getMethod($method);
if (!$action->isPublic()) {
throw new \HttpNotFoundException();
}
if (count($this->method_params) < $action->getNumberOfRequiredParameters()) {
throw new \HttpNotFoundException();
}
// fire any controller started events
\Event::instance()->has_events('controller_started') and \Event::instance()->trigger('controller_started', '', 'none');
$class->hasMethod('before') and $class->getMethod('before')->invoke($this->controller_instance);
$response = $action->invokeArgs($this->controller_instance, $this->method_params);
$class->hasMethod('after') and $response = $class->getMethod('after')->invoke($this->controller_instance, $response);
// fire any controller finished events
\Event::instance()->has_events('controller_finished') and \Event::instance()->trigger('controller_finished', '', 'none');
} else {
throw new \HttpNotFoundException();
}
}
// restore the language setting
\Config::set('language', $current_language);
} catch (\Exception $e) {
static::reset_request();
// restore the language setting
\Config::set('language', $current_language);
throw $e;
}
// Get the controller's output
if ($response instanceof Response) {
$this->response = $response;
} else {
throw new \FuelException(get_class($this->controller_instance) . '::' . $method . '() or the controller after() method must return a Response object.');
}
// fire any request finished events
\Event::instance()->has_events('request_finished') and \Event::instance()->trigger('request_finished', '', 'none');
if (\Fuel::$profiling) {
\Profiler::mark(__METHOD__ . ': End of ' . $this->uri->get());
}
static::reset_request();
return $this;
}
