<h2>Editing File: /var/softaculous/mahara/org_upgrade.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php
/**
 *
 * @package    mahara
 * @subpackage core
 * @author     Catalyst IT Limited &lt;mahara@catalyst.net.nz&gt;
 * @license    https://www.gnu.org/licenses/gpl-3.0.html GNU GPL version 3 or later
 * @copyright  For copyright information on Mahara, please see the README file distributed with this software.
 *
 */

defined('INTERNAL') || die();

/**
 * Class to use for installation exceptions
 */
class InstallationException extends SystemException {}

require_once('ddl.php');

/**
 * This function checks core and plugins for which need to be upgraded/installed
 *
 * Note: This function is sometimes executed during upgrades from
 * ancient databases.  Avoid rash assumptions about what's installed
 * or these upgrades may fail.
 *
 * @param string $name The name of the plugin to check. If no name is specified,
 *                     all plugins are checked.
 * @return mixed If a name is specified, an object will be returned with upgrade data
 *                     about the requested component (which can be &quot;core&quot;, &quot;local&quot;, or a plugin).
 *                     If the component desn't need to be updated, an empty array will be returned.
 *               If no name is specified, an array of such objects will be returned.
 *                     It will also include an array key &quot;settings&quot;, which will be an array
 *                     that may contain metadata about the upgrade/install process.
 */
function check_upgrades($name=null) {

    $pluginstocheck = plugin_types();

    $toupgrade = array();
    $settings = array();
    $toupgradecount = 0;
    $newinstallcount = 0;
    $installing = false;
    $newinstalls = array();
    // This will be set in version.php below.
    $config = new stdClass();
    require('version.php');
    // check core first...
    if (empty($name) || $name == 'core') {
        try {
            $coreversion = get_config('version');
        }
        catch (Exception $e) {
            $coreversion = 0;
        }
        $corerelease = get_config('release');
        $core = new stdClass();
        $core-&gt;to = $config-&gt;version;
        $core-&gt;torelease = $config-&gt;release;
        $core-&gt;toseries = $config-&gt;series;
        $toupgrade['core'] = $core;
        if (empty($coreversion)) {
            if (is_mysql()) { // Show a more informative error message if using mysql with skip-innodb
                // In MySQL 5.6.x, we run the command 'SHOW ENGINES' to check if InnoDB is enabled or not
                global $db;
                $result = $db-&gt;Execute(&quot;SHOW ENGINES&quot;);
                $hasinnodb = false;
                while (!$result-&gt;EOF) {
                    if ($result-&gt;fields['Engine'] == 'InnoDB' &amp;&amp; ($result-&gt;fields['Support'] == 'YES' || $result-&gt;fields['Support'] == 'DEFAULT')) {
                        $hasinnodb = true;
                        break;
                    }
                    $result-&gt;MoveNext();
                }

                if (!$hasinnodb) {
                    throw new ConfigSanityException(&quot;Mahara requires InnoDB tables.  Please ensure InnoDB tables are enabled in your MySQL server.&quot;);
                }
            }
            $core-&gt;install = true;
            $installing = true;
        }
        else if ($config-&gt;version &gt; $coreversion) {
            if (isset($config-&gt;minupgradefrom) &amp;&amp; isset($config-&gt;minupgraderelease)
                &amp;&amp; $coreversion &lt; $config-&gt;minupgradefrom) {
                throw new ConfigSanityException(&quot;Must upgrade to $config-&gt;minupgradefrom &quot;
                                          . &quot;($config-&gt;minupgraderelease) first &quot;
                                          . &quot; (you have $coreversion ($corerelease)&quot;);
            }
            $toupgradecount ++;
            $core-&gt;upgrade = true;
            $core-&gt;from = $coreversion;
            $core-&gt;fromrelease = $corerelease;
        }
        else if ($config-&gt;version &lt; $coreversion) {
            // Core can't be upgraded. Remove it from the list!
            unset($toupgrade['core']);
            if (get_config('productionmode')) {
                throw new ConfigSanityException(&quot;Database version of Mahara $corerelease ($coreversion) is newer &quot;
                                            . &quot;than files version $config-&gt;release ($config-&gt;version). &quot;
                                            . &quot;Please make sure you have the correct Mahara files in place.&quot;);
            }
            else {
                if (!defined('SITEOUTOFSYNC')) {
                    define('SITEOUTOFSYNC', 'core');
                }
            }
        }
        else {
            // Core doesn't need to be upgraded. Remove it from the list!
            unset($toupgrade['core']);
        }
    }

    // If we were just checking if the core needed to be upgraded, we can stop here
    if ($name == 'core') {
        return $toupgrade['core'];
    }

    if (!$installing &amp;&amp; (empty($name) || $name == 'local')) {
        $localversion = get_config('localversion');
        $localrelease = get_config('localrelease');
        if (is_null($localversion)) {
            $localversion = 0;
            $localrelease = 0;
        }

        $config = new stdClass();
        require(get_config('docroot') . 'local/version.php');

        if ($config-&gt;version &gt; $localversion) {
            $toupgradecount ++;
            $toupgrade['local'] = (object) array(
                'upgrade'     =&gt; true,
                'from'        =&gt; $localversion,
                'fromrelease' =&gt; $localrelease,
                'to'          =&gt; $config-&gt;version,
                'torelease'   =&gt; $config-&gt;release,
            );
        }

        if ($name == 'local') {
            return $toupgrade['local'];
        }
    }

    $plugins = array();
    if (!empty($name)) {
        try {
            $bits = explode('.', $name);
            $pt = $bits[0];
            $pn = $bits[1];
            $pp = null;
            if ($pt == 'blocktype' &amp;&amp; strpos($pn, '/') !== false) {
                $bits = explode('/', $pn);
                $pp = get_config('docroot') . 'artefact/' . $bits[0]  . '/blocktype/' . $bits[1];
            }
            validate_plugin($pt, $pn, $pp);
            $plugins[] = explode('.', $name);
        }
        catch (InstallationException $_e) {
            log_warn(get_string('pluginnotinstallable', 'mahara', $pt, $pn) . $_e-&gt;GetMessage());
        }
    }
    else {
        foreach ($pluginstocheck as $plugin) {
            $dirhandle = opendir(get_config('docroot') . $plugin);
            while (false !== ($dir = readdir($dirhandle))) {
                if (strpos($dir, '.') === 0 or 'CVS' == $dir) {
                    continue;
                }
                $plugin_dir = get_config('docroot') . $plugin . '/' . $dir;
                if (!is_dir($plugin_dir)) {
                    continue;
                }
                try {
                    validate_plugin($plugin, $dir);
                    $plugins[] = array($plugin, $dir);
                }
                catch (InstallationException $_e) {
                    log_warn(get_string('pluginnotinstallable', 'mahara', $plugin, $dir) . $_e-&gt;GetMessage(), true , false);
                }

                if ($plugin == 'artefact') { // go check it for blocks as well
                    $btlocation = $plugin_dir . '/blocktype';
                    if (!is_dir($btlocation)) {
                        continue;
                    }
                    $btdirhandle = opendir($btlocation);
                    while (false !== ($btdir = readdir($btdirhandle))) {
                        if (strpos($btdir, '.') === 0 or 'CVS' == $btdir) {
                            continue;
                        }
                        if (!is_dir(get_config('docroot') . $plugin . '/' . $dir . '/blocktype/' . $btdir)) {
                            continue;
                        }
                        $plugins[] = array('blocktype', $dir . '/' . $btdir);
                    }
                }
            }
        }
    }
    $outofsyncplugins = array();
    foreach ($plugins as $plugin) {
        $plugintype = $plugin[0];
        $pluginname = $plugin[1];
        $pluginpath = &quot;$plugin[0]/$plugin[1]&quot;;
        $pluginkey  = &quot;$plugin[0].$plugin[1]&quot;;

        if ($plugintype == 'blocktype' &amp;&amp; strpos($pluginname, '/') !== false) {
            // sigh.. we're a bit special...
            $bits = explode('/', $pluginname);
            $pluginpath = 'artefact/' . $bits[0] . '/blocktype/' . $bits[1];
        }

        // Don't try to get the plugin info if we are installing - it will
        // definitely fail
        $pluginversion = 0;
        $pluginrelease = 0;
        if (!$installing &amp;&amp; table_exists(new XMLDBTable($plugintype . '_installed'))) {
            if ($plugintype == 'blocktype' &amp;&amp; strpos($pluginname, '/')) {
                $bits = explode('/', $pluginname);
                $installed = get_record('blocktype_installed', 'name', $bits[1], 'artefactplugin', $bits[0]);
            }
            else {
                $installed = get_record($plugintype . '_installed', 'name', $pluginname);
            }
            if ($installed) {
                $pluginversion = $installed-&gt;version;
                $pluginrelease =  $installed-&gt;release;
            }
        }

        $config = new stdClass();
        require(get_config('docroot') . $pluginpath . '/version.php');

        $classname = generate_class_name($plugintype, $pluginname);
        safe_require($plugintype, $pluginname);
        // Check if there is a displayname
        $plugindisplayname = $classname::get_plugin_display_name();

        if (empty($pluginversion)) {
            $newinstall = false;
            if (empty($installing) &amp;&amp; $pluginkey != $name) {
                $newinstall = true;
            }
            $plugininfo = new stdClass();
            $plugininfo-&gt;install = true;
            $plugininfo-&gt;to = $config-&gt;version;
            $plugininfo-&gt;torelease = $config-&gt;release;
            if (property_exists($config, 'requires_config')) {
                $plugininfo-&gt;requires_config = $config-&gt;requires_config;
            }
            if (property_exists($config, 'requires_parent')) {
                $plugininfo-&gt;requires_parent = $config-&gt;requires_parent;
            }
            $plugininfo-&gt;displayname = $plugindisplayname;

            try {
                $classname::sanity_check();
            }
            catch (InstallationException $exc) {
                $plugininfo-&gt;to = get_string('notinstalled', 'admin');
                $plugininfo-&gt;torelease = get_string('notinstalled', 'admin');
                $plugininfo-&gt;errormsg = $exc-&gt;getMessage();
            }

            if ($newinstall) {
                $plugininfo-&gt;from = get_string('notinstalled', 'admin');
                $plugininfo-&gt;fromrelease = get_string('notinstalled', 'admin');
                $plugininfo-&gt;newinstall = true;
                $newinstallcount ++;
                $newinstalls[$pluginkey] = $plugininfo;
            }
            else {
                $toupgrade[$pluginkey] = $plugininfo;
            }
        }
        else if ($config-&gt;version &gt; $pluginversion) {
            if (isset($config-&gt;minupgradefrom) &amp;&amp; isset($config-&gt;minupgraderelease)
                &amp;&amp; $pluginversion &lt; $config-&gt;minupgradefrom) {
                throw new ConfigSanityException(&quot;Must upgrade to $config-&gt;minupgradefrom &quot;
                                          . &quot; ($config-&gt;minupgraderelease) first &quot;
                                          . &quot; (you have $pluginversion ($pluginrelease))&quot;);
            }
            $toupgradecount++;
            $plugininfo = new stdClass();
            $plugininfo-&gt;upgrade = true;
            $plugininfo-&gt;from = $pluginversion;
            $plugininfo-&gt;fromrelease = $pluginrelease;
            $plugininfo-&gt;to = $config-&gt;version;
            $plugininfo-&gt;torelease = $config-&gt;release;
            if (property_exists($config, 'requires_config')) {
                $plugininfo-&gt;requires_config = $config-&gt;requires_config;
            }
            if (property_exists($config, 'requires_parent')) {
                $plugininfo-&gt;requires_parent = $config-&gt;requires_parent;
            }
            $plugininfo-&gt;displayname = $plugindisplayname;

            try {
                $classname::sanity_check();
            }
            catch (InstallationException $exc) {
                $plugininfo-&gt;to = $config-&gt;version;
                $plugininfo-&gt;torelease = $pluginrelease;
                $plugininfo-&gt;errormsg = $exc-&gt;getMessage();
                $toupgrade[$pluginkey] = $plugininfo;

                continue;
            }

            $toupgrade[$pluginkey] = $plugininfo;
        }
        else if ($config-&gt;version &lt; $pluginversion) {
            $plugindisplayname = !empty($plugindisplayname) ? $plugindisplayname : (!empty($config-&gt;name) ? $config-&gt;name : $pluginpath);
            if (get_config('productionmode')) {
                throw new ConfigSanityException(&quot;Database version of Mahara plugin &quot; . $plugindisplayname . &quot; &quot;
                                            . $pluginrelease . &quot; (&quot; . $pluginversion . &quot;) is newer &quot;
                                            . &quot;than files version &quot; . $config-&gt;release . &quot; (&quot; . $config-&gt;version . &quot;). &quot;
                                            . &quot;Please make sure you have the correct Mahara plugin files in place.&quot;);
            }
            else {
                $outofsyncplugins[] = $plugindisplayname;
            }
        }
    }
    if (!empty($outofsyncplugins)) {
        if (!defined('SITEOUTOFSYNC')) {
            define('SITEOUTOFSYNC', implode(', ', $outofsyncplugins));
        }
    }
    // if we've just asked for one, don't return an array...
    if (!empty($name)) {
        if (count($toupgrade) == 1) {
            $upgrade = new stdClass();
            $upgrade-&gt;name = $name;
            foreach ((array)$toupgrade[$name] as $key =&gt; $value) {
                $upgrade-&gt;{$key} = $value;
            }
            return $upgrade;
        }
        else {
            return array();
        }
    }

    // If we get here, it's because we have an array of objects to return
    $toupgrade = sort_upgrade_order($toupgrade);
    $settings['newinstallcount'] = $newinstallcount;
    $settings['newinstalls'] = $newinstalls;
    $settings['toupgradecount'] = $toupgradecount;
    $toupgrade['settings'] = $settings;
    return $toupgrade;
}

/**
 * Upgrades the core system to given upgrade version.
 *
 * @param object $upgrade   The version to upgrade to
 * @return bool             Whether the upgrade succeeded or not
 * @throws SQLException     If the upgrade failed due to a database error
 */
function upgrade_core($upgrade) {
    global $db;

    $location = get_config('libroot') . 'db/';

    db_begin();

    if (!empty($upgrade-&gt;install)) {
        install_from_xmldb_file($location . 'install.xml');
    }
    else {
        require_once($location . 'upgrade.php');
        xmldb_core_upgrade($upgrade-&gt;from);
    }

    set_config('version', $upgrade-&gt;to);
    set_config('release', $upgrade-&gt;torelease);
    set_config('series', $upgrade-&gt;toseries);
    bump_cache_version();
    cron_check_for_updates();

    if (!empty($upgrade-&gt;install)) {
        core_postinst();
    }

    db_commit();
    return true;
}

/**
 * Upgrades local customisations.
 *
 * @param object $upgrade   The version to upgrade to
 * @return bool             Whether the upgrade succeeded or not
 * @throws SQLException     If the upgrade failed due to a database error
 */
function upgrade_local($upgrade) {
    db_begin();

    require_once(get_config('docroot') . 'local/upgrade.php');
    xmldb_local_upgrade($upgrade-&gt;from);

    set_config('localversion', $upgrade-&gt;to);
    set_config('localrelease', $upgrade-&gt;torelease);
    bump_cache_version();

    db_commit();
    return true;
}

/**
 * Upgrades the plugin to a new version
 *
 * Note: This function is sometimes executed during upgrades from
 * ancient databases.  Avoid rash assumptions about what's installed
 * or these upgrades may fail.
 *
 * @param object $upgrade   Information about the plugin to upgrade
 * @return bool             Whether the upgrade succeeded or not
 * @throws SQLException     If the upgrade failed due to a database error
 */
function upgrade_plugin($upgrade) {
    global $db;

    $plugintype = '';
    $pluginname = '';

    list($plugintype, $pluginname) = explode('.', $upgrade-&gt;name);

    if ($plugintype == 'blocktype' &amp;&amp; strpos($pluginname, '/') !== false) {
        list($artefactplugin, $blocktypename) = explode('/', $pluginname);
        $location = get_config('docroot') . 'artefact/' . $artefactplugin . '/blocktype/' . $blocktypename . '/db/';
        $function = 'xmldb_' . $plugintype . '_' . $blocktypename . '_upgrade';
    }
    else {
        $location = get_config('docroot') . $plugintype . '/' . $pluginname . '/db/';
        $function = 'xmldb_' . $plugintype . '_' . $pluginname . '_upgrade';
    }

    db_begin();

    if (!empty($upgrade-&gt;install)) {
        if (is_readable($location . 'install.xml')) {
            install_from_xmldb_file($location . 'install.xml');
        }
    }
    else {
        if (is_readable($location .  'upgrade.php')) {
            require_once($location . 'upgrade.php');
            if (!$function($upgrade-&gt;from)) {
                throw new InstallationException(&quot;Failed to run &quot; . $function . &quot; (check logs for errors)&quot;);
            }
        }
    }

    $installed = new stdClass();
    $installed-&gt;name = $pluginname;
    $installed-&gt;version = $upgrade-&gt;to;
    $installed-&gt;release = $upgrade-&gt;torelease;
    if ($plugintype == 'blocktype') {
        if (!empty($blocktypename)) {
            $installed-&gt;name = $blocktypename;
        }
        if (!empty($artefactplugin)) { // blocks come from artefactplugins.
            $installed-&gt;artefactplugin = $artefactplugin;
        }
    }
    if (property_exists($upgrade, 'requires_config')) {
        $installed-&gt;requires_config = $upgrade-&gt;requires_config;
    }
    if (property_exists($upgrade, 'requires_parent')) {
        $installed-&gt;requires_parent = $upgrade-&gt;requires_parent;
    }
    $installtable = $plugintype . '_installed';

    if (!empty($upgrade-&gt;install)) {
        insert_record($installtable,$installed);
    }
    else {
        update_record($installtable, $installed, 'name');
    }
    bump_cache_version();

    // postinst stuff...
    safe_require($plugintype, $pluginname);
    $pcname = generate_class_name($plugintype, $installed-&gt;name);

    if ($crons = $pcname::get_cron()) {
        foreach ($crons as $cron) {
            $cron = (object)$cron;
            if (empty($cron-&gt;callfunction)) {
                throw new InstallationException(&quot;cron for $pcname didn't supply function name&quot;);
            }
            if (!is_callable(array($pcname, $cron-&gt;callfunction))) {
                throw new InstallationException(&quot;cron $cron-&gt;callfunction for $pcname supplied but wasn't callable&quot;);
            }
            $new = false;
            $table = $plugintype . '_cron';
            if (!empty($upgrade-&gt;install)) {
                $new = true;
            }
            else if (!record_exists($table, 'plugin', $pluginname, 'callfunction', $cron-&gt;callfunction)) {
                $new = true;
            }
            $cron-&gt;plugin = $pluginname;
            if (!empty($new)) {
                insert_record($table, $cron);
            }
            else {
                update_record($table, $cron, array('plugin', 'callfunction'));
            }
        }
    }

    if ($events = $pcname::get_event_subscriptions()) {
        foreach ($events as $event) {
            $event = (object)$event;

            if (!record_exists('event_type', 'name', $event-&gt;event)) {
                throw new InstallationException(&quot;event $event-&gt;event for $pcname doesn't exist!&quot;);
            }
            if (empty($event-&gt;callfunction)) {
                throw new InstallationException(&quot;event $event-&gt;event for $pcname didn't supply function name&quot;);
            }
            if (!is_callable(array($pcname, $event-&gt;callfunction))) {
                throw new InstallationException(&quot;event $event-&gt;event with function $event-&gt;callfunction for $pcname supplied but wasn't callable&quot;);
            }
            $exists = false;
            $table = $plugintype . '_event_subscription';
            $block = blocktype_namespaced_to_single($pluginname);
            if (empty($upgrade-&gt;install)) {
                $exists = get_record($table, 'plugin' , $block, 'event', $event-&gt;event);
            }
            $event-&gt;plugin = $block;
            if (empty($exists)) {
                insert_record($table, $event);
            }
            else {
                update_record($table, $event, array('id' =&gt; $exists-&gt;id));
            }
        }
    }

    if ($activities = $pcname::get_activity_types()) {
        foreach ($activities as $activity) {
            $classname = 'ActivityType' . ucfirst($plugintype) . ucfirst($pluginname) . ucfirst($activity-&gt;name);
            if (!class_exists($classname)) {
                throw new InstallationException(get_string('classmissing', 'error',  $classname, $pluginname, $plugintype));
            }
            // Add activity_type if it doesn't exist
            if (!get_record('activity_type', 'name', $activity-&gt;name, 'plugintype', $plugintype, 'pluginname', $pluginname)) {
                $activity-&gt;plugintype = $plugintype;
                $activity-&gt;pluginname = $pluginname;
                $activity-&gt;defaultmethod = get_config('defaultnotificationmethod') ? get_config('defaultnotificationmethod') : $activity-&gt;defaultmethod;
                $where = (object) array(
                    'name'       =&gt; $activity-&gt;name,
                    'plugintype' =&gt; $plugintype,
                    'pluginname' =&gt; $pluginname,
                );
                ensure_record_exists('activity_type', $where, $activity);
            }
        }
    }

    // install artefact types
    if ($plugintype == 'artefact') {
        if (!is_callable(array($pcname, 'get_artefact_types'))) {
            throw new InstallationException(&quot;Artefact plugin $pcname must implement get_artefact_types and doesn't&quot;);
        }
        $types = $pcname::get_artefact_types();
        $ph = array();
        if (is_array($types)) {
            // Check for missing plugins - don't try to remove their data.
            // Bugs 505732 and 1287344.
            $used_types = get_records_sql_assoc(&quot;SELECT t.name, count(a.id) ct, t.plugin FROM {artefact_installed_type} t
                    LEFT JOIN {artefact} a ON t.name = a.artefacttype
                    GROUP BY t.name
                    HAVING count(a.id) &gt; 0 AND plugin = '$pluginname'&quot;);
            if ($used_types === FALSE) {
                $used_types = array();
            }

            foreach ($types as $type) {
                $ph[] = '?';
                if (!record_exists('artefact_installed_type', 'plugin', $pluginname, 'name', $type)) {
                    $t = new stdClass();
                    $t-&gt;name = $type;
                    $t-&gt;plugin = $pluginname;
                    insert_record('artefact_installed_type',$t);
                }
                if (isset($used_types[$type])) {
                    unset($used_types[$type]);
                }
            }

            foreach ($used_types as $type) {
                $ph[] = '?';
            }

            $used_types = array_keys($used_types);

            $select = '(plugin = ? AND name NOT IN (' . implode(',', $ph) . '))';
            delete_records_select('artefact_installed_type', $select,
                    array_merge(array($pluginname),$types,$used_types));
            if (!empty($used_types)) {
                log_warn('Plugin for artefact type(s) &quot;' . implode('&quot;, &quot;', $used_types) . '&quot; has gone away', true, false);
            }
        }
    }

    // install blocktype categories.
    if ($plugintype == 'blocktype' &amp;&amp; get_config('installed')) {
        install_blocktype_categories_for_plugin($pluginname);
        install_blocktype_viewtypes_for_plugin($pluginname);
    }

    $prevversion = (empty($upgrade-&gt;install)) ? $upgrade-&gt;from : 0;
    $pcname::postinst($prevversion);

    db_commit();
    return true;
}

function core_postinst() {
    // Attempt to create session directories
    $sessionpath = get_config('sessionpath');
    $status = Session::create_directory_levels($sessionpath);

    $now = db_format_timestamp(time());
    // Set default search plugin
    set_config('searchplugin', 'internal');

    set_config('lang', get_accept_lang());
    set_config('installation_key', get_random_key());
    set_config('installation_time', $now);
    set_config('stats_installation_time', $now);
    set_config('passwordpolicy', '8_ulns');

    // Pre-define SMTP settings
    set_config('smtphosts', '');
    set_config('smtpport', '');
    set_config('smtpuser', '');
    set_config('smtppass', '');
    set_config('smtpsecure', '');

    // XMLDB adds a table's keys immediately after creating the table.  Some
    // foreign keys therefore cannot be created during the XMLDB installation,
    // because they refer to tables created later in the installation.  These
    // missing keys can be created now that all the core tables exist.
    $table = new XMLDBTable('usr');
    $key = new XMLDBKey('profileiconfk');
    $key-&gt;setAttributes(XMLDB_KEY_FOREIGN, array('profileicon'), 'artefact', array('id'));
    add_key($table, $key);

    $table = new XMLDBTable('institution');
    $key = new XMLDBKey('logofk');
    $key-&gt;setAttributes(XMLDB_KEY_FOREIGN, array('logo'), 'artefact', array('id'));
    add_key($table, $key);

    // PostgreSQL supports indexes over functions of columns, MySQL does not.
    // We make use if this if we can
    if (is_postgres()) {
        // Improve the username index
        execute_sql('DROP INDEX {usr_use_uix}');
        execute_sql('CREATE UNIQUE INDEX {usr_use_uix} ON {usr}(LOWER(username))');

        // Add user search indexes
        // Postgres only.  We could create non-lowercased indexes in MySQL, but
        // they would not be useful, and would require a change to varchar columns.
        execute_sql('CREATE INDEX {usr_fir_ix} ON {usr}(LOWER(firstname))');
        execute_sql('CREATE INDEX {usr_las_ix} ON {usr}(LOWER(lastname))');
        execute_sql('CREATE INDEX {usr_pre_ix} ON {usr}(LOWER(preferredname))');
        execute_sql('CREATE INDEX {usr_ema_ix} ON {usr}(LOWER(email))');
        execute_sql('CREATE INDEX {usr_stu_ix} ON {usr}(LOWER(studentid))');

        // Only one profile view per user
        execute_sql(&quot;CREATE UNIQUE INDEX {view_own_type_uix} ON {view}(owner) WHERE type = 'profile'&quot;);
    }

    // Some more advanced constraints. XMLDB can't handle this in its xml file format
    execute_sql('ALTER TABLE {artefact} ADD CHECK (
        (owner IS NOT NULL AND &quot;group&quot; IS NULL     AND institution IS NULL) OR
        (owner IS NULL     AND &quot;group&quot; IS NOT NULL AND institution IS NULL) OR
        (owner IS NULL     AND &quot;group&quot; IS NULL     AND institution IS NOT NULL)
    )');
    execute_sql('ALTER TABLE {view} ADD CHECK (
        (owner IS NOT NULL AND &quot;group&quot; IS NULL     AND institution IS NULL) OR
        (owner IS NULL     AND &quot;group&quot; IS NOT NULL AND institution IS NULL) OR
        (owner IS NULL     AND &quot;group&quot; IS NULL     AND institution IS NOT NULL)
    )');
    execute_sql('ALTER TABLE {artefact} ADD CHECK (
        (author IS NOT NULL AND authorname IS NULL    ) OR
        (author IS NULL     AND authorname IS NOT NULL)
    )');
    execute_sql('ALTER TABLE {view_access} ADD CHECK (
        (accesstype IS NOT NULL AND &quot;group&quot; IS NULL     AND usr IS NULL     AND token IS NULL   AND institution IS NULL) OR
        (accesstype IS NULL     AND &quot;group&quot; IS NOT NULL AND usr IS NULL     AND token IS NULL AND institution IS NULL) OR
        (accesstype IS NULL     AND &quot;group&quot; IS NULL     AND usr IS NOT NULL AND token IS NULL AND institution IS NULL) OR
        (accesstype IS NULL     AND &quot;group&quot; IS NULL     AND usr IS NULL     AND token IS NOT NULL AND institution IS NULL) OR
        (accesstype IS NULL     AND &quot;group&quot; IS NULL     AND usr IS NULL     AND token IS NULL AND institution IS NOT NULL)
    )');
    execute_sql('ALTER TABLE {collection} ADD CHECK (
        (owner IS NOT NULL AND &quot;group&quot; IS NULL     AND institution IS NULL) OR
        (owner IS NULL     AND &quot;group&quot; IS NOT NULL AND institution IS NULL) OR
        (owner IS NULL     AND &quot;group&quot; IS NULL     AND institution IS NOT NULL)
    )');

    set_antispam_defaults();
    reload_html_filters();

    // Default set of sites from which iframe content can be embedded
    // See also the postinst() function in plugins for other valid iframes
    // by searching for 'iframe_source_icon'
    $iframesources = array(
        'www.youtube.com/embed/'                   =&gt; 'YouTube',
        'player.vimeo.com/video/'                  =&gt; 'Vimeo',
        'www.slideshare.net/slideshow/embed_code/' =&gt; 'SlideShare',
        'www.glogster.com/glog/'                   =&gt; 'Glogster',
        'www.glogster.com/glog.php'                =&gt; 'Glogster',
        'edu.glogster.com/glog/'                   =&gt; 'Glogster',
        'edu.glogster.com/glog.php'                =&gt; 'Glogster',
        'wikieducator.org/index.php'               =&gt; 'WikiEducator',
        'voki.com/php/'                            =&gt; 'Voki',
    );
    $iframedomains = array(
        'YouTube'      =&gt; 'www.youtube.com',
        'Vimeo'        =&gt; 'vimeo.com',
        'SlideShare'   =&gt; 'www.slideshare.net',
        'Glogster'     =&gt; 'www.glogster.com',
        'WikiEducator' =&gt; 'wikieducator.org',
        'Voki'         =&gt; 'voki.com',
    );
    update_safe_iframes($iframesources, $iframedomains);

    require_once(get_config('docroot') . 'lib/file.php');
    update_magicdb_path();

    return $status;
}

function core_install_lastcoredata_defaults() {
    global $USER;
    db_begin();
    $institution = new stdClass();
    $institution-&gt;name = 'mahara';
    $institution-&gt;displayname = 'No Institution';
    $institution-&gt;authplugin  = 'internal';
    $institution-&gt;theme  = 'default';
    $institution-&gt;priority = 0;
    insert_record('institution', $institution);

    $auth_instance = new stdClass();
    $auth_instance-&gt;instancename  = 'Internal';
    $auth_instance-&gt;priority='1';
    $auth_instance-&gt;institution   = 'mahara';
    $auth_instance-&gt;authname      = 'internal';
    $auth_instance-&gt;active        = 1;
    $auth_instance-&gt;id = insert_record('auth_instance', $auth_instance, 'id', true);

    // Insert the root user
    $userid = 0;
    $user = new stdClass();
    $user-&gt;id = $userid;
    $user-&gt;username = 'root';
    $user-&gt;password = '*';
    $user-&gt;salt = '*';
    $user-&gt;firstname = 'System';
    $user-&gt;lastname = 'User';
    $user-&gt;email = 'root@example.org';
    $user-&gt;quota = get_config_plugin('artefact', 'file', 'defaultquota');
    $user-&gt;authinstance = $auth_instance-&gt;id;
    $user-&gt;admin = 1;

    if (is_mysql()) { // gratuitous mysql workaround
        $newid = insert_record('usr', $user, 'id', true);
        set_field('usr', 'id', 0, 'id', $newid);
        execute_sql('ALTER TABLE {usr} AUTO_INCREMENT=1');
    }
    else {
        insert_record('usr', $user);
    }

    $pages = site_content_pages();
    $now = db_format_timestamp(time());
    foreach ($pages as $name) {
        $page = new stdClass();
        $page-&gt;ctime = $now;
        $page-&gt;institution = 'mahara';
        $page-&gt;content = get_string($name . 'defaultcontent', 'install', get_string('staticpageconfigdefaults', 'install',  get_config('wwwroot') . 'admin/site/pages.php'));
        $page-&gt;name = $name;
        $page-&gt;mtime = $now;
        $page-&gt;mauthor = $userid;
        insert_record('site_content', $page);
    }

    $versionedpages = site_content_version_pages();
    foreach ($versionedpages as $name) {
        $page = new stdClass();
        $page-&gt;ctime = $now;
        $page-&gt;institution = 'mahara';
        $page-&gt;content = get_string($name . 'defaultcontent', 'install', get_string('versionedpageconfigdefault', 'install', get_config('wwwroot') . 'admin/site/privacy.php?fs=' . $name));
        $page-&gt;type = $name;
        $page-&gt;author = $userid;
        $page-&gt;version = '1.0';
        insert_record('site_content_version', $page);
    }

    require_once('group.php');
    install_system_profile_view();
    install_system_dashboard_view();
    install_system_grouphomepage_view();
    require_once('view.php');
    install_system_portfolio_view();
    install_system_progress_view();

    require_once('license.php');
    install_licenses_default();

    require_once('skin.php');
    install_skins_default();

    install_auth_default();

    // Remove admin privs from root user as it doesn't need it now
    $user-&gt;admin = 0;
    update_record('usr', $user, array('id' =&gt; 0));

    // Insert the admin user
    $user = new stdClass();
    $user-&gt;username = 'admin';
    $user-&gt;salt = auth_get_random_salt();
    $user-&gt;password = crypt('mahara', '$2a$' . get_config('bcrypt_cost') . '$' . substr(md5(get_config('passwordsaltmain') . $user-&gt;salt), 0, 22));
    $user-&gt;password = substr($user-&gt;password, 0, 7) . substr($user-&gt;password, 7+22);
    $user-&gt;authinstance = $auth_instance-&gt;id;
    $user-&gt;passwordchange = 1;
    $user-&gt;admin = 1;
    $user-&gt;firstname = 'Admin';
    $user-&gt;lastname = 'Account';
    $user-&gt;email = 'admin@example.org';
    $user-&gt;quota = get_config_plugin('artefact', 'file', 'defaultquota');
    $user-&gt;ctime = db_format_timestamp(time());
    $user-&gt;id = insert_record('usr', $user, 'id', true);
    set_profile_field($user-&gt;id, 'email', $user-&gt;email);
    set_profile_field($user-&gt;id, 'firstname', $user-&gt;firstname);
    set_profile_field($user-&gt;id, 'lastname', $user-&gt;lastname);
    // Accept the user privacy agreement on install
    $sitecontentid = get_field('site_content_version', 'id', 'type', 'privacy', 'institution', 'mahara');
    save_user_reply_to_agreement($user-&gt;id, $sitecontentid, 1);
    // Accept the user T&amp;C on install
    $sitecontentid = get_field('site_content_version', 'id', 'type', 'termsandconditions', 'institution', 'mahara');
    save_user_reply_to_agreement($user-&gt;id, $sitecontentid, 1);
    handle_event('createuser', $user, array('password'));
    activity_add_admin_defaults(array($user-&gt;id));
    db_commit();

    // if we're installing, set up the block categories here and then poll the plugins.
    // if we're upgrading this happens somewhere else.  This is because of dependency issues around
    // the order of installation stuff.
    install_blocktype_extras();

    // Setting user access roles for content block access
    $table = new XMLDBTable('usr_access_roles');

    $roles = array('peer' =&gt; 0, 'manager' =&gt; 1, 'peermanager' =&gt; 1, 'verifier' =&gt; 1);
    foreach ($roles as $role =&gt; $state) {
        $obj = new stdClass();
        $obj-&gt;role              = $role;
        $obj-&gt;see_block_content = $state;
        insert_record('usr_access_roles', $obj);
    }
}

function core_install_firstcoredata_defaults() {
    // Install the default institution
    db_begin();

    set_config('session_timeout', 86400);
    set_config('sitename', 'Mahara');
    set_config('defaultregistrationexpirylifetime', 1209600);
    set_config('defaultaccountinactivewarn', 604800);
    set_config('creategroups', 'all');
    set_config('createpublicgroups', 'all');
    set_config('allowpublicviews', 1);
    set_config('allowpublicprofiles', 1);
    set_config('allowanonymouspages', 0);
    set_config('generatesitemap', 1);
    set_config('showselfsearchsideblock', 0);
    set_config('showtagssideblock', 1);
    set_config('tagssideblockmaxtags', 20);
    set_config('usersallowedmultipleinstitutions', 1);
    set_config('userscanchooseviewthemes', 0);
    set_config('anonymouscomments', 1);
    set_config('homepageinfo', 1);
    set_config('showonlineuserssideblock', 1);
    set_config('footerlinks', serialize(array('legal', 'about', 'contactus', 'manualhelp')));
    set_config('nousernames', 0);
    set_config('showstudentid', 0);
    set_config('onlineuserssideblockmaxusers', 10);
    set_config('loggedinprofileviewaccess', 1);
    set_config('dropdownmenu', 0);
    // Set this to a random starting number to make minor version slightly harder to detect
    set_config('cacheversion', rand(1000, 9999));
    set_config('allowcommentsbydefault', 1);

    // install the applications
    $app = new stdClass();
    $app-&gt;name = 'mahara';
    $app-&gt;displayname = 'Mahara';
    $app-&gt;xmlrpcserverurl = '/api/xmlrpc/server.php';
    $app-&gt;ssolandurl = '/auth/xmlrpc/land.php';
    insert_record('application', $app);

    $app-&gt;name = 'moodle';
    $app-&gt;displayname = 'Moodle';
    $app-&gt;xmlrpcserverurl = '/mnet/xmlrpc/server.php';
    $app-&gt;ssolandurl = '/auth/mnet/land.php';
    insert_record('application', $app);

    // insert the event types
    $eventtypes = array(
        'createuser',
        'updateuser',
        'suspenduser',
        'unsuspenduser',
        'deleteuser',
        'undeleteuser',
        'expireuser',
        'unexpireuser',
        'deactivateuser',
        'activateuser',
        'userjoinsgroup',
        'userleavesgroup',
        'userchangegrouprole',
        'saveartefact',
        'deleteartefact',
        'deleteartefacts',
        'saveview',
        'deleteview',
        'blockinstancecommit',
        'deleteblockinstance',
        'addfriend',
        'removefriend',
        'addfriendrequest',
        'removefriendrequest',
        'creategroup',
        'loginas',
        'clearcaches',
        'createview',
        'createcollection',
        'updatecollection',
        'deletecollection',
        'addsubmission',
        'releasesubmission',
        'updateviewaccess',
        'removeviewaccess',
        'sharedcommenttogroup',
        'verifiedprogress',
    );

    foreach ($eventtypes as $et) {
        $e = new stdClass();
        $e-&gt;name = $et;
        insert_record('event_type', $e);
    }

    // install the core event subscriptions
    $subs = array(
        array(
            'event'        =&gt; 'createuser',
            'callfunction' =&gt; 'activity_set_defaults',
        ),
        array(
            'event'        =&gt; 'createuser',
            'callfunction' =&gt; 'add_user_to_autoadd_groups',
        ),
        array(
            'event'         =&gt; 'blockinstancecommit',
            'callfunction'  =&gt; 'watchlist_record_changes',
        ),
        array(
            'event'         =&gt; 'deleteblockinstance',
            'callfunction'  =&gt; 'watchlist_block_deleted',
        ),
        array(
            'event'         =&gt; 'saveartefact',
            'callfunction'  =&gt; 'watchlist_record_changes',
        ),
        array(
            'event'         =&gt; 'saveview',
            'callfunction'  =&gt; 'watchlist_record_changes',
        ),
    );

    foreach ($subs as $sub) {
        insert_record('event_subscription', (object)$sub);
    }

    // Install the activity types. Name, admin, delay, allownonemethod, defaultmethod.
    $activitytypes = array(
        array('maharamessage',      0, 0, 0, 'email'),
        array('usermessage',        0, 0, 0, 'email'),
        array('watchlist',          0, 1, 1, 'email'),
        array('viewaccess',         0, 1, 1, 'email'),
        array('contactus',          1, 1, 1, 'email'),
        array('objectionable',      1, 1, 1, 'email'),
        array('virusrepeat',        1, 1, 1, 'email'),
        array('virusrelease',       1, 1, 1, 'email'),
        array('institutionmessage', 0, 0, 1, 'email'),
        array('groupmessage',       0, 1, 1, 'email'),
        array('viewaccessrevoke',   0, 0, 0, 'email')
    );

    foreach ($activitytypes as $at) {
        $a = new stdClass();
        $a-&gt;name = $at[0];
        $a-&gt;admin = $at[1];
        $a-&gt;delay = $at[2];
        $a-&gt;allownonemethod = $at[3];
        $a-&gt;defaultmethod = $at[4];
        insert_record('activity_type', $a);
    }

    // install the cronjobs...
    $cronjobs = array(
        'auth_clean_partial_registrations'          =&gt; array('5', '0', '*', '*', '*'),
        'auth_clean_expired_password_requests'      =&gt; array('5', '0', '*', '*', '*'),
        'auth_handle_account_expiries'              =&gt; array('5', '10', '*', '*', '*'),
        'auth_handle_institution_expiries'          =&gt; array('5', '9', '*', '*', '*'),
        'activity_process_queue'                    =&gt; array('*/5', '*', '*', '*', '*'),
        'auth_remove_old_session_files'             =&gt; array('30', '20', '*', '*', '*'),
        'recalculate_quota'                         =&gt; array('15', '2', '*', '*', '*'),
        'import_process_queue'                      =&gt; array('*/5', '*', '*', '*', '*'),
        'export_process_queue'                      =&gt; array('*/6', '*', '*', '*', '*'),
        'submissions_delete_removed_archive'        =&gt; array('15', '1', '1', '*', '*'),
        'cron_send_registration_data'               =&gt; array(rand(0, 59), rand(0, 23), '*', '*', rand(0, 6)),
        'export_cleanup_old_exports'                =&gt; array('0', '3,15', '*', '*', '*'),
        'import_cleanup_old_imports'                =&gt; array('0', '4,16', '*', '*', '*'),
        'cron_site_data_weekly'                     =&gt; array('55', '23', '*', '*', '6'),
        'cron_site_data_daily'                      =&gt; array('51', '23', '*', '*', '*'),
        'cron_check_for_updates'                    =&gt; array(rand(0, 59), rand(0, 23), '*', '*', '*'),
        'cron_clean_internal_activity_notifications'=&gt; array(45, 22, '*', '*', '*'),
        'cron_sitemap_daily'                        =&gt; array(0, 1, '*', '*', '*'),
        'file_cleanup_old_cached_files'             =&gt; array(0, 1, '*', '*', '*'),
        'file_cleanup_old_temp_files'               =&gt; array(0, 2, '*/2', '*', '*'),
        'user_login_tries_to_zero'                  =&gt; array('2-59/5', '*', '*', '*', '*'),
        'cron_institution_registration_data'        =&gt; array(rand(0, 59), rand(0, 23), '*', '*', rand(0, 6)),
        'cron_institution_data_weekly'              =&gt; array('0', '0', '*', '*', '1'),
        'cron_institution_data_daily'               =&gt; array('51', '23', '*', '*', '*'),
        'check_imap_for_bounces'                    =&gt; array('*', '*', '*', '*', '*'),
        'cron_event_log_expire'                     =&gt; array('7', '23', '*', '*', '*'),
        'watchlist_process_notifications'           =&gt; array('*', '*', '*', '*', '*'),
        'cron_email_reset_rebounce'                 =&gt; array(rand(0, 59), rand(0, 23), '*', '*', '*'),
        'auth_clean_expired_migrations'             =&gt; array('0', '2,14', '*', '*', '*'),
        'portfolio_auto_copy'                       =&gt; array('*', '*', '*', '*', '*'),
        'unlock_collections_by_rollover'            =&gt; array('0', '3', '*', '*', '*'),
    );
    foreach ($cronjobs as $callfunction =&gt; $times) {
        $cron = new stdClass();
        $cron-&gt;callfunction = $callfunction;
        $cron-&gt;minute       = $times[0];
        $cron-&gt;hour         = $times[1];
        $cron-&gt;day          = $times[2];
        $cron-&gt;month        = $times[3];
        $cron-&gt;dayofweek    = $times[4];
        insert_record('cron', $cron);
    }

    $viewtypes = array('dashboard', 'portfolio', 'profile', 'grouphomepage', 'progress');
    foreach ($viewtypes as $vt) {
        insert_record('view_type', (object)array(
            'type' =&gt; $vt,
        ));
    }
    db_commit();
}


/**
 * xmldb will pass us the xml file and we can perform any substitution as necessary
 */
function local_xmldb_contents_sub(&amp;$contents) {
    // the main install.xml file needs to sub in plugintype tables.
    $searchstring = '&lt;!-- PLUGIN_TYPE_SUBSTITUTION --&gt;';
    if (strstr($contents, $searchstring) === 0) {
        return;
    }
    // ok, we're in the main file and we need to install all the plugin tables
    // get the basic skeleton structure
    $plugintables = file_get_contents(get_config('docroot') . 'lib/db/plugintables.xml');
    $tosub = '';
    foreach (plugin_types() as $plugin) {
        // any that want their own stuff can put it in docroot/plugintype/lib/db/plugintables.xml
        //- like auth is a bit special
        $specialcase = get_config('docroot') . $plugin . '/plugintables.xml';
        if (is_readable($specialcase)) {
            $tosub .= file_get_contents($specialcase) . &quot;\n&quot;;
        }
        else {
            $replaced = '';
            // look for tables to put at the start...
            $pretables = get_config('docroot') . $plugin . '/beforetables.xml';
            if (is_readable($pretables)) {
                $replaced = file_get_contents($pretables) . &quot;\n&quot;;
            }

            // perform any additional once off substitutions
            require_once(get_config('docroot') . $plugin . '/lib.php');
            $classname = generate_class_name($plugin);
            if (method_exists($classname, 'extra_xmldb_substitution')) {
                $replaced  .= $classname::extra_xmldb_substitution($plugintables);
            }
            else {
                $replaced .= $plugintables;
            }
            $tosub .= str_replace('__PLUGINTYPE__', $plugin, $replaced) . &quot;\n&quot;;
            // look for any tables to put at the end..
            $extratables = get_config('docroot') . $plugin . '/extratables.xml';
            if (is_readable($extratables)) {
                $tosub .= file_get_contents($extratables) . &quot;\n&quot;;
            }
        }
    }
    $contents = str_replace($searchstring, $tosub, $contents);
}


/**
 * validates a plugin for installation
 * @throws InstallationException
*/
function validate_plugin($plugintype, $pluginname, $pluginpath='') {

    if (empty($pluginpath)) {
        $pluginpath = get_config('docroot') . $plugintype . '/' . $pluginname;
    }
    if (!file_exists($pluginpath . '/version.php')) {
        throw new InstallationException(get_string('versionphpmissing1', 'error', $plugintype, $pluginname, $pluginname, $pluginpath));
    }
    safe_require($plugintype, $pluginname);
    $classname = generate_class_name($plugintype, $pluginname);
    if (!class_exists($classname)) {
        throw new InstallationException(get_string('classmissing', 'error', $classname, $plugintype, $pluginname));
    }
    require_once(get_config('docroot') . $plugintype . '/lib.php');
    $funname = $plugintype . '_check_plugin_sanity';
    if (function_exists($funname)) {
        $funname($pluginname);
    }
}

/**
 * Sorting upgrade order and allowing for priority
 *
 * @param array $upgrades   List of core and plugins to upgrade
 * @return array            Sorted $upgrades list
 */
function sort_upgrade_order($upgrades) {
    $floaters = array();
    uksort($upgrades, 'sort_upgrades');

    // We check here if any special reordering needs to be done.
    // Some plugins need to run before others if they are both present.
    // We set up a $floaters array if there are any matches.
    if (isset($upgrades['auth.webservice']) &amp;&amp; isset($upgrades['module.lti_advantage'])) {
        $floaters['auth.webservice'] = 'module.lti_advantage';
    }

    if ($floaters) {
        // A $floater, for example, can look like key ='auth.webservice', value='lti.advantage' and the value is the item
        // we want to float up the $upgrades list but we do this by sinking
        // the key down the list. So the key 'auth.webservice' needs to exist as a key in $upgrades higher in the list
        // than the value 'lti.advantage' exists as a key in $upgrades list before reaching this part.
        // After this part the 'lti.advantage' key should appear highter than 'auth.webservice' in the $upgrades list.
        uksort($upgrades, function($k1, $k2) use (&amp;$floaters) {
            if (isset($floaters[$k1]) &amp;&amp; $k2 == $floaters[$k1]) {
                unset($floaters[$k1]);
                return 1;
            }
            else if (isset($floaters[$k1])) {
                return 1;
            }
            else {
                return 0;
            }
        });
    }

    return $upgrades;
}

/*
* the order things are installed/upgraded in matters
*/

function sort_upgrades($k1, $k2) {
    if ($k1 == 'core') {
        return -1;
    }
    else if ($k2 == 'core') {
        return 1;
    }
    else if ($k1 == 'firstcoredata') {
        return -1;
    }
    else if ($k2 == 'firstcoredata') {
        return 1;
    }
    else if ($k1 == 'localpreinst') {
        return -1;
    }
    else if ($k2 == 'localpreinst') {
        return 1;
    }
    else if ($k1 == 'localpostinst') {
        return 1;
    }
    else if ($k2 == 'localpostinst') {
        return -1;
    }
    else if ($k1 == 'lastcoredata') {
        return 1;
    }
    else if ($k2 == 'lastcoredata') {
        return -1;
    }
    // else obey the order plugin types returns (strip off plugintype. from the start)
    $weight1 = array_search(substr($k1, 0, strpos($k1, '.')), plugin_types());
    $weight2 = array_search(substr($k2, 0, strpos($k2, '.')), plugin_types());
    return ($weight1 &gt; $weight2);
}

/** blocktype categories the system exports (including artefact categories)
*/
function get_blocktype_categories() {
    return array('shortcut', 'fileimagevideo', 'blog', 'general', 'internal', 'resume', 'external');
}

function install_blocktype_categories_for_plugin($blocktype) {
    if (!safe_require('blocktype', $blocktype, 'lib.php', 'require_once', true)) {
        // Block has been uninstalled or is missing, so no category data to enter.
        return;
    }
    $blocktype = blocktype_namespaced_to_single($blocktype);
    $catsinstalled = get_column('blocktype_category', 'name');
    db_begin();
    delete_records('blocktype_installed_category', 'blocktype', $blocktype);
    $classname = generate_class_name('blocktype', $blocktype);
    $categories = $classname::get_categories();
    if ($categories) {
        foreach ($categories as $k=&gt;$v) {
            if (is_string($k) &amp;&amp; is_int($v)) {
                // New block with name =&gt; sortorder array.
                $cat = $k;
                $sortorder = $v;
            }
            else {
                // Legacy block with just categories, no sortorders. Give it the default sortorder.
                $cat = $v;
                $sortorder = PluginBlocktype::$DEFAULT_SORTORDER;
            }
            if (in_array($cat, $catsinstalled)) {
                insert_record('blocktype_installed_category', (object)array(
                    'blocktype' =&gt; $blocktype,
                    'category' =&gt; $cat,
                    'sortorder' =&gt; $sortorder,
                ));
            }
        }
    }
    db_commit();
}

function install_blocktype_viewtypes_for_plugin($blocktype) {
    if (!safe_require('blocktype', $blocktype, 'lib.php', 'require_once', true)) {
        // Block has been uninstalled or is missing, so no viewtype data to enter.
        return;
    }
    $blocktype = blocktype_namespaced_to_single($blocktype);
    $vtinstalled = get_column('view_type', 'type');
    db_begin();
    delete_records('blocktype_installed_viewtype', 'blocktype', $blocktype);
    $classname = generate_class_name('blocktype', $blocktype);
    $viewtypes = $classname::get_viewtypes();
    if ($viewtypes) {
        foreach($viewtypes as $vt) {
            if (in_array($vt, $vtinstalled)) {
                insert_record('blocktype_installed_viewtype', (object)array(
                    'blocktype' =&gt; $blocktype,
                    'viewtype'  =&gt; $vt,
                ));
            }
        }
    }
    db_commit();
}

function install_blocktype_extras() {
    db_begin();

    $categories = get_blocktype_categories();
    $installedcategories = get_column('blocktype_category', 'name');
    $sort = empty($installedcategories) ? -1 : get_record_sql('SELECT MAX(sort) AS maxsort FROM {blocktype_category}')-&gt;maxsort;

    if ($toinstall = array_diff($categories, $installedcategories)) {
        foreach ($toinstall as $i) {
            insert_record('blocktype_category', (object)array('name' =&gt; $i, 'sort' =&gt; (++$sort)));
        }
    }

    db_commit();


    // poll all the installed blocktype plugins and ask them what categories they export
    if ($blocktypes = plugins_installed('blocktype', true)) {
        foreach ($blocktypes as $bt) {
            install_blocktype_categories_for_plugin(blocktype_single_to_namespaced($bt-&gt;name, $bt-&gt;artefactplugin));
            install_blocktype_viewtypes_for_plugin(blocktype_single_to_namespaced($bt-&gt;name, $bt-&gt;artefactplugin));
        }
    }
}

/**
 * Reload htmlpurifier filters from the XML configuration file.
 */
function reload_html_filters() {
    require_once('xmlize.php');

    $newlist = xmlize(file_get_contents(get_config('libroot') . 'htmlpurifiercustom/filters.xml'));
    $filters = $newlist['filters']['#']['filter'];
    foreach ($filters as &amp;$f) {
        $f = (object) array(
            'site' =&gt; $f['#']['site'][0]['#'],
            'file' =&gt; $f['#']['filename'][0]['#']
        );
    }
    set_config('filters', serialize($filters));
    log_info('Enabled ' . count($filters) . ' HTML filters.');
}

/**
 * Update safe iframe regex
 *
 * @return bool
 * @throws SystemException
 */
function update_safe_iframe_regex() {
    $prefixes = get_column('iframe_source', 'prefix');
    if (!empty($prefixes)) {
        // We must generate a guaranteed valid regex here that's not
        // too slack.  It's easiest to whitelist a few characters, but
        // in future we may need to be more clever.  Admins who know
        // what they're doing, and need something fancy, can always
        // override this in config.php.
        foreach ($prefixes as $key =&gt; $r) {
            if (!preg_match('/^[\?a-zA-Z0-9\/\._-]+$/', $r)) {
                throw new SystemException('Invalid site passed to update_safe_iframe_regex');
            }
            if (substr($r, -1) == '/') {
                $prefixes[$key] = substr($r, 0, -1) . '($|[/?#])';
            }
        }

        // Allowed iframe URLs should be one of the partial URIs in iframe_source,
        // prefaced by http:// or https:// or just // (which is a protocol-relative URL)
        $iframeregexp = '%^(http:|https:|)//(' . str_replace('.', '\.', implode('|', $prefixes)) . ')%';
    }
    return set_config('iframeregexp', isset($iframeregexp) ? $iframeregexp : null);
}

function update_safe_iframes(array $iframesources, array $iframedomains) {
    db_begin();

    delete_records('iframe_source_icon');
    foreach ($iframedomains as $name =&gt; $domain) {
        insert_record('iframe_source_icon', (object) array('name' =&gt; $name, 'domain' =&gt; $domain));
    }

    delete_records('iframe_source');
    foreach ($iframesources as $prefix =&gt; $name) {
        insert_record('iframe_source', (object) array('prefix' =&gt; $prefix, 'name' =&gt; $name));
    }

    update_safe_iframe_regex();
    db_commit();
}

/**
 * Use meaningful defaults for the antispam settings.
 */
function set_antispam_defaults() {
    set_config('formsecret', get_random_key());
    require_once(get_config('docroot') . 'lib/antispam.php');
    if(checkdnsrr('test.uribl.com.black.uribl.com', 'A')) {
        set_config('antispam', 'advanced');
    }
    else {
        set_config('antispam', 'simple');
    }
    set_config('spamhaus', 0);
    set_config('surbl', 0);
}

function activate_plugin_form($plugintype, $plugin) {
    // Check if there is a displayname
    $classname = generate_class_name($plugintype, $plugin-&gt;name);
    $plugin-&gt;displayname = $classname::get_plugin_display_name();

    return pieform(array(
        'name'            =&gt; 'activate_' . $plugintype . '_' . $plugin-&gt;name,
        'renderer'        =&gt; 'div',
        'elementclasses'  =&gt; false,
        'successcallback' =&gt; 'activate_plugin_submit',
        'class'           =&gt; 'form-inline form-as-button float-start last btn-group-item',
        'jsform'          =&gt; false,
        'action'          =&gt; get_config('wwwroot') . 'admin/extensions/pluginconfig.php',
        'elements' =&gt; array(
            'plugintype' =&gt; array('type' =&gt; 'hidden', 'value' =&gt; $plugintype),
            'pluginname' =&gt; array('type' =&gt; 'hidden', 'value' =&gt; $plugin-&gt;name),
            'disable'    =&gt; array('type' =&gt; 'hidden', 'value' =&gt; $plugin-&gt;active),
            'enable'     =&gt; array('type' =&gt; 'hidden', 'value' =&gt; 1-$plugin-&gt;active),
            'submit'     =&gt; array(
                'type'  =&gt; 'button',
                'usebuttontag' =&gt; true,
                'class' =&gt; 'btn-secondary btn-sm',
                'elementtitle' =&gt; ($plugin-&gt;active ? get_string('hide') : get_string('show')) . ' ' . $plugintype . ' ' . (($plugin-&gt;displayname) ? $plugin-&gt;displayname : $plugin-&gt;name),
                'hiddenlabel' =&gt; true,
                'value' =&gt; $plugin-&gt;active ? '&lt;span class=&quot;icon icon-eye&quot;&gt;&lt;span class=&quot;visually-hidden&quot; aria-hidden=&quot;true&quot;&gt;' . get_string('hide') . '&lt;/span&gt;&lt;/span&gt;' : '&lt;span class=&quot;icon icon-eye-slash&quot;&gt;&lt;span class=&quot;visually-hidden&quot; aria-hidden=&quot;true&quot;&gt;' . get_string('show') . '&lt;/span&gt;&lt;/span&gt;',
            ),
        ),
    ));
}

function activate_plugin_submit(Pieform $form, $values) {
    global $SESSION;
    if ($values['plugintype'] == 'blocktype') {
        if (strpos($values['pluginname'], '/') !== false) {
            list($artefact, $values['pluginname']) = explode('/', $values['pluginname']);
            // Don't enable blocktypes unless the artefact plugin that provides them is also enabled
            if ($values['enable'] &amp;&amp; !get_field('artefact_installed', 'active', 'name', $artefact)) {
                $SESSION-&gt;add_error_msg(get_string('pluginnotenabled', 'mahara', $artefact));
                redirect('/admin/extensions/plugins.php');
            }
        }
    }
    else if ($values['plugintype'] == 'artefact' &amp;&amp; $values['disable']) {
        // Disable all the artefact's blocktypes too
        set_field('blocktype_installed', 'active', 0, 'artefactplugin', $values['pluginname']);
    }
    set_field($values['plugintype'] . '_installed', 'active', $values['enable'], 'name', $values['pluginname']);
    $SESSION-&gt;add_ok_msg(get_string('plugin' . (($values['enable']) ? 'enabled' : 'disabled')));
    redirect('/admin/extensions/plugins.php');
}

// site warnings for the admin to consider
function site_warnings() {

    $warnings = array();

    // Warn about nasty php settings that Mahara can still sort of deal with.
    if (ini_get_bool('register_globals')) {
        $warnings[] = get_string('registerglobals', 'error');
    }
    if (!defined('CRON') &amp;&amp; ini_get_bool('magic_quotes_gpc')) {
        $warnings[] = get_string('magicquotesgpc', 'error');
    }
    if (ini_get_bool('magic_quotes_runtime')) {
        $warnings[] = get_string('magicquotesruntime', 'error');
    }
    if (ini_get_bool('magic_quotes_sybase')) {
        $warnings[] = get_string('magicquotessybase', 'error');
    }

    // Check if the host returns a usable value for the timezone identifier %z
    $tz_count_date = new DateTime();
    $tz_count = preg_match(&quot;/[\+\-][0-9]{4}/&quot;, $tz_count_date-&gt;format('O'));
    if ($tz_count == 0 || $tz_count == FALSE) {
        $warnings[] = get_string('timezoneidentifierunusable', 'error');
    }
    if (get_config('dbtimezone')) {
        $warnings[] = get_string('updatesitetimezone', 'error');
    }

    // Check for low security (i.e. not random enough) session IDs
    if (version_compare(PHP_VERSION, '7.1.0') &lt; 0 &amp;&amp; (int)ini_get('session.entropy_length') &lt; 16) {
        $warnings[] = get_string('notenoughsessionentropy', 'error');
    }

    // Check noreply address is valid.
    if (!sanitize_email(get_config('noreplyaddress')) || get_config('noreplyaddress') == 'noreply@example.org') {
        $warnings[] = get_string('noreplyaddressmissingorinvalid', 'error', get_config('wwwroot') . 'admin/site/options.php?fs=emailsettings');
    }

    // If the configurable themes bug 1760732 was triggered by a recent upgrade, provide a warning that the theme needs resaving.
    $custom_themes = get_records_sql_array(&quot;SELECT i.displayname FROM {institution} i
                                            JOIN {institution_config} ic ON ic.institution = i.name
                                            WHERE ic.field = ? AND ic.value = ?
                                            ORDER BY i.displayname&quot;, array('customthemeupdate', '1'));
    if ($custom_themes) {
        $warning = get_string('resavecustomthemes', 'error') . &quot;&lt;ul&gt;&quot;;
        foreach ($custom_themes as $theme) {
            $warning .= &quot;&lt;li&gt;&quot; . hsc($theme-&gt;displayname) . &quot;&lt;/li&gt;&quot;;
        }
        $warning .= &quot;&lt;/ul&gt;&quot;;
        $warnings[] = $warning;
    }

    safe_require('auth', 'saml');
    if (PluginAuthSaml::is_active()) {
        // Check if the saml plugin config needs updating
        if (record_exists_select('auth_config', &quot;plugin = ? AND field = ?&quot;, array('saml', 'simplesamlphplib'))) {
            $warnings[] = get_string('obsoletesamlplugin', 'auth.saml', get_config('wwwroot') . 'admin/extensions/pluginconfig.php?plugintype=auth&amp;pluginname=saml');
        }
        // Check if all saml instances are configured for new auth/saml plugin.
        if ($samls = get_records_sql_array(
                 &quot;SELECT ai.id, ai.instancename, i.name, i.displayname FROM {auth_instance} ai
                  LEFT JOIN {institution} i ON i.name = ai.institution
                  WHERE ai.id NOT IN (
                                      SELECT instance FROM {auth_instance_config} aic
                                      WHERE aic.field = ?
                  ) AND ai.authname = ? ORDER BY i.displayname&quot;, array('institutionidpentityid', 'saml'))) {
            foreach ($samls as $saml) {
                $warnings[] = get_string('obsoletesamlinstance', 'auth.saml', get_config('wwwroot') . 'admin/users/addauthority.php?id=' . $saml-&gt;id . '&amp;edit=1&amp;i=' . $saml-&gt;name . '&amp;p=saml', $saml-&gt;instancename, $saml-&gt;displayname);
            }
        }
        // Check if the library is updated to the latest version Mahara supports
        $autoload = get_config('docroot') .'auth/saml/extlib/simplesamlphp/vendor/autoload.php';
        if (file_exists($autoload)) {
            require(get_config('docroot') .'auth/saml/extlib/simplesamlphp/vendor/autoload.php');
            $config = SimpleSAML\Configuration::getInstance();

            $libversion = get_config_plugin('auth', 'saml', 'version');
            if (!empty($libversion) &amp;&amp; $config-&gt;getVersion() != $libversion) {
                $warnings[] = get_string('errorupdatelib', 'auth.saml');
            }
        }

    }

    // Check that the GD library has support for jpg, png and gif at least
    $gdinfo = gd_info();
    if (!$gdinfo['JPEG Support']) {
        $warnings[] = get_string('gdlibrarylacksjpegsupport', 'error');
    }

    if (!$gdinfo['PNG Support']) {
        $warnings[] = get_string('gdlibrarylackspngsupport', 'error');
    }

    if (!$gdinfo['GIF Read Support'] || !$gdinfo['GIF Create Support']) {
        $warnings[] = get_string('gdlibrarylacksgifsupport', 'error');
    }

    // Check file upload settings.
    $postmax       = ini_get('post_max_size');
    $uploadmax     = ini_get('upload_max_filesize');
    $realpostmax   = get_real_size($postmax);
    $realuploadmax = get_real_size($uploadmax);
    if ($realpostmax &amp;&amp; $realpostmax &lt; $realuploadmax) {
        $warnings[] = get_string('postmaxlessthanuploadmax', 'error', $postmax, $uploadmax, $postmax);
    }
    else if ($realpostmax &amp;&amp; $realpostmax &lt; 9000000) {
        $warnings[] = get_string('smallpostmaxsize', 'error', $postmax, $postmax);
    }

    if (ini_get('open_basedir')) {
        $warnings[] = get_string('openbasedirenabled', 'error') . ' ' . get_string('openbasedirwarning', 'error');
    }

    $sitesalt = get_config('passwordsaltmain');
    if (empty($sitesalt)) {
        $warnings[] = get_string('nopasswordsaltset', 'error');
    }
    else if ($sitesalt == 'some long random string here with lots of characters'
            || trim($sitesalt) === ''
            || preg_match('/^([a-zA-Z0-9]{0,10})$/', $sitesalt)) {
        $warnings[] = get_string('passwordsaltweak', 'error');
    }

    $urlsecret = get_config('urlsecret');
    if (!empty($urlsecret) &amp;&amp; $urlsecret == 'mysupersecret') {
        $warnings[] = get_string('urlsecretweak', 'error');
    }

    if (!extension_loaded('mbstring')) {
        $warnings[] = get_string('mbstringneeded', 'error');
    }

    if (get_config('dbtype') == 'mysql') {
        $warnings[] = get_string('switchtomysqli', 'error');
    }

    return $warnings;
}


/**
 * Increment the cache version number.
 * This is an arbitrary number that we append to the end of static content to make sure the user
 * refreshes it when we update the site.
 */
function bump_cache_version() {
    set_config('cacheversion', get_config('cacheversion') + 1);
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fvar%2Fsoftaculous%2Fmahara'>Back to Directory</a>