Uploaded image for project: 'Moodle'
  1. Moodle
  2. MDL-4790

Language-specific grammar doesn't exist

    XMLWordPrintable

    Details

    • Type: New Feature
    • Status: Open
    • Priority: Trivial
    • Resolution: Unresolved
    • Affects Version/s: 1.5.2
    • Fix Version/s: None
    • Component/s: General
    • Labels:
      None
    • Environment:
      All
    • Affected Branches:
      MOODLE_15_STABLE

      Description

      For Slav(ic) and I think Finnish and there are certainly more languages, language-specific grammar is not handled in Moodle code, no matter the version is. For instance, when Admin goes to the Edit User Accounts he can see e.g. 6 Korisnici in Serbian instead of 6 korisnika for 6 Users, because plural form when in no count-related context (Korisnici) differs from the count-related versions, namely: 1 poruka (being 1 message in English), 2, 3, 4 poruke (messages), but then if we count further, we say 5, 6, 7,..., 20 poruka (in English it remains messages), then 21, 31, 41,... are the same as 1, 22-24,32-34,42-44 the same as 2-4, and 25-30, 35-40,... are the same as 5-10 and 11-19, 111-119, 211-219 (poruka). I can suggest a function for handling this:

      /**

      • more specific function to accommodate for plural forms of known words
      • @param int $num numerical value that has to have appropriate plural form
      • @param string $singlr singular form
      • @param string $frm2 word form for $num values ending with a number between 2 and 4
      • @param string $frm5 word form for $num values ending with a number between 5 and 9, 0 and between 11 and 14
      • @return string (hopefully) correct plural form

      */

      function sr_la_utf8_plu_ext($num = 1, $singlrfrm = '', $frm2 = '', $frm5 = '') {

      //determine what plural form to apply according to $num

      if (($num % 10 > 4 and $num % 10 < 10) or ($num % 100 < 15 and $num % 100 > 10))

      { $result = $frm5; } elseif ($num % 10 == 1) { $result = $singlrfrm; } else { $result = $frm5; }

      return $result;

      }

      Declinations are another problem - there are so many languages with them, but no support at all!

      e.g. resource = izvor in Serbian, but

      Adding a resource = dodavanje izvora

      activity=aktivnost, but adding a new activity is dodavanje nove aktivnosti.

      I have also got functions for this, they don't seem to be general enough, but I 'm still working on them. More important is, I think, how to organize the support for this. I myself have put all language-grammar-related functions into langfun.php, residing in language pack folder and then updated functions in lib/moodlelib.php to allow one more code evaluation (eval function in PHP) in get_string for translated expressions between e.g. <eval> and </eval> tags. An example for this comes from moodle.php in language pack:

      $string['addinganewto'] = 'Dodavanje nov<eval>sr_la_utf8_gen_ext(sr_la_utf8_ma_fem(\$a->what),\'og\',\'e\',\'og\')</eval> <eval>sr_la_utf8_gen(\'$a->what\')</eval> <eval>sr_la_utf8_dat(\'$a->to\')</eval>';

      (sr_la_utf8_ma_fem is the gender detection function, the others are for handling declinations, namely the Genitive and Dative Case)

      another example:

      $string['displayingrecords'] = 'Za prikaz: $a zapis<eval>sr_la_utf8_plu_ext($a,\'\',\'a\',\'a\')</eval>';

      Function for accommodating this is as follows (it is eval_get_string, located in moodlelib.php; here is the whole file, the code sequences added are commented with //Bojan Milosavljevic:...); look in lines: 4514, and for the rest of code in 836, 861, 4411, 4420, 4442, 4458:

      <?php // $Id: moodlelib.php,v 1.565.2.21 2005/07/15 11:11:08 stronk7 Exp $

      ///////////////////////////////////////////////////////////////////////////

      // //

      // NOTICE OF COPYRIGHT //

      // //

      // Moodle - Modular Object-Oriented Dynamic Learning Environment //

      // http://moodle.org //

      // //

      // Copyright (C) 1999-2004 Martin Dougiamas http://dougiamas.com //

      // //

      // This program is free software; you can redistribute it and/or modify //

      // it under the terms of the GNU General Public License as published by //

      // the Free Software Foundation; either version 2 of the License, or //

      // (at your option) any later version. //

      // //

      // This program is distributed in the hope that it will be useful, //

      // but WITHOUT ANY WARRANTY; without even the implied warranty of //

      // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //

      // GNU General Public License for more details: //

      // //

      // http://www.gnu.org/copyleft/gpl.html //

      // //

      ///////////////////////////////////////////////////////////////////////////

      /**

      • moodlelib.php - Moodle main library

      *

      • Main library file of miscellaneous general-purpose Moodle functions.
      • Other main libraries:
      • - weblib.php - functions that produce web output
      • - datalib.php - functions that access the database
      • @author Martin Dougiamas
      • @version $Id: moodlelib.php,v 1.565.2.21 2005/07/15 11:11:08 stronk7 Exp $
      • @package moodlecore

      */

      /// CONSTANTS /////////////////////////////////////////////////////////////

      /**

      • Used by some scripts to check they are being called by Moodle

      */

      define('MOODLE_INTERNAL', true);

      /**

      • No groups used?

      */

      define('NOGROUPS', 0);

      /**

      • Groups used?

      */

      define('SEPARATEGROUPS', 1);

      /**

      • Groups visible?

      */

      define('VISIBLEGROUPS', 2);

      /**

      • Time constant - the number of seconds in a week

      */

      define('WEEKSECS', 604800);

      /**

      • Time constant - the number of seconds in a day

      */

      define('DAYSECS', 86400);

      /**

      • Time constant - the number of seconds in an hour

      */

      define('HOURSECS', 3600);

      /**

      • Time constant - the number of seconds in a minute

      */

      define('MINSECS', 60);

      /**

      • Time constant - the number of minutes in a day

      */

      define('DAYMINS', 1440);

      /**

      • Time constant - the number of minutes in an hour

      */

      define('HOURMINS', 60);

      /**

      • Parameter constants - if set then the parameter is cleaned of scripts etc

      */

      define('PARAM_RAW', 0x0000);

      define('PARAM_CLEAN', 0x0001);

      define('PARAM_INT', 0x0002);

      define('PARAM_INTEGER', 0x0002); // Alias for PARAM_INT

      define('PARAM_ALPHA', 0x0004);

      define('PARAM_ACTION', 0x0004); // Alias for PARAM_ALPHA

      define('PARAM_FORMAT', 0x0004); // Alias for PARAM_ALPHA

      define('PARAM_NOTAGS', 0x0008);

      define('PARAM_FILE', 0x0010);

      define('PARAM_PATH', 0x0020);

      define('PARAM_HOST', 0x0040); // FQDN or IPv4 dotted quad

      define('PARAM_URL', 0x0080);

      define('PARAM_LOCALURL', 0x0180); // NOT orthogonal to the others! Implies PARAM_URL!

      define('PARAM_CLEANFILE',0x0200);

      define('PARAM_ALPHANUM', 0x0400); //numbers or letters only

      define('PARAM_BOOL', 0x0800); //convert to value 1 or 0 using empty()

      define('PARAM_CLEANHTML',0x1000); //actual HTML code that you want cleaned and slashes removed

      define('PARAM_ALPHAEXT', 0x2000); // PARAM_ALPHA plus the chars in quotes: /-_ allowed

      define('PARAM_SAFEDIR', 0x4000); // safe directory name, suitable for include() and require()

      /**

      • Definition of page types

      */

      define('PAGE_COURSE_VIEW', 'course-view');

      /// PARAMETER HANDLING ////////////////////////////////////////////////////

      /**

      • Returns a particular value for the named variable, taken from
      • POST or GET. If the parameter doesn't exist then an error is
      • thrown because we require this variable.

      *

      • This function should be used to initialise all required values
      • in a script that are based on parameters. Usually it will be
      • used like this:
      • $id = required_param('id');

      *

      • @param string $varname the name of the parameter variable we want
      • @param integer $options a bit field that specifies any cleaning needed
      • @return mixed

      */

      function required_param($varname, $options=PARAM_CLEAN) {

      if (isset($_POST[$varname]))

      { // POST has precedence $param = $_POST[$varname]; } else if (isset($_GET[$varname])) { $param = $_GET[$varname]; } else { error('A required parameter ('.$varname.') was missing'); }



      return clean_param($param, $options);

      }



      /**

      * Returns a particular value for the named variable, taken from

      * POST or GET, otherwise returning a given default.

      *

      * This function should be used to initialise all optional values

      * in a script that are based on parameters. Usually it will be

      * used like this:

      * $name = optional_param('name', 'Fred');

      *

      * @param string $varname the name of the parameter variable we want

      * @param mixed $default the default value to return if nothing is found

      * @param integer $options a bit field that specifies any cleaning needed

      * @return mixed

      */

      function optional_param($varname, $default=NULL, $options=PARAM_CLEAN) {



      if (isset($_POST[$varname])) { // POST has precedence $param = $_POST[$varname]; }

      else if (isset($_GET[$varname]))

      { $param = $_GET[$varname]; }

      else

      { return $default; }

      return clean_param($param, $options);

      }

      /**

      • Used by {@link optional_param()}

        and

        {@link required_param()} to

        * clean the variables and/or cast to specific types, based on

        * an options field.

        *

        * @param mixed $param the variable we are cleaning

        * @param integer $options a bit field that specifies the cleaning needed

        * @return mixed

        */

        function clean_param($param, $options) {



        global $CFG;



        if (!$options) { return $param; // Return raw value }



        if ((string)$param == (string)(int)$param) { // It's just an integer return (int)$param; }



        if ($options & PARAM_CLEAN) { $param = stripslashes($param); // Needed by kses to work fine $param = clean_text($param); // Sweep for scripts, etc $param = addslashes($param); // Restore original request parameter slashes }



        if ($options & PARAM_INT) { $param = (int)$param; // Convert to integer }



        if ($options & PARAM_ALPHA) { // Remove everything not a-z $param = eregi_replace('[^a-zA-Z]', '', $param); }



        if ($options & PARAM_ALPHANUM) { // Remove everything not a-zA-Z0-9 $param = eregi_replace('[^A-Za-z0-9]', '', $param); }



        if ($options & PARAM_ALPHAEXT) { // Remove everything not a-zA-Z/_- $param = eregi_replace('[^a-zA-Z/_-]', '', $param); }



        if ($options & PARAM_BOOL) { // Convert to 1 or 0 $param = empty($param) ? 0 : 1; }



        if ($options & PARAM_NOTAGS) { // Strip all tags completely $param = strip_tags($param); }



        if ($options & PARAM_SAFEDIR) { // Remove everything not a-zA-Z0-9_- $param = eregi_replace('[^a-zA-Z0-9_-]', '', $param); }



        if ($options & PARAM_CLEANFILE) { // allow only safe characters $param = clean_filename($param); }



        if ($options & PARAM_FILE) { // Strip all suspicious characters from filename

        $param = ereg_replace('[[:cntrl:]]/[<>`\/\':\\/]', '', $param);

        $param = ereg_replace('\.\.+', '', $param);

        if($param == '.') { $param = ''; }

        }



        if ($options & PARAM_PATH) { // Strip all suspicious characters from file path $param = str_replace('\\\'', '\'', $param); $param = str_replace('\\', '', $param); $param = str_replace('\\', '/', $param); $param = ereg_replace('[[:cntrl:]]/[<>`\/\':]', '', $param); $param = ereg_replace('\.\.+', '', $param); $param = ereg_replace('//+', '/', $param); $param = ereg_replace('/(\./)+', '/', $param); }



        if ($options & PARAM_HOST) { // allow FQDN or IPv4 dotted quad

        preg_replace('/[^\.\d\w-]/','', $param ); // only allowed chars

        // match ipv4 dotted quad

        if (preg_match('/(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/',$param, $match)){

        // confirm values are ok

        if ( $match[0] > 255

        // $match[1] > 255

        // $match[3] > 255

        // $match[4] > 255 ) { // hmmm, what kind of dotted quad is this? $param = ''; }

        } elseif ( preg_match('/^[\w\d\.-]+$/', $param) // dots, hyphens, numbers

        && !preg_match('/^[\.-]/', $param) // no leading dots/hyphens

        && !preg_match('/[\.-]$/', $param) // no trailing dots/hyphens

        ) { // all is ok - $param is respected } else { // all is not ok... $param=''; }

        }



        if ($options & PARAM_URL) { // allow safe ftp, http, mailto urls



        include_once($CFG->dirroot . '/lib/validateurlsyntax.php');



        //

        // Parameters to validateurlsyntax()

        //

        // s? scheme is optional

        // H? http optional

        // S? https optional

        // F? ftp optional

        // E? mailto optional

        // u- user section not allowed

        // P- password not allowed

        // a? address optional

        // I? Numeric IP address optional (can use IP or domain)

        // p- port not allowed – restrict to default port

        // f? file path section optional

        // q? query section optional

        // r? fragment (anchor) optional

        //

        if (!empty($param) && validateUrlSyntax($param, 's?H?S?F?E?u-P-a?I?p-f?q?r?')) { // all is ok, param is respected } else { $param =''; // not really ok }

        $options ^= PARAM_URL; // Turn off the URL bit so that simple PARAM_URLs don't test true for PARAM_LOCALURL

        }



        if ($options & PARAM_LOCALURL) {

        // assume we passed the PARAM_URL test...

        // allow http absolute, root relative and relative URLs within wwwroot

        if (!empty($param)) {

        if (preg_match(':/:', $param)) { // root-relative, ok! } elseif (preg_match('/'.preg_quote($CFG->wwwroot, '/').'/i',$param)) { // absolute, and matches our wwwroot } else {

        // relative - let's make sure there are no tricks

        if (validateUrlSyntax($param, 's-u-P-a-p-f+q?r?')) { // looks ok. } else { $param = ''; }

        }

        }

        }



        if ($options & PARAM_CLEANHTML) { $param = stripslashes($param); // Remove any slashes $param = clean_text($param); // Sweep for scripts, etc $param = trim($param); // Sweep for scripts, etc }



        return $param;

        }



        /**

        * For security purposes, this function will check that the currently

        * given sesskey (passed as a parameter to the script or this function)

        * matches that of the current user.

        *

        * @param string $sesskey optionally provided sesskey

        * @return boolean

        */

        function confirm_sesskey($sesskey=NULL) {

        global $USER;



        if (!empty($USER->ignoresesskey) // !empty($CFG->ignoresesskey)) { return true; }



        if (empty($sesskey)) { $sesskey = required_param('sesskey'); // Check script parameters }



        if (!isset($USER->sesskey)) { return false; }



        return ($USER->sesskey === $sesskey);

        }





        /**

        * Improved ensure a variable is set

        * Issue a (custom) error message if not

        * @param mixed $var the variable

        * @param string $error optional additional error message

        */

        function assert_var_set( $var, $error='' ) {

        if (! isset($var)) { error( a required variable is not set - $error ); }

        }





        /**

        * Ensure that a variable is set

        *

        * If $var is undefined throw an error, otherwise return $var.

        * This function will soon be made obsolete by {@link required_param()}

      *

      • @param mixed $var the variable which may be unset
      • @param mixed $default the value to return if $var is unset

      */

      function require_variable($var) {

      if (! isset($var))

      { error('A required parameter was missing'); }

      }

      /**

      • Ensure that a variable is set

      *

      • If $var is undefined set it (by reference), otherwise return $var.

      *

      • @param mixed $var the variable which may be unset
      • @param mixed $default the value to return if $var is unset

      */

      function optional_variable(&$var, $default=0) {

      if (! isset($var))

      { $var = $default; }

      }

      /**

      • Set a key in global configuration

      *

      • Set a key/value pair in both this session's {@link $CFG} global variable

        * and in the 'config' database table for future sessions.

        *

        * Can also be used to update keys for plugin-scoped configs in config_plugin table.

        * In that case it doesn't affect $CFG.

        *

        * @param string $name the key to set

        * @param string $value the value to set

        * @param string $plugin (optional) the plugin scope

        * @uses $CFG

        * @return bool

        */

        function set_config($name, $value, $plugin=NULL) {

        /// No need for get_config because they are usually always available in $CFG



        global $CFG;



        if (empty($plugin)) {

        $CFG->$name = $value; // So it's defined for this invocation at least



        if (get_field('config', 'name', 'name', $name)) { return set_field('config', 'value', $value, 'name', $name); } else { $config->name = $name; $config->value = $value; return insert_record('config', $config); }

        } else { // plugin scope

        if ($id = get_field('config_plugins', 'id', 'name', $name, 'plugin', $plugin)) { return set_field('config_plugins', 'value', $value, 'id', $id); } else { $config->plugin = $plugin; $config->name = $name; $config->value = $value; return insert_record('config_plugins', $config); }

        }

        }



        /**

        * Get configuration values from the global config table

        * or the config_plugins table.

        *

        * If called with no parameters it will do the right thing

        * generating $CFG safely from the database without overwriting

        * existing values.

        *

        * @param string $plugin

        * @param string $name

        * @uses $CFG

        * @return hash-like object or single value

        *

        */

        function get_config($plugin=NULL, $name=NULL) {



        global $CFG;



        if (!empty($name)) { // the user is asking for a specific value

        if (!empty($plugin)) { return get_record('config_plugins', 'plugin' , $plugin, 'name', $name); } else { return get_record('config', 'name', $name); }

        }



        // the user is after a recordset

        if (!empty($plugin)) {

        if ($configs=get_records('config_plugins', 'plugin', $plugin, '', 'name,value')) {

        $configs = (array)$configs;

        $localcfg = array();

        foreach ($configs as $config) { $localcfg[$config->name] = $config->value; }

        return (object)$localcfg;

        } else { return false; }

        } else {

        // this was originally in setup.php

        if ($configs = get_records('config')) {

        $localcfg = (array)$CFG;

        foreach ($configs as $config) {

        if (!isset($localcfg[$config->name])) { $localcfg[$config->name] = $config->value; } else {

        if ($localcfg[$config->name] != $config->value ) {

        // complain if the DB has a different

        // value than config.php does

        error_log(\$CFG->{$config->name} in config.php ({$localcfg[$config->name]}) overrides database setting ({$config->value}));

        }

        }

        }



        $localcfg = (object)$localcfg;

        return $localcfg;

        } else { // preserve $CFG if DB returns nothing or error return $CFG; }



        }

        }





        /**

        * Refresh current $USER session global variable with all their current preferences.

        * @uses $USER

        */

        function reload_user_preferences() {



        global $USER;



        if(empty($USER) // empty($USER->id)) { return false; }



        unset($USER->preference);



        if ($preferences = get_records('user_preferences', 'userid', $USER->id)) {

        foreach ($preferences as $preference) { $USER->preference[$preference->name] = $preference->value; }

        } else { //return empty preference array to hold new values $USER->preference = array(); }

        }



        /**

        * Sets a preference for the current user

        * Optionally, can set a preference for a different user object

        * @uses $USER

        * @todo Add a better description and include usage examples.

        * @param string $name The key to set as preference for the specified user

        * @param string $value The value to set forthe $name key in the specified user's record

        * @param int $userid A moodle user ID

        * @todo Add inline links to $USER and user functions in above line.

        * @return boolean

        */

        function set_user_preference($name, $value, $otheruser=NULL) {



        global $USER;



        if (empty($otheruser)){

        if (!empty($USER) && !empty($USER->id)) { $userid = $USER->id; } else { return false; }

        } else { $userid = $otheruser; }



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



        if ($preference = get_record('user_preferences', 'userid', $userid, 'name', $name)) {

        if (set_field('user_preferences', 'value', $value, 'id', $preference->id)) {

        if (empty($otheruser) and !empty($USER)) { $USER->preference[$name] = $value; }

        return true;

        } else { return false; }



        } else {

        $preference->userid = $userid;

        $preference->name = $name;

        $preference->value = (string)$value;

        if (insert_record('user_preferences', $preference)) {

        if (empty($otheruser) and !empty($USER)) { $USER->preference[$name] = $value; }

        return true;

        } else { return false; }

        }

        }



        /**

        * Unsets a preference completely by deleting it from the database

        * Optionally, can set a preference for a different user id

        * @uses $USER

        * @param string $name The key to unset as preference for the specified user

        * @param int $userid A moodle user ID

        * @return boolean

        */

        function unset_user_preference($name, $userid=NULL) {



        global $USER;



        if (empty($userid)){

        if(!empty($USER) && !empty($USER->id)) { $userid = $USER->id; }

        else { return false; }

        }



        return delete_records('user_preferences', 'userid', $userid, 'name', $name);

        }





        /**

        * Sets a whole array of preferences for the current user

        * @param array $prefarray An array of key/value pairs to be set

        * @param int $userid A moodle user ID

        * @return boolean

        */

        function set_user_preferences($prefarray, $userid=NULL) {



        global $USER;



        if (!is_array($prefarray) or empty($prefarray)) { return false; }



        if (empty($userid)){

        if (!empty($USER) && !empty($USER->id)) { $userid = NULL; // Continue with the current user below } else { return false; // No-one to set! }

        }



        $return = true;

        foreach ($prefarray as $name => $value) { // The order is important; if the test for return is done first, then // if one function call fails all the remaining ones will be optimized away $return = set_user_preference($name, $value, $userid) and $return; }

        return $return;

        }



        /**

        * If no arguments are supplied this function will return

        * all of the current user preferences as an array.

        * If a name is specified then this function

        * attempts to return that particular preference value. If

        * none is found, then the optional value $default is returned,

        * otherwise NULL.

        * @param string $name Name of the key to use in finding a preference value

        * @param string $default Value to be returned if the $name key is not set in the user preferences

        * @param int $userid A moodle user ID

        * @uses $USER

        * @return string

        */

        function get_user_preferences($name=NULL, $default=NULL, $userid=NULL) {



        global $USER;



        if (empty($userid)) { // assume current user

        if (empty($USER->preference)) { return $default; // Default value (or NULL) }

        if (empty($name)) { return $USER->preference; // Whole array }

        if (!isset($USER->preference[$name])) { return $default; // Default value (or NULL) }

        return $USER->preference[$name]; // The single value



        } else {

        $preference = get_records_menu('user_preferences', 'userid', $userid, 'name', 'name,value');



        if (empty($name)) { return $preference; }

        if (!isset($preference[$name])) { return $default; // Default value (or NULL) }

        return $preference[$name]; // The single value

        }

        }





        /// FUNCTIONS FOR HANDLING TIME ////////////////////////////////////////////



        /**

        * Given date parts in user time produce a GMT timestamp.

        *

        * @param int $year The year part to create timestamp of.

        * @param int $month The month part to create timestamp of.

        * @param int $day The day part to create timestamp of.

        * @param int $hour The hour part to create timestamp of.

        * @param int $minute The minute part to create timestamp of.

        * @param int $second The second part to create timestamp of.

        * @param float $timezone

        * @return int timestamp

        * @todo Finish documenting this function

        */

        function make_timestamp($year, $month=1, $day=1, $hour=0, $minute=0, $second=0, $timezone=99, $applydst=true) {



        $timezone = get_user_timezone_offset($timezone);



        if (abs($timezone) > 13) { $time = mktime((int)$hour,(int)$minute,(int)$second,(int)$month,(int)$day,(int)$year); } else {

        $time = gmmktime((int)$hour,(int)$minute,(int)$second,(int)$month,(int)$day,(int)$year);

        $time = usertime($time, $timezone);

        if($applydst) { $time -= dst_offset_on($time); }

        }



        return $time;



        }



        /**

        * Given an amount of time in seconds, returns string

        * formatted nicely as months, days, hours etc as needed

        *

        * @uses MINSECS

        * @uses HOURSECS

        * @uses DAYSECS

        * @param int $totalsecs ?

        * @param array $str ?

        * @return string

        * @todo Finish documenting this function

        */

        function format_time($totalsecs, $str=NULL) {



        $totalsecs = abs($totalsecs);



        if (!$str) { // Create the str structure the slow way $str->day = get_string('day'); $str->days = get_string('days'); $str->hour = get_string('hour'); $str->hours = get_string('hours'); $str->min = get_string('min'); $str->mins = get_string('mins'); $str->sec = get_string('sec'); $str->secs = get_string('secs'); }



        $days = floor($totalsecs/DAYSECS);

        $remainder = $totalsecs - ($days*DAYSECS);

        $hours = floor($remainder/HOURSECS);

        $remainder = $remainder - ($hours*HOURSECS);

        $mins = floor($remainder/MINSECS);

        $secs = $remainder - ($mins*MINSECS);



        $ss = ($secs == 1) ? $str->sec : $str->secs;

        $sm = ($mins == 1) ? $str->min : $str->mins;

        $sh = ($hours == 1) ? $str->hour : $str->hours;

        $sd = ($days == 1) ? $str->day : $str->days;



        $odays = '';

        $ohours = '';

        $omins = '';

        $osecs = '';



        if ($days) $odays = $days .' '. $sd;

        if ($hours) $ohours = $hours .' '. $sh;

        if ($mins) $omins = $mins .' '. $sm;

        if ($secs) $osecs = $secs .' '. $ss;



        if ($days) return $odays .' '. $ohours;

        if ($hours) return $ohours .' '. $omins;

        if ($mins) return $omins .' '. $osecs;

        if ($secs) return $osecs;

        return get_string('now');

        }



        /**

        * Returns a formatted string that represents a date in user time

        * <b>WARNING: note that the format is for strftime(), not date().</b>

        * Because of a bug in most Windows time libraries, we can't use

        * the nicer %e, so we have to use %d which has leading zeroes.

        * A lot of the fuss in the function is just getting rid of these leading

        * zeroes as efficiently as possible.

        *

        * If parameter fixday = true (default), then take off leading

        * zero from %d, else mantain it.

        *

        * @uses HOURSECS

        * @param int $date timestamp in GMT

        * @param string $format strftime format

        * @param float $timezone

        * @param boolean $fixday If true (default) then the leading

        * zero from %d is removed. If false then the leading zero is mantained.

        * @return string

        */

        function userdate($date, $format='', $timezone=99, $fixday = true) {



        global $CFG;



        static $strftimedaydatetime;



        if ($format == '') {

        if (empty($strftimedaydatetime)) { $strftimedaydatetime = get_string('strftimedaydatetime'); }

        $format = $strftimedaydatetime;

        }



        if (!empty($CFG->nofixday)) { // Config.php can force %d not to be fixed. $fixday = false; } else if ($fixday) { $formatnoday = str_replace('%d', 'DD', $format); $fixday = ($formatnoday != $format); }



        $date += dst_offset_on($date);



        $timezone = get_user_timezone_offset($timezone);



        if (abs($timezone) > 13) { /// Server time

        if ($fixday) { $datestring = strftime($formatnoday, $date); $daystring = str_replace(' 0', '', strftime(' %d', $date)); $datestring = str_replace('DD', $daystring, $datestring); } else { $datestring = strftime($format, $date); }

        } else {

        $date += (int)($timezone * 3600);

        if ($fixday) { $datestring = gmstrftime($formatnoday, $date); $daystring = str_replace(' 0', '', gmstrftime(' %d', $date)); $datestring = str_replace('DD', $daystring, $datestring); } else { $datestring = gmstrftime($format, $date); }

        }

        //Bojan Milosavljevic: Language specific unicode from (primarily Windows) server system date to current language charset

        sys_to_currlang_charset ($datestring);

        return $datestring;

        }



        /**

        * Converts (Windows) Unicode characters to current language character set

        *

        * @param string $datestr A date string to convert

        * @return string the converted date

        * @todo SHOULD BE MORE GENERAL!... find server-system- and current-language charset and then map corresponding chars,

        * but this is just a patch

        */

        function sys_to_currlang_charset(&$datestr) {



        //COPIED FROM get_string FUNCTION!!

        global $CFG;



        $lang = current_language();





        /// Define the two or three major locations of language strings for this module



        $location = $CFG->dirroot.'/lang/';



        /// Bojan Milosavljevic: functions for language specific grammar

        $langfunfile = $location.$lang.'/langfun.php';

        if (file_exists($langfunfile)) {

        include_once($langfunfile);

        $maps = charset_maps();





        // END OF COPIED CODE FROM get_string FUNCTION





        foreach ($maps as $i => $map) { $datestr = str_replace ($i, $map,$datestr); }

        }

        return 0;

        }



        /**

        * Given a $time timestamp in GMT (seconds since epoch),

        * returns an array that represents the date in user time

        *

        * @uses HOURSECS

        * @param int $time Timestamp in GMT

        * @param float $timezone

        * @return array An array that represents the date in user time

        * @todo Finish documenting this function

        */

        function usergetdate($time, $timezone=99) {



        $timezone = get_user_timezone_offset($timezone);



        if (abs($timezone) > 13) { // Server time return getdate($time); }



        // There is no gmgetdate so we use gmdate instead

        $time += dst_offset_on($time);

        $time += intval((float)$timezone * HOURSECS);



        $datestring = gmstrftime('%S_%M_%H_%d_%m_%Y_%w_%j_%A_%B', $time);



        list(

        $getdate['seconds'],

        $getdate['minutes'],

        $getdate['hours'],

        $getdate['mday'],

        $getdate['mon'],

        $getdate['year'],

        $getdate['wday'],

        $getdate['yday'],

        $getdate['weekday'],

        $getdate['month']

        ) = explode('_', $datestring);



        return $getdate;

        }



        /**

        * Given a GMT timestamp (seconds since epoch), offsets it by

        * the timezone. eg 3pm in India is 3pm GMT - 7 * 3600 seconds

        *

        * @uses HOURSECS

        * @param int $date Timestamp in GMT

        * @param float $timezone

        * @return int

        */

        function usertime($date, $timezone=99) {



        $timezone = get_user_timezone_offset($timezone);



        if (abs($timezone) > 13) { return $date; }

        return $date - (int)($timezone * HOURSECS);

        }



        /**

        * Given a time, return the GMT timestamp of the most recent midnight

        * for the current user.

        *

        * @param int $date Timestamp in GMT

        * @param float $timezone ?

        * @return ?

        */

        function usergetmidnight($date, $timezone=99) { $timezone = get_user_timezone_offset($timezone); $userdate = usergetdate($date, $timezone); // Time of midnight of this user's day, in GMT return make_timestamp($userdate['year'], $userdate['mon'], $userdate['mday'], 0, 0, 0, $timezone); }



        /**

        * Returns a string that prints the user's timezone

        *

        * @param float $timezone The user's timezone

        * @return string

        */

        function usertimezone($timezone=99) {



        $tz = get_user_timezone($timezone);



        if (!is_float($tz)) { return $tz; }



        if(abs($tz) > 13) { // Server time return get_string('serverlocaltime'); }



        if($tz == intval($tz)) { // Don't show .0 for whole hours $tz = intval($tz); }



        if($tz == 0) { return 'GMT'; }

        else if($tz > 0) { return 'GMT+'.$tz; }

        else { return 'GMT'.$tz; }



        }



        /**

        * Returns a float which represents the user's timezone difference from GMT in hours

        * Checks various settings and picks the most dominant of those which have a value

        *

        * @uses $CFG

        * @uses $USER

        * @param float $tz The user's timezone

        * @return int

        */

        function get_user_timezone_offset($tz = 99) {



        global $USER, $CFG;



        $tz = get_user_timezone($tz);



        if (is_float($tz)) { return $tz; } else {

        $tzrecord = get_timezone_record($tz);

        if (empty($tzrecord)) { return 99.0; }

        return (float)$tzrecord->gmtoff / HOURMINS;

        }

        }



        function get_user_timezone($tz = 99) {

        global $USER, $CFG;



        $timezones = array(

        $tz,

        isset($CFG->forcetimezone) ? $CFG->forcetimezone : 99,

        isset($USER->timezone) ? $USER->timezone : 99,

        isset($CFG->timezone) ? $CFG->timezone : 99,

        );



        $tz = 99;



        while(($tz == '' // $tz == 99) && $next = each($timezones)) { $tz = $next['value']; }



        return is_numeric($tz) ? (float) $tz : $tz;

        }



        function get_timezone_record($timezonename) {

        global $CFG, $db;

        static $cache = NULL;



        if ($cache === NULL) { $cache = array(); }



        if (isset($cache[$timezonename])) { return $cache[$timezonename]; }



        return get_record_sql('SELECT * FROM '.$CFG->prefix.'timezone

        WHERE name = '.$db->qstr($timezonename).' ORDER BY year DESC', true);

        }



        function calculate_user_dst_table($from_year = NULL, $to_year = NULL) {

        global $CFG, $USER;



        if (empty($USER)) { return false; }



        $usertz = get_user_timezone();



        if (is_float($usertz)) { // Trivial timezone, no DST return false; }



        if (!empty($USER->dstoffsettz) && $USER->dstoffsettz != $usertz) { // We have precalculated values, but the user's effective TZ has changed in the meantime, so reset unset($USER->dstoffsets); unset($USER->dstrange); }



        if (!empty($USER->dstoffsets) && empty($from_year) && empty($to_year)) { // Repeat calls which do not request specific year ranges stop here, we have already calculated the table // This will be the return path most of the time, pretty light computationally return true; }



        // Reaching here means we either need to extend our table or create it from scratch



        // Remember which TZ we calculated these changes for

        $USER->dstoffsettz = $usertz;



        if(empty($USER->dstoffsets)) { // If we 're creating from scratch, put the two guard elements in there $USER->dstoffsets = array(1 => NULL, 0 => NULL); }

        if(empty($USER->dstrange)) {

        // If creating from scratch

        $from = max((empty($from_year) ? intval(date('Y')) - 3 : $from_year), 1971);

        $to = min((empty($to_year) ? intval(date('Y')) + 3 : $to_year), 2035);



        // Fill in the array with the extra years we need to process

        $yearstoprocess = array();

        for($i = $from; $i <= $to; ++$i) { $yearstoprocess[] = $i; }



        // Take note of which years we have processed for future calls

        $USER->dstrange = array($from, $to);

        }

        else {

        // If needing to extend the table, do the same

        $yearstoprocess = array();



        $from = max((empty($from_year) ? $USER->dstrange[0] : $from_year), 1971);

        $to = min((empty($to_year) ? $USER->dstrange[1] : $to_year), 2035);



        if($from < $USER->dstrange[0]) {

        // Take note of which years we need to process and then note that we have processed them for future calls

        for($i = $from; $i < $USER->dstrange[0]; ++$i) { $yearstoprocess[] = $i; }

        $USER->dstrange[0] = $from;

        }

        if($to > $USER->dstrange[1]) {

        // Take note of which years we need to process and then note that we have processed them for future calls

        for($i = $USER->dstrange[1] + 1; $i <= $to; ++$i) { $yearstoprocess[] = $i; }

        $USER->dstrange[1] = $to;

        }

        }



        if(empty($yearstoprocess)) { // This means that there was a call requesting a SMALLER range than we have already calculated return true; }



        // From now on, we know that the array has at least the two guard elements, and $yearstoprocess has the years we need

        // Also, the array is sorted in descending timestamp order!



        // Get DB data

        $presetrecords = get_records('timezone', 'name', $usertz, 'year DESC', 'year, gmtoff, dstoff, dst_month, dst_startday, dst_weekday, dst_skipweeks, dst_time, std_month, std_startday, std_weekday, std_skipweeks, std_time');

        if(empty($presetrecords)) { return false; }



        // Remove ending guard (first element of the array)

        reset($USER->dstoffsets);

        unset($USER->dstoffsets[key($USER->dstoffsets)]);



        // Add all required change timestamps

        foreach($yearstoprocess as $y) {

        // Find the record which is in effect for the year $y

        foreach($presetrecords as $year => $preset) {

        if($year <= $y) { break; }

        }



        $changes = dst_changes_for_year($y, $preset);



        if($changes === NULL) { continue; }

        if($changes['dst'] != 0) { $USER->dstoffsets[$changes['dst']] = $preset->dstoff * MINSECS; }

        if($changes['std'] != 0) { $USER->dstoffsets[$changes['std']] = 0; }

        }



        // Put in a guard element at the top

        $maxtimestamp = max(array_keys($USER->dstoffsets));

        $USER->dstoffsets[($maxtimestamp + DAYSECS)] = NULL; // DAYSECS is arbitrary, any small number will do



        // Sort again

        krsort($USER->dstoffsets);



        return true;

        }



        function dst_changes_for_year($year, $timezone) {



        if($timezone->dst_startday == 0 && $timezone->dst_weekday == 0 && $timezone->std_startday == 0 && $timezone->std_weekday == 0) { return NULL; }



        $monthdaydst = find_day_in_month($timezone->dst_startday, $timezone->dst_weekday, $timezone->dst_month, $year);

        $monthdaystd = find_day_in_month($timezone->std_startday, $timezone->std_weekday, $timezone->std_month, $year);



        list($dst_hour, $dst_min) = explode(':', $timezone->dst_time);

        list($std_hour, $std_min) = explode(':', $timezone->std_time);



        $timedst = make_timestamp($year, $timezone->dst_month, $monthdaydst, 0, 0, 0, 99, false);

        $timestd = make_timestamp($year, $timezone->std_month, $monthdaystd, 0, 0, 0, 99, false);



        // Instead of putting hour and minute in make_timestamp(), we add them afterwards.

        // This has the advantage of being able to have negative values for hour, i.e. for timezones

        // where GMT time would be in the PREVIOUS day than the local one on which DST changes.



        $timedst += $dst_hour * HOURSECS + $dst_min * MINSECS;

        $timestd += $std_hour * HOURSECS + $std_min * MINSECS;



        return array('dst' => $timedst, 0 => $timedst, 'std' => $timestd, 1 => $timestd);

        }



        // $time must NOT be compensated at all, it has to be a pure timestamp

        function dst_offset_on($time) {

        global $USER;



        if(!calculate_user_dst_table()) { return 0; }



        if(empty($USER) // empty($USER->dstoffsets)) { return 0; }



        reset($USER->dstoffsets);

        while(list($from, $offset) = each($USER->dstoffsets)) {

        if($from <= $time) { break; }

        }



        // This is the normal return path

        if($offset !== NULL) { return $offset; }



        // Reaching this point means we haven't calculated far enough, do it now:

        // Calculate extra DST changes if needed and recurse. The recursion always

        // moves toward the stopping condition, so will always end.



        if($from == 0) {

        // We need a year smaller than $USER->dstrange[0]

        if($USER->dstrange[0] == 1971) { return 0; }

        calculate_user_dst_table($USER->dstrange[0] - 5, NULL);

        return dst_offset_on($time);

        }

        else {

        // We need a year larger than $USER->dstrange[1]

        if($USER->dstrange[1] == 2035) { return 0; }

        calculate_user_dst_table(NULL, $USER->dstrange[1] + 5);

        return dst_offset_on($time);

        }

        }



        function find_day_in_month($startday, $weekday, $month, $year) {



        $daysinmonth = days_in_month($month, $year);



        if($weekday == -1) { // Don't care about weekday, so return: // abs($startday) if $startday != -1 // $daysinmonth otherwise return ($startday == -1) ? $daysinmonth : abs($startday); }



        // From now on we 're looking for a specific weekday



        // Give end of month its actual value, since we know it

        if($startday == -1) { $startday = -1 * $daysinmonth; }



        // Starting from day $startday, the sign is the direction



        if($startday < 1) {



        $startday = abs($startday);

        $lastmonthweekday = strftime('%w', mktime(12, 0, 0, $month, $daysinmonth, $year, 0));



        // This is the last such weekday of the month

        $lastinmonth = $daysinmonth + $weekday - $lastmonthweekday;

        if($lastinmonth > $daysinmonth) { $lastinmonth -= 7; }



        // Find the first such weekday <= $startday

        while($lastinmonth > $startday) { $lastinmonth -= 7; }



        return $lastinmonth;



        }

        else {



        $indexweekday = strftime('%w', mktime(12, 0, 0, $month, $startday, $year, 0));



        $diff = $weekday - $indexweekday;

        if($diff < 0) { $diff += 7; }



        // This is the first such weekday of the month equal to or after $startday

        $firstfromindex = $startday + $diff;



        return $firstfromindex;



        }

        }



        function days_in_month($month, $year) { return intval(date('t', mktime(12, 0, 0, $month, 1, $year, 0))); }



        function dayofweek($day, $month, $year) { // I wonder if this is any different from // strftime('%w', mktime(12, 0, 0, $month, $daysinmonth, $year, 0)); return intval(date('w', mktime(12, 0, 0, $month, $day, $year, 0))); }



        /// USER AUTHENTICATION AND LOGIN ////////////////////////////////////////



        // Makes sure that $USER->sesskey exists, if $USER itself exists. It sets a new sesskey

        // if one does not already exist, but does not overwrite existing sesskeys. Returns the

        // sesskey string if $USER exists, or boolean false if not.

        function sesskey() {

        global $USER;



        if(!isset($USER)) { return false; }



        if (empty($USER->sesskey)) { $USER->sesskey = random_string(10); }



        return $USER->sesskey;

        }



        /**

        * This function checks that the current user is logged in and has the

        * required privileges

        *

        * This function checks that the current user is logged in, and optionally

        * whether they are allowed to be in a particular course and view a particular

        * course module.

        * If they are not logged in, then it redirects them to the site login unless

        * $autologinguest is set and {@link $CFG}

        ->autologinguests is set to 1 in which

      • case they are automatically logged in as guests.
      • If $courseid is given and the user is not enrolled in that course then the
      • user is redirected to the course enrolment page.
      • If $cm is given and the coursemodule is hidden and the user is not a teacher
      • in the course then the user is redirected to the course home page.

      *

      • @uses $CFG
      • @uses $SESSION
      • @uses $USER
      • @uses $FULLME
      • @uses SITEID
      • @uses $MoodleSession
      • @param int $courseid id of the course
      • @param boolean $autologinguest
      • @param $cm course module object

      */

      function require_login($courseid=0, $autologinguest=true, $cm=null) {

      global $CFG, $SESSION, $USER, $FULLME, $MoodleSession;

      // First check that the user is logged in to the site.

      if (! (isset($USER->loggedin) and $USER->confirmed and ($USER->site == $CFG->wwwroot)) ) { // They're not

      $SESSION->wantsurl = $FULLME;

      if (!empty($_SERVER['HTTP_REFERER']))

      { $SESSION->fromurl = $_SERVER['HTTP_REFERER']; }

      $USER = NULL;

      if ($autologinguest and $CFG->autologinguests and $courseid and get_field('course','guest','id',$courseid))

      { $loginguest = '?loginguest=true'; }

      else

      { $loginguest = ''; }

      if (empty($CFG->loginhttps))

      { redirect($CFG->wwwroot .'/login/index.php'. $loginguest); }

      else

      { $wwwroot = str_replace('http','https', $CFG->wwwroot); redirect($wwwroot .'/login/index.php'. $loginguest); }

      exit;

      }

      // check whether the user should be changing password

      // reload_user_preferences(); // Why is this necessary? Seems wasteful. - MD

      if (!empty($USER->preference['auth_forcepasswordchange'])){

      if (is_internal_auth() // $CFG->

      {'auth_'.$USER->auth.'_stdchangepassword'}

      )

      { $SESSION->wantsurl = $FULLME; redirect($CFG->wwwroot .'/login/change_password.php'); }

      elseif($CFG->changepassword)

      { redirect($CFG->changepassword); }

      else

      { error('You cannot proceed without changing your password. However there is no available page for changing it. Please contact your Moodle Administrator.'); }

      }

      // Check that the user account is properly set up

      if (user_not_fully_set_up($USER))

      { $SESSION->wantsurl = $FULLME; redirect($CFG->wwwroot .'/user/edit.php?id='. $USER->id .'&course='. SITEID); }

      // Make sure current IP matches the one for this session (if required)

      if (!empty($CFG->tracksessionip)) {

      if ($USER->sessionIP != md5(getremoteaddr()))

      { error(get_string('sessionipnomatch', 'error')); }

      }

      // Make sure the USER has a sesskey set up. Used for checking script parameters.

      sesskey();

      // Check that the user has agreed to a site policy if there is one

      if (!empty($CFG->sitepolicy)) {

      if (!$USER->policyagreed)

      { $SESSION->wantsurl = $FULLME; redirect($CFG->wwwroot .'/user/policy.php'); }

      }

      // If the site is currently under maintenance, then print a message

      if (!isadmin()) {

      if (file_exists($CFG->dataroot.'/'.SITEID.'/maintenance.html'))

      { print_maintenance_message(); exit; }

      }

      // Next, check if the user can be in a particular course

      if ($courseid) {

      if ($courseid == SITEID) { // Anyone can be in the site course

      if (isset($cm) and !$cm->visible and !isteacher(SITEID))

      { // Not allowed to see module, send to course page redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden')); }

      return;

      }

      if (!empty($USER->student[$courseid]) or !empty($USER->teacher[$courseid]) or !empty($USER->admin)) {

      if (isset($USER->realuser)) { // Make sure the REAL person can also access this course

      if (!isteacher($courseid, $USER->realuser)) { print_header(); notice(get_string('studentnotallowed', '', fullname($USER, true)), $CFG->wwwroot .'/'); }

      }

      if (isset($cm) and !$cm->visible and !isteacher($courseid)) { // Not allowed to see module, send to course page redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden')); }

      return; // user is a member of this course.

      }

      if (! $course = get_record('course', 'id', $courseid))

      { error('That course doesn\'t exist'); }

      if (!$course->visible)

      { print_header(); notice(get_string('coursehidden'), $CFG->wwwroot .'/'); }

      if ($USER->username == 'guest') {

      switch ($course->guest) {

      case 0: // Guests not allowed

      print_header();

      notice(get_string('guestsnotallowed', '', $course->fullname), $CFG->wwwroot/login/index.php);

      break;

      case 1: // Guests allowed

      if (isset($cm) and !$cm->visible)

      { // Not allowed to see module, send to course page redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden')); }

      return;

      case 2: // Guests allowed with key (drop through)

      break;

      }

      }

      //User is not enrolled in the course, wants to access course content

      //as a guest, and course setting allow unlimited guest access

      //Code cribbed from course/loginas.php

      if (strstr($FULLME,username=guest) && ($course->guest==1)) {

      $realuser = $USER->id;

      $realname = fullname($USER, true);

      $USER = guest_user();

      $USER->loggedin = true;

      $USER->site = $CFG->wwwroot;

      $USER->realuser = $realuser;

      $USER->sessionIP = md5(getremoteaddr()); // Store the current IP in the session

      if (isset($SESSION->currentgroup))

      { // Remember current cache setting for later $SESSION->oldcurrentgroup = $SESSION->currentgroup; unset($SESSION->currentgroup); }

      $guest_name = fullname($USER, true);

      add_to_log($course->id, course, loginas, ../user/view.php?id=$course->id&$USER->id$, $realname -> $guest_name);

      if (isset($cm) and !$cm->visible)

      { // Not allowed to see module, send to course page redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden')); }

      return;

      }

      // Currently not enrolled in the course, so see if they want to enrol

      $SESSION->wantsurl = $FULLME;

      redirect($CFG->wwwroot .'/course/enrol.php?id='. $courseid);

      die;

      }

      }

      /**

      • This is a weaker version of {@link require_login()}

        which only requires login

      • when called from within a course rather than the site page, unless
      • the forcelogin option is turned on.

      *

      • @uses $CFG
      • @param object $course The course object in question
      • @param boolean $autologinguest Allow autologin guests if that is wanted
      • @param object $cm Course activity module if known

      */

      function require_course_login($course, $autologinguest=true, $cm=null) {

      global $CFG;

      if (!empty($CFG->forcelogin))

      { require_login(); }

      if ($course->id != SITEID)

      { require_login($course->id, $autologinguest, $cm); }

      }

      /**

      • Modify the user table by setting the currently logged in user's
      • last login to now.

      *

      • @uses $USER
      • @return boolean

      */

      function update_user_login_times()

      { global $USER; $USER->lastlogin = $user->lastlogin = $USER->currentlogin; $USER->currentlogin = $user->lastaccess = $user->currentlogin = time(); $user->id = $USER->id; return update_record('user', $user); }

      /**

      • Determines if a user has completed setting up their account.

      *

      • @param user $user A {@link $USER}

        object to test for the existance of a valid name and email

      • @return boolean

      */

      function user_not_fully_set_up($user)

      { return ($user->username != 'guest' and (empty($user->firstname) or empty($user->lastname) or empty($user->email) or over_bounce_threshold($user))); }

      function over_bounce_threshold($user) {

      global $CFG;

      if (empty($CFG->handlebounces))

      { return false; }

      // set sensible defaults

      if (empty($CFG->minbounces)) { $CFG->minbounces = 10; }

      if (empty($CFG->bounceratio)) { $CFG->bounceratio = .20; }

      $bouncecount = 0;

      $sendcount = 0;

      if ($bounce = get_record('user_preferences','userid',$user->id,'name','email_bounce_count')) { $bouncecount = $bounce->value; }

      if ($send = get_record('user_preferences','userid',$user->id,'name','email_send_count')) { $sendcount = $send->value; }

      return ($bouncecount >= $CFG->minbounces && $bouncecount/$sendcount >= $CFG->bounceratio);

      }



      /**

      * @param $user - object containing an id

      * @param $reset - will reset the count to 0

      */

      function set_send_count($user,$reset=false) {

      if ($pref = get_record('user_preferences','userid',$user->id,'name','email_send_count')) { $pref->value = (!empty($reset)) ? 0 : $pref->value+1; update_record('user_preferences',$pref); }

      else if (!empty($reset)) { // if it's not there and we're resetting, don't bother. // make a new one $pref->name = 'email_send_count'; $pref->value = 1; $pref->userid = $user->id; insert_record('user_preferences',$pref); }

      }



      /**

      * @param $user - object containing an id

      * @param $reset - will reset the count to 0

      */

      function set_bounce_count($user,$reset=false) {

      if ($pref = get_record('user_preferences','userid',$user->id,'name','email_bounce_count')) { $pref->value = (!empty($reset)) ? 0 : $pref->value+1; update_record('user_preferences',$pref); }

      else if (!empty($reset)) { // if it's not there and we're resetting, don't bother. // make a new one $pref->name = 'email_bounce_count'; $pref->value = 1; $pref->userid = $user->id; insert_record('user_preferences',$pref); }

      }



      /**

      * Keeps track of login attempts

      *

      * @uses $SESSION

      */

      function update_login_count() {



      global $SESSION;



      $max_logins = 10;



      if (empty($SESSION->logincount)) { $SESSION->logincount = 1; } else { $SESSION->logincount++; }



      if ($SESSION->logincount > $max_logins) { unset($SESSION->wantsurl); error(get_string('errortoomanylogins')); }

      }



      /**

      * Resets login attempts

      *

      * @uses $SESSION

      */

      function reset_login_count() { global $SESSION; $SESSION->logincount = 0; }



      /**

      * check_for_restricted_user

      *

      * @uses $CFG

      * @uses $USER

      * @param string $username ?

      * @param string $redirect ?

      * @todo Finish documenting this function

      */

      function check_for_restricted_user($username=NULL, $redirect='') {

      global $CFG, $USER;



      if (!$username) {

      if (!empty($USER->username)) { $username = $USER->username; } else { return false; }

      }



      if (!empty($CFG->restrictusers)) {

      $names = explode(',', $CFG->restrictusers);

      if (in_array($username, $names)) { error(get_string('restricteduser', 'error', fullname($USER)), $redirect); }

      }

      }



      function sync_metacourses() {



      global $CFG;



      if (!$courses = get_records_sql(SELECT DISTINCT parent_course,1 FROM {$CFG->prefix}course_meta)) { return; }



      foreach ($courses as $course) { sync_metacourse($course->parent_course); }

      }





      /**

      * Goes through all enrolment records for the courses inside the metacourse and sync with them.

      */



      function sync_metacourse($metacourseid) {



      global $CFG,$db;



      if (!$metacourse = get_record(course,id,$metacourseid)) { return false; }

      if (count_records('course_meta','parent_course',$metacourseid) == 0) { // if there are no child courses for this meta course, nuke the enrolments

      if ($enrolments = get_records('user_students','course',$metacourseid,'','userid,1')) {

      foreach ($enrolments as $enrolment)

      { unenrol_student($enrolment->userid,$metacourseid); }

      }

      return true;

      }

      // this will return a list of userids from user_student for enrolments in the metacourse that shouldn't be there.

      $sql = SELECT parent.userid,max(child.course) as course

      FROM {$CFG->prefix}course_meta meta

      JOIN {$CFG->prefix}user_students parent

      ON meta.parent_course = parent.course

      LEFT OUTER JOIN {$CFG->prefix}user_students child

      ON child.course = meta.child_course

      AND child.userid = parent.userid

      WHERE meta.parent_course = $metacourseid

      GROUP BY child.course,parent.userid

      ORDER BY parent.userid,child.course;

      $res = $db->Execute($sql);

      //iterate results

      $enrolmentstodelete = array();

      while( !$res->EOF && isset($res->fields) )

      { $enrolmentstodelete[] = $res->fields; $res->MoveNext(); }

      if (!empty($enrolmentstodelete)) {

      $last->id = 0;

      $last->course = 0;

      foreach ($enrolmentstodelete as $enrolment) {

      $enrolment = (object)$enrolment;

      if (count($enrolmentstodelete) == 1 && empty($enrolment->course))

      { unenrol_student($enrolment->userid,$metacourseid); break; }

      if ($last->id != $enrolment->userid) { // we've changed

      if (empty($last->course) && !empty($last->id))

      { unenrol_student($last->id,$metacourseid); // doing it this way for forum subscriptions etc. }

      $last->course = 0;

      $last->id = $enrolment->userid;

      }

      if (!empty($enrolment->course))

      { $last->course = $enrolment->course; }

      }

      if (!empty($last->id) && empty($last->course))

      { unenrol_student($last->id,$metacourseid); // doing it this way for forum subscriptions etc. }

      }

      // this will return a list of userids that need to be enrolled in the metacourse

      $sql = SELECT DISTINCT child.userid,1

      FROM {$CFG->prefix}course_meta meta

      JOIN {$CFG->prefix}user_students child

      ON meta.child_course = child.course

      LEFT OUTER JOIN {$CFG->prefix}user_students parent

      ON meta.parent_course = parent.course

      AND parent.userid = child.userid

      WHERE parent.course IS NULL

      AND meta.parent_course = $metacourseid;

      if ($userstoadd = get_records_sql($sql)) {

      foreach ($userstoadd as $user)

      { enrol_student($user->userid,$metacourseid); }

      }

      // and next make sure that we have the right start time and end time (ie max and min) for them all.

      if ($enrolments = get_records('user_students','course',$metacourseid,'','id,userid')) {

      foreach ($enrolments as $enrol) {

      if ($maxmin = get_record_sql(SELECT min(timestart) AS timestart, max(timeend) AS timeend

      FROM {$CFG->prefix}user_students u JOIN {$CFG->prefix}course_meta mc ON u.course = mc.child_course WHERE userid = $enrol->userid

      AND mc.parent_course = $metacourseid))

      { $enrol->timestart = $maxmin->timestart; $enrol->timeend = $maxmin->timeend; update_record('user_students',$enrol); }

      }

      }

      return true;

      }

      /**

      • Adds a record to the metacourse table and calls sync_metacoures

      */

      function add_to_metacourse ($metacourseid, $courseid) {

      if (!$metacourse = get_record(course,id,$metacourseid))

      { return false; }



      if (!$course = get_record(course,id,$courseid)) { return false; }

      if (!$record = get_record(course_meta,parent_course,$metacourseid,child_course,$courseid)) {

      $rec->parent_course = $metacourseid;

      $rec->child_course = $courseid;

      if (!insert_record('course_meta',$rec))

      { return false; }

      return sync_metacourse($metacourseid);

      }

      return true;

      }

      /**

      • Removes the record from the metacourse table and calls sync_metacourse

      */

      function remove_from_metacourse($metacourseid, $courseid) {

      if (delete_records('course_meta','parent_course',$metacourseid,'child_course',

        Attachments

          Issue Links

            Activity

              People

              Assignee:
              moodle.com moodle.com
              Reporter:
              imported Imported
              Participants:
              Component watchers:
              Adrian Greeve, Jake Dallimore, Mathew May, Mihail Geshoski, Peter Dias
              Votes:
              2 Vote for this issue
              Watchers:
              2 Start watching this issue

                Dates

                Created:
                Updated: