mirror of
https://github.com/moodle/moodle.git
synced 2025-01-18 05:58:34 +01:00
1816 lines
64 KiB
PHP
1816 lines
64 KiB
PHP
<?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/>.
|
|
|
|
/**
|
|
* This file contains the moodle hooks for the assign module.
|
|
*
|
|
* It delegates most functions to the assignment class.
|
|
*
|
|
* @package mod_assign
|
|
* @copyright 2012 NetSpot {@link http://www.netspot.com.au}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
require_once(__DIR__ . '/deprecatedlib.php');
|
|
|
|
/**
|
|
* Adds an assignment instance
|
|
*
|
|
* This is done by calling the add_instance() method of the assignment type class
|
|
* @param stdClass $data
|
|
* @param mod_assign_mod_form $form
|
|
* @return int The instance id of the new assignment
|
|
*/
|
|
function assign_add_instance(stdClass $data, mod_assign_mod_form $form = null) {
|
|
global $CFG;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
$assignment = new assign(context_module::instance($data->coursemodule), null, null);
|
|
return $assignment->add_instance($data, true);
|
|
}
|
|
|
|
/**
|
|
* delete an assignment instance
|
|
* @param int $id
|
|
* @return bool
|
|
*/
|
|
function assign_delete_instance($id) {
|
|
global $CFG;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
$cm = get_coursemodule_from_instance('assign', $id, 0, false, MUST_EXIST);
|
|
$context = context_module::instance($cm->id);
|
|
|
|
$assignment = new assign($context, null, null);
|
|
return $assignment->delete_instance();
|
|
}
|
|
|
|
/**
|
|
* This function is used by the reset_course_userdata function in moodlelib.
|
|
* This function will remove all assignment submissions and feedbacks in the database
|
|
* and clean up any related data.
|
|
*
|
|
* @param stdClass $data the data submitted from the reset course.
|
|
* @return array
|
|
*/
|
|
function assign_reset_userdata($data) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
$status = array();
|
|
$params = array('courseid'=>$data->courseid);
|
|
$sql = "SELECT a.id FROM {assign} a WHERE a.course=:courseid";
|
|
$course = $DB->get_record('course', array('id'=>$data->courseid), '*', MUST_EXIST);
|
|
if ($assigns = $DB->get_records_sql($sql, $params)) {
|
|
foreach ($assigns as $assign) {
|
|
$cm = get_coursemodule_from_instance('assign',
|
|
$assign->id,
|
|
$data->courseid,
|
|
false,
|
|
MUST_EXIST);
|
|
$context = context_module::instance($cm->id);
|
|
$assignment = new assign($context, $cm, $course);
|
|
$status = array_merge($status, $assignment->reset_userdata($data));
|
|
}
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
/**
|
|
* This standard function will check all instances of this module
|
|
* and make sure there are up-to-date events created for each of them.
|
|
* If courseid = 0, then every assignment event in the site is checked, else
|
|
* only assignment events belonging to the course specified are checked.
|
|
*
|
|
* @param int $courseid
|
|
* @param int|stdClass $instance Assign module instance or ID.
|
|
* @param int|stdClass $cm Course module object or ID (not used in this module).
|
|
* @return bool
|
|
*/
|
|
function assign_refresh_events($courseid = 0, $instance = null, $cm = null) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
// If we have instance information then we can just update the one event instead of updating all events.
|
|
if (isset($instance)) {
|
|
if (!is_object($instance)) {
|
|
$instance = $DB->get_record('assign', array('id' => $instance), '*', MUST_EXIST);
|
|
}
|
|
if (isset($cm)) {
|
|
if (!is_object($cm)) {
|
|
assign_prepare_update_events($instance);
|
|
return true;
|
|
} else {
|
|
$course = get_course($instance->course);
|
|
assign_prepare_update_events($instance, $course, $cm);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($courseid) {
|
|
// Make sure that the course id is numeric.
|
|
if (!is_numeric($courseid)) {
|
|
return false;
|
|
}
|
|
if (!$assigns = $DB->get_records('assign', array('course' => $courseid))) {
|
|
return false;
|
|
}
|
|
// Get course from courseid parameter.
|
|
if (!$course = $DB->get_record('course', array('id' => $courseid), '*')) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (!$assigns = $DB->get_records('assign')) {
|
|
return false;
|
|
}
|
|
}
|
|
foreach ($assigns as $assign) {
|
|
assign_prepare_update_events($assign);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This actually updates the normal and completion calendar events.
|
|
*
|
|
* @param stdClass $assign Assignment object (from DB).
|
|
* @param stdClass $course Course object.
|
|
* @param stdClass $cm Course module object.
|
|
*/
|
|
function assign_prepare_update_events($assign, $course = null, $cm = null) {
|
|
global $DB;
|
|
if (!isset($course)) {
|
|
// Get course and course module for the assignment.
|
|
list($course, $cm) = get_course_and_cm_from_instance($assign->id, 'assign', $assign->course);
|
|
}
|
|
// Refresh the assignment's calendar events.
|
|
$context = context_module::instance($cm->id);
|
|
$assignment = new assign($context, $cm, $course);
|
|
$assignment->update_calendar($cm->id);
|
|
// Refresh the calendar events also for the assignment overrides.
|
|
$overrides = $DB->get_records('assign_overrides', ['assignid' => $assign->id], '',
|
|
'id, groupid, userid, duedate, sortorder, timelimit');
|
|
foreach ($overrides as $override) {
|
|
if (empty($override->userid)) {
|
|
unset($override->userid);
|
|
}
|
|
if (empty($override->groupid)) {
|
|
unset($override->groupid);
|
|
}
|
|
assign_update_events($assignment, $override);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes all grades from gradebook
|
|
*
|
|
* @param int $courseid The ID of the course to reset
|
|
* @param string $type Optional type of assignment to limit the reset to a particular assignment type
|
|
*/
|
|
function assign_reset_gradebook($courseid, $type='') {
|
|
global $CFG, $DB;
|
|
|
|
$params = array('moduletype'=>'assign', 'courseid'=>$courseid);
|
|
$sql = 'SELECT a.*, cm.idnumber as cmidnumber, a.course as courseid
|
|
FROM {assign} a, {course_modules} cm, {modules} m
|
|
WHERE m.name=:moduletype AND m.id=cm.module AND cm.instance=a.id AND a.course=:courseid';
|
|
|
|
if ($assignments = $DB->get_records_sql($sql, $params)) {
|
|
foreach ($assignments as $assignment) {
|
|
assign_grade_item_update($assignment, 'reset');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implementation of the function for printing the form elements that control
|
|
* whether the course reset functionality affects the assignment.
|
|
* @param MoodleQuickForm $mform form passed by reference
|
|
*/
|
|
function assign_reset_course_form_definition(&$mform) {
|
|
$mform->addElement('header', 'assignheader', get_string('modulenameplural', 'assign'));
|
|
$name = get_string('deleteallsubmissions', 'assign');
|
|
$mform->addElement('advcheckbox', 'reset_assign_submissions', $name);
|
|
$mform->addElement('advcheckbox', 'reset_assign_user_overrides',
|
|
get_string('removealluseroverrides', 'assign'));
|
|
$mform->addElement('advcheckbox', 'reset_assign_group_overrides',
|
|
get_string('removeallgroupoverrides', 'assign'));
|
|
}
|
|
|
|
/**
|
|
* Course reset form defaults.
|
|
* @param object $course
|
|
* @return array
|
|
*/
|
|
function assign_reset_course_form_defaults($course) {
|
|
return array('reset_assign_submissions' => 1,
|
|
'reset_assign_group_overrides' => 1,
|
|
'reset_assign_user_overrides' => 1);
|
|
}
|
|
|
|
/**
|
|
* Update an assignment instance
|
|
*
|
|
* This is done by calling the update_instance() method of the assignment type class
|
|
* @param stdClass $data
|
|
* @param stdClass $form - unused
|
|
* @return object
|
|
*/
|
|
function assign_update_instance(stdClass $data, $form) {
|
|
global $CFG;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
$context = context_module::instance($data->coursemodule);
|
|
$assignment = new assign($context, null, null);
|
|
return $assignment->update_instance($data);
|
|
}
|
|
|
|
/**
|
|
* This function updates the events associated to the assign.
|
|
* If $override is non-zero, then it updates only the events
|
|
* associated with the specified override.
|
|
*
|
|
* @param assign $assign the assign object.
|
|
* @param object $override (optional) limit to a specific override
|
|
*/
|
|
function assign_update_events($assign, $override = null) {
|
|
global $CFG, $DB;
|
|
|
|
require_once($CFG->dirroot . '/calendar/lib.php');
|
|
|
|
$assigninstance = $assign->get_instance();
|
|
|
|
// Load the old events relating to this assign.
|
|
$conds = array('modulename' => 'assign', 'instance' => $assigninstance->id);
|
|
if (!empty($override)) {
|
|
// Only load events for this override.
|
|
if (isset($override->userid)) {
|
|
$conds['userid'] = $override->userid;
|
|
} else if (isset($override->groupid)) {
|
|
$conds['groupid'] = $override->groupid;
|
|
} else {
|
|
// This is not a valid override, it may have been left from a bad import or restore.
|
|
$conds['groupid'] = $conds['userid'] = 0;
|
|
}
|
|
}
|
|
$oldevents = $DB->get_records('event', $conds, 'id ASC');
|
|
|
|
// Now make a to-do list of all that needs to be updated.
|
|
if (empty($override)) {
|
|
// We are updating the primary settings for the assignment, so we need to add all the overrides.
|
|
$overrides = $DB->get_records('assign_overrides', array('assignid' => $assigninstance->id), 'id ASC');
|
|
// It is necessary to add an empty stdClass to the beginning of the array as the $oldevents
|
|
// list contains the original (non-override) event for the module. If this is not included
|
|
// the logic below will end up updating the wrong row when we try to reconcile this $overrides
|
|
// list against the $oldevents list.
|
|
array_unshift($overrides, new stdClass());
|
|
} else {
|
|
// Just do the one override.
|
|
$overrides = array($override);
|
|
}
|
|
|
|
if (!empty($assign->get_course_module())) {
|
|
$cmid = $assign->get_course_module()->id;
|
|
} else {
|
|
$cmid = get_coursemodule_from_instance('assign', $assigninstance->id, $assigninstance->course)->id;
|
|
}
|
|
|
|
foreach ($overrides as $current) {
|
|
$groupid = isset($current->groupid) ? $current->groupid : 0;
|
|
$userid = isset($current->userid) ? $current->userid : 0;
|
|
$duedate = isset($current->duedate) ? $current->duedate : $assigninstance->duedate;
|
|
$timelimit = isset($current->timelimit) ? $current->timelimit : 0;
|
|
|
|
// Only add 'due' events for an override if they differ from the assign default.
|
|
$addclose = empty($current->id) || !empty($current->duedate);
|
|
|
|
$event = new stdClass();
|
|
$event->type = CALENDAR_EVENT_TYPE_ACTION;
|
|
$event->description = format_module_intro('assign', $assigninstance, $cmid, false);
|
|
$event->format = FORMAT_HTML;
|
|
// Events module won't show user events when the courseid is nonzero.
|
|
$event->courseid = ($userid) ? 0 : $assigninstance->course;
|
|
$event->groupid = $groupid;
|
|
$event->userid = $userid;
|
|
$event->modulename = 'assign';
|
|
$event->instance = $assigninstance->id;
|
|
$event->timestart = $duedate;
|
|
$event->timeduration = $timelimit;
|
|
$event->timesort = $event->timestart + $event->timeduration;
|
|
$event->visible = instance_is_visible('assign', $assigninstance);
|
|
$event->eventtype = ASSIGN_EVENT_TYPE_DUE;
|
|
$event->priority = null;
|
|
|
|
// Determine the event name and priority.
|
|
if ($groupid) {
|
|
// Group override event.
|
|
$params = new stdClass();
|
|
$params->assign = $assigninstance->name;
|
|
$params->group = groups_get_group_name($groupid);
|
|
if ($params->group === false) {
|
|
// Group doesn't exist, just skip it.
|
|
continue;
|
|
}
|
|
$eventname = get_string('overridegroupeventname', 'assign', $params);
|
|
// Set group override priority.
|
|
if (isset($current->sortorder)) {
|
|
$event->priority = $current->sortorder;
|
|
}
|
|
} else if ($userid) {
|
|
// User override event.
|
|
$params = new stdClass();
|
|
$params->assign = $assigninstance->name;
|
|
$eventname = get_string('overrideusereventname', 'assign', $params);
|
|
// Set user override priority.
|
|
$event->priority = CALENDAR_EVENT_USER_OVERRIDE_PRIORITY;
|
|
} else {
|
|
// The parent event.
|
|
$eventname = $assigninstance->name;
|
|
}
|
|
|
|
if ($duedate && $addclose) {
|
|
if ($oldevent = array_shift($oldevents)) {
|
|
$event->id = $oldevent->id;
|
|
} else {
|
|
unset($event->id);
|
|
}
|
|
$event->name = $eventname.' ('.get_string('duedate', 'assign').')';
|
|
calendar_event::create($event, false);
|
|
}
|
|
}
|
|
|
|
// Delete any leftover events.
|
|
foreach ($oldevents as $badevent) {
|
|
$badevent = calendar_event::load($badevent);
|
|
$badevent->delete();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the list if Moodle features this module supports
|
|
*
|
|
* @param string $feature FEATURE_xx constant for requested feature
|
|
* @return mixed True if module supports feature, false if not, null if doesn't know or string for the module purpose.
|
|
*/
|
|
function assign_supports($feature) {
|
|
switch($feature) {
|
|
case FEATURE_GROUPS:
|
|
return true;
|
|
case FEATURE_GROUPINGS:
|
|
return true;
|
|
case FEATURE_MOD_INTRO:
|
|
return true;
|
|
case FEATURE_COMPLETION_TRACKS_VIEWS:
|
|
return true;
|
|
case FEATURE_COMPLETION_HAS_RULES:
|
|
return true;
|
|
case FEATURE_GRADE_HAS_GRADE:
|
|
return true;
|
|
case FEATURE_GRADE_OUTCOMES:
|
|
return true;
|
|
case FEATURE_BACKUP_MOODLE2:
|
|
return true;
|
|
case FEATURE_SHOW_DESCRIPTION:
|
|
return true;
|
|
case FEATURE_ADVANCED_GRADING:
|
|
return true;
|
|
case FEATURE_PLAGIARISM:
|
|
return true;
|
|
case FEATURE_COMMENT:
|
|
return true;
|
|
case FEATURE_MOD_PURPOSE:
|
|
return MOD_PURPOSE_ASSESSMENT;
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* extend an assigment navigation settings
|
|
*
|
|
* @param settings_navigation $settings
|
|
* @param navigation_node $navref
|
|
* @return void
|
|
*/
|
|
function assign_extend_settings_navigation(settings_navigation $settings, navigation_node $navref) {
|
|
global $DB;
|
|
|
|
// We want to add these new nodes after the Edit settings node, and before the
|
|
// Locally assigned roles node. Of course, both of those are controlled by capabilities.
|
|
$keys = $navref->get_children_key_list();
|
|
$beforekey = null;
|
|
$i = array_search('modedit', $keys);
|
|
if ($i === false and array_key_exists(0, $keys)) {
|
|
$beforekey = $keys[0];
|
|
} else if (array_key_exists($i + 1, $keys)) {
|
|
$beforekey = $keys[$i + 1];
|
|
}
|
|
|
|
$cm = $settings->get_page()->cm;
|
|
if (!$cm) {
|
|
return;
|
|
}
|
|
|
|
$context = $cm->context;
|
|
$course = $settings->get_page()->course;
|
|
|
|
if (!$course) {
|
|
return;
|
|
}
|
|
|
|
if (has_capability('mod/assign:manageoverrides', $settings->get_page()->cm->context)) {
|
|
$url = new moodle_url('/mod/assign/overrides.php', ['cmid' => $settings->get_page()->cm->id, 'mode' => 'user']);
|
|
|
|
$node = navigation_node::create(get_string('overrides', 'assign'),
|
|
$url,
|
|
navigation_node::TYPE_SETTING, null, 'mod_assign_useroverrides');
|
|
$navref->add_node($node, $beforekey);
|
|
}
|
|
|
|
if (has_capability('mod/assign:revealidentities', $context)) {
|
|
$dbparams = array('id'=>$cm->instance);
|
|
$assignment = $DB->get_record('assign', $dbparams, 'blindmarking, revealidentities');
|
|
|
|
if ($assignment && $assignment->blindmarking && !$assignment->revealidentities) {
|
|
$urlparams = array('id' => $cm->id, 'action'=>'revealidentities');
|
|
$url = new moodle_url('/mod/assign/view.php', $urlparams);
|
|
$linkname = get_string('revealidentities', 'assign');
|
|
$node = $navref->add($linkname, $url, navigation_node::TYPE_SETTING);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a get_coursemodule_info function in case any assignment type wants to add 'extra' information
|
|
* for the course (see resource).
|
|
*
|
|
* Given a course_module object, this function returns any "extra" information that may be needed
|
|
* when printing this activity in a course listing. See get_array_of_activities() in course/lib.php.
|
|
*
|
|
* @param stdClass $coursemodule The coursemodule object (record).
|
|
* @return cached_cm_info An object on information that the courses
|
|
* will know about (most noticeably, an icon).
|
|
*/
|
|
function assign_get_coursemodule_info($coursemodule) {
|
|
global $DB;
|
|
|
|
$dbparams = array('id'=>$coursemodule->instance);
|
|
$fields = 'id, name, alwaysshowdescription, allowsubmissionsfromdate, intro, introformat, completionsubmit,
|
|
duedate, cutoffdate, allowsubmissionsfromdate';
|
|
if (! $assignment = $DB->get_record('assign', $dbparams, $fields)) {
|
|
return false;
|
|
}
|
|
|
|
$result = new cached_cm_info();
|
|
$result->name = $assignment->name;
|
|
if ($coursemodule->showdescription) {
|
|
if ($assignment->alwaysshowdescription || time() > $assignment->allowsubmissionsfromdate) {
|
|
// Convert intro to html. Do not filter cached version, filters run at display time.
|
|
$result->content = format_module_intro('assign', $assignment, $coursemodule->id, false);
|
|
}
|
|
}
|
|
|
|
// Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.
|
|
if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {
|
|
$result->customdata['customcompletionrules']['completionsubmit'] = $assignment->completionsubmit;
|
|
}
|
|
|
|
// Populate some other values that can be used in calendar or on dashboard.
|
|
if ($assignment->duedate) {
|
|
$result->customdata['duedate'] = $assignment->duedate;
|
|
}
|
|
if ($assignment->cutoffdate) {
|
|
$result->customdata['cutoffdate'] = $assignment->cutoffdate;
|
|
}
|
|
if ($assignment->allowsubmissionsfromdate) {
|
|
$result->customdata['allowsubmissionsfromdate'] = $assignment->allowsubmissionsfromdate;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Sets dynamic information about a course module
|
|
*
|
|
* This function is called from cm_info when displaying the module
|
|
*
|
|
* @param cm_info $cm
|
|
*/
|
|
function mod_assign_cm_info_dynamic(cm_info $cm) {
|
|
global $USER;
|
|
|
|
$cache = cache::make('mod_assign', 'overrides');
|
|
$override = $cache->get("{$cm->instance}_u_{$USER->id}");
|
|
|
|
if (!$override) {
|
|
$override = (object) [
|
|
'allowsubmissionsfromdate' => null,
|
|
'duedate' => null,
|
|
'cutoffdate' => null,
|
|
];
|
|
}
|
|
|
|
// No need to look for group overrides if there are user overrides for all allowsubmissionsfromdate, duedate and cutoffdate.
|
|
if (is_null($override->allowsubmissionsfromdate) || is_null($override->duedate) || is_null($override->cutoffdate)) {
|
|
$selectedgroupoverride = (object) [
|
|
'allowsubmissionsfromdate' => null,
|
|
'duedate' => null,
|
|
'cutoffdate' => null,
|
|
'sortorder' => PHP_INT_MAX, // So that every sortorder read from DB is less than this.
|
|
];
|
|
$groupings = groups_get_user_groups($cm->course, $USER->id);
|
|
foreach ($groupings[0] as $groupid) {
|
|
$groupoverride = $cache->get("{$cm->instance}_g_{$groupid}");
|
|
if ($groupoverride) {
|
|
if ($groupoverride->sortorder < $selectedgroupoverride->sortorder) {
|
|
$selectedgroupoverride = $groupoverride;
|
|
}
|
|
}
|
|
}
|
|
// If there is a user override for a setting, ignore the group override.
|
|
if (is_null($override->allowsubmissionsfromdate)) {
|
|
$override->allowsubmissionsfromdate = $selectedgroupoverride->allowsubmissionsfromdate;
|
|
}
|
|
if (is_null($override->duedate)) {
|
|
$override->duedate = $selectedgroupoverride->duedate;
|
|
}
|
|
if (is_null($override->cutoffdate)) {
|
|
$override->cutoffdate = $selectedgroupoverride->cutoffdate;
|
|
}
|
|
}
|
|
|
|
// Calculate relative dates. The assignment module calculates relative date only for duedate.
|
|
// A user or group override always has higher priority over any relative date calculation.
|
|
if (empty($override->duedate) && !empty($cm->customdata['duedate'])) {
|
|
$course = get_course($cm->course);
|
|
$usercoursedates = course_get_course_dates_for_user_id($course, $USER->id);
|
|
if ($usercoursedates['start']) {
|
|
$override->duedate = $cm->customdata['duedate'] + $usercoursedates['startoffset'];
|
|
}
|
|
}
|
|
|
|
// Populate some other values that can be used in calendar or on dashboard.
|
|
if (!is_null($override->allowsubmissionsfromdate)) {
|
|
$cm->override_customdata('allowsubmissionsfromdate', $override->allowsubmissionsfromdate);
|
|
}
|
|
if (!is_null($override->duedate)) {
|
|
$cm->override_customdata('duedate', $override->duedate);
|
|
}
|
|
if (!is_null($override->cutoffdate)) {
|
|
$cm->override_customdata('cutoffdate', $override->cutoffdate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Callback which returns human-readable strings describing the active completion custom rules for the module instance.
|
|
*
|
|
* @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']
|
|
* @return array $descriptions the array of descriptions for the custom rules.
|
|
*/
|
|
function mod_assign_get_completion_active_rule_descriptions($cm) {
|
|
// Values will be present in cm_info, and we assume these are up to date.
|
|
if (empty($cm->customdata['customcompletionrules'])
|
|
|| $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {
|
|
return [];
|
|
}
|
|
|
|
$descriptions = [];
|
|
foreach ($cm->customdata['customcompletionrules'] as $key => $val) {
|
|
switch ($key) {
|
|
case 'completionsubmit':
|
|
if (!empty($val)) {
|
|
$descriptions[] = get_string('completionsubmit', 'assign');
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return $descriptions;
|
|
}
|
|
|
|
/**
|
|
* Return a list of page types
|
|
* @param string $pagetype current page type
|
|
* @param stdClass $parentcontext Block's parent context
|
|
* @param stdClass $currentcontext Current context of block
|
|
*/
|
|
function assign_page_type_list($pagetype, $parentcontext, $currentcontext) {
|
|
$modulepagetype = array(
|
|
'mod-assign-*' => get_string('page-mod-assign-x', 'assign'),
|
|
'mod-assign-view' => get_string('page-mod-assign-view', 'assign'),
|
|
);
|
|
return $modulepagetype;
|
|
}
|
|
|
|
/**
|
|
* Print recent activity from all assignments in a given course
|
|
*
|
|
* This is used by the recent activity block
|
|
* @param mixed $course the course to print activity for
|
|
* @param bool $viewfullnames boolean to determine whether to show full names or not
|
|
* @param int $timestart the time the rendering started
|
|
* @return bool true if activity was printed, false otherwise.
|
|
*/
|
|
function assign_print_recent_activity($course, $viewfullnames, $timestart) {
|
|
global $CFG, $USER, $DB, $OUTPUT;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
// Do not use log table if possible, it may be huge.
|
|
|
|
$dbparams = array($timestart, $course->id, 'assign', ASSIGN_SUBMISSION_STATUS_SUBMITTED);
|
|
$userfieldsapi = \core_user\fields::for_userpic();
|
|
$namefields = $userfieldsapi->get_sql('u', false, '', 'userid', false)->selects;;
|
|
if (!$submissions = $DB->get_records_sql("SELECT asb.id, asb.timemodified, cm.id AS cmid, um.id as recordid,
|
|
$namefields
|
|
FROM {assign_submission} asb
|
|
JOIN {assign} a ON a.id = asb.assignment
|
|
JOIN {course_modules} cm ON cm.instance = a.id
|
|
JOIN {modules} md ON md.id = cm.module
|
|
JOIN {user} u ON u.id = asb.userid
|
|
LEFT JOIN {assign_user_mapping} um ON um.userid = u.id AND um.assignment = a.id
|
|
WHERE asb.timemodified > ? AND
|
|
asb.latest = 1 AND
|
|
a.course = ? AND
|
|
md.name = ? AND
|
|
asb.status = ?
|
|
ORDER BY asb.timemodified ASC", $dbparams)) {
|
|
return false;
|
|
}
|
|
|
|
$modinfo = get_fast_modinfo($course);
|
|
$show = array();
|
|
$grader = array();
|
|
|
|
$showrecentsubmissions = get_config('assign', 'showrecentsubmissions');
|
|
|
|
foreach ($submissions as $submission) {
|
|
if (!array_key_exists($submission->cmid, $modinfo->get_cms())) {
|
|
continue;
|
|
}
|
|
$cm = $modinfo->get_cm($submission->cmid);
|
|
if (!$cm->uservisible) {
|
|
continue;
|
|
}
|
|
if ($submission->userid == $USER->id) {
|
|
$show[] = $submission;
|
|
continue;
|
|
}
|
|
|
|
$context = context_module::instance($submission->cmid);
|
|
// The act of submitting of assignment may be considered private -
|
|
// only graders will see it if specified.
|
|
if (empty($showrecentsubmissions)) {
|
|
if (!array_key_exists($cm->id, $grader)) {
|
|
$grader[$cm->id] = has_capability('moodle/grade:viewall', $context);
|
|
}
|
|
if (!$grader[$cm->id]) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
$groupmode = groups_get_activity_groupmode($cm, $course);
|
|
|
|
if ($groupmode == SEPARATEGROUPS &&
|
|
!has_capability('moodle/site:accessallgroups', $context)) {
|
|
if (isguestuser()) {
|
|
// Shortcut - guest user does not belong into any group.
|
|
continue;
|
|
}
|
|
|
|
// This will be slow - show only users that share group with me in this cm.
|
|
if (!$modinfo->get_groups($cm->groupingid)) {
|
|
continue;
|
|
}
|
|
$usersgroups = groups_get_all_groups($course->id, $submission->userid, $cm->groupingid);
|
|
if (is_array($usersgroups)) {
|
|
$usersgroups = array_keys($usersgroups);
|
|
$intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
|
|
if (empty($intersect)) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
$show[] = $submission;
|
|
}
|
|
|
|
if (empty($show)) {
|
|
return false;
|
|
}
|
|
|
|
echo $OUTPUT->heading(get_string('newsubmissions', 'assign') . ':', 6);
|
|
|
|
foreach ($show as $submission) {
|
|
$cm = $modinfo->get_cm($submission->cmid);
|
|
$context = context_module::instance($submission->cmid);
|
|
$assign = new assign($context, $cm, $cm->course);
|
|
$link = $CFG->wwwroot.'/mod/assign/view.php?id='.$cm->id;
|
|
// Obscure first and last name if blind marking enabled.
|
|
if ($assign->is_blind_marking()) {
|
|
$submission->firstname = get_string('participant', 'mod_assign');
|
|
if (empty($submission->recordid)) {
|
|
$submission->recordid = $assign->get_uniqueid_for_user($submission->userid);
|
|
}
|
|
$submission->lastname = $submission->recordid;
|
|
}
|
|
print_recent_activity_note($submission->timemodified,
|
|
$submission,
|
|
$cm->name,
|
|
$link,
|
|
false,
|
|
$viewfullnames);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns all assignments since a given time.
|
|
*
|
|
* @param array $activities The activity information is returned in this array
|
|
* @param int $index The current index in the activities array
|
|
* @param int $timestart The earliest activity to show
|
|
* @param int $courseid Limit the search to this course
|
|
* @param int $cmid The course module id
|
|
* @param int $userid Optional user id
|
|
* @param int $groupid Optional group id
|
|
* @return void
|
|
*/
|
|
function assign_get_recent_mod_activity(&$activities,
|
|
&$index,
|
|
$timestart,
|
|
$courseid,
|
|
$cmid,
|
|
$userid=0,
|
|
$groupid=0) {
|
|
global $CFG, $COURSE, $USER, $DB;
|
|
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
if ($COURSE->id == $courseid) {
|
|
$course = $COURSE;
|
|
} else {
|
|
$course = $DB->get_record('course', array('id'=>$courseid));
|
|
}
|
|
|
|
$modinfo = get_fast_modinfo($course);
|
|
|
|
$cm = $modinfo->get_cm($cmid);
|
|
$params = array();
|
|
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 = '';
|
|
}
|
|
|
|
$params['cminstance'] = $cm->instance;
|
|
$params['timestart'] = $timestart;
|
|
$params['submitted'] = ASSIGN_SUBMISSION_STATUS_SUBMITTED;
|
|
|
|
$userfieldsapi = \core_user\fields::for_userpic();
|
|
$userfields = $userfieldsapi->get_sql('u', false, '', 'userid', false)->selects;
|
|
|
|
if (!$submissions = $DB->get_records_sql('SELECT asb.id, asb.timemodified, ' .
|
|
$userfields .
|
|
' FROM {assign_submission} asb
|
|
JOIN {assign} a ON a.id = asb.assignment
|
|
JOIN {user} u ON u.id = asb.userid ' .
|
|
$groupjoin .
|
|
' WHERE asb.timemodified > :timestart AND
|
|
asb.status = :submitted AND
|
|
a.id = :cminstance
|
|
' . $userselect . ' ' . $groupselect .
|
|
' ORDER BY asb.timemodified ASC', $params)) {
|
|
return;
|
|
}
|
|
|
|
$groupmode = groups_get_activity_groupmode($cm, $course);
|
|
$cmcontext = context_module::instance($cm->id);
|
|
$grader = has_capability('moodle/grade:viewall', $cmcontext);
|
|
$accessallgroups = has_capability('moodle/site:accessallgroups', $cmcontext);
|
|
$viewfullnames = has_capability('moodle/site:viewfullnames', $cmcontext);
|
|
|
|
|
|
$showrecentsubmissions = get_config('assign', 'showrecentsubmissions');
|
|
$show = array();
|
|
foreach ($submissions as $submission) {
|
|
if ($submission->userid == $USER->id) {
|
|
$show[] = $submission;
|
|
continue;
|
|
}
|
|
// The act of submitting of assignment may be considered private -
|
|
// only graders will see it if specified.
|
|
if (empty($showrecentsubmissions)) {
|
|
if (!$grader) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
|
|
if (isguestuser()) {
|
|
// Shortcut - guest user does not belong into any group.
|
|
continue;
|
|
}
|
|
|
|
// This will be slow - show only users that share group with me in this cm.
|
|
if (!$modinfo->get_groups($cm->groupingid)) {
|
|
continue;
|
|
}
|
|
$usersgroups = groups_get_all_groups($course->id, $submission->userid, $cm->groupingid);
|
|
if (is_array($usersgroups)) {
|
|
$usersgroups = array_keys($usersgroups);
|
|
$intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
|
|
if (empty($intersect)) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
$show[] = $submission;
|
|
}
|
|
|
|
if (empty($show)) {
|
|
return;
|
|
}
|
|
|
|
if ($grader) {
|
|
require_once($CFG->libdir.'/gradelib.php');
|
|
$userids = array();
|
|
foreach ($show as $id => $submission) {
|
|
$userids[] = $submission->userid;
|
|
}
|
|
$grades = grade_get_grades($courseid, 'mod', 'assign', $cm->instance, $userids);
|
|
}
|
|
|
|
$aname = format_string($cm->name, true);
|
|
foreach ($show as $submission) {
|
|
$activity = new stdClass();
|
|
|
|
$activity->type = 'assign';
|
|
$activity->cmid = $cm->id;
|
|
$activity->name = $aname;
|
|
$activity->sectionnum = $cm->sectionnum;
|
|
$activity->timestamp = $submission->timemodified;
|
|
$activity->user = new stdClass();
|
|
if ($grader) {
|
|
$activity->grade = $grades->items[0]->grades[$submission->userid]->str_long_grade;
|
|
}
|
|
|
|
$userfields = explode(',', implode(',', \core_user\fields::get_picture_fields()));
|
|
foreach ($userfields as $userfield) {
|
|
if ($userfield == 'id') {
|
|
// Aliased in SQL above.
|
|
$activity->user->{$userfield} = $submission->userid;
|
|
} else {
|
|
$activity->user->{$userfield} = $submission->{$userfield};
|
|
}
|
|
}
|
|
$activity->user->fullname = fullname($submission, $viewfullnames);
|
|
|
|
$activities[$index++] = $activity;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Print recent activity from all assignments in a given course
|
|
*
|
|
* This is used by course/recent.php
|
|
* @param stdClass $activity
|
|
* @param int $courseid
|
|
* @param bool $detail
|
|
* @param array $modnames
|
|
*/
|
|
function assign_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
|
|
global $CFG, $OUTPUT;
|
|
|
|
echo '<table border="0" cellpadding="3" cellspacing="0" class="assignment-recent">';
|
|
|
|
echo '<tr><td class="userpicture" valign="top">';
|
|
echo $OUTPUT->user_picture($activity->user);
|
|
echo '</td><td>';
|
|
|
|
if ($detail) {
|
|
$modname = $modnames[$activity->type];
|
|
echo '<div class="title">';
|
|
echo $OUTPUT->image_icon('monologo', $modname, 'assign');
|
|
echo '<a href="' . $CFG->wwwroot . '/mod/assign/view.php?id=' . $activity->cmid . '">';
|
|
echo $activity->name;
|
|
echo '</a>';
|
|
echo '</div>';
|
|
}
|
|
|
|
if (isset($activity->grade)) {
|
|
echo '<div class="grade">';
|
|
echo get_string('gradenoun') . ': ';
|
|
echo $activity->grade;
|
|
echo '</div>';
|
|
}
|
|
|
|
echo '<div class="user">';
|
|
echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&course=$courseid\">";
|
|
echo "{$activity->user->fullname}</a> - " . userdate($activity->timestamp);
|
|
echo '</div>';
|
|
|
|
echo '</td></tr></table>';
|
|
}
|
|
|
|
/**
|
|
* Checks if scale is being used by any instance of assignment
|
|
*
|
|
* This is used to find out if scale used anywhere
|
|
* @param int $scaleid
|
|
* @return boolean True if the scale is used by any assignment
|
|
*/
|
|
function assign_scale_used_anywhere($scaleid) {
|
|
global $DB;
|
|
|
|
if ($scaleid and $DB->record_exists('assign', array('grade'=>-$scaleid))) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* List the actions that correspond to a view of this module.
|
|
* This is used by the participation report.
|
|
*
|
|
* Note: This is not used by new logging system. Event with
|
|
* crud = 'r' and edulevel = LEVEL_PARTICIPATING will
|
|
* be considered as view action.
|
|
*
|
|
* @return array
|
|
*/
|
|
function assign_get_view_actions() {
|
|
return array('view submission', 'view feedback');
|
|
}
|
|
|
|
/**
|
|
* List the actions that correspond to a post of this module.
|
|
* This is used by the participation report.
|
|
*
|
|
* Note: This is not used by new logging system. Event with
|
|
* crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
|
|
* will be considered as post action.
|
|
*
|
|
* @return array
|
|
*/
|
|
function assign_get_post_actions() {
|
|
return array('upload', 'submit', 'submit for grading');
|
|
}
|
|
|
|
/**
|
|
* Returns all other capabilities used by this module.
|
|
* @return array Array of capability strings
|
|
*/
|
|
function assign_get_extra_capabilities() {
|
|
return ['gradereport/grader:view', 'moodle/grade:viewall'];
|
|
}
|
|
|
|
/**
|
|
* Create grade item for given assignment.
|
|
*
|
|
* @param stdClass $assign record with extra cmidnumber
|
|
* @param array $grades optional array/object of grade(s); 'reset' means reset grades in gradebook
|
|
* @return int 0 if ok, error code otherwise
|
|
*/
|
|
function assign_grade_item_update($assign, $grades=null) {
|
|
global $CFG;
|
|
require_once($CFG->libdir.'/gradelib.php');
|
|
|
|
if (!isset($assign->courseid)) {
|
|
$assign->courseid = $assign->course;
|
|
}
|
|
|
|
$params = array('itemname'=>$assign->name, 'idnumber'=>$assign->cmidnumber);
|
|
|
|
// Check if feedback plugin for gradebook is enabled, if yes then
|
|
// gradetype = GRADE_TYPE_TEXT else GRADE_TYPE_NONE.
|
|
$gradefeedbackenabled = false;
|
|
|
|
if (isset($assign->gradefeedbackenabled)) {
|
|
$gradefeedbackenabled = $assign->gradefeedbackenabled;
|
|
} else if ($assign->grade == 0) { // Grade feedback is needed only when grade == 0.
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
$mod = get_coursemodule_from_instance('assign', $assign->id, $assign->courseid);
|
|
$cm = context_module::instance($mod->id);
|
|
$assignment = new assign($cm, null, null);
|
|
$gradefeedbackenabled = $assignment->is_gradebook_feedback_enabled();
|
|
}
|
|
|
|
if ($assign->grade > 0) {
|
|
$params['gradetype'] = GRADE_TYPE_VALUE;
|
|
$params['grademax'] = $assign->grade;
|
|
$params['grademin'] = 0;
|
|
|
|
} else if ($assign->grade < 0) {
|
|
$params['gradetype'] = GRADE_TYPE_SCALE;
|
|
$params['scaleid'] = -$assign->grade;
|
|
|
|
} else if ($gradefeedbackenabled) {
|
|
// $assign->grade == 0 and feedback enabled.
|
|
$params['gradetype'] = GRADE_TYPE_TEXT;
|
|
} else {
|
|
// $assign->grade == 0 and no feedback enabled.
|
|
$params['gradetype'] = GRADE_TYPE_NONE;
|
|
}
|
|
|
|
if ($grades === 'reset') {
|
|
$params['reset'] = true;
|
|
$grades = null;
|
|
}
|
|
|
|
return grade_update('mod/assign',
|
|
$assign->courseid,
|
|
'mod',
|
|
'assign',
|
|
$assign->id,
|
|
0,
|
|
$grades,
|
|
$params);
|
|
}
|
|
|
|
/**
|
|
* Return grade for given user or all users.
|
|
*
|
|
* @param stdClass $assign record of assign with an additional cmidnumber
|
|
* @param int $userid optional user id, 0 means all users
|
|
* @return array array of grades, false if none
|
|
*/
|
|
function assign_get_user_grades($assign, $userid=0) {
|
|
global $CFG;
|
|
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
$cm = get_coursemodule_from_instance('assign', $assign->id, 0, false, MUST_EXIST);
|
|
$context = context_module::instance($cm->id);
|
|
$assignment = new assign($context, null, null);
|
|
$assignment->set_instance($assign);
|
|
return $assignment->get_user_grades_for_gradebook($userid);
|
|
}
|
|
|
|
/**
|
|
* Update activity grades.
|
|
*
|
|
* @param stdClass $assign database record
|
|
* @param int $userid specific user only, 0 means all
|
|
* @param bool $nullifnone - not used
|
|
*/
|
|
function assign_update_grades($assign, $userid=0, $nullifnone=true) {
|
|
global $CFG;
|
|
require_once($CFG->libdir.'/gradelib.php');
|
|
|
|
if ($assign->grade == 0) {
|
|
assign_grade_item_update($assign);
|
|
|
|
} else if ($grades = assign_get_user_grades($assign, $userid)) {
|
|
foreach ($grades as $k => $v) {
|
|
if ($v->rawgrade == -1) {
|
|
$grades[$k]->rawgrade = null;
|
|
}
|
|
}
|
|
assign_grade_item_update($assign, $grades);
|
|
|
|
} else {
|
|
assign_grade_item_update($assign);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* List the file areas that can be browsed.
|
|
*
|
|
* @param stdClass $course
|
|
* @param stdClass $cm
|
|
* @param stdClass $context
|
|
* @return array
|
|
*/
|
|
function assign_get_file_areas($course, $cm, $context) {
|
|
global $CFG;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
$areas = array(
|
|
ASSIGN_INTROATTACHMENT_FILEAREA => get_string('introattachments', 'mod_assign'),
|
|
ASSIGN_ACTIVITYATTACHMENT_FILEAREA => get_string('activityattachments', 'mod_assign'),
|
|
);
|
|
|
|
$assignment = new assign($context, $cm, $course);
|
|
foreach ($assignment->get_submission_plugins() as $plugin) {
|
|
if ($plugin->is_visible()) {
|
|
$pluginareas = $plugin->get_file_areas();
|
|
|
|
if ($pluginareas) {
|
|
$areas = array_merge($areas, $pluginareas);
|
|
}
|
|
}
|
|
}
|
|
foreach ($assignment->get_feedback_plugins() as $plugin) {
|
|
if ($plugin->is_visible()) {
|
|
$pluginareas = $plugin->get_file_areas();
|
|
|
|
if ($pluginareas) {
|
|
$areas = array_merge($areas, $pluginareas);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $areas;
|
|
}
|
|
|
|
/**
|
|
* File browsing support for assign module.
|
|
*
|
|
* @param file_browser $browser
|
|
* @param object $areas
|
|
* @param object $course
|
|
* @param object $cm
|
|
* @param object $context
|
|
* @param string $filearea
|
|
* @param int $itemid
|
|
* @param string $filepath
|
|
* @param string $filename
|
|
* @return object file_info instance or null if not found
|
|
*/
|
|
function assign_get_file_info($browser,
|
|
$areas,
|
|
$course,
|
|
$cm,
|
|
$context,
|
|
$filearea,
|
|
$itemid,
|
|
$filepath,
|
|
$filename) {
|
|
global $CFG;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
if ($context->contextlevel != CONTEXT_MODULE) {
|
|
return null;
|
|
}
|
|
|
|
$urlbase = $CFG->wwwroot.'/pluginfile.php';
|
|
$fs = get_file_storage();
|
|
$filepath = is_null($filepath) ? '/' : $filepath;
|
|
$filename = is_null($filename) ? '.' : $filename;
|
|
|
|
// Need to find where this belongs to.
|
|
$assignment = new assign($context, $cm, $course);
|
|
if ($filearea === ASSIGN_INTROATTACHMENT_FILEAREA || $filearea === ASSIGN_ACTIVITYATTACHMENT_FILEAREA) {
|
|
if (!has_capability('moodle/course:managefiles', $context)) {
|
|
// Students can not peak here!
|
|
return null;
|
|
}
|
|
if (!($storedfile = $fs->get_file($assignment->get_context()->id,
|
|
'mod_assign', $filearea, 0, $filepath, $filename))) {
|
|
return null;
|
|
}
|
|
return new file_info_stored($browser,
|
|
$assignment->get_context(),
|
|
$storedfile,
|
|
$urlbase,
|
|
$filearea,
|
|
$itemid,
|
|
true,
|
|
true,
|
|
false);
|
|
}
|
|
|
|
$pluginowner = null;
|
|
foreach ($assignment->get_submission_plugins() as $plugin) {
|
|
if ($plugin->is_visible()) {
|
|
$pluginareas = $plugin->get_file_areas();
|
|
|
|
if (array_key_exists($filearea, $pluginareas)) {
|
|
$pluginowner = $plugin;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!$pluginowner) {
|
|
foreach ($assignment->get_feedback_plugins() as $plugin) {
|
|
if ($plugin->is_visible()) {
|
|
$pluginareas = $plugin->get_file_areas();
|
|
|
|
if (array_key_exists($filearea, $pluginareas)) {
|
|
$pluginowner = $plugin;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!$pluginowner) {
|
|
return null;
|
|
}
|
|
|
|
$result = $pluginowner->get_file_info($browser, $filearea, $itemid, $filepath, $filename);
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Prints the complete info about a user's interaction with an assignment.
|
|
*
|
|
* @param stdClass $course
|
|
* @param stdClass $user
|
|
* @param stdClass $coursemodule
|
|
* @param stdClass $assign the database assign record
|
|
*
|
|
* This prints the submission summary and feedback summary for this student.
|
|
*/
|
|
function assign_user_complete($course, $user, $coursemodule, $assign) {
|
|
global $CFG;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
$context = context_module::instance($coursemodule->id);
|
|
|
|
$assignment = new assign($context, $coursemodule, $course);
|
|
|
|
echo $assignment->view_student_summary($user, false);
|
|
}
|
|
|
|
/**
|
|
* Rescale all grades for this activity and push the new grades to the gradebook.
|
|
*
|
|
* @param stdClass $course Course db record
|
|
* @param stdClass $cm Course module db record
|
|
* @param float $oldmin
|
|
* @param float $oldmax
|
|
* @param float $newmin
|
|
* @param float $newmax
|
|
*/
|
|
function assign_rescale_activity_grades($course, $cm, $oldmin, $oldmax, $newmin, $newmax) {
|
|
global $DB;
|
|
|
|
if ($oldmax <= $oldmin) {
|
|
// Grades cannot be scaled.
|
|
return false;
|
|
}
|
|
$scale = ($newmax - $newmin) / ($oldmax - $oldmin);
|
|
if (($newmax - $newmin) <= 1) {
|
|
// We would lose too much precision, lets bail.
|
|
return false;
|
|
}
|
|
|
|
$params = array(
|
|
'p1' => $oldmin,
|
|
'p2' => $scale,
|
|
'p3' => $newmin,
|
|
'a' => $cm->instance
|
|
);
|
|
|
|
// Only rescale grades that are greater than or equal to 0. Anything else is a special value.
|
|
$sql = 'UPDATE {assign_grades} set grade = (((grade - :p1) * :p2) + :p3) where assignment = :a and grade >= 0';
|
|
$dbupdate = $DB->execute($sql, $params);
|
|
if (!$dbupdate) {
|
|
return false;
|
|
}
|
|
|
|
// Now re-push all grades to the gradebook.
|
|
$dbparams = array('id' => $cm->instance);
|
|
$assign = $DB->get_record('assign', $dbparams);
|
|
$assign->cmidnumber = $cm->idnumber;
|
|
|
|
assign_update_grades($assign);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Print the grade information for the assignment for this user.
|
|
*
|
|
* @param stdClass $course
|
|
* @param stdClass $user
|
|
* @param stdClass $coursemodule
|
|
* @param stdClass $assignment
|
|
*/
|
|
function assign_user_outline($course, $user, $coursemodule, $assignment) {
|
|
global $CFG;
|
|
require_once($CFG->libdir.'/gradelib.php');
|
|
require_once($CFG->dirroot.'/grade/grading/lib.php');
|
|
|
|
$gradinginfo = grade_get_grades($course->id,
|
|
'mod',
|
|
'assign',
|
|
$assignment->id,
|
|
$user->id);
|
|
|
|
$gradingitem = $gradinginfo->items[0];
|
|
$gradebookgrade = $gradingitem->grades[$user->id];
|
|
|
|
if (empty($gradebookgrade->str_long_grade)) {
|
|
return null;
|
|
}
|
|
$result = new stdClass();
|
|
if (!$gradingitem->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
|
|
$result->info = get_string('outlinegrade', 'assign', $gradebookgrade->str_long_grade);
|
|
} else {
|
|
$result->info = get_string('gradenoun') . ': ' . get_string('hidden', 'grades');
|
|
}
|
|
$result->time = $gradebookgrade->dategraded;
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Serves intro attachment files.
|
|
*
|
|
* @param mixed $course course or id of the course
|
|
* @param mixed $cm course module or id of the course module
|
|
* @param context $context
|
|
* @param string $filearea
|
|
* @param array $args
|
|
* @param bool $forcedownload
|
|
* @param array $options additional options affecting the file serving
|
|
* @return bool false if file not found, does not return if found - just send the file
|
|
*/
|
|
function assign_pluginfile($course,
|
|
$cm,
|
|
context $context,
|
|
$filearea,
|
|
$args,
|
|
$forcedownload,
|
|
array $options=array()) {
|
|
global $CFG;
|
|
|
|
if ($context->contextlevel != CONTEXT_MODULE) {
|
|
return false;
|
|
}
|
|
|
|
require_login($course, false, $cm);
|
|
if (!has_capability('mod/assign:view', $context)) {
|
|
return false;
|
|
}
|
|
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
$assign = new assign($context, $cm, $course);
|
|
|
|
if ($filearea !== ASSIGN_INTROATTACHMENT_FILEAREA && $filearea !== ASSIGN_ACTIVITYATTACHMENT_FILEAREA) {
|
|
return false;
|
|
}
|
|
if (!$assign->show_intro()) {
|
|
return false;
|
|
}
|
|
|
|
$itemid = (int)array_shift($args);
|
|
if ($itemid != 0) {
|
|
return false;
|
|
}
|
|
|
|
$relativepath = implode('/', $args);
|
|
|
|
$fullpath = "/{$context->id}/mod_assign/$filearea/$itemid/$relativepath";
|
|
|
|
$fs = get_file_storage();
|
|
if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
|
|
return false;
|
|
}
|
|
send_stored_file($file, 0, 0, $forcedownload, $options);
|
|
}
|
|
|
|
/**
|
|
* Serve the grading panel as a fragment.
|
|
*
|
|
* @param array $args List of named arguments for the fragment loader.
|
|
* @return string
|
|
*/
|
|
function mod_assign_output_fragment_gradingpanel($args) {
|
|
global $CFG;
|
|
|
|
$context = $args['context'];
|
|
|
|
if ($context->contextlevel != CONTEXT_MODULE) {
|
|
return null;
|
|
}
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
$assign = new assign($context, null, null);
|
|
|
|
$userid = clean_param($args['userid'], PARAM_INT);
|
|
|
|
$participant = $assign->get_participant($userid);
|
|
$isfiltered = $assign->is_userid_filtered($userid);
|
|
if (!$participant || !$isfiltered) {
|
|
// User is not enrolled or filtered out by filters and table preferences.
|
|
return '';
|
|
}
|
|
|
|
$attemptnumber = clean_param($args['attemptnumber'], PARAM_INT);
|
|
$formdata = array();
|
|
if (!empty($args['jsonformdata'])) {
|
|
$serialiseddata = json_decode($args['jsonformdata']);
|
|
parse_str($serialiseddata, $formdata);
|
|
}
|
|
$viewargs = array(
|
|
'userid' => $userid,
|
|
'attemptnumber' => $attemptnumber,
|
|
'formdata' => $formdata
|
|
);
|
|
|
|
return $assign->view('gradingpanel', $viewargs);
|
|
}
|
|
|
|
/**
|
|
* Check if the module has any update that affects the current user since a given time.
|
|
*
|
|
* @param cm_info $cm course module data
|
|
* @param int $from the time to check updates from
|
|
* @param array $filter if we need to check only specific updates
|
|
* @return stdClass an object with the different type of areas indicating if they were updated or not
|
|
* @since Moodle 3.2
|
|
*/
|
|
function assign_check_updates_since(cm_info $cm, $from, $filter = array()) {
|
|
global $DB, $USER, $CFG;
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
$updates = new stdClass();
|
|
$updates = course_check_module_updates_since($cm, $from, array(ASSIGN_INTROATTACHMENT_FILEAREA), $filter);
|
|
|
|
// Check if there is a new submission by the user or new grades.
|
|
$select = 'assignment = :id AND userid = :userid AND (timecreated > :since1 OR timemodified > :since2)';
|
|
$params = array('id' => $cm->instance, 'userid' => $USER->id, 'since1' => $from, 'since2' => $from);
|
|
$updates->submissions = (object) array('updated' => false);
|
|
$submissions = $DB->get_records_select('assign_submission', $select, $params, '', 'id');
|
|
if (!empty($submissions)) {
|
|
$updates->submissions->updated = true;
|
|
$updates->submissions->itemids = array_keys($submissions);
|
|
}
|
|
|
|
$updates->grades = (object) array('updated' => false);
|
|
$grades = $DB->get_records_select('assign_grades', $select, $params, '', 'id');
|
|
if (!empty($grades)) {
|
|
$updates->grades->updated = true;
|
|
$updates->grades->itemids = array_keys($grades);
|
|
}
|
|
|
|
// Now, teachers should see other students updates.
|
|
if (has_capability('mod/assign:viewgrades', $cm->context)) {
|
|
$params = array('id' => $cm->instance, 'since1' => $from, 'since2' => $from);
|
|
$select = 'assignment = :id AND (timecreated > :since1 OR timemodified > :since2)';
|
|
|
|
if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
|
|
$groupusers = array_keys(groups_get_activity_shared_group_members($cm));
|
|
if (empty($groupusers)) {
|
|
return $updates;
|
|
}
|
|
list($insql, $inparams) = $DB->get_in_or_equal($groupusers, SQL_PARAMS_NAMED);
|
|
$select .= ' AND userid ' . $insql;
|
|
$params = array_merge($params, $inparams);
|
|
}
|
|
|
|
$updates->usersubmissions = (object) array('updated' => false);
|
|
$submissions = $DB->get_records_select('assign_submission', $select, $params, '', 'id');
|
|
if (!empty($submissions)) {
|
|
$updates->usersubmissions->updated = true;
|
|
$updates->usersubmissions->itemids = array_keys($submissions);
|
|
}
|
|
|
|
$updates->usergrades = (object) array('updated' => false);
|
|
$grades = $DB->get_records_select('assign_grades', $select, $params, '', 'id');
|
|
if (!empty($grades)) {
|
|
$updates->usergrades->updated = true;
|
|
$updates->usergrades->itemids = array_keys($grades);
|
|
}
|
|
}
|
|
|
|
return $updates;
|
|
}
|
|
|
|
/**
|
|
* Is the event visible?
|
|
*
|
|
* This is used to determine global visibility of an event in all places throughout Moodle. For example,
|
|
* the ASSIGN_EVENT_TYPE_GRADINGDUE event will not be shown to students on their calendar.
|
|
*
|
|
* @param calendar_event $event
|
|
* @param int $userid User id to use for all capability checks, etc. Set to 0 for current user (default).
|
|
* @return bool Returns true if the event is visible to the current user, false otherwise.
|
|
*/
|
|
function mod_assign_core_calendar_is_event_visible(calendar_event $event, $userid = 0) {
|
|
global $CFG, $USER;
|
|
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
if (empty($userid)) {
|
|
$userid = $USER->id;
|
|
}
|
|
|
|
$cm = get_fast_modinfo($event->courseid, $userid)->instances['assign'][$event->instance];
|
|
$context = context_module::instance($cm->id);
|
|
|
|
$assign = new assign($context, $cm, null);
|
|
|
|
if ($event->eventtype == ASSIGN_EVENT_TYPE_GRADINGDUE) {
|
|
return $assign->can_grade($userid);
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function receives a calendar event and returns the action associated with it, or null if there is none.
|
|
*
|
|
* This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
|
|
* is not displayed on the block.
|
|
*
|
|
* @param calendar_event $event
|
|
* @param \core_calendar\action_factory $factory
|
|
* @param int $userid User id to use for all capability checks, etc. Set to 0 for current user (default).
|
|
* @return \core_calendar\local\event\entities\action_interface|null
|
|
*/
|
|
function mod_assign_core_calendar_provide_event_action(calendar_event $event,
|
|
\core_calendar\action_factory $factory,
|
|
$userid = 0) {
|
|
|
|
global $CFG, $USER;
|
|
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
if (empty($userid)) {
|
|
$userid = $USER->id;
|
|
}
|
|
|
|
$cm = get_fast_modinfo($event->courseid, $userid)->instances['assign'][$event->instance];
|
|
$context = context_module::instance($cm->id);
|
|
|
|
$completion = new \completion_info($cm->get_course());
|
|
|
|
$completiondata = $completion->get_data($cm, false, $userid);
|
|
|
|
if ($completiondata->completionstate != COMPLETION_INCOMPLETE) {
|
|
return null;
|
|
}
|
|
|
|
$assign = new assign($context, $cm, null);
|
|
|
|
// Apply overrides.
|
|
$assign->update_effective_access($userid);
|
|
|
|
if ($event->eventtype == ASSIGN_EVENT_TYPE_GRADINGDUE) {
|
|
$name = get_string('gradeverb');
|
|
$url = new \moodle_url('/mod/assign/view.php', [
|
|
'id' => $cm->id,
|
|
'action' => 'grader'
|
|
]);
|
|
$actionable = $assign->can_grade($userid) && (time() >= $assign->get_instance()->allowsubmissionsfromdate);
|
|
$itemcount = $actionable ? $assign->count_submissions_need_grading() : 0;
|
|
} else {
|
|
$usersubmission = $assign->get_user_submission($userid, false);
|
|
if ($usersubmission && $usersubmission->status === ASSIGN_SUBMISSION_STATUS_SUBMITTED) {
|
|
// The user has already submitted.
|
|
// We do not want to change the text to edit the submission, we want to remove the event from the Dashboard entirely.
|
|
return null;
|
|
}
|
|
|
|
$participant = $assign->get_participant($userid);
|
|
|
|
if (!$participant) {
|
|
// If the user is not a participant in the assignment then they have
|
|
// no action to take. This will filter out the events for teachers.
|
|
return null;
|
|
}
|
|
|
|
// The user has not yet submitted anything. Show the addsubmission link.
|
|
$name = get_string('addsubmission', 'assign');
|
|
$url = new \moodle_url('/mod/assign/view.php', [
|
|
'id' => $cm->id,
|
|
'action' => 'editsubmission'
|
|
]);
|
|
$itemcount = 1;
|
|
$actionable = $assign->is_any_submission_plugin_enabled() && $assign->can_edit_submission($userid, $userid);
|
|
}
|
|
|
|
return $factory->create_instance(
|
|
$name,
|
|
$url,
|
|
$itemcount,
|
|
$actionable
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Callback function that determines whether an action event should be showing its item count
|
|
* based on the event type and the item count.
|
|
*
|
|
* @param calendar_event $event The calendar event.
|
|
* @param int $itemcount The item count associated with the action event.
|
|
* @return bool
|
|
*/
|
|
function mod_assign_core_calendar_event_action_shows_item_count(calendar_event $event, $itemcount = 0) {
|
|
// List of event types where the action event's item count should be shown.
|
|
$eventtypesshowingitemcount = [
|
|
ASSIGN_EVENT_TYPE_GRADINGDUE
|
|
];
|
|
// For mod_assign, item count should be shown if the event type is 'gradingdue' and there is one or more item count.
|
|
return in_array($event->eventtype, $eventtypesshowingitemcount) && $itemcount > 0;
|
|
}
|
|
|
|
/**
|
|
* This function calculates the minimum and maximum cutoff values for the timestart of
|
|
* the given event.
|
|
*
|
|
* It will return an array with two values, the first being the minimum cutoff value and
|
|
* the second being the maximum cutoff value. Either or both values can be null, which
|
|
* indicates there is no minimum or maximum, respectively.
|
|
*
|
|
* If a cutoff is required then the function must return an array containing the cutoff
|
|
* timestamp and error string to display to the user if the cutoff value is violated.
|
|
*
|
|
* A minimum and maximum cutoff return value will look like:
|
|
* [
|
|
* [1505704373, 'The due date must be after the sbumission start date'],
|
|
* [1506741172, 'The due date must be before the cutoff date']
|
|
* ]
|
|
*
|
|
* If the event does not have a valid timestart range then [false, false] will
|
|
* be returned.
|
|
*
|
|
* @param calendar_event $event The calendar event to get the time range for
|
|
* @param stdClass $instance The module instance to get the range from
|
|
* @return array
|
|
*/
|
|
function mod_assign_core_calendar_get_valid_event_timestart_range(\calendar_event $event, \stdClass $instance) {
|
|
global $CFG;
|
|
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
$courseid = $event->courseid;
|
|
$modulename = $event->modulename;
|
|
$instanceid = $event->instance;
|
|
$coursemodule = get_fast_modinfo($courseid)->instances[$modulename][$instanceid];
|
|
$context = context_module::instance($coursemodule->id);
|
|
$assign = new assign($context, null, null);
|
|
$assign->set_instance($instance);
|
|
|
|
return $assign->get_valid_calendar_event_timestart_range($event);
|
|
}
|
|
|
|
/**
|
|
* This function will update the assign module according to the
|
|
* event that has been modified.
|
|
*
|
|
* @throws \moodle_exception
|
|
* @param \calendar_event $event
|
|
* @param stdClass $instance The module instance to get the range from
|
|
*/
|
|
function mod_assign_core_calendar_event_timestart_updated(\calendar_event $event, \stdClass $instance) {
|
|
global $CFG, $DB;
|
|
|
|
require_once($CFG->dirroot . '/mod/assign/locallib.php');
|
|
|
|
if (empty($event->instance) || $event->modulename != 'assign') {
|
|
return;
|
|
}
|
|
|
|
if ($instance->id != $event->instance) {
|
|
return;
|
|
}
|
|
|
|
if (!in_array($event->eventtype, [ASSIGN_EVENT_TYPE_DUE, ASSIGN_EVENT_TYPE_GRADINGDUE])) {
|
|
return;
|
|
}
|
|
|
|
$courseid = $event->courseid;
|
|
$modulename = $event->modulename;
|
|
$instanceid = $event->instance;
|
|
$modified = false;
|
|
$coursemodule = get_fast_modinfo($courseid)->instances[$modulename][$instanceid];
|
|
$context = context_module::instance($coursemodule->id);
|
|
|
|
// The user does not have the capability to modify this activity.
|
|
if (!has_capability('moodle/course:manageactivities', $context)) {
|
|
return;
|
|
}
|
|
|
|
$assign = new assign($context, $coursemodule, null);
|
|
$assign->set_instance($instance);
|
|
|
|
if ($event->eventtype == ASSIGN_EVENT_TYPE_DUE) {
|
|
// This check is in here because due date events are currently
|
|
// the only events that can be overridden, so we can save a DB
|
|
// query if we don't bother checking other events.
|
|
if ($assign->is_override_calendar_event($event)) {
|
|
// This is an override event so we should ignore it.
|
|
return;
|
|
}
|
|
|
|
$newduedate = $event->timestart;
|
|
|
|
if ($newduedate != $instance->duedate) {
|
|
$instance->duedate = $newduedate;
|
|
$modified = true;
|
|
}
|
|
} else if ($event->eventtype == ASSIGN_EVENT_TYPE_GRADINGDUE) {
|
|
$newduedate = $event->timestart;
|
|
|
|
if ($newduedate != $instance->gradingduedate) {
|
|
$instance->gradingduedate = $newduedate;
|
|
$modified = true;
|
|
}
|
|
}
|
|
|
|
if ($modified) {
|
|
$instance->timemodified = time();
|
|
// Persist the assign instance changes.
|
|
$DB->update_record('assign', $instance);
|
|
$assign->update_calendar($coursemodule->id);
|
|
$event = \core\event\course_module_updated::create_from_cm($coursemodule, $context);
|
|
$event->trigger();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return a list of all the user preferences used by mod_assign.
|
|
*
|
|
* @return array
|
|
*/
|
|
function mod_assign_user_preferences() {
|
|
$preferences = array();
|
|
$preferences['assign_filter'] = array(
|
|
'type' => PARAM_ALPHA,
|
|
'null' => NULL_NOT_ALLOWED,
|
|
'default' => ''
|
|
);
|
|
$preferences['assign_workflowfilter'] = array(
|
|
'type' => PARAM_ALPHA,
|
|
'null' => NULL_NOT_ALLOWED,
|
|
'default' => ''
|
|
);
|
|
$preferences['assign_markerfilter'] = array(
|
|
'type' => PARAM_ALPHANUMEXT,
|
|
'null' => NULL_NOT_ALLOWED,
|
|
'default' => ''
|
|
);
|
|
|
|
return $preferences;
|
|
}
|
|
|
|
/**
|
|
* Given an array with a file path, it returns the itemid and the filepath for the defined filearea.
|
|
*
|
|
* @param string $filearea The filearea.
|
|
* @param array $args The path (the part after the filearea and before the filename).
|
|
* @return array The itemid and the filepath inside the $args path, for the defined filearea.
|
|
*/
|
|
function mod_assign_get_path_from_pluginfile(string $filearea, array $args) : array {
|
|
// Assign never has an itemid (the number represents the revision but it's not stored in database).
|
|
array_shift($args);
|
|
|
|
// Get the filepath.
|
|
if (empty($args)) {
|
|
$filepath = '/';
|
|
} else {
|
|
$filepath = '/' . implode('/', $args) . '/';
|
|
}
|
|
|
|
return [
|
|
'itemid' => 0,
|
|
'filepath' => $filepath,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Callback to fetch the activity event type lang string.
|
|
*
|
|
* @param string $eventtype The event type.
|
|
* @return lang_string The event type lang string.
|
|
*/
|
|
function mod_assign_core_calendar_get_event_action_string(string $eventtype): string {
|
|
$modulename = get_string('modulename', 'assign');
|
|
|
|
switch ($eventtype) {
|
|
case ASSIGN_EVENT_TYPE_DUE:
|
|
$identifier = 'calendardue';
|
|
break;
|
|
case ASSIGN_EVENT_TYPE_GRADINGDUE:
|
|
$identifier = 'calendargradingdue';
|
|
break;
|
|
default:
|
|
return get_string('requiresaction', 'calendar', $modulename);
|
|
}
|
|
|
|
return get_string($identifier, 'assign', $modulename);
|
|
}
|