<?php
/**
* $header
* @copyright Copyright 2007, Peter Goodman
* @package valkyrie
* @subpackage Controller
* @author Peter Goodman
*/
if(!defined('IN_VALKYRIE')) {
exit;
}
/**
* Deal with errors that happen in the ApplicationController
* @author Peter Goodman
* @see ApplicationController
*/
class ControllerException extends ValkyrieException {
}
/**
* Deal with incoming action/event requests and initialize the Request,
* Response (template), DatabaseDriver and other main classes.
* @author Peter Goodman
*/
class ApplicationController extends Registry {
/**
* A string holding the action name. The action is the function to be called
* in the appropriate PageController. The default action is 'index'.
* @internal
*/
private $action = 'index';
/**
* An array holding all of the path parts. The path is passed via index.php?path=
* and--when using mod_rewrite--looks like a clean url to a sub-folder of the site.
* @internal
*/
private $path = array();
/**
* The name of the page controller to load.
* @internal
*/
private $page;
/**
* An array of special variables passed in through the path
* @see ApplicationController::parseRoutes()
* @internal
*/
private $vars = array();
/**
* A reference to the database layer
* @see ApplicationController::connectToDatabase()
* @see Database
* @internal
*/
//protected $dba;
/**
* A reference to the page controller object for this action.
* @see ApplicationController::loadPageController()
* @see PageController
* @internal
*/
private $controller;
/**
* The directory to look for the page controller in. It is stored in this variable
* because page controllers can be location in sub-directories of the VK_CONTROLLERS_DIR.
* @see ApplicationControll::parsePath()
* @internal
*/
private $controller_dir = VK_CONTROLLERS_DIR;
/**
* ApplicationController constructor.
* class.
*/
public function __construct() {
}
/**
* ApplicationController destructor. Unset the database, response, and request
* reference objects. Also unset the reference variable holding an instance of
* the current page controller.
* @see Database, PageController, Response, Request
* @internal
*/
public function __destruct() {
unset($this->controller, $this->dba, $this->request, $this->response, $this->models);
$this->destroyRegistry();
}
/**
* Parse the path request variable and derive the
* page controller from it, then return an array
* of all of the elements in the path (without the
* leading controller name). The Path request variable (index.php?path=) will
* normally look like a folder path because of .htaccess mod_rewrite
* @internal
*/
private function parsePath()
{
// Get the path and then split it up by the /'s
// P.S. explode() does not work in this scenario
// because explode() will get empty elements.
$path = $this->request['path'];
$path = preg_split('~/~', $path, -1, PREG_SPLIT_NO_EMPTY);
// Shift off elements of the array if directories
// in the controller dir exist for this path.
$i = -1;
while(isset($path[++$i])) {
if(is_dir($this->controller_dir . $path[$i])) {
$this->controller_dir .= array_shift($path) . '/';
} else {
break;
}
}
// Figure out what controller function should be
// used.
$page = empty($path) ? 'index' : array_shift($path);
// Set the info.
$this->page = $page;
$this->path = $path;
if(!empty($path)) {
$this->action = $path[0];
}
}
/**
* Create a connection to a database. This will first find the
* database abstraction layer (eg: MySQLi, SQLite) using the Layers
* class in the /layers/database/ directory, then using config data
* try to connect to it.
* @see Layers, Database
* @internal
*/
private function connectToDatabase() {
if(DBA_DRIVER != '') {
$driver = strtolower(DBA_DRIVER);
try {
lazy_load(VK_DIR .'/database/database.php');
lazy_load(VK_DIR .'/database/drivers/'. $driver .'/driver.php');
lazy_load(VK_DIR .'/database/drivers/'. $driver .'/result.php');
lazy_load(VK_DIR .'/database/drivers/'. $driver .'/transaction.php');
lazy_load(VK_DIR .'/database/drivers/'. $driver .'/table.php');
} catch(LazyLoadException $e) {
throw new ControllerException("Failed to load the database driver. Please check that it exists.");
}
$driver = ucfirst($driver) .'Driver';
// load the database into the registry
$this->dba = new $driver(DBA_HOST, DBA_DATABASE, DBA_USER, DBA_PASS);
}
}
/**
* Parse the routes and figure out which one is the
* one we're on. Routes are defined in PageController::$routes
* in the form of /controller/function/(int)var/(str)var/(bool)var/(float)var
* where all of the 'var' elements are the different types of variables
* that can be passed in. Each 'var' is added as a key to the Request reference
* object as if it were a $_REQUEST variable, where its value is the corresponding
* value in the path (url) itself.
* @see Request, PageController
* @internal
*/
private function parseRoutes() {
// Get the routes defined in the controllers and
// setup some other variables while at it.
$routes = $this->controller->routes;
$matched = FALSE;
// If there are parts to the path...
if(!empty($this->path) && isset($routes[$this->path[0]])) {
$vars = array();
$rparts = preg_split("~/~", $routes[$this->path[0]], -1, PREG_SPLIT_NO_EMPTY);
$i = 0;
while(isset($rparts[$i]) && isset($this->path[$i])) {
$ppart = $this->path[$i];
$rpart = $rparts[$i];
if($rpart{0} == '(') {
$type = '';
if(FALSE === ($ii = strpos($rpart, ')'))) {
throw new ControllerException("Invalid route: missing closing ')'");
}
$type = substr($rpart, 1, $ii - 1);
$var = substr($rpart, $ii + 1);
$callback = "rt_$type";
$vars[$var] = $callback($ppart);
}
++$i;
}
$this->action = $this->path[0];
$this->vars = $vars;
$matched = TRUE;
}
// add the variables that we found to the Request object
$this->request->setArray($this->vars);
}
/**
* Try to find, include, and instanciate a PageController class for this action.
* @see PageController
* @internal
*/
private function loadPageController($rec = FALSE)
{
$filename = $this->controller_dir . $this->page . '.php';
if(!file_exists($filename) || !is_readable($filename)) {
// we'll try one last time with the index controller
// and the $this->page being the action
if(!$rec) {
$this->action = $this->page;
$this->page = 'index';
array_unshift($this->path, $this->action);
return $this->loadPageController(TRUE);
} else {
$this->setNotFound();
}
}
require_once $filename;
$class = camelize($this->page) . 'Controller';
if(!class_exists($class, FALSE)) {
$this->setNotFound();
}
$controller = new $class; //($this->dba, $this->request, $this->response);
if(!$controller instanceof PageController) {
$this->setNotFound();
}
// reset for the default action if it's different
if($this->action === 'index') {
$this->action = $controller->default_action;
}
// more advanced stuff, first check if the action is callable
if(!is_callable(array($controller, $this->action))) {
$this->setNotFound();
// action is callable, does the method exists or are we using __call?
} else {
// callable, must be using __call, assume index route
if(!method_exists($controller, $this->action)) {
array_unshift($this->path, '*');
}
}
$this->controller = $controller;
}
/**
* Now that the PageController has been loaded, run the appropriate action
* function in it. The default action is 'index'. Pass a reference to the
* Request and Response objects as the two action function arguments.
* @see Request, Response
* @internal
*/
private function runPageController()
{
if(!is_callable(array($this->controller, $this->action))) {
throw new ControllerException("No controller function present for the action: {$this->action}", E_USER_ERROR);
}
call_user_func_array(array($this->controller, $this->action), array($this->request, $this->response));
}
/**
* Run any filters in the page controller.
* @internal
*/
private function runFilters($which) {
// get the filters
$filters = $this->controller->$which;
// loop the filters
foreach($filters as $f) {
try {
lazy_load(VK_APP_DIR .'/filters/'. $f .'.php');
$class = camelize($f) .'Filter';
// can depend on parent catch ;)
if(!class_exists($class, FALSE)) {
throw new LazyLoadException;
}
// run the filter
$filter = new $class($this->dba, $this->request, $this->response);
$filter->run($this->request, $this->response);
// not a pre/post filter, lets see if we're trying to load a library as a filter
} catch(LazyLoadException $e) {
// try to load up the library without cloning it
try {
$this->load($f, FALSE);
// so, the library doesn't exist either
} catch(LazyLoadException $e) {
throw new ControllerException("Could not load filter/library [{$f}], please make sure that it exists.");
}
}
}
}
/**
* Call most of the ApplicationControllers functions to bring everything together
* and run the action.
*/
public function run() {
try {
$this->connectToDatabase();
echo $this->page .' '. $this->action .'<br>';
$this->parsePath();
echo $this->page .' '. $this->action .'<br>';
$this->loadPageController();
echo $this->page .' '. $this->action .'<br>';
$this->parseRoutes();
echo $this->page .' '. $this->action .'<br>';
$this->runFilters('pre_filters');
$this->runPageController();
echo $this->page .' '. $this->action .'<br>';
$this->runFilters('post_filters');
$this->response->render($this->dba, $this->request);
} catch(Exception $e) {
fatal_error($e);
}
}
/**
* If the action was not found in the PageController, then a custom
* 404 error page will be displayed.
* @see ApplicationController::loadPageController()
* @internal
*/
public function setNotFound() {
header('Status: 404 Not Found');
$this->response->getFile('/errors/error_404.html');
exit;
}
}
/**
* The page controller represents a namespace of actions available
* to users. The default action in a page controller will be PageController::index.
* To pass variables to these actions, see PageController::$routes and
* ApplicationController::parseRoutes(). The PageController has a "registry" that is
* simply PageController::$registry and can be accessed via object overloading
* with Overload.
* @see Overload
* @author Peter Goodman
*/
abstract class PageController extends Registry {
/**
* The datasource we are currently using.
*/
private $datasource = 'database';
/**
* Get a PageControllers custom routes. If no custom routes exist (custom routes being
* ones that include either special variables and/or more path elements after the action
* name, eg: /controller_name/action_name/custom/custom/)
* @see ApplicationController::parseRoutes()
*/
public $routes = array();
/**
* Get an array of filters to execute before a controller's action is called.
*/
public $pre_filters = array();
/**
* Get an array of filters to execute after a controller's action is called.
*/
public $post_filters = array();
/**
* The default action to call for a controller. Normally it's 'index' but if any page controller
* redefines this method, it can be changed to anything.
* @return string
*/
public $default_action = 'index';
/**
* PageController constructor, take in the database, request, response (template) and
* layers reference objects.
* @param mixed $dba A reference to the DatabaseDriver object.
* @param mixed $request A reference to the Request object.
* @param mixed $response A reference to the Response object.
* @param mixed $layers A reference to the Layers object.
* @see Database, Request, Response, Layers
* @internal
*/
// DatabaseDriver $dba, Request $request, Response $response
final public function __construct() {
/**
* @todo Find a nicer solution to loading different models.
*/
try {
lazy_load(VK_DIR .'/models/database/model.php');
} catch(LazyLoadException $e) {
throw new ControllerException("Could not load database model. Please make sure it exists.");
}
$this->models = array();
$this->models['database'] = new DatabaseModel;
}
/**
*/
final public function getFinder($name = '') {
return $this->models[$this->datasource]->getFinder($name);
}
/**
* Change the datasource, eg: database->authorize.net/google/whatever.
*/
final public function setDatasource($ds = 'database') {
if(!isset($this->models[$ds])) {
lazy_load(VK_DIR .'/models/'. $ds .'/model.php');
$class = camelize($ds) .'Model';
$this->models[$ds] = new $class;
}
$this->datasource = $ds;
}
/**
* If the action was not found in the PageController, then a custom
* 404 error page will be displayed.
* @see ApplicationController::loadPageController()
* @internal
*/
public function setNotFound() {
header('Status: 404 Not Found');
$this->response->getFile('/errors/error_404.html');
exit;
}
}
/**
* Controllers for components.
*/
abstract class ComponentController extends PageController {
abstract public function run(Request $request, Response $response);
}
/**
* Controllers for filters.
*/
abstract class FilterController extends PageController {
abstract public function run(Request $request, Response $response);
}