Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle 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 3 of the License, or

// (at your option) any later version.

//

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

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

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

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Library of functions and constants for module glossary

 * (replace glossary with the name of your module and delete this line)

 *

 * @package   mod_glossary

 * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

require_once($CFG->libdir . '/completionlib.php');

define("GLOSSARY_SHOW_ALL_CATEGORIES", 0);

define("GLOSSARY_SHOW_NOT_CATEGORISED", -1);

define("GLOSSARY_NO_VIEW", -1);

define("GLOSSARY_STANDARD_VIEW", 0);

define("GLOSSARY_CATEGORY_VIEW", 1);

define("GLOSSARY_DATE_VIEW", 2);

define("GLOSSARY_AUTHOR_VIEW", 3);

define("GLOSSARY_ADDENTRY_VIEW", 4);

define("GLOSSARY_IMPORT_VIEW", 5);

define("GLOSSARY_EXPORT_VIEW", 6);

define("GLOSSARY_APPROVAL_VIEW", 7);

// Glossary tabs.

define('GLOSSARY_STANDARD', 'standard');

define('GLOSSARY_AUTHOR', 'author');

define('GLOSSARY_CATEGORY', 'category');

define('GLOSSARY_DATE', 'date');

// Glossary displayformats.

define('GLOSSARY_CONTINUOUS', 'continuous');

define('GLOSSARY_DICTIONARY', 'dictionary');

define('GLOSSARY_FULLWITHOUTAUTHOR', 'fullwithoutauthor');

require_once(__DIR__ . '/deprecatedlib.php');

/// STANDARD FUNCTIONS ///////////////////////////////////////////////////////////

/**

 * @global object

 * @param object $glossary

 * @return int

 */

function glossary_add_instance($glossary) {

    global $DB;

/// Given an object containing all the necessary data,

/// (defined by the form in mod_form.php) this function

/// will create a new instance and return the id number

/// of the new instance.

    if (empty($glossary->ratingtime) or empty($glossary->assessed)) {

        $glossary->assesstimestart  = 0;

        $glossary->assesstimefinish = 0;

    }

    if (empty($glossary->globalglossary) ) {

        $glossary->globalglossary = 0;

    }

    if (!has_capability('mod/glossary:manageentries', context_system::instance())) {

        $glossary->globalglossary = 0;

    }

    $glossary->timecreated  = time();

    $glossary->timemodified = $glossary->timecreated;

    //Check displayformat is a valid one

    $formats = get_list_of_plugins('mod/glossary/formats','TEMPLATE');

    if (!in_array($glossary->displayformat, $formats)) {

        throw new \moodle_exception('unknowformat', '', '', $glossary->displayformat);

    }

    $returnid = $DB->insert_record("glossary", $glossary);

    $glossary->id = $returnid;

    glossary_grade_item_update($glossary);

    $completiontimeexpected = !empty($glossary->completionexpected) ? $glossary->completionexpected : null;

    \core_completion\api::update_completion_date_event($glossary->coursemodule,

        'glossary', $glossary->id, $completiontimeexpected);

    return $returnid;

}

/**

 * Given an object containing all the necessary data,

 * (defined by the form in mod_form.php) this function

 * will update an existing instance with new data.

 *

 * @global object

 * @global object

 * @param object $glossary

 * @return bool

 */

function glossary_update_instance($glossary) {

    global $CFG, $DB;

    if (empty($glossary->globalglossary)) {

        $glossary->globalglossary = 0;

    }

    if (!has_capability('mod/glossary:manageentries', context_system::instance())) {

        // keep previous

        unset($glossary->globalglossary);

    }

    $glossary->timemodified = time();

    $glossary->id           = $glossary->instance;

    if (empty($glossary->ratingtime) or empty($glossary->assessed)) {

        $glossary->assesstimestart  = 0;

        $glossary->assesstimefinish = 0;

    }

    //Check displayformat is a valid one

    $formats = get_list_of_plugins('mod/glossary/formats','TEMPLATE');

    if (!in_array($glossary->displayformat, $formats)) {

        throw new \moodle_exception('unknowformat', '', '', $glossary->displayformat);

    }

    $DB->update_record("glossary", $glossary);

    if ($glossary->defaultapproval) {

        $DB->execute("UPDATE {glossary_entries} SET approved = 1 where approved <> 1 and glossaryid = ?", array($glossary->id));

    }

    glossary_grade_item_update($glossary);

    $completiontimeexpected = !empty($glossary->completionexpected) ? $glossary->completionexpected : null;

    \core_completion\api::update_completion_date_event($glossary->coursemodule,

        'glossary', $glossary->id, $completiontimeexpected);

    return true;

}

/**

 * Given an ID of an instance of this module,

 * this function will permanently delete the instance

 * and any data that depends on it.

 *

 * @global object

 * @param int $id glossary id

 * @return bool success

 */

function glossary_delete_instance($id) {

    global $DB, $CFG;

    if (!$glossary = $DB->get_record('glossary', array('id'=>$id))) {

        return false;

    }

    if (!$cm = get_coursemodule_from_instance('glossary', $id)) {

        return false;

    }

    if (!$context = context_module::instance($cm->id, IGNORE_MISSING)) {

        return false;

    }

    $fs = get_file_storage();

    if ($glossary->mainglossary) {

        // unexport entries

        $sql = "SELECT ge.id, ge.sourceglossaryid, cm.id AS sourcecmid

                  FROM {glossary_entries} ge

                  JOIN {modules} m ON m.name = 'glossary'

                  JOIN {course_modules} cm ON (cm.module = m.id AND cm.instance = ge.sourceglossaryid)

                 WHERE ge.glossaryid = ? AND ge.sourceglossaryid > 0";

        if ($exported = $DB->get_records_sql($sql, array($id))) {

            foreach ($exported as $entry) {

                $entry->glossaryid = $entry->sourceglossaryid;

                $entry->sourceglossaryid = 0;

                $newcontext = context_module::instance($entry->sourcecmid);

                if ($oldfiles = $fs->get_area_files($context->id, 'mod_glossary', 'attachment', $entry->id)) {

                    foreach ($oldfiles as $oldfile) {

                        $file_record = new stdClass();

                        $file_record->contextid = $newcontext->id;

                        $fs->create_file_from_storedfile($file_record, $oldfile);

                    }

                    $fs->delete_area_files($context->id, 'mod_glossary', 'attachment', $entry->id);

                    $entry->attachment = '1';

                } else {

                    $entry->attachment = '0';

                }

                $DB->update_record('glossary_entries', $entry);

            }

        }

    } else {

        // move exported entries to main glossary

        $sql = "UPDATE {glossary_entries}

                   SET sourceglossaryid = 0

                 WHERE sourceglossaryid = ?";

        $DB->execute($sql, array($id));

    }

    // Delete any dependent records

    $entry_select = "SELECT id FROM {glossary_entries} WHERE glossaryid = ?";

    $DB->delete_records_select('comments', "contextid=? AND commentarea=? AND itemid IN ($entry_select)", array($id, 'glossary_entry', $context->id));

    $DB->delete_records_select('glossary_alias',    "entryid IN ($entry_select)", array($id));

    $category_select = "SELECT id FROM {glossary_categories} WHERE glossaryid = ?";

    $DB->delete_records_select('glossary_entries_categories', "categoryid IN ($category_select)", array($id));

    $DB->delete_records('glossary_categories', array('glossaryid'=>$id));

    $DB->delete_records('glossary_entries', array('glossaryid'=>$id));

    // delete all files

    $fs->delete_area_files($context->id);

    glossary_grade_item_delete($glossary);

    \core_completion\api::update_completion_date_event($cm->id, 'glossary', $glossary->id, null);

    $DB->delete_records('glossary', array('id'=>$id));

    // Reset caches.

    \mod_glossary\local\concept_cache::reset_glossary($glossary);

    return true;

}

/**

 * Return a small object with summary information about what a

 * user has done with a given particular instance of this module

 * Used for user activity reports.

 * $return->time = the time they did it

 * $return->info = a short text description

 *

 * @param object $course

 * @param object $user

 * @param object $mod

 * @param object $glossary

 * @return object|null

 */

function glossary_user_outline($course, $user, $mod, $glossary) {

    global $CFG;

    require_once("$CFG->libdir/gradelib.php");

    $grades = grade_get_grades($course->id, 'mod', 'glossary', $glossary->id, $user->id);

    if (empty($grades->items[0]->grades)) {

        $grade = false;

    } else {

        $grade = reset($grades->items[0]->grades);

    }

    if ($entries = glossary_get_user_entries($glossary->id, $user->id)) {

        $result = new stdClass();

        $result->info = count($entries) . ' ' . get_string("entries", "glossary");

        $lastentry = array_pop($entries);

        $result->time = $lastentry->timemodified;

        if ($grade) {

            if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {

                $result->info .= ', ' . get_string('gradenoun') . ': ' . $grade->str_long_grade;

            } else {

                $result->info = get_string('gradenoun') . ': ' . get_string('hidden', 'grades');

            }

        }

        return $result;

    } else if ($grade) {

        $result = (object) [

            'time' => grade_get_date_for_user_grade($grade, $user),

        ];

        if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {

            $result->info = get_string('gradenoun') . ': ' . $grade->str_long_grade;

        } else {

            $result->info = get_string('gradenoun') . ': ' . get_string('hidden', 'grades');

        }

        return $result;

    }

    return NULL;

}

/**

 * @global object

 * @param int $glossaryid

 * @param int $userid

 * @return array

 */

function glossary_get_user_entries($glossaryid, $userid) {

/// Get all the entries for a user in a glossary

    global $DB;

    return $DB->get_records_sql("SELECT e.*, u.firstname, u.lastname, u.email, u.picture

                                   FROM {glossary} g, {glossary_entries} e, {user} u

                             WHERE g.id = ?

                               AND e.glossaryid = g.id

                               AND e.userid = ?

                               AND e.userid = u.id

                          ORDER BY e.timemodified ASC", array($glossaryid, $userid));

}

/**

 * Print a detailed representation of what a  user has done with

 * a given particular instance of this module, for user activity reports.

 *

 * @global object

 * @param object $course

 * @param object $user

 * @param object $mod

 * @param object $glossary

 */

function glossary_user_complete($course, $user, $mod, $glossary) {

    global $CFG, $OUTPUT;

    require_once("$CFG->libdir/gradelib.php");

    $grades = grade_get_grades($course->id, 'mod', 'glossary', $glossary->id, $user->id);

    if (!empty($grades->items[0]->grades)) {

        $grade = reset($grades->items[0]->grades);

        if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {

            echo $OUTPUT->container(get_string('gradenoun') . ': ' . $grade->str_long_grade);

            if ($grade->str_feedback) {

                echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);

            }

        } else {

            echo $OUTPUT->container(get_string('gradenoun') . ': ' . get_string('hidden', 'grades'));

        }

    }

    if ($entries = glossary_get_user_entries($glossary->id, $user->id)) {

        echo '<table width="95%" border="0"><tr><td>';

        foreach ($entries as $entry) {

            $cm = get_coursemodule_from_instance("glossary", $glossary->id, $course->id);

            glossary_print_entry($course, $cm, $glossary, $entry,"","",0);

            echo '<p>';

        }

        echo '</td></tr></table>';

    }

}

/**

 * Returns all glossary entries since a given time for specified glossary

 *

 * @param array $activities sequentially indexed array of objects

 * @param int   $index

 * @param int   $timestart

 * @param int   $courseid

 * @param int   $cmid

 * @param int   $userid defaults to 0

 * @param int   $groupid defaults to 0

 * @return void adds items into $activities and increases $index

 */

function glossary_get_recent_mod_activity(&$activities, &$index, $timestart, $courseid, $cmid, $userid = 0, $groupid = 0) {

    global $COURSE, $USER, $DB;

    if ($COURSE->id == $courseid) {

        $course = $COURSE;

    } else {

        $course = $DB->get_record('course', array('id' => $courseid));

    }

    $modinfo = get_fast_modinfo($course);

    $cm = $modinfo->cms[$cmid];

    $context = context_module::instance($cm->id);

    if (!$cm->uservisible) {

        return;

    }

    $viewfullnames = has_capability('moodle/site:viewfullnames', $context);

    // Groups are not yet supported for glossary. See MDL-10728 .

    /*

    $accessallgroups = has_capability('moodle/site:accessallgroups', $context);

    $groupmode = groups_get_activity_groupmode($cm, $course);

     */

    $params['timestart'] = $timestart;

    if ($userid) {

        $userselect = "AND u.id = :userid";

        $params['userid'] = $userid;

    } else {

        $userselect = '';

    }

    if ($groupid) {

        $groupselect = 'AND gm.groupid = :groupid';

        $groupjoin   = 'JOIN {groups_members} gm ON  gm.userid=u.id';

        $params['groupid'] = $groupid;

    } else {

        $groupselect = '';

        $groupjoin   = '';

    }

    $approvedselect = "";

    if (!has_capability('mod/glossary:approve', $context)) {

        $approvedselect = " AND ge.approved = 1 ";

    }

    $params['timestart'] = $timestart;

    $params['glossaryid'] = $cm->instance;

    $userfieldsapi = \core_user\fields::for_userpic();

    $ufields = $userfieldsapi->get_sql('u', false, '', 'userid', false)->selects;

    $entries = $DB->get_records_sql("

              SELECT ge.id AS entryid, ge.glossaryid, ge.concept, ge.definition, ge.approved,

                     ge.timemodified, $ufields

                FROM {glossary_entries} ge

                JOIN {user} u ON u.id = ge.userid

                     $groupjoin

               WHERE ge.timemodified > :timestart

                 AND ge.glossaryid = :glossaryid

                     $approvedselect

                     $userselect

                     $groupselect

            ORDER BY ge.timemodified ASC", $params);

    if (!$entries) {

        return;

    }

    foreach ($entries as $entry) {

        // Groups are not yet supported for glossary. See MDL-10728 .

        /*

        $usersgroups = null;

        if ($entry->userid != $USER->id) {

            if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {

                if (is_null($usersgroups)) {

                    $usersgroups = groups_get_all_groups($course->id, $entry->userid, $cm->groupingid);

                    if (is_array($usersgroups)) {

                        $usersgroups = array_keys($usersgroups);

                    } else {

                        $usersgroups = array();

                    }

                }

                if (!array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid))) {

                    continue;

                }

            }

        }

         */

        $tmpactivity                       = new stdClass();

        $tmpactivity->user                 = user_picture::unalias($entry, null, 'userid');

        $tmpactivity->user->fullname       = fullname($tmpactivity->user, $viewfullnames);

        $tmpactivity->type                 = 'glossary';

        $tmpactivity->cmid                 = $cm->id;

        $tmpactivity->glossaryid           = $entry->glossaryid;

        $tmpactivity->name                 = format_string($cm->name, true);

        $tmpactivity->sectionnum           = $cm->sectionnum;

        $tmpactivity->timestamp            = $entry->timemodified;

        $tmpactivity->content              = new stdClass();

        $tmpactivity->content->entryid     = $entry->entryid;

        $tmpactivity->content->concept     = $entry->concept;

        $tmpactivity->content->definition  = $entry->definition;

        $tmpactivity->content->approved    = $entry->approved;

        $activities[$index++] = $tmpactivity;

    }

    return true;

}

/**

 * Outputs the glossary entry indicated by $activity

 *

 * @param object $activity      the activity object the glossary resides in

 * @param int    $courseid      the id of the course the glossary resides in

 * @param bool   $detail        not used, but required for compatibilty with other modules

 * @param int    $modnames      not used, but required for compatibilty with other modules

 * @param bool   $viewfullnames not used, but required for compatibilty with other modules

 * @return void

 */

function glossary_print_recent_mod_activity($activity, $courseid, $detail, $modnames, $viewfullnames) {

    global $OUTPUT;

    echo html_writer::start_tag('div', array('class'=>'glossary-activity clearfix'));

    if (!empty($activity->user)) {

        echo html_writer::tag('div', $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid)),

            array('class' => 'glossary-activity-picture'));

    }

    echo html_writer::start_tag('div', array('class'=>'glossary-activity-content'));

    echo html_writer::start_tag('div', array('class'=>'glossary-activity-entry'));

    if (isset($activity->content->approved) && !$activity->content->approved) {

        $urlparams = array('g' => $activity->glossaryid, 'mode' => 'approval', 'hook' => $activity->content->concept);

        $class = array('class' => 'dimmed_text');

    } else {

        $urlparams = array('g' => $activity->glossaryid, 'mode' => 'entry', 'hook' => $activity->content->entryid);

        $class = array();

    }

    echo html_writer::link(new moodle_url('/mod/glossary/view.php', $urlparams),

            strip_tags($activity->content->concept), $class);

    echo html_writer::end_tag('div');

    $url = new moodle_url('/user/view.php', array('course'=>$courseid, 'id'=>$activity->user->id));

    $name = $activity->user->fullname;

    $link = html_writer::link($url, $name, $class);

    echo html_writer::start_tag('div', array('class'=>'user'));

    echo $link .' - '. userdate($activity->timestamp);

    echo html_writer::end_tag('div');

    echo html_writer::end_tag('div');

    echo html_writer::end_tag('div');

    return;

}

/**

 * Given a course and a time, this module should find recent activity

 * that has occurred in glossary activities and print it out.

 * Return true if there was output, or false is there was none.

 *

 * @global object

 * @global object

 * @global object

 * @param object $course

 * @param object $viewfullnames

 * @param int $timestart

 * @return bool

 */

function glossary_print_recent_activity($course, $viewfullnames, $timestart) {

    global $CFG, $USER, $DB, $OUTPUT, $PAGE;

    //TODO: use timestamp in approved field instead of changing timemodified when approving in 2.0

    if (!defined('GLOSSARY_RECENT_ACTIVITY_LIMIT')) {

        define('GLOSSARY_RECENT_ACTIVITY_LIMIT', 50);

    }

    $modinfo = get_fast_modinfo($course);

    $ids = array();

    foreach ($modinfo->cms as $cm) {

        if ($cm->modname != 'glossary') {

            continue;

        }

        if (!$cm->uservisible) {

            continue;

        }

        $ids[$cm->instance] = $cm->id;

    }

    if (!$ids) {

        return false;

    }

    // generate list of approval capabilities for all glossaries in the course.

    $approvals = array();

    foreach ($ids as $glinstanceid => $glcmid) {

        $context = context_module::instance($glcmid);

        if (has_capability('mod/glossary:view', $context)) {

            // get records glossary entries that are approved if user has no capability to approve entries.

            if (has_capability('mod/glossary:approve', $context)) {

                $approvals[] = ' ge.glossaryid = :glsid'.$glinstanceid.' ';

            } else {

                $approvals[] = ' (ge.approved = 1 AND ge.glossaryid = :glsid'.$glinstanceid.') ';

            }

            $params['glsid'.$glinstanceid] = $glinstanceid;

        }

    }

    if (count($approvals) == 0) {

        return false;

    }

    $userfieldsapi = \core_user\fields::for_userpic();

    $userfields = $userfieldsapi->get_sql('u', false, '', 'userid', false)->selects;

    $selectsql = 'SELECT ge.id, ge.concept, ge.approved, ge.timemodified, ge.glossaryid,

            ' . $userfields;

    $countsql = 'SELECT COUNT(*)';

    $joins = array(' FROM {glossary_entries} ge ');

    $joins[] = 'JOIN {user} u ON u.id = ge.userid ';

    $fromsql = implode("\n", $joins);

    $params['timestart'] = $timestart;

    $clausesql = ' WHERE ge.timemodified > :timestart ';

    if (count($approvals) > 0) {

        $approvalsql = 'AND ('. implode(' OR ', $approvals) .') ';

    } else {

        $approvalsql = '';

    }

    $ordersql = 'ORDER BY ge.timemodified ASC';

    $entries = $DB->get_records_sql($selectsql.$fromsql.$clausesql.$approvalsql.$ordersql, $params, 0, (GLOSSARY_RECENT_ACTIVITY_LIMIT+1));

    if (empty($entries)) {

        return false;

    }

    echo $OUTPUT->heading(get_string('newentries', 'glossary') . ':', 6);

    $strftimerecent = get_string('strftimerecent');

    $entrycount = 0;

    foreach ($entries as $entry) {

        if ($entrycount < GLOSSARY_RECENT_ACTIVITY_LIMIT) {

            if ($entry->approved) {

                $dimmed = '';

                $urlparams = array('g' => $entry->glossaryid, 'mode' => 'entry', 'hook' => $entry->id);

            } else {

                $dimmed = ' dimmed_text';

                $urlparams = array('id' => $ids[$entry->glossaryid], 'mode' => 'approval', 'hook' => format_text($entry->concept, true));

            }

            $link = new moodle_url($CFG->wwwroot.'/mod/glossary/view.php' , $urlparams);

            echo '<div class="head'.$dimmed.'">';

            echo '<div class="date">'.userdate($entry->timemodified, $strftimerecent).'</div>';

            echo '<div class="name">'.fullname($entry, $viewfullnames).'</div>';

            echo '</div>';

            echo '<div class="info"><a href="'.$link.'">'.format_string($entry->concept, true).'</a></div>';

            $entrycount += 1;

        } else {

            $numnewentries = $DB->count_records_sql($countsql.$joins[0].$clausesql.$approvalsql, $params);

            echo '<div class="head"><div class="activityhead">'.get_string('andmorenewentries', 'glossary', $numnewentries - GLOSSARY_RECENT_ACTIVITY_LIMIT).'</div></div>';

            break;

        }

    }

    return true;

}

/**

 * @global object

 * @param object $log

 */

function glossary_log_info($log) {

    global $DB;

    return $DB->get_record_sql("SELECT e.*, u.firstname, u.lastname

                                  FROM {glossary_entries} e, {user} u

                                 WHERE e.id = ? AND u.id = ?", array($log->info, $log->userid));

}

/**

 * Function to be run periodically according to the moodle cron

 * This function searches for things that need to be done, such

 * as sending out mail, toggling flags etc ...

 * @return bool

 */

function glossary_cron () {

    return true;

}

/**

 * Return grade for given user or all users.

 *

 * @param stdClass $glossary A glossary instance

 * @param int $userid Optional user id, 0 means all users

 * @return array An array of grades, false if none

 */

function glossary_get_user_grades($glossary, $userid=0) {

    global $CFG;

    require_once($CFG->dirroot.'/rating/lib.php');

    $ratingoptions = new stdClass;

    //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?

    $ratingoptions->modulename = 'glossary';

    $ratingoptions->moduleid   = $glossary->id;

    $ratingoptions->component  = 'mod_glossary';

    $ratingoptions->ratingarea = 'entry';

    $ratingoptions->userid = $userid;

    $ratingoptions->aggregationmethod = $glossary->assessed;

    $ratingoptions->scaleid = $glossary->scale;

    $ratingoptions->itemtable = 'glossary_entries';

    $ratingoptions->itemtableusercolumn = 'userid';

    $rm = new rating_manager();

    return $rm->get_user_grades($ratingoptions);

}

/**

 * Return rating related permissions

 *

 * @param int $contextid the context id

 * @param string $component The component we want to get permissions for

 * @param string $ratingarea The ratingarea that we want to get permissions for

 * @return array an associative array of the user's rating permissions

 */

function glossary_rating_permissions($contextid, $component, $ratingarea) {

    if ($component != 'mod_glossary' || $ratingarea != 'entry') {

        // We don't know about this component/ratingarea so just return null to get the

        // default restrictive permissions.

        return null;

    }

    $context = context::instance_by_id($contextid);

    return array(

        'view'    => has_capability('mod/glossary:viewrating', $context),

        'viewany' => has_capability('mod/glossary:viewanyrating', $context),

        'viewall' => has_capability('mod/glossary:viewallratings', $context),

        'rate'    => has_capability('mod/glossary:rate', $context)

    );

}

/**

 * Validates a submitted rating

 * @param array $params submitted data

 *            context => object the context in which the rated items exists [required]

 *            component => The component for this module - should always be mod_forum [required]

 *            ratingarea => object the context in which the rated items exists [required]

 *            itemid => int the ID of the object being rated [required]

 *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]

 *            rating => int the submitted rating

 *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]

 *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [optional]

 * @return boolean true if the rating is valid. Will throw rating_exception if not

 */

function glossary_rating_validate($params) {

    global $DB, $USER;

    // Check the component is mod_forum

    if ($params['component'] != 'mod_glossary') {

        throw new rating_exception('invalidcomponent');

    }

    // Check the ratingarea is post (the only rating area in forum)

    if ($params['ratingarea'] != 'entry') {

        throw new rating_exception('invalidratingarea');

    }

    // Check the rateduserid is not the current user .. you can't rate your own posts

    if ($params['rateduserid'] == $USER->id) {

        throw new rating_exception('nopermissiontorate');

    }

    $glossarysql = "SELECT g.id as glossaryid, g.scale, g.course, e.userid as userid, e.approved, e.timecreated, g.assesstimestart, g.assesstimefinish

                      FROM {glossary_entries} e

                      JOIN {glossary} g ON e.glossaryid = g.id

                     WHERE e.id = :itemid";

    $glossaryparams = array('itemid' => $params['itemid']);

    $info = $DB->get_record_sql($glossarysql, $glossaryparams);

    if (!$info) {

        //item doesn't exist

        throw new rating_exception('invaliditemid');

    }

    if ($info->scale != $params['scaleid']) {

        //the scale being submitted doesnt match the one in the database

        throw new rating_exception('invalidscaleid');

    }

    //check that the submitted rating is valid for the scale

    // lower limit

    if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {

        throw new rating_exception('invalidnum');

    }

    // upper limit

    if ($info->scale < 0) {

        //its a custom scale

        $scalerecord = $DB->get_record('scale', array('id' => -$info->scale));

        if ($scalerecord) {

            $scalearray = explode(',', $scalerecord->scale);

            if ($params['rating'] > count($scalearray)) {

                throw new rating_exception('invalidnum');

            }

        } else {

            throw new rating_exception('invalidscaleid');

        }

    } else if ($params['rating'] > $info->scale) {

        //if its numeric and submitted rating is above maximum

        throw new rating_exception('invalidnum');

    }

    //check the item we're rating was created in the assessable time window

    if (!empty($info->assesstimestart) && !empty($info->assesstimefinish)) {

        if ($info->timecreated < $info->assesstimestart || $info->timecreated > $info->assesstimefinish) {

            throw new rating_exception('notavailable');

        }

    }

    $cm = get_coursemodule_from_instance('glossary', $info->glossaryid, $info->course, false, MUST_EXIST);

    $context = context_module::instance($cm->id, MUST_EXIST);

    // if the supplied context doesnt match the item's context

    if ($context->id != $params['context']->id) {

        throw new rating_exception('invalidcontext');

    }

    return true;

}

/**

 * Update activity grades

 *

 * @category grade

 * @param stdClass $glossary Null means all glossaries (with extra cmidnumber property)

 * @param int $userid specific user only, 0 means all

 * @param bool $nullifnone If true and the user has no grade then a grade item with rawgrade == null will be inserted

 */

function glossary_update_grades($glossary=null, $userid=0, $nullifnone=true) {

    global $CFG, $DB;

    require_once($CFG->libdir.'/gradelib.php');

    if (!$glossary->assessed) {

        glossary_grade_item_update($glossary);

    } else if ($grades = glossary_get_user_grades($glossary, $userid)) {

        glossary_grade_item_update($glossary, $grades);

    } else if ($userid and $nullifnone) {

        $grade = new stdClass();

        $grade->userid   = $userid;

        $grade->rawgrade = NULL;

        glossary_grade_item_update($glossary, $grade);

    } else {

        glossary_grade_item_update($glossary);

    }

}

/**

 * Create/update grade item for given glossary

 *

 * @category grade

 * @param stdClass $glossary object with extra cmidnumber

 * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook

 * @return int, 0 if ok, error code otherwise

 */

function glossary_grade_item_update($glossary, $grades=NULL) {

    global $CFG;

    require_once($CFG->libdir.'/gradelib.php');

    $params = array('itemname'=>$glossary->name, 'idnumber'=>$glossary->cmidnumber);

    if (!$glossary->assessed or $glossary->scale == 0) {

        $params['gradetype'] = GRADE_TYPE_NONE;

    } else if ($glossary->scale > 0) {

        $params['gradetype'] = GRADE_TYPE_VALUE;

        $params['grademax']  = $glossary->scale;

        $params['grademin']  = 0;

    } else if ($glossary->scale < 0) {

        $params['gradetype'] = GRADE_TYPE_SCALE;

        $params['scaleid']   = -$glossary->scale;

    }

    if ($grades  === 'reset') {

        $params['reset'] = true;

        $grades = NULL;

    }

    return grade_update('mod/glossary', $glossary->course, 'mod', 'glossary', $glossary->id, 0, $grades, $params);

}

/**

 * Delete grade item for given glossary

 *

 * @category grade

 * @param object $glossary object

 */

function glossary_grade_item_delete($glossary) {

    global $CFG;

    require_once($CFG->libdir.'/gradelib.php');

    return grade_update('mod/glossary', $glossary->course, 'mod', 'glossary', $glossary->id, 0, NULL, array('deleted'=>1));

}

/**

 * @deprecated since Moodle 3.8

 */

function glossary_scale_used() {

    throw new coding_exception('glossary_scale_used() can not be used anymore. Plugins can implement ' .

        '<modname>_scale_used_anywhere, all implementations of <modname>_scale_used are now ignored');

}

/**

 * Checks if scale is being used by any instance of glossary

 *

 * This is used to find out if scale used anywhere

 *

 * @global object

 * @param int $scaleid

 * @return boolean True if the scale is used by any glossary

 */

function glossary_scale_used_anywhere($scaleid) {

    global $DB;

    if ($scaleid and $DB->record_exists_select('glossary', "scale = ? and assessed > 0", [-$scaleid])) {

        return true;

    } else {

        return false;

    }

}

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

/// Any other glossary functions go here.  Each of them must have a name that

/// starts with glossary_

/**

 * This function return an array of valid glossary_formats records

 * Everytime it's called, every existing format is checked, new formats

 * are included if detected and old formats are deleted and any glossary

 * using an invalid format is updated to the default (dictionary).

 *

 * @global object

 * @global object

 * @return array

 */

function glossary_get_available_formats() {

    global $CFG, $DB;

    // Get available formats (plugin) and insert them (if necessary) into glossary_formats.

    $formats = get_list_of_plugins('mod/glossary/formats', 'TEMPLATE');

    $pluginformats = array();

    $formatrecords = $DB->get_records("glossary_formats");

    foreach ($formats as $format) {

        // If the format file exists.

        if (file_exists($CFG->dirroot.'/mod/glossary/formats/'.$format.'/'.$format.'_format.php')) {

            include_once($CFG->dirroot.'/mod/glossary/formats/'.$format.'/'.$format.'_format.php');

            //If the function exists

            if (function_exists('glossary_show_entry_'.$format)) {

                // Acummulate it as a valid format.

                $pluginformats[] = $format;

                // Check if the format exists in the table.

                $rec = null;

                foreach ($formatrecords as $record) {

                    if ($record->name == $format) {

                        $rec = $record;

                        break;

                    }

                }

                if (!$rec) {

                    // Insert the record in glossary_formats.

                    $gf = new stdClass();

                    $gf->name = $format;

                    $gf->popupformatname = $format;

                    $gf->visible = 1;

                    $id = $DB->insert_record('glossary_formats', $gf);

                    $rec = $DB->get_record('glossary_formats', array('id' => $id));

                    array_push($formatrecords, $rec);

                }

                if (empty($rec->showtabs)) {

                    glossary_set_default_visible_tabs($rec);

                }

            }

        }

    }

    // Delete non_existent formats from glossary_formats table.

    foreach ($formatrecords as $record) {

        $todelete = false;

        // If the format in DB isn't a valid previously detected format then delete the record.

        if (!in_array($record->name, $pluginformats)) {

            $todelete = true;

        }

        if ($todelete) {

            // Delete the format.

            $DB->delete_records('glossary_formats', array('id' => $record->id));

            unset($formatrecords[$record->id]);

            // Reassign existing glossaries to default (dictionary) format.

            if ($glossaries = $DB->get_records('glossary', array('displayformat' => $record->name))) {

                foreach($glossaries as $glossary) {

                    $DB->set_field('glossary', 'displayformat', 'dictionary', array('id' => $glossary->id));

                }

            }

        }

    }

    return $formatrecords;

}

/**

 * @param bool $debug

 * @param string $text

 * @param int $br

 */

function glossary_debug($debug,$text,$br=1) {

    if ( $debug ) {

        echo '<font color="red">' . $text . '</font>';

        if ( $br ) {

            echo '<br />';

        }

    }

}

/**

 *

 * @global object

 * @param int $glossaryid

 * @param string $entrylist

 * @param string $pivot

 * @return array

 */

function glossary_get_entries($glossaryid, $entrylist, $pivot = "") {

    global $DB;

    if ($pivot) {

       $pivot .= ",";

    }

    return $DB->get_records_sql("SELECT $pivot id,userid,concept,definition,format

                                   FROM {glossary_entries}

                                  WHERE glossaryid = ?