basejumper.inc.php

Go to the documentation of this file.

<?
class BaseJumper
{
    public $defaultClass;
    
    public $defaultTemplate;

    public $object;

    public static $tables = null;

    public static $tableData = array();

    public static $tableCacheLife = 3000000;

    public static $trackHits = true;

    public static $hitTrackingTable = 'site_hits';

    private $modules = array();
    
    public function __construct($defaultTemplate = 'DefaultTemplate', $defaultClass = 'Main')
    {
        //set our stuff.
        $this->defaultClass = $defaultClass;
        $this->defaultTemplate = $defaultTemplate;

        if (!Config::get('basejumper_installed'))
        {
            self::$trackHits = false;
        }
    }

    public function addModule($module)
    {
        $module = strtolower($module);
        
        //if we dont already have it, add it in.
        if (!$this->hasModule($module))
            $this->modules[] = $module;
    }

    public function addModules($modules)
    {
        foreach ($modules AS $module)
            $this->addModule($module);
    }

    public function removeModule($module)
    {
        $module = strtolower($module);
        
        //do we have the module loaded?
        if ($this->hasModule($module))
            //yup, go thru each of our modules.
            foreach ($this->modules AS $key => $val)
                //if this is the right one, delete it.
                if ($val == $module)
                    unset($this->modules[$key]);
    }

    public function hasModule($module)
    {
        $module = strtolower($module);
        
        return in_array($module, $this->modules);
    }

    public static function getDbTables()
    {
        self::lookupDbTables();

        return self::$tables;
    }

    public static function getDbTable($table)
    {
        self::lookupDbTable($table);

        return self::$tableData[$table];
    }

    public static function getTableIndexes($table)
    {
        //init
        $rval = array();
        
        //get our keys from the table.
        $rs = dbQuery("
            SHOW INDEXES FROM $table
        ");
        while ($ar = dbFetchAssoc($rs))
            $rval[] = $ar;

        //send her home
        return $rval;
    }

    public static function dbHasTable($table)
    {
        self::lookupDbTables();
    
        return isset(self::$tables[$table]);
    }
    
    public static function tableHasField($table, $field)
    {
        self::lookupDbTable($table);

        return isset(self::$tableData[$table][$field]);
    }

    private static function lookupDbTables()
    {
        //if we already have it, do nothing
        if (self::$tables === null)
        {
            //try our cache.
            $rval = CacheBot::get("BaseJumper:Tables", self::$tableCacheLife);
            
            //no cache?  do it from db.
            if (!$rval)
            {
                //get all the tables.
                $tableRs = dbQuery("SHOW TABLES");
                while ($tableAr = dbFetchArray($tableRs))
                    $rval[$tableAr[0]] = true;
                
                //cache it for 4 hours.
                CacheBot::set("BaseJumper:Tables", $rval, self::$tableCacheLife);
            }
            
            //send it home
            self::$tables = $rval;
        }
    }
    
    private static function lookupDbTable($table)
    {
        //if we already have it, do nothing
        if (!isset(self::$tableData[$table]))
        {
            //try our cache.
            $rval = CacheBot::get("BaseJumper:Table:$table", self::$tableCacheLife);
            
            //did we get it?
            if (!$rval)
            {
                //save the hassle (and exception) of looking up a nonexistant table.
                if (self::dbHasTable($table))
                {
                    //nope have the db tell us.
                    $descRs = dbQuery("DESCRIBE $table");
                    while ($descAr = dbFetchAssoc($descRs))
                    {
                        //get our field.
                        $field = $descAr['Field'];
                        
                        //save it.
                        $rval[$field] = $descAr;
                    }
                    
                    //cache it for 4 hours.
                    CacheBot::set("BaseJumper:Table:$table", $rval, self::$tableCacheLife);
                }
            }

            //save it.
            self::$tableData[$table] = $rval;
        }
    }
    
    protected function checkCredentials()
    {
        //authenticate...
        global $me;
        $me = new User();
        $me->authenticate();
    }

    protected function checkHost()
    {
        //first check to see if we're on teh right server...
        if ($_SERVER["HTTP_HOST"] != Config::get('site_hostname'))
            Util::redirect("http://" . Config::get('site_hostname') . $_SERVER["REQUEST_URI"]);
    }

    public function start()
    {
        //we want output buffering so we can add variables in...
        ob_start();

        //attempt to have the object draw itself.
        try
        {
            //make sure we're on the right server.
            $this->checkHost();

            //log our page request
            if (self::$trackHits)
                $this->trackPageHit();
            
            //try to get our page if its cached.
            $page = BaseModule::getCachedPage();
            if ($page)
                echo $page;
            else
            {
                //now do our checking.
                $this->checkCredentials();

                //do we need tables?
                if (Config::get('db_host'))
                    self::getDbTables();

                //initialize our module
                $this->init();
                
                //turn output buffering on so we can show error forms and stuff cleanly.
                ob_start();
                $this->object->draw();
                $contents = ob_get_contents();
                ob_end_clean();

                //show the contents.
                echo $contents;

                //save it if we got it.
                if ($this->object->doCachePage)
                    BaseModule::setCachedPage($contents);
            }
        }
        //have our error handler clean up any juices.
        catch (Exception $e)
        {
            ErrorHandler::handleException($e);      
        }
        
        //get the output.
        $contents = ob_get_contents();
        ob_end_clean();
        
        //add in our stuff...
        echo $this->filterFinalOutput($contents);
    }

    protected function filterFinalOutput($output)
    {
        global $runtimeStart, $sqlQueryCount;

        //how long did it take?
        $runtimeStop = microtime(true);
        $total = round($runtimeStop - $runtimeStart, 4);
        
        //replace our shit.
        $output = str_replace("%%BJ_RUNTIME%%", $total, $output); 
        $output = str_replace("%%BJ_QUERIES%%", (int)$sqlQueryCount, $output);
        $output = str_replace("%%BJ_CACHE_HITS%%", (int)EasyCache::$hits, $output);

        //finally show our site.
        return $output;
    }

    protected function init()
    {
        //we want our default module.
        $this->setModule(new MyModule());
        
        //make the object init.
        try
        {
            //well first try and load our object.
            $object = $this->loadModule();
            
            //did we get an object?
            if ($object)
            {
                $this->setModule($object);
                
                //get our parameters array..
                $page = $this->getPage();
                $params = $this->getParams();
                
                //did we get a global template passed in?
                $template = $this->getGlobalTemplate($params);
                if ($template instanceOf BaseTemplate)
                    $this->object->setTemplate($template);
                
                //check our auth code.
                $this->checkAuthCode($params);
                
                //finially, init!
                $this->object->init($page, $params);
                
                //we may need to reset the template if the module set its own template
                if ($template instanceOf BaseTemplate && get_class($template) != get_class($this->object->template))
                    $this->object->setTemplate($template);

                //let them know we were successful
                return true;
            }
            //no object... return false
            else
                return false;
        }
        //did we get any errors?
        catch(PageError $err)
        {
            $this->object->setError($err->getMessage());
        }
    }

    public function setModule(BaseModule $module)
    {
        //save the module
        $this->object = $module;
                
        //give it a default template.
        $this->object->setTemplate(new $this->defaultTemplate());
    }

    protected function getPage()
    {
        if (isset($_REQUEST['page']))
            return $_REQUEST['page'];
        else
            return 'main';
    }

    protected function getParams()
    {
        //start off with all our request vars.
        $vars = $_REQUEST;
        
        //do our url rewriting stuff
        if (Config::get("use_mod_rewrite"))
        {
            //get our params
            $params = $vars['params'];
            unset($vars['params']);

            //explode our parameters
            $paramA = explode('/', $params);
            if (count($paramA) && $params != '')
            {
                //put them in the array
                if (count($paramA) % 2 == 0)
                    for ($i = 0; $i < count($paramA); $i += 2)
                        $vars[$paramA[$i]] = $paramA[$i+1];
                else
                    throw new PageError('Wrong parameter count.');
            }
        }

        //send them home
        return $vars;
    }
    
    protected function getGlobalTemplate($params)
    {
        //did we get one passed in?
        if (isset($params['bjtemplate']))
        {
            //does it exist?
            $class = trim($params['bjtemplate']) . "Template";
            if (class_exists($class))
            {
                //yup, unset it and send it home.
                unset($params['bjtemplate']);
                return new $class();
            }
        }
    }

    protected function checkAuthCode($params)
    {
        //did we get one passed in?
        if (isset($params['bjauthcode']))
        {
            //get it..
            $code = trim($params['bjauthcode']);

            //try our auth code!!
            $user = new User(); 
            if (!$user->tryAuthCode($code, false))
                throw new PageError('Authorization code failed.');
        }
    }
    
    protected function loadModule($module = null)
    {
        //did we get a module?
        if ($module === null)
        {
            //figure out what our class is.
            if (isset($_REQUEST['module']))
                $module = trim($_REQUEST['module']);
            else
                $module = $this->defaultClass;
        }

        //does it already exist?
        if ($this->hasModule($module))
        {
            //if we can find the class.. do it.
            if (class_exists($module))
                return new $module();
            //otherwise, this is a programmer error, throw an exception for them.
            else
                throw new Exception("Class $module not found.");
        }
        //nope, its not on our list... you cant get in.
        else
            throw new PageError("The module '$module' does not exist in " . Config::get('site_name') . ".");
    
        return false;
    }
    
    public static function autoload($class)
    {
        //set up some default names...
        $lowerClass = strtolower($class);
        $dashClass = strtolower(preg_replace("/([a-z])([A-Z])/", "$1-$2", $class));
        
        //if it doesnt exist, can we open the file?
        if (file_exists("include/$lowerClass.inc.php"))
        {
            require_once("include/$lowerClass.inc.php");
            return true;
        }
        //if it doesnt exist, can we open the file?
        else if (file_exists("include/$dashClass.inc.php"))
        {
            require_once("include/$dashClass.inc.php");
            return true;
        }
        //if it doesnt exist, can we open the file?
        else if (file_exists("include/{$class}.inc.php"))
        {
            require_once("include/{$class}.inc.php");
            return true;
        }

        return false;
    }

    public function getCreateHitTrackingTable()
    {
        return 
"CREATE TABLE " . self::$hitTrackingTable . "
(
    id int(11) not null auto_increment,
    module varchar(64) default '' not null,
    page varchar(64) default '' not null,
    access_date datetime not null,
    PRIMARY KEY(id)
) TYPE=MyISAM;";
    }

    public function trackPageHit($module = null, $page = null)
    {
        //set some defaults.
        if ($module === null)
            $module = $_REQUEST['module'];
        if ($page === null)
            $page = $_REQUEST['page'];

        //safety first
        $module = dbEscape($module);
        $page = dbEscape($page);

        //track it.
        dbExecute("
            INSERT INTO " . self::$hitTrackingTable . "
                (module, page, access_date)
            VALUES
                ('$module', '$page', NOW())
        ");
    }

    public function clearHits()
    {
        dbExecute("DELETE FROM " . self::$hitTrackingTable);
    }
    
    public function getModulesArray()
    {
        //sort first!
        sort($this->modules);
        
        return $this->modules;
    }

    public function getModulesXml()
    {
        $xml = '<modules>';

        //get our modules xml data.
        $modules = $this->getModulesArray();
        foreach ($modules AS $module)
        {
            $obj = new $module;
            $xml .= $obj->getModuleXml();
        }

        $xml .= '</modules>';

        return $xml;
    }
}

?>

---