f9fb3e200341efd941307f5c0e9695c55c8eda69
[moodle.git] / mod / assign / lib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * This file contains the moodle hooks for the assign module.
19  *
20  * It delegates most functions to the assignment class.
21  *
22  * @package   mod_assign
23  * @copyright 2012 NetSpot {@link http://www.netspot.com.au}
24  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25  */
26 defined('MOODLE_INTERNAL') || die();
28 /**
29  * Adds an assignment instance
30  *
31  * This is done by calling the add_instance() method of the assignment type class
32  * @param stdClass $data
33  * @param mod_assign_mod_form $form
34  * @return int The instance id of the new assignment
35  */
36 function assign_add_instance(stdClass $data, mod_assign_mod_form $form = null) {
37     global $CFG;
38     require_once($CFG->dirroot . '/mod/assign/locallib.php');
40     $assignment = new assign(context_module::instance($data->coursemodule), null, null);
41     return $assignment->add_instance($data, true);
42 }
44 /**
45  * delete an assignment instance
46  * @param int $id
47  * @return bool
48  */
49 function assign_delete_instance($id) {
50     global $CFG;
51     require_once($CFG->dirroot . '/mod/assign/locallib.php');
52     $cm = get_coursemodule_from_instance('assign', $id, 0, false, MUST_EXIST);
53     $context = context_module::instance($cm->id);
55     $assignment = new assign($context, null, null);
56     return $assignment->delete_instance();
57 }
59 /**
60  * This function is used by the reset_course_userdata function in moodlelib.
61  * This function will remove all assignment submissions and feedbacks in the database
62  * and clean up any related data.
63  *
64  * @param stdClass $data the data submitted from the reset course.
65  * @return array
66  */
67 function assign_reset_userdata($data) {
68     global $CFG, $DB;
69     require_once($CFG->dirroot . '/mod/assign/locallib.php');
71     $status = array();
72     $params = array('courseid'=>$data->courseid);
73     $sql = "SELECT a.id FROM {assign} a WHERE a.course=:courseid";
74     $course = $DB->get_record('course', array('id'=>$data->courseid), '*', MUST_EXIST);
75     if ($assigns = $DB->get_records_sql($sql, $params)) {
76         foreach ($assigns as $assign) {
77             $cm = get_coursemodule_from_instance('assign',
78                                                  $assign->id,
79                                                  $data->courseid,
80                                                  false,
81                                                  MUST_EXIST);
82             $context = context_module::instance($cm->id);
83             $assignment = new assign($context, $cm, $course);
84             $status = array_merge($status, $assignment->reset_userdata($data));
85         }
86     }
87     return $status;
88 }
90 /**
91  * This standard function will check all instances of this module
92  * and make sure there are up-to-date events created for each of them.
93  * If courseid = 0, then every assignment event in the site is checked, else
94  * only assignment events belonging to the course specified are checked.
95  *
96  * @param int $courseid
97  * @return bool
98  */
99 function assign_refresh_events($courseid = 0) {
100     global $CFG, $DB;
101     require_once($CFG->dirroot . '/mod/assign/locallib.php');
103     if ($courseid) {
104         // Make sure that the course id is numeric.
105         if (!is_numeric($courseid)) {
106             return false;
107         }
108         if (!$assigns = $DB->get_records('assign', array('course' => $courseid))) {
109             return false;
110         }
111         // Get course from courseid parameter.
112         if (!$course = $DB->get_record('course', array('id' => $courseid), '*')) {
113             return false;
114         }
115     } else {
116         if (!$assigns = $DB->get_records('assign')) {
117             return false;
118         }
119     }
120     foreach ($assigns as $assign) {
121         // Use assignment's course column if courseid parameter is not given.
122         if (!$courseid) {
123             $courseid = $assign->course;
124             if (!$course = $DB->get_record('course', array('id' => $courseid), '*')) {
125                 continue;
126             }
127         }
128         if (!$cm = get_coursemodule_from_instance('assign', $assign->id, $courseid, false)) {
129             continue;
130         }
131         $context = context_module::instance($cm->id);
132         $assignment = new assign($context, $cm, $course);
133         $assignment->update_calendar($cm->id);
134     }
136     return true;
139 /**
140  * Removes all grades from gradebook
141  *
142  * @param int $courseid The ID of the course to reset
143  * @param string $type Optional type of assignment to limit the reset to a particular assignment type
144  */
145 function assign_reset_gradebook($courseid, $type='') {
146     global $CFG, $DB;
148     $params = array('moduletype'=>'assign', 'courseid'=>$courseid);
149     $sql = 'SELECT a.*, cm.idnumber as cmidnumber, a.course as courseid
150             FROM {assign} a, {course_modules} cm, {modules} m
151             WHERE m.name=:moduletype AND m.id=cm.module AND cm.instance=a.id AND a.course=:courseid';
153     if ($assignments = $DB->get_records_sql($sql, $params)) {
154         foreach ($assignments as $assignment) {
155             assign_grade_item_update($assignment, 'reset');
156         }
157     }
160 /**
161  * Implementation of the function for printing the form elements that control
162  * whether the course reset functionality affects the assignment.
163  * @param moodleform $mform form passed by reference
164  */
165 function assign_reset_course_form_definition(&$mform) {
166     $mform->addElement('header', 'assignheader', get_string('modulenameplural', 'assign'));
167     $name = get_string('deleteallsubmissions', 'assign');
168     $mform->addElement('advcheckbox', 'reset_assign_submissions', $name);
169     $mform->addElement('advcheckbox', 'reset_assign_user_overrides',
170         get_string('removealluseroverrides', 'assign'));
171     $mform->addElement('advcheckbox', 'reset_assign_group_overrides',
172         get_string('removeallgroupoverrides', 'assign'));
175 /**
176  * Course reset form defaults.
177  * @param  object $course
178  * @return array
179  */
180 function assign_reset_course_form_defaults($course) {
181     return array('reset_assign_submissions' => 1,
182             'reset_assign_group_overrides' => 1,
183             'reset_assign_user_overrides' => 1);
186 /**
187  * Update an assignment instance
188  *
189  * This is done by calling the update_instance() method of the assignment type class
190  * @param stdClass $data
191  * @param stdClass $form - unused
192  * @return object
193  */
194 function assign_update_instance(stdClass $data, $form) {
195     global $CFG;
196     require_once($CFG->dirroot . '/mod/assign/locallib.php');
197     $context = context_module::instance($data->coursemodule);
198     $assignment = new assign($context, null, null);
199     return $assignment->update_instance($data);
202 /**
203  * This function updates the events associated to the assign.
204  * If $override is non-zero, then it updates only the events
205  * associated with the specified override.
206  *
207  * @param assign $assign the assign object.
208  * @param object $override (optional) limit to a specific override
209  */
210 function assign_update_events($assign, $override = null) {
211     global $CFG, $DB;
213     require_once($CFG->dirroot . '/calendar/lib.php');
215     $assigninstance = $assign->get_instance();
217     // Load the old events relating to this assign.
218     $conds = array('modulename' => 'assign', 'instance' => $assigninstance->id);
219     if (!empty($override)) {
220         // Only load events for this override.
221         if (isset($override->userid)) {
222             $conds['userid'] = $override->userid;
223         } else {
224             $conds['groupid'] = $override->groupid;
225         }
226     }
227     $oldevents = $DB->get_records('event', $conds);
229     // Now make a to-do list of all that needs to be updated.
230     if (empty($override)) {
231         // We are updating the primary settings for the assign, so we need to add all the overrides.
232         $overrides = $DB->get_records('assign_overrides', array('assignid' => $assigninstance->id));
233         // As well as the original assign (empty override).
234         $overrides[] = new stdClass();
235     } else {
236         // Just do the one override.
237         $overrides = array($override);
238     }
240     if (!empty($assign->get_course_module())) {
241         $cmid = $assign->get_course_module()->id;
242     } else {
243         $cmid = get_coursemodule_from_instance('assign', $assigninstance->id, $assigninstance->course)->id;
244     }
246     foreach ($overrides as $current) {
247         $groupid   = isset($current->groupid) ? $current->groupid : 0;
248         $userid    = isset($current->userid) ? $current->userid : 0;
249         $duedate = isset($current->duedate) ? $current->duedate : $assigninstance->duedate;
251         // Only add 'due' events for an override if they differ from the assign default.
252         $addclose = empty($current->id) || !empty($current->duedate);
254         $event = new stdClass();
255         $event->type = CALENDAR_EVENT_TYPE_ACTION;
256         $event->description = format_module_intro('assign', $assigninstance, $cmid);
257         // Events module won't show user events when the courseid is nonzero.
258         $event->courseid    = ($userid) ? 0 : $assigninstance->course;
259         $event->groupid     = $groupid;
260         $event->userid      = $userid;
261         $event->modulename  = 'assign';
262         $event->instance    = $assigninstance->id;
263         $event->timestart   = $duedate;
264         $event->timeduration = 0;
265         $event->timesort    = $event->timestart + $event->timeduration;
266         $event->visible     = instance_is_visible('assign', $assigninstance);
267         $event->eventtype   = ASSIGN_EVENT_TYPE_DUE;
269         // Determine the event name and priority.
270         if ($groupid) {
271             // Group override event.
272             $params = new stdClass();
273             $params->assign = $assigninstance->name;
274             $params->group = groups_get_group_name($groupid);
275             if ($params->group === false) {
276                 // Group doesn't exist, just skip it.
277                 continue;
278             }
279             $eventname = get_string('overridegroupeventname', 'assign', $params);
280             // Set group override priority.
281             if (isset($current->sortorder)) {
282                 $event->priority = $current->sortorder;
283             }
284         } else if ($userid) {
285             // User override event.
286             $params = new stdClass();
287             $params->assign = $assigninstance->name;
288             $eventname = get_string('overrideusereventname', 'assign', $params);
289             // Set user override priority.
290             $event->priority = CALENDAR_EVENT_USER_OVERRIDE_PRIORITY;
291         } else {
292             // The parent event.
293             $eventname = $assigninstance->name;
294         }
296         if ($duedate && $addclose) {
297             if ($oldevent = array_shift($oldevents)) {
298                 $event->id = $oldevent->id;
299             } else {
300                 unset($event->id);
301             }
302             $event->name      = $eventname.' ('.get_string('duedate', 'assign').')';
303             calendar_event::create($event);
304         }
305     }
307     // Delete any leftover events.
308     foreach ($oldevents as $badevent) {
309         $badevent = calendar_event::load($badevent);
310         $badevent->delete();
311     }
314 /**
315  * Return the list if Moodle features this module supports
316  *
317  * @param string $feature FEATURE_xx constant for requested feature
318  * @return mixed True if module supports feature, null if doesn't know
319  */
320 function assign_supports($feature) {
321     switch($feature) {
322         case FEATURE_GROUPS:
323             return true;
324         case FEATURE_GROUPINGS:
325             return true;
326         case FEATURE_MOD_INTRO:
327             return true;
328         case FEATURE_COMPLETION_TRACKS_VIEWS:
329             return true;
330         case FEATURE_COMPLETION_HAS_RULES:
331             return true;
332         case FEATURE_GRADE_HAS_GRADE:
333             return true;
334         case FEATURE_GRADE_OUTCOMES:
335             return true;
336         case FEATURE_BACKUP_MOODLE2:
337             return true;
338         case FEATURE_SHOW_DESCRIPTION:
339             return true;
340         case FEATURE_ADVANCED_GRADING:
341             return true;
342         case FEATURE_PLAGIARISM:
343             return true;
344         case FEATURE_COMMENT:
345             return true;
347         default:
348             return null;
349     }
352 /**
353  * Lists all gradable areas for the advanced grading methods gramework
354  *
355  * @return array('string'=>'string') An array with area names as keys and descriptions as values
356  */
357 function assign_grading_areas_list() {
358     return array('submissions'=>get_string('submissions', 'assign'));
362 /**
363  * extend an assigment navigation settings
364  *
365  * @param settings_navigation $settings
366  * @param navigation_node $navref
367  * @return void
368  */
369 function assign_extend_settings_navigation(settings_navigation $settings, navigation_node $navref) {
370     global $PAGE, $DB;
372     // We want to add these new nodes after the Edit settings node, and before the
373     // Locally assigned roles node. Of course, both of those are controlled by capabilities.
374     $keys = $navref->get_children_key_list();
375     $beforekey = null;
376     $i = array_search('modedit', $keys);
377     if ($i === false and array_key_exists(0, $keys)) {
378         $beforekey = $keys[0];
379     } else if (array_key_exists($i + 1, $keys)) {
380         $beforekey = $keys[$i + 1];
381     }
383     $cm = $PAGE->cm;
384     if (!$cm) {
385         return;
386     }
388     $context = $cm->context;
389     $course = $PAGE->course;
391     if (!$course) {
392         return;
393     }
395     if (has_capability('mod/assign:manageoverrides', $PAGE->cm->context)) {
396         $url = new moodle_url('/mod/assign/overrides.php', array('cmid' => $PAGE->cm->id));
397         $node = navigation_node::create(get_string('groupoverrides', 'assign'),
398             new moodle_url($url, array('mode' => 'group')),
399             navigation_node::TYPE_SETTING, null, 'mod_assign_groupoverrides');
400         $navref->add_node($node, $beforekey);
402         $node = navigation_node::create(get_string('useroverrides', 'assign'),
403             new moodle_url($url, array('mode' => 'user')),
404             navigation_node::TYPE_SETTING, null, 'mod_assign_useroverrides');
405         $navref->add_node($node, $beforekey);
406     }
408     // Link to gradebook.
409     if (has_capability('gradereport/grader:view', $cm->context) &&
410             has_capability('moodle/grade:viewall', $cm->context)) {
411         $link = new moodle_url('/grade/report/grader/index.php', array('id' => $course->id));
412         $linkname = get_string('viewgradebook', 'assign');
413         $node = $navref->add($linkname, $link, navigation_node::TYPE_SETTING);
414     }
416     // Link to download all submissions.
417     if (has_any_capability(array('mod/assign:grade', 'mod/assign:viewgrades'), $context)) {
418         $link = new moodle_url('/mod/assign/view.php', array('id' => $cm->id, 'action'=>'grading'));
419         $node = $navref->add(get_string('viewgrading', 'assign'), $link, navigation_node::TYPE_SETTING);
421         $link = new moodle_url('/mod/assign/view.php', array('id' => $cm->id, 'action'=>'downloadall'));
422         $node = $navref->add(get_string('downloadall', 'assign'), $link, navigation_node::TYPE_SETTING);
423     }
425     if (has_capability('mod/assign:revealidentities', $context)) {
426         $dbparams = array('id'=>$cm->instance);
427         $assignment = $DB->get_record('assign', $dbparams, 'blindmarking, revealidentities');
429         if ($assignment && $assignment->blindmarking && !$assignment->revealidentities) {
430             $urlparams = array('id' => $cm->id, 'action'=>'revealidentities');
431             $url = new moodle_url('/mod/assign/view.php', $urlparams);
432             $linkname = get_string('revealidentities', 'assign');
433             $node = $navref->add($linkname, $url, navigation_node::TYPE_SETTING);
434         }
435     }
438 /**
439  * Add a get_coursemodule_info function in case any assignment type wants to add 'extra' information
440  * for the course (see resource).
441  *
442  * Given a course_module object, this function returns any "extra" information that may be needed
443  * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.
444  *
445  * @param stdClass $coursemodule The coursemodule object (record).
446  * @return cached_cm_info An object on information that the courses
447  *                        will know about (most noticeably, an icon).
448  */
449 function assign_get_coursemodule_info($coursemodule) {
450     global $CFG, $DB;
452     $dbparams = array('id'=>$coursemodule->instance);
453     $fields = 'id, name, alwaysshowdescription, allowsubmissionsfromdate, intro, introformat';
454     if (! $assignment = $DB->get_record('assign', $dbparams, $fields)) {
455         return false;
456     }
458     $result = new cached_cm_info();
459     $result->name = $assignment->name;
460     if ($coursemodule->showdescription) {
461         if ($assignment->alwaysshowdescription || time() > $assignment->allowsubmissionsfromdate) {
462             // Convert intro to html. Do not filter cached version, filters run at display time.
463             $result->content = format_module_intro('assign', $assignment, $coursemodule->id, false);
464         }
465     }
466     return $result;
469 /**
470  * Return a list of page types
471  * @param string $pagetype current page type
472  * @param stdClass $parentcontext Block's parent context
473  * @param stdClass $currentcontext Current context of block
474  */
475 function assign_page_type_list($pagetype, $parentcontext, $currentcontext) {
476     $modulepagetype = array(
477         'mod-assign-*' => get_string('page-mod-assign-x', 'assign'),
478         'mod-assign-view' => get_string('page-mod-assign-view', 'assign'),
479     );
480     return $modulepagetype;
483 /**
484  * Print an overview of all assignments
485  * for the courses.
486  *
487  * @deprecated since 3.3
488  *
489  * @param mixed $courses The list of courses to print the overview for
490  * @param array $htmlarray The array of html to return
491  * @return true
492  */
493 function assign_print_overview($courses, &$htmlarray) {
494     global $CFG, $DB;
496     debugging('The function assign_print_overview() is now deprecated.', DEBUG_DEVELOPER);
498     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
499         return true;
500     }
502     if (!$assignments = get_all_instances_in_courses('assign', $courses)) {
503         return true;
504     }
506     $assignmentids = array();
508     // Do assignment_base::isopen() here without loading the whole thing for speed.
509     foreach ($assignments as $key => $assignment) {
510         $time = time();
511         $isopen = false;
512         if ($assignment->duedate) {
513             $duedate = false;
514             if ($assignment->cutoffdate) {
515                 $duedate = $assignment->cutoffdate;
516             }
517             if ($duedate) {
518                 $isopen = ($assignment->allowsubmissionsfromdate <= $time && $time <= $duedate);
519             } else {
520                 $isopen = ($assignment->allowsubmissionsfromdate <= $time);
521             }
522         }
523         if ($isopen) {
524             $assignmentids[] = $assignment->id;
525         }
526     }
528     if (empty($assignmentids)) {
529         // No assignments to look at - we're done.
530         return true;
531     }
533     // Definitely something to print, now include the constants we need.
534     require_once($CFG->dirroot . '/mod/assign/locallib.php');
536     $strduedate = get_string('duedate', 'assign');
537     $strcutoffdate = get_string('nosubmissionsacceptedafter', 'assign');
538     $strnolatesubmissions = get_string('nolatesubmissions', 'assign');
539     $strduedateno = get_string('duedateno', 'assign');
540     $strassignment = get_string('modulename', 'assign');
542     // We do all possible database work here *outside* of the loop to ensure this scales.
543     list($sqlassignmentids, $assignmentidparams) = $DB->get_in_or_equal($assignmentids);
545     $mysubmissions = null;
546     $unmarkedsubmissions = null;
548     foreach ($assignments as $assignment) {
550         // Do not show assignments that are not open.
551         if (!in_array($assignment->id, $assignmentids)) {
552             continue;
553         }
555         $context = context_module::instance($assignment->coursemodule);
557         // Does the submission status of the assignment require notification?
558         if (has_capability('mod/assign:submit', $context, null, false)) {
559             // Does the submission status of the assignment require notification?
560             $submitdetails = assign_get_mysubmission_details_for_print_overview($mysubmissions, $sqlassignmentids,
561                     $assignmentidparams, $assignment);
562         } else {
563             $submitdetails = false;
564         }
566         if (has_capability('mod/assign:grade', $context, null, false)) {
567             // Does the grading status of the assignment require notification ?
568             $gradedetails = assign_get_grade_details_for_print_overview($unmarkedsubmissions, $sqlassignmentids,
569                     $assignmentidparams, $assignment, $context);
570         } else {
571             $gradedetails = false;
572         }
574         if (empty($submitdetails) && empty($gradedetails)) {
575             // There is no need to display this assignment as there is nothing to notify.
576             continue;
577         }
579         $dimmedclass = '';
580         if (!$assignment->visible) {
581             $dimmedclass = ' class="dimmed"';
582         }
583         $href = $CFG->wwwroot . '/mod/assign/view.php?id=' . $assignment->coursemodule;
584         $basestr = '<div class="assign overview">' .
585                '<div class="name">' .
586                $strassignment . ': '.
587                '<a ' . $dimmedclass .
588                    'title="' . $strassignment . '" ' .
589                    'href="' . $href . '">' .
590                format_string($assignment->name) .
591                '</a></div>';
592         if ($assignment->duedate) {
593             $userdate = userdate($assignment->duedate);
594             $basestr .= '<div class="info">' . $strduedate . ': ' . $userdate . '</div>';
595         } else {
596             $basestr .= '<div class="info">' . $strduedateno . '</div>';
597         }
598         if ($assignment->cutoffdate) {
599             if ($assignment->cutoffdate == $assignment->duedate) {
600                 $basestr .= '<div class="info">' . $strnolatesubmissions . '</div>';
601             } else {
602                 $userdate = userdate($assignment->cutoffdate);
603                 $basestr .= '<div class="info">' . $strcutoffdate . ': ' . $userdate . '</div>';
604             }
605         }
607         // Show only relevant information.
608         if (!empty($submitdetails)) {
609             $basestr .= $submitdetails;
610         }
612         if (!empty($gradedetails)) {
613             $basestr .= $gradedetails;
614         }
615         $basestr .= '</div>';
617         if (empty($htmlarray[$assignment->course]['assign'])) {
618             $htmlarray[$assignment->course]['assign'] = $basestr;
619         } else {
620             $htmlarray[$assignment->course]['assign'] .= $basestr;
621         }
622     }
623     return true;
626 /**
627  * This api generates html to be displayed to students in print overview section, related to their submission status of the given
628  * assignment.
629  *
630  * @deprecated since 3.3
631  *
632  * @param array $mysubmissions list of submissions of current user indexed by assignment id.
633  * @param string $sqlassignmentids sql clause used to filter open assignments.
634  * @param array $assignmentidparams sql params used to filter open assignments.
635  * @param stdClass $assignment current assignment
636  *
637  * @return bool|string html to display , false if nothing needs to be displayed.
638  * @throws coding_exception
639  */
640 function assign_get_mysubmission_details_for_print_overview(&$mysubmissions, $sqlassignmentids, $assignmentidparams,
641                                                             $assignment) {
642     global $USER, $DB;
644     debugging('The function assign_get_mysubmission_details_for_print_overview() is now deprecated.', DEBUG_DEVELOPER);
646     if ($assignment->nosubmissions) {
647         // Offline assignment. No need to display alerts for offline assignments.
648         return false;
649     }
651     $strnotsubmittedyet = get_string('notsubmittedyet', 'assign');
653     if (!isset($mysubmissions)) {
655         // Get all user submissions, indexed by assignment id.
656         $dbparams = array_merge(array($USER->id), $assignmentidparams, array($USER->id));
657         $mysubmissions = $DB->get_records_sql('SELECT a.id AS assignment,
658                                                       a.nosubmissions AS nosubmissions,
659                                                       g.timemodified AS timemarked,
660                                                       g.grader AS grader,
661                                                       g.grade AS grade,
662                                                       s.status AS status
663                                                  FROM {assign} a, {assign_submission} s
664                                             LEFT JOIN {assign_grades} g ON
665                                                       g.assignment = s.assignment AND
666                                                       g.userid = ? AND
667                                                       g.attemptnumber = s.attemptnumber
668                                                 WHERE a.id ' . $sqlassignmentids . ' AND
669                                                       s.latest = 1 AND
670                                                       s.assignment = a.id AND
671                                                       s.userid = ?', $dbparams);
672     }
674     $submitdetails = '';
675     $submitdetails .= '<div class="details">';
676     $submitdetails .= get_string('mysubmission', 'assign');
677     $submission = false;
679     if (isset($mysubmissions[$assignment->id])) {
680         $submission = $mysubmissions[$assignment->id];
681     }
683     if ($submission && $submission->status == ASSIGN_SUBMISSION_STATUS_SUBMITTED) {
684         // A valid submission already exists, no need to notify students about this.
685         return false;
686     }
688     // We need to show details only if a valid submission doesn't exist.
689     if (!$submission ||
690         !$submission->status ||
691         $submission->status == ASSIGN_SUBMISSION_STATUS_DRAFT ||
692         $submission->status == ASSIGN_SUBMISSION_STATUS_NEW
693     ) {
694         $submitdetails .= $strnotsubmittedyet;
695     } else {
696         $submitdetails .= get_string('submissionstatus_' . $submission->status, 'assign');
697     }
698     if ($assignment->markingworkflow) {
699         $workflowstate = $DB->get_field('assign_user_flags', 'workflowstate', array('assignment' =>
700                 $assignment->id, 'userid' => $USER->id));
701         if ($workflowstate) {
702             $gradingstatus = 'markingworkflowstate' . $workflowstate;
703         } else {
704             $gradingstatus = 'markingworkflowstate' . ASSIGN_MARKING_WORKFLOW_STATE_NOTMARKED;
705         }
706     } else if (!empty($submission->grade) && $submission->grade !== null && $submission->grade >= 0) {
707         $gradingstatus = ASSIGN_GRADING_STATUS_GRADED;
708     } else {
709         $gradingstatus = ASSIGN_GRADING_STATUS_NOT_GRADED;
710     }
711     $submitdetails .= ', ' . get_string($gradingstatus, 'assign');
712     $submitdetails .= '</div>';
713     return $submitdetails;
716 /**
717  * This api generates html to be displayed to teachers in print overview section, related to the grading status of the given
718  * assignment's submissions.
719  *
720  * @deprecated since 3.3
721  *
722  * @param array $unmarkedsubmissions list of submissions of that are currently unmarked indexed by assignment id.
723  * @param string $sqlassignmentids sql clause used to filter open assignments.
724  * @param array $assignmentidparams sql params used to filter open assignments.
725  * @param stdClass $assignment current assignment
726  * @param context $context context of the assignment.
727  *
728  * @return bool|string html to display , false if nothing needs to be displayed.
729  * @throws coding_exception
730  */
731 function assign_get_grade_details_for_print_overview(&$unmarkedsubmissions, $sqlassignmentids, $assignmentidparams,
732                                                      $assignment, $context) {
733     global $DB;
735     debugging('The function assign_get_grade_details_for_print_overview() is now deprecated.', DEBUG_DEVELOPER);
737     if (!isset($unmarkedsubmissions)) {
738         // Build up and array of unmarked submissions indexed by assignment id/ userid
739         // for use where the user has grading rights on assignment.
740         $dbparams = array_merge(array(ASSIGN_SUBMISSION_STATUS_SUBMITTED), $assignmentidparams);
741         $rs = $DB->get_recordset_sql('SELECT s.assignment as assignment,
742                                              s.userid as userid,
743                                              s.id as id,
744                                              s.status as status,
745                                              g.timemodified as timegraded
746                                         FROM {assign_submission} s
747                                    LEFT JOIN {assign_grades} g ON
748                                              s.userid = g.userid AND
749                                              s.assignment = g.assignment AND
750                                              g.attemptnumber = s.attemptnumber
751                                        WHERE
752                                              ( g.timemodified is NULL OR
753                                              s.timemodified >= g.timemodified OR
754                                              g.grade IS NULL ) AND
755                                              s.timemodified IS NOT NULL AND
756                                              s.status = ? AND
757                                              s.latest = 1 AND
758                                              s.assignment ' . $sqlassignmentids, $dbparams);
760         $unmarkedsubmissions = array();
761         foreach ($rs as $rd) {
762             $unmarkedsubmissions[$rd->assignment][$rd->userid] = $rd->id;
763         }
764         $rs->close();
765     }
767     // Count how many people can submit.
768     $submissions = 0;
769     if ($students = get_enrolled_users($context, 'mod/assign:view', 0, 'u.id')) {
770         foreach ($students as $student) {
771             if (isset($unmarkedsubmissions[$assignment->id][$student->id])) {
772                 $submissions++;
773             }
774         }
775     }
777     if ($submissions) {
778         $urlparams = array('id' => $assignment->coursemodule, 'action' => 'grading');
779         $url = new moodle_url('/mod/assign/view.php', $urlparams);
780         $gradedetails = '<div class="details">' .
781                 '<a href="' . $url . '">' .
782                 get_string('submissionsnotgraded', 'assign', $submissions) .
783                 '</a></div>';
784         return $gradedetails;
785     } else {
786         return false;
787     }
791 /**
792  * Print recent activity from all assignments in a given course
793  *
794  * This is used by the recent activity block
795  * @param mixed $course the course to print activity for
796  * @param bool $viewfullnames boolean to determine whether to show full names or not
797  * @param int $timestart the time the rendering started
798  * @return bool true if activity was printed, false otherwise.
799  */
800 function assign_print_recent_activity($course, $viewfullnames, $timestart) {
801     global $CFG, $USER, $DB, $OUTPUT;
802     require_once($CFG->dirroot . '/mod/assign/locallib.php');
804     // Do not use log table if possible, it may be huge.
806     $dbparams = array($timestart, $course->id, 'assign', ASSIGN_SUBMISSION_STATUS_SUBMITTED);
807     $namefields = user_picture::fields('u', null, 'userid');
808     if (!$submissions = $DB->get_records_sql("SELECT asb.id, asb.timemodified, cm.id AS cmid, um.id as recordid,
809                                                      $namefields
810                                                 FROM {assign_submission} asb
811                                                      JOIN {assign} a      ON a.id = asb.assignment
812                                                      JOIN {course_modules} cm ON cm.instance = a.id
813                                                      JOIN {modules} md        ON md.id = cm.module
814                                                      JOIN {user} u            ON u.id = asb.userid
815                                                 LEFT JOIN {assign_user_mapping} um ON um.userid = u.id AND um.assignment = a.id
816                                                WHERE asb.timemodified > ? AND
817                                                      asb.latest = 1 AND
818                                                      a.course = ? AND
819                                                      md.name = ? AND
820                                                      asb.status = ?
821                                             ORDER BY asb.timemodified ASC", $dbparams)) {
822          return false;
823     }
825     $modinfo = get_fast_modinfo($course);
826     $show    = array();
827     $grader  = array();
829     $showrecentsubmissions = get_config('assign', 'showrecentsubmissions');
831     foreach ($submissions as $submission) {
832         if (!array_key_exists($submission->cmid, $modinfo->get_cms())) {
833             continue;
834         }
835         $cm = $modinfo->get_cm($submission->cmid);
836         if (!$cm->uservisible) {
837             continue;
838         }
839         if ($submission->userid == $USER->id) {
840             $show[] = $submission;
841             continue;
842         }
844         $context = context_module::instance($submission->cmid);
845         // The act of submitting of assignment may be considered private -
846         // only graders will see it if specified.
847         if (empty($showrecentsubmissions)) {
848             if (!array_key_exists($cm->id, $grader)) {
849                 $grader[$cm->id] = has_capability('moodle/grade:viewall', $context);
850             }
851             if (!$grader[$cm->id]) {
852                 continue;
853             }
854         }
856         $groupmode = groups_get_activity_groupmode($cm, $course);
858         if ($groupmode == SEPARATEGROUPS &&
859                 !has_capability('moodle/site:accessallgroups',  $context)) {
860             if (isguestuser()) {
861                 // Shortcut - guest user does not belong into any group.
862                 continue;
863             }
865             // This will be slow - show only users that share group with me in this cm.
866             if (!$modinfo->get_groups($cm->groupingid)) {
867                 continue;
868             }
869             $usersgroups =  groups_get_all_groups($course->id, $submission->userid, $cm->groupingid);
870             if (is_array($usersgroups)) {
871                 $usersgroups = array_keys($usersgroups);
872                 $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
873                 if (empty($intersect)) {
874                     continue;
875                 }
876             }
877         }
878         $show[] = $submission;
879     }
881     if (empty($show)) {
882         return false;
883     }
885     echo $OUTPUT->heading(get_string('newsubmissions', 'assign').':', 3);
887     foreach ($show as $submission) {
888         $cm = $modinfo->get_cm($submission->cmid);
889         $context = context_module::instance($submission->cmid);
890         $assign = new assign($context, $cm, $cm->course);
891         $link = $CFG->wwwroot.'/mod/assign/view.php?id='.$cm->id;
892         // Obscure first and last name if blind marking enabled.
893         if ($assign->is_blind_marking()) {
894             $submission->firstname = get_string('participant', 'mod_assign');
895             if (empty($submission->recordid)) {
896                 $submission->recordid = $assign->get_uniqueid_for_user($submission->userid);
897             }
898             $submission->lastname = $submission->recordid;
899         }
900         print_recent_activity_note($submission->timemodified,
901                                    $submission,
902                                    $cm->name,
903                                    $link,
904                                    false,
905                                    $viewfullnames);
906     }
908     return true;
911 /**
912  * Returns all assignments since a given time.
913  *
914  * @param array $activities The activity information is returned in this array
915  * @param int $index The current index in the activities array
916  * @param int $timestart The earliest activity to show
917  * @param int $courseid Limit the search to this course
918  * @param int $cmid The course module id
919  * @param int $userid Optional user id
920  * @param int $groupid Optional group id
921  * @return void
922  */
923 function assign_get_recent_mod_activity(&$activities,
924                                         &$index,
925                                         $timestart,
926                                         $courseid,
927                                         $cmid,
928                                         $userid=0,
929                                         $groupid=0) {
930     global $CFG, $COURSE, $USER, $DB;
932     require_once($CFG->dirroot . '/mod/assign/locallib.php');
934     if ($COURSE->id == $courseid) {
935         $course = $COURSE;
936     } else {
937         $course = $DB->get_record('course', array('id'=>$courseid));
938     }
940     $modinfo = get_fast_modinfo($course);
942     $cm = $modinfo->get_cm($cmid);
943     $params = array();
944     if ($userid) {
945         $userselect = 'AND u.id = :userid';
946         $params['userid'] = $userid;
947     } else {
948         $userselect = '';
949     }
951     if ($groupid) {
952         $groupselect = 'AND gm.groupid = :groupid';
953         $groupjoin   = 'JOIN {groups_members} gm ON  gm.userid=u.id';
954         $params['groupid'] = $groupid;
955     } else {
956         $groupselect = '';
957         $groupjoin   = '';
958     }
960     $params['cminstance'] = $cm->instance;
961     $params['timestart'] = $timestart;
962     $params['submitted'] = ASSIGN_SUBMISSION_STATUS_SUBMITTED;
964     $userfields = user_picture::fields('u', null, 'userid');
966     if (!$submissions = $DB->get_records_sql('SELECT asb.id, asb.timemodified, ' .
967                                                      $userfields .
968                                              '  FROM {assign_submission} asb
969                                                 JOIN {assign} a ON a.id = asb.assignment
970                                                 JOIN {user} u ON u.id = asb.userid ' .
971                                           $groupjoin .
972                                             '  WHERE asb.timemodified > :timestart AND
973                                                      asb.status = :submitted AND
974                                                      a.id = :cminstance
975                                                      ' . $userselect . ' ' . $groupselect .
976                                             ' ORDER BY asb.timemodified ASC', $params)) {
977          return;
978     }
980     $groupmode       = groups_get_activity_groupmode($cm, $course);
981     $cmcontext      = context_module::instance($cm->id);
982     $grader          = has_capability('moodle/grade:viewall', $cmcontext);
983     $accessallgroups = has_capability('moodle/site:accessallgroups', $cmcontext);
984     $viewfullnames   = has_capability('moodle/site:viewfullnames', $cmcontext);
987     $showrecentsubmissions = get_config('assign', 'showrecentsubmissions');
988     $show = array();
989     foreach ($submissions as $submission) {
990         if ($submission->userid == $USER->id) {
991             $show[] = $submission;
992             continue;
993         }
994         // The act of submitting of assignment may be considered private -
995         // only graders will see it if specified.
996         if (empty($showrecentsubmissions)) {
997             if (!$grader) {
998                 continue;
999             }
1000         }
1002         if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {
1003             if (isguestuser()) {
1004                 // Shortcut - guest user does not belong into any group.
1005                 continue;
1006             }
1008             // This will be slow - show only users that share group with me in this cm.
1009             if (!$modinfo->get_groups($cm->groupingid)) {
1010                 continue;
1011             }
1012             $usersgroups =  groups_get_all_groups($course->id, $submission->userid, $cm->groupingid);
1013             if (is_array($usersgroups)) {
1014                 $usersgroups = array_keys($usersgroups);
1015                 $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));
1016                 if (empty($intersect)) {
1017                     continue;
1018                 }
1019             }
1020         }
1021         $show[] = $submission;
1022     }
1024     if (empty($show)) {
1025         return;
1026     }
1028     if ($grader) {
1029         require_once($CFG->libdir.'/gradelib.php');
1030         $userids = array();
1031         foreach ($show as $id => $submission) {
1032             $userids[] = $submission->userid;
1033         }
1034         $grades = grade_get_grades($courseid, 'mod', 'assign', $cm->instance, $userids);
1035     }
1037     $aname = format_string($cm->name, true);
1038     foreach ($show as $submission) {
1039         $activity = new stdClass();
1041         $activity->type         = 'assign';
1042         $activity->cmid         = $cm->id;
1043         $activity->name         = $aname;
1044         $activity->sectionnum   = $cm->sectionnum;
1045         $activity->timestamp    = $submission->timemodified;
1046         $activity->user         = new stdClass();
1047         if ($grader) {
1048             $activity->grade = $grades->items[0]->grades[$submission->userid]->str_long_grade;
1049         }
1051         $userfields = explode(',', user_picture::fields());
1052         foreach ($userfields as $userfield) {
1053             if ($userfield == 'id') {
1054                 // Aliased in SQL above.
1055                 $activity->user->{$userfield} = $submission->userid;
1056             } else {
1057                 $activity->user->{$userfield} = $submission->{$userfield};
1058             }
1059         }
1060         $activity->user->fullname = fullname($submission, $viewfullnames);
1062         $activities[$index++] = $activity;
1063     }
1065     return;
1068 /**
1069  * Print recent activity from all assignments in a given course
1070  *
1071  * This is used by course/recent.php
1072  * @param stdClass $activity
1073  * @param int $courseid
1074  * @param bool $detail
1075  * @param array $modnames
1076  */
1077 function assign_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {
1078     global $CFG, $OUTPUT;
1080     echo '<table border="0" cellpadding="3" cellspacing="0" class="assignment-recent">';
1082     echo '<tr><td class="userpicture" valign="top">';
1083     echo $OUTPUT->user_picture($activity->user);
1084     echo '</td><td>';
1086     if ($detail) {
1087         $modname = $modnames[$activity->type];
1088         echo '<div class="title">';
1089         echo $OUTPUT->image_icon('icon', $modname, 'assign');
1090         echo '<a href="' . $CFG->wwwroot . '/mod/assign/view.php?id=' . $activity->cmid . '">';
1091         echo $activity->name;
1092         echo '</a>';
1093         echo '</div>';
1094     }
1096     if (isset($activity->grade)) {
1097         echo '<div class="grade">';
1098         echo get_string('grade').': ';
1099         echo $activity->grade;
1100         echo '</div>';
1101     }
1103     echo '<div class="user">';
1104     echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">";
1105     echo "{$activity->user->fullname}</a>  - " . userdate($activity->timestamp);
1106     echo '</div>';
1108     echo '</td></tr></table>';
1111 /**
1112  * Checks if a scale is being used by an assignment.
1113  *
1114  * This is used by the backup code to decide whether to back up a scale
1115  * @param int $assignmentid
1116  * @param int $scaleid
1117  * @return boolean True if the scale is used by the assignment
1118  */
1119 function assign_scale_used($assignmentid, $scaleid) {
1120     global $DB;
1122     $return = false;
1123     $rec = $DB->get_record('assign', array('id'=>$assignmentid, 'grade'=>-$scaleid));
1125     if (!empty($rec) && !empty($scaleid)) {
1126         $return = true;
1127     }
1129     return $return;
1132 /**
1133  * Checks if scale is being used by any instance of assignment
1134  *
1135  * This is used to find out if scale used anywhere
1136  * @param int $scaleid
1137  * @return boolean True if the scale is used by any assignment
1138  */
1139 function assign_scale_used_anywhere($scaleid) {
1140     global $DB;
1142     if ($scaleid and $DB->record_exists('assign', array('grade'=>-$scaleid))) {
1143         return true;
1144     } else {
1145         return false;
1146     }
1149 /**
1150  * List the actions that correspond to a view of this module.
1151  * This is used by the participation report.
1152  *
1153  * Note: This is not used by new logging system. Event with
1154  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
1155  *       be considered as view action.
1156  *
1157  * @return array
1158  */
1159 function assign_get_view_actions() {
1160     return array('view submission', 'view feedback');
1163 /**
1164  * List the actions that correspond to a post of this module.
1165  * This is used by the participation report.
1166  *
1167  * Note: This is not used by new logging system. Event with
1168  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
1169  *       will be considered as post action.
1170  *
1171  * @return array
1172  */
1173 function assign_get_post_actions() {
1174     return array('upload', 'submit', 'submit for grading');
1177 /**
1178  * Call cron on the assign module.
1179  */
1180 function assign_cron() {
1181     global $CFG;
1183     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1184     assign::cron();
1186     $plugins = core_component::get_plugin_list('assignsubmission');
1188     foreach ($plugins as $name => $plugin) {
1189         $disabled = get_config('assignsubmission_' . $name, 'disabled');
1190         if (!$disabled) {
1191             $class = 'assign_submission_' . $name;
1192             require_once($CFG->dirroot . '/mod/assign/submission/' . $name . '/locallib.php');
1193             $class::cron();
1194         }
1195     }
1196     $plugins = core_component::get_plugin_list('assignfeedback');
1198     foreach ($plugins as $name => $plugin) {
1199         $disabled = get_config('assignfeedback_' . $name, 'disabled');
1200         if (!$disabled) {
1201             $class = 'assign_feedback_' . $name;
1202             require_once($CFG->dirroot . '/mod/assign/feedback/' . $name . '/locallib.php');
1203             $class::cron();
1204         }
1205     }
1207     return true;
1210 /**
1211  * Returns all other capabilities used by this module.
1212  * @return array Array of capability strings
1213  */
1214 function assign_get_extra_capabilities() {
1215     return array('gradereport/grader:view',
1216                  'moodle/grade:viewall',
1217                  'moodle/site:viewfullnames',
1218                  'moodle/site:config');
1221 /**
1222  * Create grade item for given assignment.
1223  *
1224  * @param stdClass $assign record with extra cmidnumber
1225  * @param array $grades optional array/object of grade(s); 'reset' means reset grades in gradebook
1226  * @return int 0 if ok, error code otherwise
1227  */
1228 function assign_grade_item_update($assign, $grades=null) {
1229     global $CFG;
1230     require_once($CFG->libdir.'/gradelib.php');
1232     if (!isset($assign->courseid)) {
1233         $assign->courseid = $assign->course;
1234     }
1236     $params = array('itemname'=>$assign->name, 'idnumber'=>$assign->cmidnumber);
1238     // Check if feedback plugin for gradebook is enabled, if yes then
1239     // gradetype = GRADE_TYPE_TEXT else GRADE_TYPE_NONE.
1240     $gradefeedbackenabled = false;
1242     if (isset($assign->gradefeedbackenabled)) {
1243         $gradefeedbackenabled = $assign->gradefeedbackenabled;
1244     } else if ($assign->grade == 0) { // Grade feedback is needed only when grade == 0.
1245         require_once($CFG->dirroot . '/mod/assign/locallib.php');
1246         $mod = get_coursemodule_from_instance('assign', $assign->id, $assign->courseid);
1247         $cm = context_module::instance($mod->id);
1248         $assignment = new assign($cm, null, null);
1249         $gradefeedbackenabled = $assignment->is_gradebook_feedback_enabled();
1250     }
1252     if ($assign->grade > 0) {
1253         $params['gradetype'] = GRADE_TYPE_VALUE;
1254         $params['grademax']  = $assign->grade;
1255         $params['grademin']  = 0;
1257     } else if ($assign->grade < 0) {
1258         $params['gradetype'] = GRADE_TYPE_SCALE;
1259         $params['scaleid']   = -$assign->grade;
1261     } else if ($gradefeedbackenabled) {
1262         // $assign->grade == 0 and feedback enabled.
1263         $params['gradetype'] = GRADE_TYPE_TEXT;
1264     } else {
1265         // $assign->grade == 0 and no feedback enabled.
1266         $params['gradetype'] = GRADE_TYPE_NONE;
1267     }
1269     if ($grades  === 'reset') {
1270         $params['reset'] = true;
1271         $grades = null;
1272     }
1274     return grade_update('mod/assign',
1275                         $assign->courseid,
1276                         'mod',
1277                         'assign',
1278                         $assign->id,
1279                         0,
1280                         $grades,
1281                         $params);
1284 /**
1285  * Return grade for given user or all users.
1286  *
1287  * @param stdClass $assign record of assign with an additional cmidnumber
1288  * @param int $userid optional user id, 0 means all users
1289  * @return array array of grades, false if none
1290  */
1291 function assign_get_user_grades($assign, $userid=0) {
1292     global $CFG;
1294     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1296     $cm = get_coursemodule_from_instance('assign', $assign->id, 0, false, MUST_EXIST);
1297     $context = context_module::instance($cm->id);
1298     $assignment = new assign($context, null, null);
1299     $assignment->set_instance($assign);
1300     return $assignment->get_user_grades_for_gradebook($userid);
1303 /**
1304  * Update activity grades.
1305  *
1306  * @param stdClass $assign database record
1307  * @param int $userid specific user only, 0 means all
1308  * @param bool $nullifnone - not used
1309  */
1310 function assign_update_grades($assign, $userid=0, $nullifnone=true) {
1311     global $CFG;
1312     require_once($CFG->libdir.'/gradelib.php');
1314     if ($assign->grade == 0) {
1315         assign_grade_item_update($assign);
1317     } else if ($grades = assign_get_user_grades($assign, $userid)) {
1318         foreach ($grades as $k => $v) {
1319             if ($v->rawgrade == -1) {
1320                 $grades[$k]->rawgrade = null;
1321             }
1322         }
1323         assign_grade_item_update($assign, $grades);
1325     } else {
1326         assign_grade_item_update($assign);
1327     }
1330 /**
1331  * List the file areas that can be browsed.
1332  *
1333  * @param stdClass $course
1334  * @param stdClass $cm
1335  * @param stdClass $context
1336  * @return array
1337  */
1338 function assign_get_file_areas($course, $cm, $context) {
1339     global $CFG;
1340     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1342     $areas = array(ASSIGN_INTROATTACHMENT_FILEAREA => get_string('introattachments', 'mod_assign'));
1344     $assignment = new assign($context, $cm, $course);
1345     foreach ($assignment->get_submission_plugins() as $plugin) {
1346         if ($plugin->is_visible()) {
1347             $pluginareas = $plugin->get_file_areas();
1349             if ($pluginareas) {
1350                 $areas = array_merge($areas, $pluginareas);
1351             }
1352         }
1353     }
1354     foreach ($assignment->get_feedback_plugins() as $plugin) {
1355         if ($plugin->is_visible()) {
1356             $pluginareas = $plugin->get_file_areas();
1358             if ($pluginareas) {
1359                 $areas = array_merge($areas, $pluginareas);
1360             }
1361         }
1362     }
1364     return $areas;
1367 /**
1368  * File browsing support for assign module.
1369  *
1370  * @param file_browser $browser
1371  * @param object $areas
1372  * @param object $course
1373  * @param object $cm
1374  * @param object $context
1375  * @param string $filearea
1376  * @param int $itemid
1377  * @param string $filepath
1378  * @param string $filename
1379  * @return object file_info instance or null if not found
1380  */
1381 function assign_get_file_info($browser,
1382                               $areas,
1383                               $course,
1384                               $cm,
1385                               $context,
1386                               $filearea,
1387                               $itemid,
1388                               $filepath,
1389                               $filename) {
1390     global $CFG;
1391     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1393     if ($context->contextlevel != CONTEXT_MODULE) {
1394         return null;
1395     }
1397     $urlbase = $CFG->wwwroot.'/pluginfile.php';
1398     $fs = get_file_storage();
1399     $filepath = is_null($filepath) ? '/' : $filepath;
1400     $filename = is_null($filename) ? '.' : $filename;
1402     // Need to find where this belongs to.
1403     $assignment = new assign($context, $cm, $course);
1404     if ($filearea === ASSIGN_INTROATTACHMENT_FILEAREA) {
1405         if (!has_capability('moodle/course:managefiles', $context)) {
1406             // Students can not peak here!
1407             return null;
1408         }
1409         if (!($storedfile = $fs->get_file($assignment->get_context()->id,
1410                                           'mod_assign', $filearea, 0, $filepath, $filename))) {
1411             return null;
1412         }
1413         return new file_info_stored($browser,
1414                         $assignment->get_context(),
1415                         $storedfile,
1416                         $urlbase,
1417                         $filearea,
1418                         $itemid,
1419                         true,
1420                         true,
1421                         false);
1422     }
1424     $pluginowner = null;
1425     foreach ($assignment->get_submission_plugins() as $plugin) {
1426         if ($plugin->is_visible()) {
1427             $pluginareas = $plugin->get_file_areas();
1429             if (array_key_exists($filearea, $pluginareas)) {
1430                 $pluginowner = $plugin;
1431                 break;
1432             }
1433         }
1434     }
1435     if (!$pluginowner) {
1436         foreach ($assignment->get_feedback_plugins() as $plugin) {
1437             if ($plugin->is_visible()) {
1438                 $pluginareas = $plugin->get_file_areas();
1440                 if (array_key_exists($filearea, $pluginareas)) {
1441                     $pluginowner = $plugin;
1442                     break;
1443                 }
1444             }
1445         }
1446     }
1448     if (!$pluginowner) {
1449         return null;
1450     }
1452     $result = $pluginowner->get_file_info($browser, $filearea, $itemid, $filepath, $filename);
1453     return $result;
1456 /**
1457  * Prints the complete info about a user's interaction with an assignment.
1458  *
1459  * @param stdClass $course
1460  * @param stdClass $user
1461  * @param stdClass $coursemodule
1462  * @param stdClass $assign the database assign record
1463  *
1464  * This prints the submission summary and feedback summary for this student.
1465  */
1466 function assign_user_complete($course, $user, $coursemodule, $assign) {
1467     global $CFG;
1468     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1470     $context = context_module::instance($coursemodule->id);
1472     $assignment = new assign($context, $coursemodule, $course);
1474     echo $assignment->view_student_summary($user, false);
1477 /**
1478  * Rescale all grades for this activity and push the new grades to the gradebook.
1479  *
1480  * @param stdClass $course Course db record
1481  * @param stdClass $cm Course module db record
1482  * @param float $oldmin
1483  * @param float $oldmax
1484  * @param float $newmin
1485  * @param float $newmax
1486  */
1487 function assign_rescale_activity_grades($course, $cm, $oldmin, $oldmax, $newmin, $newmax) {
1488     global $DB;
1490     if ($oldmax <= $oldmin) {
1491         // Grades cannot be scaled.
1492         return false;
1493     }
1494     $scale = ($newmax - $newmin) / ($oldmax - $oldmin);
1495     if (($newmax - $newmin) <= 1) {
1496         // We would lose too much precision, lets bail.
1497         return false;
1498     }
1500     $params = array(
1501         'p1' => $oldmin,
1502         'p2' => $scale,
1503         'p3' => $newmin,
1504         'a' => $cm->instance
1505     );
1507     $sql = 'UPDATE {assign_grades} set grade = (((grade - :p1) * :p2) + :p3) where assignment = :a';
1508     $dbupdate = $DB->execute($sql, $params);
1509     if (!$dbupdate) {
1510         return false;
1511     }
1513     // Now re-push all grades to the gradebook.
1514     $dbparams = array('id' => $cm->instance);
1515     $assign = $DB->get_record('assign', $dbparams);
1516     $assign->cmidnumber = $cm->idnumber;
1518     assign_update_grades($assign);
1520     return true;
1523 /**
1524  * Print the grade information for the assignment for this user.
1525  *
1526  * @param stdClass $course
1527  * @param stdClass $user
1528  * @param stdClass $coursemodule
1529  * @param stdClass $assignment
1530  */
1531 function assign_user_outline($course, $user, $coursemodule, $assignment) {
1532     global $CFG;
1533     require_once($CFG->libdir.'/gradelib.php');
1534     require_once($CFG->dirroot.'/grade/grading/lib.php');
1536     $gradinginfo = grade_get_grades($course->id,
1537                                         'mod',
1538                                         'assign',
1539                                         $assignment->id,
1540                                         $user->id);
1542     $gradingitem = $gradinginfo->items[0];
1543     $gradebookgrade = $gradingitem->grades[$user->id];
1545     if (empty($gradebookgrade->str_long_grade)) {
1546         return null;
1547     }
1548     $result = new stdClass();
1549     $result->info = get_string('outlinegrade', 'assign', $gradebookgrade->str_long_grade);
1550     $result->time = $gradebookgrade->dategraded;
1552     return $result;
1555 /**
1556  * Obtains the automatic completion state for this module based on any conditions
1557  * in assign settings.
1558  *
1559  * @param object $course Course
1560  * @param object $cm Course-module
1561  * @param int $userid User ID
1562  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
1563  * @return bool True if completed, false if not, $type if conditions not set.
1564  */
1565 function assign_get_completion_state($course, $cm, $userid, $type) {
1566     global $CFG, $DB;
1567     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1569     $assign = new assign(null, $cm, $course);
1571     // If completion option is enabled, evaluate it and return true/false.
1572     if ($assign->get_instance()->completionsubmit) {
1573         if ($assign->get_instance()->teamsubmission) {
1574             $submission = $assign->get_group_submission($userid, 0, false);
1575         } else {
1576             $submission = $assign->get_user_submission($userid, false);
1577         }
1578         return $submission && $submission->status == ASSIGN_SUBMISSION_STATUS_SUBMITTED;
1579     } else {
1580         // Completion option is not enabled so just return $type.
1581         return $type;
1582     }
1585 /**
1586  * Serves intro attachment files.
1587  *
1588  * @param mixed $course course or id of the course
1589  * @param mixed $cm course module or id of the course module
1590  * @param context $context
1591  * @param string $filearea
1592  * @param array $args
1593  * @param bool $forcedownload
1594  * @param array $options additional options affecting the file serving
1595  * @return bool false if file not found, does not return if found - just send the file
1596  */
1597 function assign_pluginfile($course,
1598                 $cm,
1599                 context $context,
1600                 $filearea,
1601                 $args,
1602                 $forcedownload,
1603                 array $options=array()) {
1604     global $CFG;
1606     if ($context->contextlevel != CONTEXT_MODULE) {
1607         return false;
1608     }
1610     require_login($course, false, $cm);
1611     if (!has_capability('mod/assign:view', $context)) {
1612         return false;
1613     }
1615     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1616     $assign = new assign($context, $cm, $course);
1618     if ($filearea !== ASSIGN_INTROATTACHMENT_FILEAREA) {
1619         return false;
1620     }
1621     if (!$assign->show_intro()) {
1622         return false;
1623     }
1625     $itemid = (int)array_shift($args);
1626     if ($itemid != 0) {
1627         return false;
1628     }
1630     $relativepath = implode('/', $args);
1632     $fullpath = "/{$context->id}/mod_assign/$filearea/$itemid/$relativepath";
1634     $fs = get_file_storage();
1635     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
1636         return false;
1637     }
1638     send_stored_file($file, 0, 0, $forcedownload, $options);
1641 /**
1642  * Serve the grading panel as a fragment.
1643  *
1644  * @param array $args List of named arguments for the fragment loader.
1645  * @return string
1646  */
1647 function mod_assign_output_fragment_gradingpanel($args) {
1648     global $CFG;
1650     $context = $args['context'];
1652     if ($context->contextlevel != CONTEXT_MODULE) {
1653         return null;
1654     }
1655     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1656     $assign = new assign($context, null, null);
1658     $userid = clean_param($args['userid'], PARAM_INT);
1659     $attemptnumber = clean_param($args['attemptnumber'], PARAM_INT);
1660     $formdata = array();
1661     if (!empty($args['jsonformdata'])) {
1662         $serialiseddata = json_decode($args['jsonformdata']);
1663         parse_str($serialiseddata, $formdata);
1664     }
1665     $viewargs = array(
1666         'userid' => $userid,
1667         'attemptnumber' => $attemptnumber,
1668         'formdata' => $formdata
1669     );
1671     return $assign->view('gradingpanel', $viewargs);
1674 /**
1675  * Check if the module has any update that affects the current user since a given time.
1676  *
1677  * @param  cm_info $cm course module data
1678  * @param  int $from the time to check updates from
1679  * @param  array $filter  if we need to check only specific updates
1680  * @return stdClass an object with the different type of areas indicating if they were updated or not
1681  * @since Moodle 3.2
1682  */
1683 function assign_check_updates_since(cm_info $cm, $from, $filter = array()) {
1684     global $DB, $USER, $CFG;
1685     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1687     $updates = new stdClass();
1688     $updates = course_check_module_updates_since($cm, $from, array(ASSIGN_INTROATTACHMENT_FILEAREA), $filter);
1690     // Check if there is a new submission by the user or new grades.
1691     $select = 'assignment = :id AND userid = :userid AND (timecreated > :since1 OR timemodified > :since2)';
1692     $params = array('id' => $cm->instance, 'userid' => $USER->id, 'since1' => $from, 'since2' => $from);
1693     $updates->submissions = (object) array('updated' => false);
1694     $submissions = $DB->get_records_select('assign_submission', $select, $params, '', 'id');
1695     if (!empty($submissions)) {
1696         $updates->submissions->updated = true;
1697         $updates->submissions->itemids = array_keys($submissions);
1698     }
1700     $updates->grades = (object) array('updated' => false);
1701     $grades = $DB->get_records_select('assign_grades', $select, $params, '', 'id');
1702     if (!empty($grades)) {
1703         $updates->grades->updated = true;
1704         $updates->grades->itemids = array_keys($grades);
1705     }
1707     return $updates;
1710 /**
1711  * Is the event visible?
1712  *
1713  * This is used to determine global visibility of an event in all places throughout Moodle. For example,
1714  * the ASSIGN_EVENT_TYPE_GRADINGDUE event will not be shown to students on their calendar, and
1715  * ASSIGN_EVENT_TYPE_DUE events will not be shown to teachers.
1716  *
1717  * @param calendar_event $event
1718  * @return bool Returns true if the event is visible to the current user, false otherwise.
1719  */
1720 function mod_assign_core_calendar_is_event_visible(calendar_event $event) {
1721     global $CFG, $USER;
1723     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1725     $cm = get_fast_modinfo($event->courseid)->instances['assign'][$event->instance];
1726     $context = context_module::instance($cm->id);
1728     $assign = new assign($context, $cm, null);
1730     if ($event->eventtype == ASSIGN_EVENT_TYPE_GRADINGDUE) {
1731         return $assign->can_grade();
1732     } else {
1733         return !$assign->can_grade() && $assign->can_view_submission($USER->id);
1734     }
1737 /**
1738  * Handles creating actions for events.
1739  *
1740  * @param calendar_event $event
1741  * @param \core_calendar\action_factory $factory
1742  * @return \core_calendar\local\event\value_objects\action|\core_calendar\local\interfaces\action_interface|null
1743  */
1744 function mod_assign_core_calendar_provide_event_action(calendar_event $event,
1745                                                        \core_calendar\action_factory $factory) {
1747     global $CFG, $USER;
1749     require_once($CFG->dirroot . '/mod/assign/locallib.php');
1751     $cm = get_fast_modinfo($event->courseid)->instances['assign'][$event->instance];
1752     $context = context_module::instance($cm->id);
1754     $assign = new assign($context, $cm, null);
1756     // Apply overrides.
1757     $assign->update_effective_access($USER->id);
1759     if ($event->eventtype == ASSIGN_EVENT_TYPE_GRADINGDUE) {
1760         $name = get_string('grade');
1761         $url = new \moodle_url('/mod/assign/view.php', [
1762             'id' => $cm->id,
1763             'action' => 'grader'
1764         ]);
1765         $itemcount = $assign->count_submissions_need_grading();
1766         $actionable = $assign->can_grade() && (time() >= $assign->get_instance()->allowsubmissionsfromdate);
1767     } else {
1768         $usersubmission = $assign->get_user_submission($USER->id, false);
1769         if ($usersubmission && $usersubmission->status === ASSIGN_SUBMISSION_STATUS_SUBMITTED) {
1770             // The user has already submitted.
1771             // We do not want to change the text to edit the submission, we want to remove the event from the Dashboard entirely.
1772             return null;
1773         }
1775         // The user has not yet submitted anything. Show the addsubmission link.
1776         $name = get_string('addsubmission', 'assign');
1777         $url = new \moodle_url('/mod/assign/view.php', [
1778             'id' => $cm->id,
1779             'action' => 'editsubmission'
1780         ]);
1781         $itemcount = 1;
1782         $actionable = $assign->is_any_submission_plugin_enabled() && $assign->can_edit_submission($USER->id);
1783     }
1785     return $factory->create_instance(
1786         $name,
1787         $url,
1788         $itemcount,
1789         $actionable
1790     );
1793 /**
1794  * Callback function that determines whether an action event should be showing its item count
1795  * based on the event type and the item count.
1796  *
1797  * @param calendar_event $event The calendar event.
1798  * @param int $itemcount The item count associated with the action event.
1799  * @return bool
1800  */
1801 function mod_assign_core_calendar_event_action_shows_item_count(calendar_event $event, $itemcount = 0) {
1802     // List of event types where the action event's item count should be shown.
1803     $eventtypesshowingitemcount = [
1804         ASSIGN_EVENT_TYPE_GRADINGDUE
1805     ];
1806     // For mod_assign, item count should be shown if the event type is 'gradingdue' and there is one or more item count.
1807     return in_array($event->eventtype, $eventtypesshowingitemcount) && $itemcount > 0;