elgglib.php

Go to the documentation of this file.

<?php
function elgg_register_library($name, $location) {
    global $CONFIG;

    if (!isset($CONFIG->libraries)) {
        $CONFIG->libraries = array();
    }

    $CONFIG->libraries[$name] = $location;
}

function elgg_load_library($name) {
    global $CONFIG;

    static $loaded_libraries = array();

    if (in_array($name, $loaded_libraries)) {
        return;
    }

    if (!isset($CONFIG->libraries)) {
        $CONFIG->libraries = array();
    }

    if (!isset($CONFIG->libraries[$name])) {
        $error = $name . " is not a registered library";
        throw new InvalidParameterException($error);
    }

    if (!include_once($CONFIG->libraries[$name])) {
        $error = "Could not load the " . $name . " library from " . $CONFIG->libraries[$name];
        throw new InvalidParameterException($error);
    }

    $loaded_libraries[] = $name;
}

function forward($location = "", $reason = 'system') {
    if (!headers_sent($file, $line)) {
        if ($location === REFERER) {
            $location = _elgg_services()->request->headers->get('Referer');
        }

        $location = elgg_normalize_url($location);

        // return new forward location or false to stop the forward or empty string to exit
        $current_page = current_page_url();
        $params = array('current_url' => $current_page, 'forward_url' => $location);
        $location = elgg_trigger_plugin_hook('forward', $reason, $params, $location);

        if ($location) {
            header("Location: {$location}");
            exit;
        } else if ($location === '') {
            exit;
        }
    } else {
        throw new SecurityException("Redirect could not be issued due to headers already being sent. Halting execution for security. "
            . "Output started in file $file at line $line. Search http://learn.elgg.org/ for more information.");
    }
}

function elgg_register_js($name, $url, $location = 'head', $priority = null) {
    return elgg_register_external_file('js', $name, $url, $location, $priority);
}

function elgg_define_js($name, $config) {
    $src = elgg_extract('src', $config);

    if ($src) {
        $url = elgg_normalize_url($src);
        _elgg_services()->amdConfig->addPath($name, $url);
    }

    // shimmed module
    if (isset($config['deps']) || isset($config['exports'])) {
        _elgg_services()->amdConfig->addShim($name, $config);
    }
}

function elgg_unregister_js($name) {
    return elgg_unregister_external_file('js', $name);
}

function elgg_load_js($name) {
    elgg_load_external_file('js', $name);
}


function elgg_require_js($name) {
    _elgg_services()->amdConfig->addDependency($name);
}


function elgg_get_loaded_js($location = 'head') {
    return elgg_get_loaded_external_files('js', $location);
}

function elgg_register_css($name, $url, $priority = null) {
    return elgg_register_external_file('css', $name, $url, 'head', $priority);
}

function elgg_unregister_css($name) {
    return elgg_unregister_external_file('css', $name);
}

function elgg_load_css($name) {
    elgg_load_external_file('css', $name);
}

function elgg_get_loaded_css() {
    return elgg_get_loaded_external_files('css', 'head');
}

function elgg_register_external_file($type, $name, $url, $location, $priority = 500) {
    global $CONFIG;

    if (empty($name) || empty($url)) {
        return false;
    }

    $url = elgg_format_url($url);
    $url = elgg_normalize_url($url);

    _elgg_bootstrap_externals_data_structure($type);

    $name = trim(strtolower($name));

    // normalize bogus priorities, but allow empty, null, and false to be defaults.
    if (!is_numeric($priority)) {
        $priority = 500;
    }

    // no negative priorities right now.
    $priority = max((int)$priority, 0);

    $item = elgg_extract($name, $CONFIG->externals_map[$type]);

    if ($item) {
        // updating a registered item
        // don't update loaded because it could already be set
        $item->url = $url;
        $item->location = $location;

        // if loaded before registered, that means it hasn't been added to the list yet
        if ($CONFIG->externals[$type]->contains($item)) {
            $priority = $CONFIG->externals[$type]->move($item, $priority);
        } else {
            $priority = $CONFIG->externals[$type]->add($item, $priority);
        }
    } else {
        $item = new stdClass();
        $item->loaded = false;
        $item->url = $url;
        $item->location = $location;

        $priority = $CONFIG->externals[$type]->add($item, $priority);
    }

    $CONFIG->externals_map[$type][$name] = $item;

    return $priority !== false;
}

function elgg_unregister_external_file($type, $name) {
    global $CONFIG;

    _elgg_bootstrap_externals_data_structure($type);

    $name = trim(strtolower($name));
    $item = elgg_extract($name, $CONFIG->externals_map[$type]);

    if ($item) {
        unset($CONFIG->externals_map[$type][$name]);
        return $CONFIG->externals[$type]->remove($item);
    }

    return false;
}

function elgg_load_external_file($type, $name) {
    global $CONFIG;

    _elgg_bootstrap_externals_data_structure($type);

    $name = trim(strtolower($name));

    $item = elgg_extract($name, $CONFIG->externals_map[$type]);

    if ($item) {
        // update a registered item
        $item->loaded = true;
    } else {
        $item = new stdClass();
        $item->loaded = true;
        $item->url = '';
        $item->location = '';

        $CONFIG->externals[$type]->add($item);
        $CONFIG->externals_map[$type][$name] = $item;
    }
}

function elgg_get_loaded_external_files($type, $location) {
    global $CONFIG;

    if (isset($CONFIG->externals) && $CONFIG->externals[$type] instanceof ElggPriorityList) {
        $items = $CONFIG->externals[$type]->getElements();

        $callback = "return \$v->loaded == true && \$v->location == '$location';";
        $items = array_filter($items, create_function('$v', $callback));
        if ($items) {
            array_walk($items, create_function('&$v,$k', '$v = $v->url;'));
        }
        return $items;
    }
    return array();
}

function _elgg_bootstrap_externals_data_structure($type) {
    global $CONFIG;

    if (!isset($CONFIG->externals)) {
        $CONFIG->externals = array();
    }

    if (!isset($CONFIG->externals[$type]) || !$CONFIG->externals[$type] instanceof ElggPriorityList) {
        $CONFIG->externals[$type] = new ElggPriorityList();
    }

    if (!isset($CONFIG->externals_map)) {
        $CONFIG->externals_map = array();
    }

    if (!isset($CONFIG->externals_map[$type])) {
        $CONFIG->externals_map[$type] = array();
    }
}

function elgg_get_file_list($directory, $exceptions = array(), $list = array(),
$extensions = null) {

    $directory = sanitise_filepath($directory);
    if ($handle = opendir($directory)) {
        while (($file = readdir($handle)) !== false) {
            if (!is_file($directory . $file) || in_array($file, $exceptions)) {
                continue;
            }

            if (is_array($extensions)) {
                if (in_array(strrchr($file, '.'), $extensions)) {
                    $list[] = $directory . $file;
                }
            } else {
                $list[] = $directory . $file;
            }
        }
        closedir($handle);
    }

    return $list;
}

function sanitise_filepath($path, $append_slash = true) {
    // Convert to correct UNIX paths
    $path = str_replace('\\', '/', $path);
    $path = str_replace('../', '/', $path);
    // replace // with / except when preceeded by :
    $path = preg_replace("/([^:])\/\//", "$1/", $path);

    // Sort trailing slash
    $path = trim($path);
    // rtrim defaults plus /
    $path = rtrim($path, " \n\t\0\x0B/");

    if ($append_slash) {
        $path = $path . '/';
    }

    return $path;
}

function system_messages($message = null, $register = "success", $count = false) {
    $session = _elgg_services()->session;
    $messages = $session->get('msg', array());
    if (!isset($messages[$register]) && !empty($register)) {
        $messages[$register] = array();
    }
    if (!$count) {
        if (!empty($message) && is_array($message)) {
            $messages[$register] = array_merge($messages[$register], $message);
            return true;
        } else if (!empty($message) && is_string($message)) {
            $messages[$register][] = $message;
            $session->set('msg', $messages);
            return true;
        } else if (is_null($message)) {
            if ($register != "") {
                $returnarray = array();
                $returnarray[$register] = $messages[$register];
                $messages[$register] = array();
            } else {
                $returnarray = $messages;
                $messages = array();
            }
            $session->set('msg', $messages);
            return $returnarray;
        }
    } else {
        if (!empty($register)) {
            return sizeof($messages[$register]);
        } else {
            $count = 0;
            foreach ($messages as $submessages) {
                $count += sizeof($submessages);
            }
            return $count;
        }
    }
    return false;
}

function count_messages($register = "") {
    return system_messages(null, $register, true);
}

function system_message($message) {
    return system_messages($message, "success");
}

function register_error($error) {
    return system_messages($error, "error");
}

function elgg_register_event_handler($event, $object_type, $callback, $priority = 500) {
    return _elgg_services()->events->registerHandler($event, $object_type, $callback, $priority);
}

function elgg_unregister_event_handler($event, $object_type, $callback) {
    return _elgg_services()->events->unregisterHandler($event, $object_type, $callback);
}

function elgg_trigger_event($event, $object_type, $object = null) {
    return _elgg_services()->events->trigger($event, $object_type, $object);
}

function elgg_trigger_before_event($event, $object_type, $object = null) {
    return _elgg_services()->events->trigger("$event:before", $object_type, $object);
}

function elgg_trigger_after_event($event, $object_type, $object = null) {
    $options = array(
        Elgg_EventsService::OPTION_STOPPABLE => false,
    );
    return _elgg_services()->events->trigger("$event:after", $object_type, $object, $options);
}

function elgg_trigger_deprecated_event($event, $object_type, $object = null, $message, $version) {
    $options = array(
        Elgg_EventsService::OPTION_DEPRECATION_MESSAGE => $message,
        Elgg_EventsService::OPTION_DEPRECATION_VERSION => $version,
    );
    return _elgg_services()->events->trigger($event, $object_type, $object, $options);
}

function elgg_register_plugin_hook_handler($hook, $type, $callback, $priority = 500) {
    return _elgg_services()->hooks->registerHandler($hook, $type, $callback, $priority);
}

function elgg_unregister_plugin_hook_handler($hook, $entity_type, $callback) {
    _elgg_services()->hooks->unregisterHandler($hook, $entity_type, $callback);
}

function elgg_trigger_plugin_hook($hook, $type, $params = null, $returnvalue = null) {
    return _elgg_services()->hooks->trigger($hook, $type, $params, $returnvalue);
}

function _elgg_php_exception_handler($exception) {
    $timestamp = time();
    error_log("Exception #$timestamp: $exception");

    // Wipe any existing output buffer
    ob_end_clean();

    // make sure the error isn't cached
    header("Cache-Control: no-cache, must-revalidate", true);
    header('Expires: Fri, 05 Feb 1982 00:00:00 -0500', true);
    // @note Do not send a 500 header because it is not a server error

    // we don't want the 'pagesetup', 'system' event to fire
    global $CONFIG;
    $CONFIG->pagesetupdone = true;

    try {
        // allow custom scripts to trigger on exception
        // $CONFIG->exception_include can be set locally in settings.php
        // value should be a system path to a file to include
        if (!empty($CONFIG->exception_include) && is_file($CONFIG->exception_include)) {
            ob_start();
            include $CONFIG->exception_include;
            $exception_output = ob_get_clean();

            // if content is returned from the custom handler we will output
            // that instead of our default failsafe view
            if (!empty($exception_output)) {
                echo $exception_output;
                exit;
            }
        }

        elgg_set_viewtype('failsafe');

        if (elgg_is_admin_logged_in()) {
            if (!elgg_view_exists("messages/exceptions/admin_exception")) {
                elgg_set_viewtype('failsafe');
            }

            $body = elgg_view("messages/exceptions/admin_exception", array(
                'object' => $exception,
                'ts' => $timestamp
            ));
        } else {
            if (!elgg_view_exists("messages/exceptions/exception")) {
                elgg_set_viewtype('failsafe');
            }

            $body = elgg_view("messages/exceptions/exception", array(
                'object' => $exception,
                'ts' => $timestamp
            ));
        }
        echo elgg_view_page(elgg_echo('exception:title'), $body);
    } catch (Exception $e) {
        $timestamp = time();
        $message = $e->getMessage();
        echo "Fatal error in exception handler. Check log for Exception #$timestamp";
        error_log("Exception #$timestamp : fatal error in exception handler : $message");
    }
}

function _elgg_php_error_handler($errno, $errmsg, $filename, $linenum, $vars) {
    $error = date("Y-m-d H:i:s (T)") . ": \"$errmsg\" in file $filename (line $linenum)";

    switch ($errno) {
        case E_USER_ERROR:
            error_log("PHP ERROR: $error");
            register_error("ERROR: $error");

            // Since this is a fatal error, we want to stop any further execution but do so gracefully.
            throw new Exception($error);
            break;

        case E_WARNING :
        case E_USER_WARNING :
        case E_RECOVERABLE_ERROR: // (e.g. type hint violation)

            // check if the error wasn't suppressed by the error control operator (@)
            if (error_reporting()) {
                error_log("PHP WARNING: $error");
            }
            break;

        default:
            global $CONFIG;
            if (isset($CONFIG->debug) && $CONFIG->debug === 'NOTICE') {
                error_log("PHP NOTICE: $error");
            }
    }

    return true;
}


function elgg_log($message, $level = 'NOTICE') {
    static $levels = array(
        'INFO' => 200,
        'NOTICE' => 250,
        'WARNING' => 300,
        'DEBUG' => 300,
        'ERROR' => 400,
    );

    if ($level == 'DEBUG') {
        elgg_deprecated_notice("The 'DEBUG' level for logging has been deprecated.", 1.9);
    }

    $level = $levels[$level];
    return _elgg_services()->logger->log($message, $level);
}

function elgg_dump($value, $to_screen = true) {
    _elgg_services()->logger->dump($value, $to_screen);
}

function elgg_get_version($human_readable = false) {
    global $CONFIG;

    static $version, $release;

    if (isset($CONFIG->path)) {
        if (!isset($version) || !isset($release)) {
            if (!include($CONFIG->path . "version.php")) {
                return false;
            }
        }
        return $human_readable ? $release : $version;
    }

    return false;
}

function elgg_deprecated_notice($msg, $dep_version, $backtrace_level = 1) {
    // if it's a major release behind, visual and logged
    // if it's a 1 minor release behind, visual and logged
    // if it's for current minor release, logged.
    // bugfixes don't matter because we are not deprecating between them

    if (!$dep_version) {
        return false;
    }

    $elgg_version = elgg_get_version(true);
    $elgg_version_arr = explode('.', $elgg_version);
    $elgg_major_version = (int)$elgg_version_arr[0];
    $elgg_minor_version = (int)$elgg_version_arr[1];

    $dep_major_version = (int)$dep_version;
    $dep_minor_version = 10 * ($dep_version - $dep_major_version);

    $visual = false;

    if (($dep_major_version < $elgg_major_version) ||
        ($dep_minor_version < $elgg_minor_version)) {
        $visual = true;
    }

    $msg = "Deprecated in $dep_major_version.$dep_minor_version: $msg";

    if ($visual && elgg_is_admin_logged_in()) {
        register_error($msg);
    }

    // Get a file and line number for the log. Never show this in the UI.
    // Skip over the function that sent this notice and see who called the deprecated
    // function itself.
    $msg .= " Called from ";
    $stack = array();
    $backtrace = debug_backtrace();
    // never show this call.
    array_shift($backtrace);
    $i = count($backtrace);

    foreach ($backtrace as $trace) {
        $stack[] = "[#$i] {$trace['file']}:{$trace['line']}";
        $i--;

        if ($backtrace_level > 0) {
            if ($backtrace_level <= 1) {
                break;
            }
            $backtrace_level--;
        }
    }

    $msg .= implode("<br /> -> ", $stack);

    elgg_log($msg, 'WARNING');

    return true;
}

function elgg_http_build_url(array $parts, $html_encode = true) {
    // build only what's given to us.
    $scheme = isset($parts['scheme']) ? "{$parts['scheme']}://" : '';
    $host = isset($parts['host']) ? "{$parts['host']}" : '';
    $port = isset($parts['port']) ? ":{$parts['port']}" : '';
    $path = isset($parts['path']) ? "{$parts['path']}" : '';
    $query = isset($parts['query']) ? "?{$parts['query']}" : '';
    $fragment = isset($parts['fragment']) ? "#{$parts['fragment']}" : '';

    $string = $scheme . $host . $port . $path . $query . $fragment;

    if ($html_encode) {
        return elgg_format_url($string);
    } else {
        return $string;
    }
}

function elgg_add_action_tokens_to_url($url, $html_encode = false) {
    $url = elgg_normalize_url($url);
    $components = parse_url($url);

    if (isset($components['query'])) {
        $query = elgg_parse_str($components['query']);
    } else {
        $query = array();
    }

    if (isset($query['__elgg_ts']) && isset($query['__elgg_token'])) {
        return $url;
    }

    // append action tokens to the existing query
    $query['__elgg_ts'] = time();
    $query['__elgg_token'] = generate_action_token($query['__elgg_ts']);
    $components['query'] = http_build_query($query);

    // rebuild the full url
    return elgg_http_build_url($components, $html_encode);
}

function elgg_http_remove_url_query_element($url, $element) {
    return elgg_http_add_url_query_elements($url, array($element => null));
}

function elgg_http_add_url_query_elements($url, array $elements) {
    $url_array = parse_url($url);

    if (isset($url_array['query'])) {
        $query = elgg_parse_str($url_array['query']);
    } else {
        $query = array();
    }

    foreach ($elements as $k => $v) {
        if ($v === null) {
            unset($query[$k]);
        } else {
            $query[$k] = $v;
        }
    }

    // why check path? A: if no path, this may be a relative URL like "?foo=1". In this case,
    // the output "" would be interpreted the current URL, so in this case we *must* set
    // a query to make sure elements are removed.
    if ($query || empty($url_array['path'])) {
        $url_array['query'] = http_build_query($query);
    } else {
        unset($url_array['query']);
    }
    $string = elgg_http_build_url($url_array, false);

    return $string;
}

function elgg_http_url_is_identical($url1, $url2, $ignore_params = array('offset', 'limit')) {
    $url1 = elgg_normalize_url($url1);
    $url2 = elgg_normalize_url($url2);

    // @todo - should probably do something with relative URLs

    if ($url1 == $url2) {
        return true;
    }

    $url1_info = parse_url($url1);
    $url2_info = parse_url($url2);

    if (isset($url1_info['path'])) {
        $url1_info['path'] = trim($url1_info['path'], '/');
    }
    if (isset($url2_info['path'])) {
        $url2_info['path'] = trim($url2_info['path'], '/');
    }

    // compare basic bits
    $parts = array('scheme', 'host', 'path');

    foreach ($parts as $part) {
        if ((isset($url1_info[$part]) && isset($url2_info[$part]))
        && $url1_info[$part] != $url2_info[$part]) {
            return false;
        } elseif (isset($url1_info[$part]) && !isset($url2_info[$part])) {
            return false;
        } elseif (!isset($url1_info[$part]) && isset($url2_info[$part])) {
            return false;
        }
    }

    // quick compare of get params
    if (isset($url1_info['query']) && isset($url2_info['query'])
    && $url1_info['query'] == $url2_info['query']) {
        return true;
    }

    // compare get params that might be out of order
    $url1_params = array();
    $url2_params = array();

    if (isset($url1_info['query'])) {
        if ($url1_info['query'] = html_entity_decode($url1_info['query'])) {
            $url1_params = elgg_parse_str($url1_info['query']);
        }
    }

    if (isset($url2_info['query'])) {
        if ($url2_info['query'] = html_entity_decode($url2_info['query'])) {
            $url2_params = elgg_parse_str($url2_info['query']);
        }
    }

    // drop ignored params
    foreach ($ignore_params as $param) {
        if (isset($url1_params[$param])) {
            unset($url1_params[$param]);
        }
        if (isset($url2_params[$param])) {
            unset($url2_params[$param]);
        }
    }

    // array_diff_assoc only returns the items in arr1 that aren't in arrN
    // but not the items that ARE in arrN but NOT in arr1
    // if arr1 is an empty array, this function will return 0 no matter what.
    // since we only care if they're different and not how different,
    // add the results together to get a non-zero (ie, different) result
    $diff_count = count(array_diff_assoc($url1_params, $url2_params));
    $diff_count += count(array_diff_assoc($url2_params, $url1_params));
    if ($diff_count > 0) {
        return false;
    }

    return true;
}

function elgg_extract($key, array $array, $default = null, $strict = true) {
    if (!is_array($array)) {
        return $default;
    }

    if ($strict) {
        return (isset($array[$key])) ? $array[$key] : $default;
    } else {
        return (isset($array[$key]) && !empty($array[$key])) ? $array[$key] : $default;
    }
}

function elgg_sort_3d_array_by_value(&$array, $element, $sort_order = SORT_ASC,
$sort_type = SORT_LOCALE_STRING) {

    $sort = array();

    foreach ($array as $v) {
        if (isset($v[$element])) {
            $sort[] = strtolower($v[$element]);
        } else {
            $sort[] = null;
        }
    };

    return array_multisort($sort, $sort_order, $sort_type, $array);
}

function ini_get_bool($ini_get_arg) {
    $temp = strtolower(ini_get($ini_get_arg));

    if ($temp == '1' || $temp == 'on' || $temp == 'true') {
        return true;
    }
    return false;
}

function elgg_get_ini_setting_in_bytes($setting) {
    // retrieve INI setting
    $val = ini_get($setting);

    // convert INI setting when shorthand notation is used
    $last = strtolower($val[strlen($val) - 1]);
    switch($last) {
        case 'g':
            $val *= 1024;
            // fallthrough intentional
        case 'm':
            $val *= 1024;
            // fallthrough intentional
        case 'k':
            $val *= 1024;
    }

    // return byte value
    return $val;
}

function is_not_null($string) {
    if (($string === '') || ($string === false) || ($string === null)) {
        return false;
    }

    return true;
}

function _elgg_normalize_plural_options_array($options, $singulars) {
    foreach ($singulars as $singular) {
        $plural = $singular . 's';

        if (array_key_exists($singular, $options)) {
            if ($options[$singular] === ELGG_ENTITIES_ANY_VALUE) {
                $options[$plural] = $options[$singular];
            } else {
                // Test for array refs #2641
                if (!is_array($options[$singular])) {
                    $options[$plural] = array($options[$singular]);
                } else {
                    $options[$plural] = $options[$singular];
                }
            }
        }

        unset($options[$singular]);
    }

    return $options;
}

function _elgg_shutdown_hook() {
    global $START_MICROTIME;

    try {
        elgg_trigger_event('shutdown', 'system');

        $time = (float)(microtime(true) - $START_MICROTIME);
        $uri = _elgg_services()->request->server->get('REQUEST_URI', 'CLI');
        // demoted to NOTICE from DEBUG so javascript is not corrupted
        elgg_log("Page {$uri} generated in $time seconds", 'INFO');
    } catch (Exception $e) {
        $message = 'Error: ' . get_class($e) . ' thrown within the shutdown handler. ';
        $message .= "Message: '{$e->getMessage()}' in file {$e->getFile()} (line {$e->getLine()})";
        error_log($message);
        error_log("Exception trace stack: {$e->getTraceAsString()}");
    }

    // Prevent an APC session bug: https://bugs.php.net/bug.php?id=60657
    session_write_close();
}

function _elgg_js_page_handler($page) {
    return _elgg_cacheable_view_page_handler($page, 'js');
}

function _elgg_ajax_page_handler($page) {
    if (is_array($page) && sizeof($page)) {
        // throw away 'view' and form the view name
        unset($page[0]);
        $view = implode('/', $page);

        $allowed_views = elgg_get_config('allowed_ajax_views');
        if (!array_key_exists($view, $allowed_views)) {
            header('HTTP/1.1 403 Forbidden');
            exit;
        }

        // pull out GET parameters through filter
        $vars = array();
        foreach (_elgg_services()->request->query->keys() as $name) {
            $vars[$name] = get_input($name);
        }

        if (isset($vars['guid'])) {
            $vars['entity'] = get_entity($vars['guid']);
        }

        // Try to guess the mime-type
        switch ($page[1]) {
            case "js":
                header("Content-Type: text/javascript");
                break;
            case "css":
                header("Content-Type: text/css");
                break;
        }

        echo elgg_view($view, $vars);
        return true;
    }
    return false;
}

function _elgg_css_page_handler($page) {
    if (!isset($page[0])) {
        // default css
        $page[0] = 'elgg';
    }

    return _elgg_cacheable_view_page_handler($page, 'css');
}

function _elgg_cacheable_view_page_handler($page, $type) {

    switch ($type) {
        case 'js':
            $content_type = 'text/javascript';
            break;

        case 'css':
            $content_type = 'text/css';
            break;

        default:
            return false;
            break;
    }

    if ($page) {
        // the view file names can have multiple dots
        // eg: views/default/js/calendars/jquery.fullcalendar.min.php
        // translates to the url /js/<ts>/calendars/jquery.fullcalendar.min.js
        // and the view js/calendars/jquery.fullcalendar.min
        // we ignore the last two dots for the ts and the ext.
        // Additionally, the timestamp is optional.
        $page = implode('/', $page);
        $regex = '|(.+?)\.\w+$|';
        if (!preg_match($regex, $page, $matches)) {
            return false;
        }
        $view = "$type/{$matches[1]}";
        if (!elgg_view_exists($view)) {
            return false;
        }
        $return = elgg_view($view);

        header("Content-type: $content_type");

        // @todo should js be cached when simple cache turned off
        //header('Expires: ' . gmdate('D, d M Y H:i:s \G\M\T', strtotime("+10 days")), true);
        //header("Pragma: public");
        //header("Cache-Control: public");
        //header("Content-Length: " . strlen($return));

        echo $return;
        return true;
    }
    return false;
}

function _elgg_sql_reverse_order_by_clause($order_by) {
    $order_by = strtolower($order_by);

    if (strpos($order_by, ' asc') !== false) {
        $return = str_replace(' asc', ' desc', $order_by);
    } elseif (strpos($order_by, ' desc') !== false) {
        $return = str_replace(' desc', ' asc', $order_by);
    } else {
        // no order specified, so default to desc since mysql defaults to asc
        $return = $order_by . ' desc';
    }

    return $return;
}

function elgg_batch_enable_callback($object) {
    // our db functions return the number of rows affected...
    return $object->enable() ? true : false;
}

function elgg_batch_disable_callback($object) {
    // our db functions return the number of rows affected...
    return $object->disable() ? true : false;
}

function elgg_batch_delete_callback($object) {
    // our db functions return the number of rows affected...
    return $object->delete() ? true : false;
}

function _elgg_is_valid_options_for_batch_operation($options, $type) {
    if (!$options || !is_array($options)) {
        return false;
    }

    // at least one of these is required.
    $required = array(
        // generic restraints
        'guid', 'guids'
    );

    switch ($type) {
        case 'metadata':
            $metadata_required = array(
                'metadata_owner_guid', 'metadata_owner_guids',
                'metadata_name', 'metadata_names',
                'metadata_value', 'metadata_values'
            );

            $required = array_merge($required, $metadata_required);
            break;

        case 'annotations':
        case 'annotation':
            $annotations_required = array(
                'annotation_owner_guid', 'annotation_owner_guids',
                'annotation_name', 'annotation_names',
                'annotation_value', 'annotation_values'
            );

            $required = array_merge($required, $annotations_required);
            break;

        default:
            return false;
    }

    foreach ($required as $key) {
        // check that it exists and is something.
        if (isset($options[$key]) && $options[$key]) {
            return true;
        }
    }

    return false;
}

function _elgg_walled_garden_index() {

    elgg_load_css('elgg.walled_garden');
    elgg_load_js('elgg.walled_garden');

    $content = elgg_view('core/walled_garden/login');

    $params = array(
        'content' => $content,
        'class' => 'elgg-walledgarden-double',
        'id' => 'elgg-walledgarden-login',
    );
    $body = elgg_view_layout('walled_garden', $params);
    echo elgg_view_page('', $body, 'walled_garden');

    return true;
}


function _elgg_walled_garden_ajax_handler($page) {
    $view = $page[0];
    $params = array(
        'content' => elgg_view("core/walled_garden/$view"),
        'class' => 'elgg-walledgarden-single hidden',
        'id' => str_replace('_', '-', "elgg-walledgarden-$view"),
    );
    echo elgg_view_layout('walled_garden', $params);
    return true;
}

function _elgg_walled_garden_init() {
    global $CONFIG;

    elgg_register_css('elgg.walled_garden', elgg_get_simplecache_url('css', 'walled_garden'));
    elgg_register_js('elgg.walled_garden', elgg_get_simplecache_url('js', 'walled_garden'));

    elgg_register_page_handler('walled_garden', '_elgg_walled_garden_ajax_handler');

    // check for external page view
    if (isset($CONFIG->site) && $CONFIG->site instanceof ElggSite) {
        $CONFIG->site->checkWalledGarden();
    }
}

function _elgg_walled_garden_remove_public_access($hook, $type, $accesses) {
    if (isset($accesses[ACCESS_PUBLIC])) {
        unset($accesses[ACCESS_PUBLIC]);
    }
    return $accesses;
}

function _elgg_engine_boot() {
    // Register the error handlers
    set_error_handler('_elgg_php_error_handler');
    set_exception_handler('_elgg_php_exception_handler');

    _elgg_services()->db->setupConnections();

    _elgg_services()->db->assertInstalled();

    _elgg_load_application_config();

    _elgg_load_autoload_cache();

    _elgg_load_site_config();

    _elgg_session_boot();

    _elgg_load_cache();

    _elgg_load_translations();
}

function _elgg_init() {
    global $CONFIG;

    elgg_register_action('comment/save');
    elgg_register_action('comment/delete');

    elgg_register_page_handler('js', '_elgg_js_page_handler');
    elgg_register_page_handler('css', '_elgg_css_page_handler');
    elgg_register_page_handler('ajax', '_elgg_ajax_page_handler');

    elgg_register_js('elgg.autocomplete', 'js/lib/ui.autocomplete.js');
    elgg_register_js('jquery.ui.autocomplete.html', 'vendors/jquery/jquery.ui.autocomplete.html.js');

    elgg_register_external_view('js/elgg/UserPicker.js', true);

    elgg_register_js('elgg.friendspicker', 'js/lib/ui.friends_picker.js');
    elgg_register_js('elgg.avatar_cropper', 'js/lib/ui.avatar_cropper.js');
    elgg_register_js('jquery.imgareaselect', 'vendors/jquery/jquery.imgareaselect/scripts/jquery.imgareaselect.min.js');
    elgg_register_js('elgg.ui.river', 'js/lib/ui.river.js');

    elgg_register_css('jquery.imgareaselect', 'vendors/jquery/jquery.imgareaselect/css/imgareaselect-deprecated.css');

    // Trigger the shutdown:system event upon PHP shutdown.
    register_shutdown_function('_elgg_shutdown_hook');

    // Sets a blacklist of words in the current language.
    // This is a comma separated list in word:blacklist.
    // @todo possibly deprecate
    $CONFIG->wordblacklist = array();
    $list = explode(',', elgg_echo('word:blacklist'));
    if ($list) {
        foreach ($list as $l) {
            $CONFIG->wordblacklist[] = trim($l);
        }
    }
}

function _elgg_api_test($hook, $type, $value, $params) {
    global $CONFIG;
    $value[] = $CONFIG->path . 'engine/tests/ElggTravisInstallTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreHelpersTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreRegressionBugsTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggBatchTest.php';
    return $value;
}

define('ACCESS_DEFAULT', -1);
define('ACCESS_PRIVATE', 0);
define('ACCESS_LOGGED_IN', 1);
define('ACCESS_PUBLIC', 2);
define('ACCESS_FRIENDS', -2);
define('ELGG_ENTITIES_ANY_VALUE', null);

define('ELGG_ENTITIES_NO_VALUE', 0);

define('REFERRER', -1);

define('REFERER', -1);

elgg_register_event_handler('init', 'system', '_elgg_init');
elgg_register_event_handler('boot', 'system', '_elgg_engine_boot', 1);
elgg_register_plugin_hook_handler('unit_test', 'system', '_elgg_api_test');

elgg_register_event_handler('init', 'system', '_elgg_walled_garden_init', 1000);