Location: PHPKode > scripts > Usermanage > usermanage/LEMP/lemp.php
<?php 
// ----------------------------------------------------------------------
// LEMP - Lightweight Efficient Modular PHP Application Framework
//  @copyright 2002-2003 The CGI Open Source Federation. (http://cosf.sf.net)
//  @version $Id: lemp.php,v 1.23 2004/05/16 20:59:11 cogs Exp $
// ----------------------------------------------------------------------
// LICENSE
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License (GPL)
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have recieved the lincence included with the disribution.
// If not visit http://www.gnu.org/copyleft/gpl.html
// ----------------------------------------------------------------------
// Shorthand constants
define ("LEMP_PATH_TO_LIBRARY", dirname (__FILE__));
// You could also want to replace the following if-else block with
// define ('LEMP_PATH_TO_CONFIG', 'path_to_config_file');
// but you will have to do this every time you update LEMP
if (file_exists(LEMP_PATH_TO_LIBRARY . '/../config.php')) {
    define ('LEMP_PATH_TO_CONFIG', realpath (LEMP_PATH_TO_LIBRARY . '/../config.php'));
} elseif (file_exists(LEMP_PATH_TO_LIBRARY . '/config.php')) {
    define ('LEMP_PATH_TO_CONFIG', realpath (LEMP_PATH_TO_LIBRARY . '/config.php'));
} else {
    define ('LEMP_PATH_TO_CONFIG', '');
} 
// Some usefull constants...
define ("ENDL", "\n");
define ("ENDLB", "<br>\n");
// Variable types
define ("LEMP_NULL", 0);
define ("LEMP_BOOL", 1);
define ("LEMP_SCALAR", 10);
define ("LEMP_INT", 11);
define ("LEMP_COUNT", 11);
define ("LEMP_STRING", 12);
define ("LEMP_FIELD", 12);
define ("LEMP_TEXT", 13); // Multi-Line Text
define ("LEMP_HTML", 14);
define ("LEMP_XML", 15);
define ("LEMP_ARRAY", 100);
define ("LEMP_ARRAY_NUM", 101);
define ("LEMP_ARRAY_ASSOC", 102);
define ("LEMP_ARRAY_BOTH", 103);
define ("LEMP_MULTI_ARRAY", 110);
define ("LEMP_MULTI_ARRAY_NUM", 111);
define ("LEMP_MULTI_ARRAY_ASSOC", 112);
define ("LEMP_MULTI_ARRAY_BOTH", 113);
define ("LEMP_OBJECT", 200);

$LEMP_error_log = array ();
$LEMP_config_vars = array ();

/**
 * LEMP is a mini-framework that can help developers focus on their
 * concept. It is extended by modules to form the base and provide
 * functions like database interaction, which could also be extended
 * by other modules like user management.
 */

class LEMP {
    var $db; // The DB object used by LEMP to interact with the databse.
    var $input; // Is equal to $_REQUEST
    var $in; // Reference to $input
    /**
     * LEMP::LEMP() LEMP's constructor.  It will set up the variables that LEMP needs to
     * run.
     * 
     * @access private 
     * @return void 
     */
    function LEMP ()
    { 
        // Create database object
        $this->db = &create_obj ('db_handle');
        $this->input = $_REQUEST;
        $this->in = &$this->input;
    } 

    /**
     * LEMP::dbconnect() alias of db_handle::dbconnect()
     */
    function dbconnect ()
    {
        return $this->db->connect();
    } 

    /**
     * LEMP::dbclose() alias of db_handle::dbclose()
     */
    function dbclose ()
    {
        return $this->db->close();
    } 
    /**
     * LEMP::dbquery() alias of db_handle::dbquery()
     */
    function dbquery ($query)
    {
        return $this->db->query ($query);
    } 
    /**
     * LEMP::dbfetch() alias of db_handle::dbfetch()
     */
    function dbfetch ($result, $result_type = 103)
    {
        return $this->db->fetch ($result, $result_type);
    } 
    /**
     * LEMP::dbquery_fetch() alias of  db_handle::dbquery_fetch()
     */
    function dbquery_fetch ($query, $result_type = 103)
    {
        return $this->db->query_fetch ($query, $result_type);
    } 
    /**
     * LEMP::dbnum_rows() alias of db_handle::dbnum_rows()
     */
    function dbnum_rows ($result)
    {
        return $this->db->num_rows ($result);
    } 
} 

/**
 * Database functions that LEMP uses.
 */
class db_handle {
    var $db_link; // The DB link
    /**
     * db_handle::db_handle() db_handle's constructor.
     * 
     * @access private 
     * @return void 
     */
    function db_handle ()
    {
        $this->db_link = false;
    } 

    /**
     * db_handle::connect() Object connects and selects database
     * (settings are set in config.php file), or returns the database
     * link a connection exists.
     * 
     * @return bool Successful | Not Successful
     */
    function connect ()
    {
        $db = get_config('db'); // Get the database configuration                                         
        // If there already is a link exit the function
        if ($this->db_link !== false) {
            return true;
        } 

        if ($db['type'] == 'mysql') { // Determine handler
            // Connect to mysql database if mysql database is used
            $this->db_link = mysql_connect($db['host'], $db['username'], $db['password']);
            if (!$this->db_link) {
                return error_add ('DB Error: Could not connect to mysql host:' . $db['host'], __FILE__, __LINE__, true);
            } 
            // Select database
            $selected = mysql_select_db ($db['database'], $this->db_link);
            if (!$selected) {
                return error_add ('DB Error: Could not select database:' . $db['database'], __FILE__, __LINE__, true);
            } 
        } else {
            // If database type is not mysql, trigger any external hooks
            $result = trigger_event ('db_handle:connect:alternate');
            if (is_null ($result)) {
                return error_add ('Config Error: Unknown database type', __FILE__, __LINE__, true);
            } 
        } 

        return true;
    } 

    /**
     * db_handle::close() Closes database connection and destroys link handler.
     * 
     * @return bool Successful | Not Successful
     */
    function close ()
    {
        $db = get_config('db'); 
        // Determine handler
        if ($db['type'] == 'mysql') {
            // Close link to mysql database if mysql database is used
            $return = mysql_close ($this->db_link);
        } else {
            // If database type is not mysql, trigger any external hooks
            $result = trigger_event ('db_handle:close:alternate', array($this->db_link));
            if (is_null ($result)) {
                return error_add ('Config Error: Unknown database type', __FILE__, __LINE__, true);
            } 
        } 
        // Reset $this->db_link
        $this->db_link = false;
        return true;
    } 

    /**
     * db_handle::query() Sends queries to database.
     * 
     * @param string $query SQL query to send to SQL database.
     * @return resource 
     */
    function query ($query)
    { 
        // If there already is a link exit the function
        if (!$this->db_link) {
            $this->connect();
        } 
        // Get the $db['type'] value from config
        $db_type = get_config('db', 'type'); 
        // Determine handler
        if ($db_type == 'mysql') {
            // Close link to mysql database if mysql database is used
            $return = mysql_query ($query, $this->db_link);
        } else {
            // If database type is not mysql, trigger any external hooks
            $return = trigger_event ('db_handle:query:alternate', array($query, $this->db_link));
            if (is_null ($result)) {
                return error_add ('Config Error: Unknown database type', __FILE__, __LINE__, true);
            } 
        } 

        if (!$return) {
            $error_str = "Error performing SQL Query: <p><pre>$query</pre></p>";
            if (function_exists($db_type . '_error')) {
                $error_str .= "\n<p><pre>Error Message: " . call_user_func ("{$db_type}_error", $this->db_link) . "</pre></p>";
            } 
            return error_add ($error_str, __FILE__, __LINE__, true);
        } 
        return $return;
    } 

    /**
     * db_handle::fetch() Fetches data from the result associated with the specified result identifier.
     * Subsequent calls to dbfetch() would return the next row in the result set, or FALSE if there are no more rows.
     * Simulates *sql_result functions when LEMP_SCALAR is passed for $result_type
     * 
     * @param resource $result SQL result to use.
     * @param const $result_type (Default LEMP_ARRAY_BOTH) Takes the following values: LEMP_ASSOC, LEMP_NUM, LEMP_BOTH,
     * LEMP_SCALAR (simulates [database[_fetch]]_result), and LEMP_OBJECT
     * @return mixed return depends on $result_type
     */
    function fetch ($result, $result_type = 103)
    {
        static $row;

        $db = get_config('db'); 
        // Make sure that the result is valid
        if (is_bool($result) || empty($result)) {
            return error_add('Invalid Arguments: Supplied argument is not a valid result resource', __FILE__, __LINE__, true);
        } 
        // Determine if result is multi
        if ($result_type >= LEMP_MULTI_ARRAY && $result_type <= LEMP_MULTI_ARRAY_BOTH) {
            // If it is, set result type
            $multi_array = true;
            $result_type -= 10;
        } else {
            $multi_array = false;
        } 

        do {
            // Determine handler
            if ($db['type'] == 'mysql') {
                // Convert lemp result types to mysql
                $result_type = ($result_type == LEMP_ARRAY_ASSOC)? MYSQL_ASSOC :
                ($result_type == LEMP_ARRAY_NUM)? MYSQL_NUM :
                ($result_type == LEMP_ARRAY_BOTH)? MYSQL_BOTH : $result_type; 
                // Fetch from mysql database if mysql database is used
                if ($result_type == LEMP_OBJECT) {
                    $return = mysql_fetch_object ($result);
                } elseif ($result_type == LEMP_SCALAR) {
                    $return = mysql_fetch_array ($result, MYSQL_NUM);
                    if ($return !== false) {
                        $return = $return[0];
                    } 
                    $return = stripslashes ($return);
                } else {
                    $return = mysql_fetch_array ($result, $result_type);
                } 
            } else {
                // If database type is not mysql, trigger any external hooks
                $return = trigger_event ('db_handle:fetch:alternate', array($result, $row[$result], $result_type, $this->db_link));
                if (is_null ($return)) {
                    return error_add ('Config Error: Unknown database type', __FILE__, __LINE__, true);
                } 
            } 
            // Apply Strip Slashes to results
            if (is_array($return)) {
                $striped_return = array ();
                foreach ($return as $column => $value) { // TODO: Replace $column with table schema in UM_Dbdat
                    $striped_return[$column] = stripslashes($value);
                } 
                $return = $striped_return;
            } 

            if ($multi_array == true && $return !== false) {
                $multi_return[] = $return;
            } 

            $row[$result]++;
        } while ($return !== false && $multi_array == true);
        return ($multi_array == true)? $multi_return: $return;
    } 

    /**
     * db_handle::num_rows() Get number of rows in result.  This command is only valid for SELECT statements.
     * 
     * @param resource $result returns the number of rows in a result set or false on error
     * @return mixed 
     */
    function num_rows ($result)
    {
        $db = get_config('db');
        if ($db['type'] == 'mysql') {
            $return = mysql_num_rows($result);
        } else {
            $result = trigger_event ('db_handle:num_rows:alternate', array($result, $this->db_link));
            if (is_null ($result)) {
                return error_add ('Config Error: Unknown database type', __FILE__, __LINE__, true);
            } 
        } 

        if ($return === false) {
            error_add ('Error retrieving the number of rows in result set', __FILE__, __LINE__, true);
        } 
        return $return;
    } 

    /**
     * db_handle::query_fetch() Sends SQL query and fetches results.
     * 
     * @param mixed $query Either an sql select statement or array($select, $from, [$where], [$limit])
     * @param const $result_type See db_handle::fetch()
     * @param integer $start_row See db_handle::fetch()
     * @param string $field See db_handle::fetch()
     * @return See db_handle::fetch()
     */
    function query_fetch ($query, $result_type = 113)
    {
        if (($result_type > LEMP_MULTI_ARRAY_BOTH || $result_type < LEMP_ARRAY) && $result_type != LEMP_SCALAR) {
            return error_add ('dbquery_fetch only accepts: LEMP_MULTI_ARRAY*, LEMP_ARRAY*, or LEMP_SCALAR not ' . $query, __FILE__, __LINE__, true);
        } 

        if (is_array($query)) {
            $parts = $query;
            $query = "SELECT {$parts[0]} FROM {$parts[1]}";
            if (isset($parts[2])) {
                $query .= ' WHERE ' . $parts[2];
            } 
            if (isset($parts[3])) {
                $query .= ' LIMIT ' . $parts[3];
            } 
            $query .= ';';
        } 

        $result = $this->query ($query);
        return ($result !== false)? $this->fetch ($result, $result_type) : false;
    } 
} 

/**
 * Functions used in LEMP
 */

/**
 * error_add() Adds an error/warning/notice to LEMP's internal error handler.
 * 
 * You can retrieve all errors with error_get_all ().
 * 
 * @param mixed $error_name What just happened?
 * @param string $errfile In what file was error_add called? (Use __FILE__)
 * @param string $errline In what line was error_add called? (Use __LINE__)
 * @param bool $script_error Is this not a user error?
 * @param string $details Extended information
 * @return mixed 
 */
function error_add ($error_name, $errfile = '', $errline = 0, $script_error = false, $details = '')
{
    global $LEMP_error_log;
    if (empty ($error_name)) {
        return true;
    } 

    if ($script_error == false) {
        $script_error = ($errfile != '')? true : false;
    } 

    $can_write = false;
    if ($script_error && is_writable(LEMP_PATH_TO_LIBRARY . '/logs/error_log.txt')) {
        $can_write = true;
        $error_message = '';
    } 

    if (!is_array($error_name)) {
        $error_name = array($error_name);
    } 

    foreach ($error_name as $name) {
        if ($can_write) {
            if ($errfile == '') {
                $errfile = 'unknown';
            } 
            $error_message .= <<<EOL
<pre>
File: $errfile<br>
Line: $errline<br>
Message: "$name"<br>
Details: "$details"<br>
</pre>
EOL;
        } 
        $LEMP_error_log[] = array('name' => $name, 'file' => $errfile, 'line' => $errline, 'script_error' => $script_error, 'details' => $details);
    } 

    if ($can_write && $error_message != '') {
        $error_log = fopen (UM_LEMP_PATH_TO_LIBRARY . '/logs/error_log.txt' , 'a+');
        fwrite ($error_log, $error_message);
        fclose ($error_log);
    } 

    return false;
} 

/**
 * error_get_all() Retrieve all errors encountered by script.
 * 
 * @param const $return_as Return as LEMP_ARRAY, LEMP_STRING, LEMP_HTML or LEMP_INT (number of errors).
 * @return mixed 
 */
function error_get_all ($return_as = 14)
{
    global $LEMP_error_log;
    $config_config = get_config ('config');
    $config_errors = get_config ('errors');

    $count = count ($LEMP_error_log);
    if ($count == 0) {
        $error_string = 'NONE';
    } elseif ($return_as == LEMP_HTML || $return_as == LEMP_STRING || $return_as == LEMP_ERROR) {
        $error_string = '';
        foreach ($LEMP_error_log as $error_info) {
            if ($error_info['script_error'] && !$config_config['debug']) {
                continue;
            } 

            if ($config_config['debug'] && $error_info['script_error']) {
                $error_string .= ENDL . "File: {$error_info['file']}, line: {$error_info['line']}, message: \"{$error_info['name']}\", details: \"{$error_info['details']}\"\n";
            } else {
                $error_string .= ENDL . $error_info['name'];
            } 
        } 
        if ($error_string == '') {
            $error_string = 'NONE';
        } 
    } 

    if ($return_as == LEMP_STRING) {
        return $error_string;
    } elseif ($return_as == LEMP_HTML) {
        return nl2br($error_string);
    } elseif ($return_as == LEMP_INT) {
        return $count;
    } elseif ($return_as == LEMP_ARRAY_NUM || $return_as == LEMP_ARRAY) {
        return $LEMP_error_log;
    } elseif ($config_config['allow_terminate'] && $return_as == LEMP_ERROR) {
        exit (nl2br($error_string));
    } 
} 

/**
 * init_config() config database's constructor.  It load the initial config file
 * 
 * @access private 
 * @return void 
 */
function init_config ()
{
    if (LEMP_PATH_TO_CONFIG == '') {
        return error_add ('Could not find config.php', __FILE__, __LINE__, true);
    } 

    global $LEMP_config_vars;

    $config_vars['static'] = array ('db');
    $config_vars['extendible'] = array ('objects', 'config', 'extensions', 'tables', 'trigger', 'config_vars', 'static', 'extendible');

    require_once (LEMP_PATH_TO_CONFIG);

    if ($db['type'] != 'mysql') {
        require (LEMP_PATH_TO_LIBRARY . "/db/{$db['type']}_handler.php");
    } 

    $LEMP_config_vars = compact ($config_vars['static'], $config_vars['extendible']);
    if (isset ($LEMP_config_vars['extensions']['config'])) {
        add_config ($LEMP_config_vars['extensions']['config']);
        unset ($LEMP_config_vars['extensions']['config']);
    } 
} 

/**
 * Fetches data from a config file.
 * ie get_config ('tables', 'table_name', 'column')
 * * Using get_config to retrieve table information is discouraged, used get_table_columns instead.
 * @return mixed 
 */
function get_config ()
{
    $num_args = func_num_args (); 
    // if (($num_args == 3 || $num_args == 2) && func_get_arg(0) == 'tables') {
    // return get_table_cols (func_get_arg(1), @func _get_arg(2));
    // }
    global $LEMP_config_vars;
    if (empty ($LEMP_config_vars)) {
        init_config ();
    } 
    if ($num_args > 0) {
        if ($num_args > 1) {
            $current_location = $LEMP_config_vars[func_get_arg(0)][func_get_arg(1)];
            for($i = 2; $i < $num_args; $i++) {
                $current_location = $current_location[func_get_arg($i)];
            } 
        } else {
            $current_location = $LEMP_config_vars[func_get_arg(0)];
        } 
        return $current_location;
    } else {
        return $LEMP_config_vars;
    } 
} 

/**
 * Fetches table data from the config database.
 * 
 * @param string $table_name The table name.
 * @param string $columns The column names to fetch.  If left empty, all column names are returned.
 * @return mixed 
 */
function get_table_columns ($table_name, $columns = array ())
{
    global $LEMP_config_vars;
    if (empty ($LEMP_config_vars)) {
        init_config ();
    } 
    if (is_array ($LEMP_config_vars['tables'][$table_name])) {
        foreach ($LEMP_config_vars['tables'][$table_name] as $key => $column) {
            if (is_int($key) || empty ($column)) {
                if (empty ($column) && $key{0} == '_') {
                    $LEMP_config_vars['tables'][$table_name][$column] = substr($key, 1);
                } else {
                    $LEMP_config_vars['tables'][$table_name][$column] = $column;
                } 
                if (is_int($key)) {
                    unset ($LEMP_config_vars['tables'][$table_name][$key]);
                } 
            } 
        } 
    } 
    if (!empty ($columns)) {
        if (is_string($columns)) {
            if (empty ($LEMP_config_vars['tables'][$table_name][$columns]) && $columns{0} != '_') {
                return $columns;
            } 
            return $LEMP_config_vars['tables'][$table_name][$column];
        } else {
            foreach ($columns as $column) {
                $table[$column] = $LEMP_config_vars['tables'][$table_name][$column];
            } 
            return $table;
        } 
    } else {
        return $LEMP_config_vars['tables'][$table_name];
    } 
} 
/**
 * Adds a config file (no config files are not changed).
 * 
 * @param mixed $config_files Array (or string) of config file(s)'s location
 * @return void 
 */
function add_config ($config_files)
{
    global $LEMP_config_vars;
    static $included_config_exts = array ();

    if (empty ($LEMP_config_vars)) {
        init_config ();
    } 

    if (is_string ($config_files) && (!in_array($config_files, $included_config_exts))) {
        $config_files = array ($config_files);
    } elseif (is_array ($config_files)) {
        $config_files = array_diff ($config_files, $included_config_exts);
    } else {
        return;
    } 

    if (empty($config_files)) {
        return;
    } 
    // Make sure that variables like $db are availabe within the scope.
    if (is_array($LEMP_config_vars['config_vars']['static'])) {
        foreach ($LEMP_config_vars['config_vars']['static'] as $static_var) {
            $$static_var = $LEMP_config_vars[$static_var];
        } 
    } 
    // Include any config extensions
    while (count ($config_files) > 0) {
        foreach ($config_files as $config_key => $config_ext) {
            if (file_exists($config_ext)) {
                include_once ($config_ext);
            } elseif (file_exists(LEMP_PATH_TO_LIBRARY . '/' . $config_ext)) {
                include_once (LEMP_PATH_TO_LIBRARY . '/' . $config_ext);
            } 
            $included_config_exts[] = $config_ext;
            unset ($config_files[$config_key]);

            if (isset ($extensions['config'])) {
                if (is_string ($extensions['config']) && !in_array($extensions['config'], $included_config_exts)) {
                    $config_files[] = $extensions['config'];
                } else {
                    $extensions['config'] = array_diff ($extensions['config'], $included_config_exts, $config_files);
                    $config_files = array_merge ($extensions['config'], $config_files);
                } 
                unset ($extensions['config']);
            } 
        } 
    } 

    if (isset($config_vars['static'])) {
        $LEMP_config_vars['config_vars']['static'] = array_merge ($LEMP_config_vars['config_vars']['static'], $config_vars['static']);
        array_unique ($LEMP_config_vars['config_vars']['static']);
        unset ($config_vars['static']);
    } 

    if (isset($config_vars['extendible'])) {
        $LEMP_config_vars['config_vars']['extendible'] = array_merge ($LEMP_config_vars['config_vars']['extendible'], $config_vars['extendible']);
        array_unique ($LEMP_config_vars['config_vars']['static']);
        unset ($config_vars['extendible']);
    } 

    $LEMP_config_vars = array_merge_recursive ($LEMP_config_vars, compact ($LEMP_config_vars['config_vars']['extendible']));
    return;
} 

/**
 * create_obj() Creates or returns a LEMP object.
 * 
 * @param mixed $object Object schema or module name.
 * @param array $args This is sent to the object's constructor, this is merged with
 * the args set in the object schema.
 * @return object 
 */
function &create_obj ($object = 'default', $args = array ())
{
    static $objects = array();
    static $auto_name = array ();

    if (empty ($object)) {
        return add_error ('Object name must be specified for create_obj', __FILE__, __LINE__);
    } 

    if (is_string ($object)) {
        if ($object == 'default') {
            $object = get_config ('objects', 'default');

            if (empty ($object)) {
                $object == 'LEMP';
            } 
        } 
        if ($object == 'db_handle' || $object == 'LEMP' || $object == 'lemp') {
            $objects[$object] = new $object;
            return $objects[$object];
        } else {
            $object_name = $object;
            $object = get_config ('objects', $object);
            $object['name'] = $object_name;
            $object['class'] = $object_name;
        } 
    } 

    if ($object['name'] != '' && isset($objects[$object['name']])) {
        return $objects[$object['name']];
    } 

    if ($object['name'] == '') {
        $object['name'] = 'Nameless object instance #' . ++$auto_name['nameless'];
    } elseif ($object['mode'] == 'multi') {
        $object['name'] = "{$object['name']} object instance #" . ++$auto_name[$object['name']];
    } 

    if (!empty ($object['file']) && $object['file'] != 'lemp.php') {
        load_module ($object['name']);
    } 

    if (empty ($object['class'])) {
        if (!empty($object['file']) && !empty($object['name'])) {
            list ($name) = explode ('.', $object['file']);

            if ($name == $object['name']) {
                $object['class'] = $object['name'];
            } 
        } 
    } 

    if (!class_exists($object['class'])) {
        return error_add ("Class ({$object['name']}) does not exist", __FILE__, __LINE__);
    } 

    if (isset ($object['args'])) {
        $args = array_merge($args, $object['args']);
    } 

    $objects[$object['name']] = new $object['class'] ($args); 
    // $objects[$object['name']] = (!empty($object['args']))? new $object['class'] ($object['args']) : new $object['class'];
    return $objects[$object['name']];
} 

/**
 * load_module() Loads a module.
 * 
 * @access private 
 * @param string $object_name 
 * @return bool Successful | Not Successful
 */
function load_module ($module_name = '')
{
    static $loaded = array ('lemp', 'LEMP');

    if (empty ($module_name) || !is_string ($module_name)) {
        return error_add("Invalid parameter for load_module ($module_name)", __FILE__, __LINE__);
    } elseif (in_array ($module_name, $loaded)) {
        return true; // Should give out a notice that module is already loaded.
    } 
    // NOTE: $object is short for object schema and is not an actual object
    $object = (is_array($module_name))? $module_name : get_config ('objects', $module_name);

    if (!is_array($object)) {
        return error_add("Can not find module schematics for load_module ($module_name)", __FILE__, __LINE__);
    } 

    if (!empty($object['parent']) && is_array ($object['parent'])) {
        $object_parents = array_diff($object['parent'], $loaded);
        foreach ($object_parents as $object_parent) {
            load_module ($object_parent);
        } 
    } 

    if (file_exists (LEMP_PATH_TO_LIBRARY . '/' . $object['file'])) {
        $include_path = LEMP_PATH_TO_LIBRARY . '/' . $object['file'];
    } elseif (file_exists ($object['file'])) {
        $include_path = $object['file'];
    } else {
        return error_add ("Could not locate class file {$object['file']} of module $module_name)", __FILE__, __LINE__);
    } 

    include_once ($include_path);
    $loaded[] = $module_name;

    return true;
} 

/**
 * trigger_event() Calls hooks, and passes some information.
 * 
 * Examples assume that you are using the user manage module.
 * 
 * ex 1) If you want to add a row to a table when a user logs in, you
 * would first create an entry $trigger['hooks']['login'] = 'mymodulename_login' in the
 * config, then create a function called mymodulename_login. LEMP calls
 * trigger_event('login') whenever a user logs in. $trigger['hooks']['login'] could also
 * be an array.
 * 
 * ex 2) If you want to add a row to a table when a user logs in, or joins, you
 * would first create an entry $trigger['prefixes'][] = 'mymodulename_login' in the
 * config, then create the functions called mymodulename_login, mymodulename_create_user.
 * LEMP calls trigger_event('login') whenever a user logs in and
 * trigger_event('create_user') when a user joins.
 * 
 * You will have to look at LEMP's sourcecode to find when events are triggered (pre or
 * post events).
 * 
 * @param string $event What just happened?
 * @param array $args This is passed to the hooks
 * @param bool $limit Set to 1 if you only want one event to be called
 * @return mixed If limit is set to false, trigger_event will return an array containing the return of all the events called.
 * If limit is set to true, trigger_event will call one only event, and return with the event's return.
 */
function trigger_event ($event, $args = array(), $limit = false)
{
    static $trigger = '';

    if ($trigger == '') {
        $trigger = get_config ('trigger');
    } 

    if (empty ($trigger) || (empty ($trigger[$event]['hooks']) && empty ($trigger[$event]['include']))) {
        return;
    } 

    if (is_array($trigger[$event]['include'])) {
        foreach ($trigger[$event]['include'] as $include) {
            if (file_exists($include)) {
                include_once ($include);
            } elseif (file_exists(LEMP_PATH_TO_LIBRARY . "/$include")) {
                include_once (LEMP_PATH_TO_LIBRARY . "/$include");
            } 
        } 
    } 

    if ($limit) {
        if (is_string($trigger[$event]['hooks']) && function_exists ($trigger[$event]['hooks'])) {
            return call_user_func ($trigger[$event]['hooks'], $args);
        } elseif (is_array($trigger[$event]['hooks']) && function_exists ($trigger[$event]['hooks'][0])) {
            return call_user_func ($trigger[$event]['hooks'][0], $args);
        } 
    } else {
        $return = array();
        if (is_array($trigger[$event]['hooks'])) {
            foreach ($trigger[$event]['hooks'] as $hook) {
                if (function_exists ($hook)) {
                    $return[] = call_user_func ($hook, $args);
                } 
            } 
        } 
        return $return;
    } 
} 

?>
Return current item: Usermanage