lesson MDL-26571 made lesson accept a custom scale
[moodle.git] / mod / lesson / lib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * Standard library of functions and constants for lesson
20  *
21  * @package    mod
22  * @subpackage lesson
23  * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
24  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25  **/
27 defined('MOODLE_INTERNAL') || die();
29 /* Do not include any libraries here! */
31 /**
32  * Given an object containing all the necessary data,
33  * (defined by the form in mod_form.php) this function
34  * will create a new instance and return the id number
35  * of the new instance.
36  *
37  * @global object
38  * @global object
39  * @param object $lesson Lesson post data from the form
40  * @return int
41  **/
42 function lesson_add_instance($data, $mform) {
43     global $DB;
45     $cmid = $data->coursemodule;
47     lesson_process_pre_save($data);
49     unset($data->mediafile);
50     $lessonid = $DB->insert_record("lesson", $data);
51     $data->id = $lessonid;
53     $context = get_context_instance(CONTEXT_MODULE, $cmid);
54     $lesson = $DB->get_record('lesson', array('id'=>$lessonid), '*', MUST_EXIST);
56     if ($filename = $mform->get_new_filename('mediafilepicker')) {
57         if ($file = $mform->save_stored_file('mediafilepicker', $context->id, 'mod_lesson', 'mediafile', 0, '/', $filename)) {
58             $DB->set_field('lesson', 'mediafile', '/'.$file->get_filename(), array('id'=>$lesson->id));
59         }
60     }
62     lesson_process_post_save($data);
64     lesson_grade_item_update($data);
66     return $lesson->id;
67 }
69 /**
70  * Given an object containing all the necessary data,
71  * (defined by the form in mod_form.php) this function
72  * will update an existing instance with new data.
73  *
74  * @global object
75  * @param object $lesson Lesson post data from the form
76  * @return boolean
77  **/
78 function lesson_update_instance($data, $mform) {
79     global $DB;
81     $data->id = $data->instance;
82     $cmid = $data->coursemodule;
84     lesson_process_pre_save($data);
86     unset($data->mediafile);
87     $DB->update_record("lesson", $data);
89     $context = get_context_instance(CONTEXT_MODULE, $cmid);
90     if ($filename = $mform->get_new_filename('mediafilepicker')) {
91         if ($file = $mform->save_stored_file('mediafilepicker', $context->id, 'mod_lesson', 'mediafile', 0, '/', $filename, true)) {
92             $DB->set_field('lesson', 'mediafile', '/'.$file->get_filename(), array('id'=>$data->id));
93         } else {
94             $DB->set_field('lesson', 'mediafile', '', array('id'=>$data->id));
95         }
96     } else {
97         $DB->set_field('lesson', 'mediafile', '', array('id'=>$data->id));
98     }
100     lesson_process_post_save($data);
102     // update grade item definition
103     lesson_grade_item_update($data);
105     // update grades - TODO: do it only when grading style changes
106     lesson_update_grades($data, 0, false);
108     return true;
112 /**
113  * Given an ID of an instance of this module,
114  * this function will permanently delete the instance
115  * and any data that depends on it.
116  *
117  * @global object
118  * @param int $id
119  * @return bool
120  */
121 function lesson_delete_instance($id) {
122     global $DB, $CFG;
123     require_once($CFG->dirroot . '/mod/lesson/locallib.php');
125     $lesson = $DB->get_record("lesson", array("id"=>$id), '*', MUST_EXIST);
126     $lesson = new lesson($lesson);
127     return $lesson->delete();
130 /**
131  * Given a course object, this function will clean up anything that
132  * would be leftover after all the instances were deleted
133  *
134  * @global object
135  * @param object $course an object representing the course that is being deleted
136  * @param boolean $feedback to specify if the process must output a summary of its work
137  * @return boolean
138  */
139 function lesson_delete_course($course, $feedback=true) {
140     return true;
143 /**
144  * Return a small object with summary information about what a
145  * user has done with a given particular instance of this module
146  * Used for user activity reports.
147  * $return->time = the time they did it
148  * $return->info = a short text description
149  *
150  * @global object
151  * @param object $course
152  * @param object $user
153  * @param object $mod
154  * @param object $lesson
155  * @return object
156  */
157 function lesson_user_outline($course, $user, $mod, $lesson) {
158     global $CFG;
160     require_once("$CFG->libdir/gradelib.php");
161     $grades = grade_get_grades($course->id, 'mod', 'lesson', $lesson->id, $user->id);
163     $return = new stdClass();
164     if (empty($grades->items[0]->grades)) {
165         $return->info = get_string("no")." ".get_string("attempts", "lesson");
166     } else {
167         $grade = reset($grades->items[0]->grades);
168         $return->info = get_string("grade") . ': ' . $grade->str_long_grade;
169         $return->time = $grade->dategraded;
170         $return->info = get_string("no")." ".get_string("attempts", "lesson");
171     }
172     return $return;
175 /**
176  * Print a detailed representation of what a  user has done with
177  * a given particular instance of this module, for user activity reports.
178  *
179  * @global object
180  * @param object $course
181  * @param object $user
182  * @param object $mod
183  * @param object $lesson
184  * @return bool
185  */
186 function lesson_user_complete($course, $user, $mod, $lesson) {
187     global $DB, $OUTPUT, $CFG;
189     require_once("$CFG->libdir/gradelib.php");
191     $grades = grade_get_grades($course->id, 'mod', 'lesson', $lesson->id, $user->id);
192     if (!empty($grades->items[0]->grades)) {
193         $grade = reset($grades->items[0]->grades);
194         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
195         if ($grade->str_feedback) {
196             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
197         }
198     }
200     $params = array ("lessonid" => $lesson->id, "userid" => $user->id);
201     if ($attempts = $DB->get_records_select("lesson_attempts", "lessonid = :lessonid AND userid = :userid", $params,
202                 "retry, timeseen")) {
203         echo $OUTPUT->box_start();
204         $table = new html_table();
205         $table->head = array (get_string("attempt", "lesson"),  get_string("numberofpagesviewed", "lesson"),
206             get_string("numberofcorrectanswers", "lesson"), get_string("time"));
207         $table->width = "100%";
208         $table->align = array ("center", "center", "center", "center");
209         $table->size = array ("*", "*", "*", "*");
210         $table->cellpadding = 2;
211         $table->cellspacing = 0;
213         $retry = 0;
214         $npages = 0;
215         $ncorrect = 0;
217         foreach ($attempts as $attempt) {
218             if ($attempt->retry == $retry) {
219                 $npages++;
220                 if ($attempt->correct) {
221                     $ncorrect++;
222                 }
223                 $timeseen = $attempt->timeseen;
224             } else {
225                 $table->data[] = array($retry + 1, $npages, $ncorrect, userdate($timeseen));
226                 $retry++;
227                 $npages = 1;
228                 if ($attempt->correct) {
229                     $ncorrect = 1;
230                 } else {
231                     $ncorrect = 0;
232                 }
233             }
234         }
235         if ($npages) {
236                 $table->data[] = array($retry + 1, $npages, $ncorrect, userdate($timeseen));
237         }
238         echo html_writer::table($table);
239         echo $OUTPUT->box_end();
240     }
242     return true;
245 /**
246  * Prints lesson summaries on MyMoodle Page
247  *
248  * Prints lesson name, due date and attempt information on
249  * lessons that have a deadline that has not already passed
250  * and it is available for taking.
251  *
252  * @global object
253  * @global stdClass
254  * @global object
255  * @uses CONTEXT_MODULE
256  * @param array $courses An array of course objects to get lesson instances from
257  * @param array $htmlarray Store overview output array( course ID => 'lesson' => HTML output )
258  * @return void
259  */
260 function lesson_print_overview($courses, &$htmlarray) {
261     global $USER, $CFG, $DB, $OUTPUT;
263     if (!$lessons = get_all_instances_in_courses('lesson', $courses)) {
264         return;
265     }
267 /// Get Necessary Strings
268     $strlesson       = get_string('modulename', 'lesson');
269     $strnotattempted = get_string('nolessonattempts', 'lesson');
270     $strattempted    = get_string('lessonattempted', 'lesson');
272     $now = time();
273     foreach ($lessons as $lesson) {
274         if ($lesson->deadline != 0                                         // The lesson has a deadline
275             and $lesson->deadline >= $now                                  // And it is before the deadline has been met
276             and ($lesson->available == 0 or $lesson->available <= $now)) { // And the lesson is available
278             // Lesson name
279             if (!$lesson->visible) {
280                 $class = ' class="dimmed"';
281             } else {
282                 $class = '';
283             }
284             $str = $OUTPUT->box("$strlesson: <a$class href=\"$CFG->wwwroot/mod/lesson/view.php?id=$lesson->coursemodule\">".
285                              format_string($lesson->name).'</a>', 'name');
287             // Deadline
288             $str .= $OUTPUT->box(get_string('lessoncloseson', 'lesson', userdate($lesson->deadline)), 'info');
290             // Attempt information
291             if (has_capability('mod/lesson:manage', get_context_instance(CONTEXT_MODULE, $lesson->coursemodule))) {
292                 // Number of user attempts
293                 $attempts = $DB->count_records('lesson_attempts', array('lessonid'=>$lesson->id));
294                 $str     .= $OUTPUT->box(get_string('xattempts', 'lesson', $attempts), 'info');
295             } else {
296                 // Determine if the user has attempted the lesson or not
297                 if ($DB->count_records('lesson_attempts', array('lessonid'=>$lesson->id, 'userid'=>$USER->id))) {
298                     $str .= $OUTPUT->box($strattempted, 'info');
299                 } else {
300                     $str .= $OUTPUT->box($strnotattempted, 'info');
301                 }
302             }
303             $str = $OUTPUT->box($str, 'lesson overview');
305             if (empty($htmlarray[$lesson->course]['lesson'])) {
306                 $htmlarray[$lesson->course]['lesson'] = $str;
307             } else {
308                 $htmlarray[$lesson->course]['lesson'] .= $str;
309             }
310         }
311     }
314 /**
315  * Function to be run periodically according to the moodle cron
316  * This function searches for things that need to be done, such
317  * as sending out mail, toggling flags etc ...
318  * @global stdClass
319  * @return bool true
320  */
321 function lesson_cron () {
322     global $CFG;
324     return true;
327 /**
328  * Return grade for given user or all users.
329  *
330  * @global stdClass
331  * @global object
332  * @param int $lessonid id of lesson
333  * @param int $userid optional user id, 0 means all users
334  * @return array array of grades, false if none
335  */
336 function lesson_get_user_grades($lesson, $userid=0) {
337     global $CFG, $DB;
339     $params = array("lessonid" => $lesson->id,"lessonid2" => $lesson->id);
341     if (isset($userid)) {
342         $params["userid"] = $userid;
343         $params["userid2"] = $userid;
344         $user = "AND u.id = :userid";
345         $fuser = "AND uu.id = :userid2";
346     }
347     else {
348         $user="";
349         $fuser="";
350     }
352     if ($lesson->retake) {
353         if ($lesson->usemaxgrade) {
354             $sql = "SELECT u.id, u.id AS userid, MAX(g.grade) AS rawgrade
355                       FROM {user} u, {lesson_grades} g
356                      WHERE u.id = g.userid AND g.lessonid = :lessonid
357                            $user
358                   GROUP BY u.id";
359         } else {
360             $sql = "SELECT u.id, u.id AS userid, AVG(g.grade) AS rawgrade
361                       FROM {user} u, {lesson_grades} g
362                      WHERE u.id = g.userid AND g.lessonid = :lessonid
363                            $user
364                   GROUP BY u.id";
365         }
366         unset($params['lessonid2']);
367         unset($params['userid2']);
368     } else {
369         // use only first attempts (with lowest id in lesson_grades table)
370         $firstonly = "SELECT uu.id AS userid, MIN(gg.id) AS firstcompleted
371                         FROM {user} uu, {lesson_grades} gg
372                        WHERE uu.id = gg.userid AND gg.lessonid = :lessonid2
373                              $fuser
374                        GROUP BY uu.id";
376         $sql = "SELECT u.id, u.id AS userid, g.grade AS rawgrade
377                   FROM {user} u, {lesson_grades} g, ($firstonly) f
378                  WHERE u.id = g.userid AND g.lessonid = :lessonid
379                        AND g.id = f.firstcompleted AND g.userid=f.userid
380                        $user";
381     }
383     return $DB->get_records_sql($sql, $params);
386 /**
387  * Update grades in central gradebook
388  *
389  * @global stdclass
390  * @global object
391  * @param object $lesson
392  * @param int $userid specific user only, 0 means all
393  * @param bool $nullifnone
394  */
395 function lesson_update_grades($lesson, $userid=0, $nullifnone=true) {
396     global $CFG, $DB;
397     require_once($CFG->libdir.'/gradelib.php');
399     if ($lesson->grade == 0) {
400         lesson_grade_item_update($lesson);
402     } else if ($grades = lesson_get_user_grades($lesson, $userid)) {
403         lesson_grade_item_update($lesson, $grades);
405     } else if ($userid and $nullifnone) {
406         $grade = new stdClass();
407         $grade->userid   = $userid;
408         $grade->rawgrade = NULL;
409         lesson_grade_item_update($lesson, $grade);
411     } else {
412         lesson_grade_item_update($lesson);
413     }
416 /**
417  * Update all grades in gradebook.
418  *
419  * @global object
420  */
421 function lesson_upgrade_grades() {
422     global $DB;
424     $sql = "SELECT COUNT('x')
425               FROM {lesson} l, {course_modules} cm, {modules} m
426              WHERE m.name='lesson' AND m.id=cm.module AND cm.instance=l.id";
427     $count = $DB->count_records_sql($sql);
429     $sql = "SELECT l.*, cm.idnumber AS cmidnumber, l.course AS courseid
430               FROM {lesson} l, {course_modules} cm, {modules} m
431              WHERE m.name='lesson' AND m.id=cm.module AND cm.instance=l.id";
432     $rs = $DB->get_recordset_sql($sql);
433     if ($rs->valid()) {
434         $pbar = new progress_bar('lessonupgradegrades', 500, true);
435         $i=0;
436         foreach ($rs as $lesson) {
437             $i++;
438             upgrade_set_timeout(60*5); // set up timeout, may also abort execution
439             lesson_update_grades($lesson, 0, false);
440             $pbar->update($i, $count, "Updating Lesson grades ($i/$count).");
441         }
442     }
443     $rs->close();
446 /**
447  * Create grade item for given lesson
448  *
449  * @global stdClass
450  * @uses GRADE_TYPE_VALUE
451  * @uses GRADE_TYPE_NONE
452  * @param object $lesson object with extra cmidnumber
453  * @param array|object $grades optional array/object of grade(s); 'reset' means reset grades in gradebook
454  * @return int 0 if ok, error code otherwise
455  */
456 function lesson_grade_item_update($lesson, $grades=NULL) {
457     global $CFG;
458     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
459         require_once($CFG->libdir.'/gradelib.php');
460     }
462     if (array_key_exists('cmidnumber', $lesson)) { //it may not be always present
463         $params = array('itemname'=>$lesson->name, 'idnumber'=>$lesson->cmidnumber);
464     } else {
465         $params = array('itemname'=>$lesson->name);
466     }
468     if ($lesson->grade > 0) {
469         $params['gradetype']  = GRADE_TYPE_VALUE;
470         $params['grademax']   = $lesson->grade;
471         $params['grademin']   = 0;
472     } else if ($lesson->grade < 0) {
473         $params['gradetype']  = GRADE_TYPE_SCALE;
474         $params['scaleid']   = -$lesson->grade;
475     } else {
476         $params['gradetype']  = GRADE_TYPE_NONE;
477     }
479     if ($grades  === 'reset') {
480         $params['reset'] = true;
481         $grades = NULL;
482     } else if (!empty($grades)) {
483         // Need to calculate raw grade (Note: $grades has many forms)
484         if (is_object($grades)) {
485             $grades = array($grades->userid => $grades);
486         } else if (array_key_exists('userid', $grades)) {
487             $grades = array($grades['userid'] => $grades);
488         }
489         foreach ($grades as $key => $grade) {
490             if (!is_array($grade)) {
491                 $grades[$key] = $grade = (array) $grade;
492             }
493             $grades[$key]['rawgrade'] = ($grade['rawgrade'] * $lesson->grade / 100);
494         }
495     }
497     return grade_update('mod/lesson', $lesson->course, 'mod', 'lesson', $lesson->id, 0, $grades, $params);
500 /**
501  * Delete grade item for given lesson
502  *
503  * @global stdClass
504  * @param object $lesson object
505  * @return object lesson
506  */
507 function lesson_grade_item_delete($lesson) {
508     global $CFG;
513 /**
514  * Must return an array of user records (all data) who are participants
515  * for a given instance of lesson. Must include every user involved
516  * in the instance, independent of his role (student, teacher, admin...)
517  *
518  * @global stdClass
519  * @global object
520  * @param int $lessonid
521  * @return array
522  */
523 function lesson_get_participants($lessonid) {
524     global $CFG, $DB;
526     //Get students
527     $params = array ("lessonid" => $lessonid);
528     $students = $DB->get_records_sql("SELECT DISTINCT u.id, u.id
529                                  FROM {user} u,
530                                       {lesson_attempts} a
531                                  WHERE a.lessonid = :lessonid and
532                                        u.id = a.userid", $params);
534     //Return students array (it contains an array of unique users)
535     return ($students);
538 /**
539  * @return array
540  */
541 function lesson_get_view_actions() {
542     return array('view','view all');
545 /**
546  * @return array
547  */
548 function lesson_get_post_actions() {
549     return array('end','start');
552 /**
553  * Runs any processes that must run before
554  * a lesson insert/update
555  *
556  * @global object
557  * @param object $lesson Lesson form data
558  * @return void
559  **/
560 function lesson_process_pre_save(&$lesson) {
561     global $DB;
563     $lesson->timemodified = time();
565     if (empty($lesson->timed)) {
566         $lesson->timed = 0;
567     }
568     if (empty($lesson->timespent) or !is_numeric($lesson->timespent) or $lesson->timespent < 0) {
569         $lesson->timespent = 0;
570     }
571     if (!isset($lesson->completed)) {
572         $lesson->completed = 0;
573     }
574     if (empty($lesson->gradebetterthan) or !is_numeric($lesson->gradebetterthan) or $lesson->gradebetterthan < 0) {
575         $lesson->gradebetterthan = 0;
576     } else if ($lesson->gradebetterthan > 100) {
577         $lesson->gradebetterthan = 100;
578     }
580     if (empty($lesson->width)) {
581         $lesson->width = 640;
582     }
583     if (empty($lesson->height)) {
584         $lesson->height = 480;
585     }
586     if (empty($lesson->bgcolor)) {
587         $lesson->bgcolor = '#FFFFFF';
588     }
590     // Conditions for dependency
591     $conditions = new stdClass;
592     $conditions->timespent = $lesson->timespent;
593     $conditions->completed = $lesson->completed;
594     $conditions->gradebetterthan = $lesson->gradebetterthan;
595     $lesson->conditions = serialize($conditions);
596     unset($lesson->timespent);
597     unset($lesson->completed);
598     unset($lesson->gradebetterthan);
600     if (empty($lesson->password)) {
601         unset($lesson->password);
602     }
605 /**
606  * Runs any processes that must be run
607  * after a lesson insert/update
608  *
609  * @global object
610  * @param object $lesson Lesson form data
611  * @return void
612  **/
613 function lesson_process_post_save(&$lesson) {
614     global $DB, $CFG;
615     require_once($CFG->dirroot.'/calendar/lib.php');
616     require_once($CFG->dirroot . '/mod/lesson/locallib.php');
618     if ($events = $DB->get_records('event', array('modulename'=>'lesson', 'instance'=>$lesson->id))) {
619         foreach($events as $event) {
620             $event = calendar_event::load($event->id);
621             $event->delete();
622         }
623     }
625     $event = new stdClass;
626     $event->description = $lesson->name;
627     $event->courseid    = $lesson->course;
628     $event->groupid     = 0;
629     $event->userid      = 0;
630     $event->modulename  = 'lesson';
631     $event->instance    = $lesson->id;
632     $event->eventtype   = 'open';
633     $event->timestart   = $lesson->available;
635     $event->visible     = instance_is_visible('lesson', $lesson);
637     $event->timeduration = ($lesson->deadline - $lesson->available);
639     if ($lesson->deadline and $lesson->available and $event->timeduration <= LESSON_MAX_EVENT_LENGTH) {
640         // Single event for the whole lesson.
641         $event->name = $lesson->name;
642         calendar_event::create(clone($event));
643     } else {
644         // Separate start and end events.
645         $event->timeduration  = 0;
646         if ($lesson->available) {
647             $event->name = $lesson->name.' ('.get_string('lessonopens', 'lesson').')';
648             calendar_event::create(clone($event));
649         } else if ($lesson->deadline) {
650             $event->name      = $lesson->name.' ('.get_string('lessoncloses', 'lesson').')';
651             $event->timestart = $lesson->deadline;
652             $event->eventtype = 'close';
653             calendar_event::create(clone($event));
654         }
655     }
659 /**
660  * Implementation of the function for printing the form elements that control
661  * whether the course reset functionality affects the lesson.
662  *
663  * @param $mform form passed by reference
664  */
665 function lesson_reset_course_form_definition(&$mform) {
666     $mform->addElement('header', 'lessonheader', get_string('modulenameplural', 'lesson'));
667     $mform->addElement('advcheckbox', 'reset_lesson', get_string('deleteallattempts','lesson'));
670 /**
671  * Course reset form defaults.
672  * @param object $course
673  * @return array
674  */
675 function lesson_reset_course_form_defaults($course) {
676     return array('reset_lesson'=>1);
679 /**
680  * Removes all grades from gradebook
681  *
682  * @global stdClass
683  * @global object
684  * @param int $courseid
685  * @param string optional type
686  */
687 function lesson_reset_gradebook($courseid, $type='') {
688     global $CFG, $DB;
690     $sql = "SELECT l.*, cm.idnumber as cmidnumber, l.course as courseid
691               FROM {lesson} l, {course_modules} cm, {modules} m
692              WHERE m.name='lesson' AND m.id=cm.module AND cm.instance=l.id AND l.course=:course";
693     $params = array ("course" => $courseid);
694     if ($lessons = $DB->get_records_sql($sql,$params)) {
695         foreach ($lessons as $lesson) {
696             lesson_grade_item_update($lesson, 'reset');
697         }
698     }
701 /**
702  * Actual implementation of the reset course functionality, delete all the
703  * lesson attempts for course $data->courseid.
704  *
705  * @global stdClass
706  * @global object
707  * @param object $data the data submitted from the reset course.
708  * @return array status array
709  */
710 function lesson_reset_userdata($data) {
711     global $CFG, $DB;
713     $componentstr = get_string('modulenameplural', 'lesson');
714     $status = array();
716     if (!empty($data->reset_lesson)) {
717         $lessonssql = "SELECT l.id
718                          FROM {lesson} l
719                         WHERE l.course=:course";
721         $params = array ("course" => $data->courseid);
722         $DB->delete_records_select('lesson_timer', "lessonid IN ($lessonssql)", $params);
723         $DB->delete_records_select('lesson_high_scores', "lessonid IN ($lessonssql)", $params);
724         $DB->delete_records_select('lesson_grades', "lessonid IN ($lessonssql)", $params);
725         $DB->delete_records_select('lesson_attempts', "lessonid IN ($lessonssql)", $params);
727         // remove all grades from gradebook
728         if (empty($data->reset_gradebook_grades)) {
729             lesson_reset_gradebook($data->courseid);
730         }
732         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallattempts', 'lesson'), 'error'=>false);
733     }
735     /// updating dates - shift may be negative too
736     if ($data->timeshift) {
737         shift_course_mod_dates('lesson', array('available', 'deadline'), $data->timeshift, $data->courseid);
738         $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
739     }
741     return $status;
744 /**
745  * Returns all other caps used in module
746  * @return array
747  */
748 function lesson_get_extra_capabilities() {
749     return array('moodle/site:accessallgroups');
752 /**
753  * @uses FEATURE_GROUPS
754  * @uses FEATURE_GROUPINGS
755  * @uses FEATURE_GROUPMEMBERSONLY
756  * @uses FEATURE_MOD_INTRO
757  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
758  * @uses FEATURE_GRADE_HAS_GRADE
759  * @uses FEATURE_GRADE_OUTCOMES
760  * @param string $feature FEATURE_xx constant for requested feature
761  * @return mixed True if module supports feature, false if not, null if doesn't know
762  */
763 function lesson_supports($feature) {
764     switch($feature) {
765         case FEATURE_GROUPS:                  return false;
766         case FEATURE_GROUPINGS:               return false;
767         case FEATURE_GROUPMEMBERSONLY:        return true;
768         case FEATURE_MOD_INTRO:               return false;
769         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
770         case FEATURE_GRADE_HAS_GRADE:         return true;
771         case FEATURE_GRADE_OUTCOMES:          return true;
772         case FEATURE_BACKUP_MOODLE2:          return true;
773         default: return null;
774     }
777 /**
778  * This function extends the global navigation for the site.
779  * It is important to note that you should not rely on PAGE objects within this
780  * body of code as there is no guarantee that during an AJAX request they are
781  * available
782  *
783  * @param navigation_node $navigation The lesson node within the global navigation
784  * @param stdClass $course The course object returned from the DB
785  * @param stdClass $module The module object returned from the DB
786  * @param stdClass $cm The course module instance returned from the DB
787  */
788 function lesson_extend_navigation($navigation, $course, $module, $cm) {
789     /**
790      * This is currently just a stub so  that it can be easily expanded upon.
791      * When expanding just remove this comment and the line below and then add
792      * you content.
793      */
794     $navigation->nodetype = navigation_node::NODETYPE_LEAF;
797 /**
798  * This function extends the settings navigation block for the site.
799  *
800  * It is safe to rely on PAGE here as we will only ever be within the module
801  * context when this is called
802  *
803  * @param settings_navigation $settings
804  * @param navigation_node $lessonnode
805  */
806 function lesson_extend_settings_navigation($settings, $lessonnode) {
807     global $PAGE, $DB;
809     $canedit = has_capability('mod/lesson:edit', $PAGE->cm->context);
811     $url = new moodle_url('/mod/lesson/view.php', array('id'=>$PAGE->cm->id));
812     $lessonnode->add(get_string('preview', 'lesson'), $url);
814     if ($canedit) {
815         $url = new moodle_url('/mod/lesson/edit.php', array('id'=>$PAGE->cm->id));
816         $lessonnode->add(get_string('edit', 'lesson'), $url);
817     }
819     if (has_capability('mod/lesson:manage', $PAGE->cm->context)) {
820         $reportsnode = $lessonnode->add(get_string('reports', 'lesson'));
821         $url = new moodle_url('/mod/lesson/report.php', array('id'=>$PAGE->cm->id, 'action'=>'reportoverview'));
822         $reportsnode->add(get_string('overview', 'lesson'), $url);
823         $url = new moodle_url('/mod/lesson/report.php', array('id'=>$PAGE->cm->id, 'action'=>'reportdetail'));
824         $reportsnode->add(get_string('detailedstats', 'lesson'), $url);
825     }
827     if ($canedit) {
828         $url = new moodle_url('/mod/lesson/essay.php', array('id'=>$PAGE->cm->id));
829         $lessonnode->add(get_string('manualgrading', 'lesson'), $url);
830     }
832     if ($PAGE->activityrecord->highscores) {
833         $url = new moodle_url('/mod/lesson/highscores.php', array('id'=>$PAGE->cm->id));
834         $lessonnode->add(get_string('highscores', 'lesson'), $url);
835     }
838 /**
839  * Get list of available import or export formats
840  *
841  * Copied and modified from lib/questionlib.php
842  *
843  * @param string $type 'import' if import list, otherwise export list assumed
844  * @return array sorted list of import/export formats available
845  */
846 function lesson_get_import_export_formats($type) {
847     global $CFG;
848     $fileformats = get_plugin_list("qformat");
850     $fileformatname=array();
851     foreach ($fileformats as $fileformat=>$fdir) {
852         $format_file = "$fdir/format.php";
853         if (file_exists($format_file) ) {
854             require_once($format_file);
855         } else {
856             continue;
857         }
858         $classname = "qformat_$fileformat";
859         $format_class = new $classname();
860         if ($type=='import') {
861             $provided = $format_class->provide_import();
862         } else {
863             $provided = $format_class->provide_export();
864         }
865         if ($provided) {
866             //TODO: do NOT rely on [[]] any more!!
867             $formatname = get_string($fileformat, 'quiz');
868             if ($formatname == "[[$fileformat]]") {
869                 $formatname = get_string($fileformat, 'qformat_'.$fileformat);
870                 if ($formatname == "[[$fileformat]]") {
871                     $formatname = $fileformat;  // Just use the raw folder name
872                 }
873             }
874             $fileformatnames[$fileformat] = $formatname;
875         }
876     }
877     natcasesort($fileformatnames);
879     return $fileformatnames;
882 /**
883  * Serves the lesson attachments. Implements needed access control ;-)
884  *
885  * @param object $course
886  * @param object $cm
887  * @param object $context
888  * @param string $filearea
889  * @param array $args
890  * @param bool $forcedownload
891  * @return bool false if file not found, does not return if found - justsend the file
892  */
893 function lesson_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload) {
894     global $CFG, $DB;
896     if ($context->contextlevel != CONTEXT_MODULE) {
897         return false;
898     }
900     $fileareas = lesson_get_file_areas();
901     if (!array_key_exists($filearea, $fileareas)) {
902         return false;
903     }
905     if (!$lesson = $DB->get_record('lesson', array('id'=>$cm->instance))) {
906         return false;
907     }
909     require_course_login($course, true, $cm);
911     if ($filearea === 'page_contents') {
912         $pageid = (int)array_shift($args);
913         if (!$page = $DB->get_record('lesson_pages', array('id'=>$pageid))) {
914             return false;
915         }
916         $fullpath = "/$context->id/mod_lesson/$filearea/$pageid/".implode('/', $args);
918     } else if ($filearea === 'mediafile') {
919         array_shift($args); // ignore itemid - caching only
920         $fullpath = "/$context->id/mod_lesson/$filearea/0/".implode('/', $args);
922     } else {
923         return false;
924     }
926     $fs = get_file_storage();
927     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
928         return false;
929     }
931     // finally send the file
932     send_stored_file($file, 0, 0, $forcedownload); // download MUST be forced - security!
935 /**
936  * Returns an array of file areas
937  * @return array
938  */
939 function lesson_get_file_areas() {
940     $areas = array();
941     $areas['page_contents'] = 'Page contents'; //TODO: localize!!!!
942     $areas['mediafile'] = 'Media file'; //TODO: localize!!!!
944     return $areas;
947 /**
948  * Returns a file_info_stored object for the file being requested here
949  *
950  * @global <type> $CFG
951  * @param file_browse $browser
952  * @param array $areas
953  * @param object $course
954  * @param object $cm
955  * @param object $context
956  * @param string $filearea
957  * @param int $itemid
958  * @param string $filepath
959  * @param string $filename
960  * @return file_info_stored
961  */
962 function lesson_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
963     global $CFG;
964     if (has_capability('moodle/course:managefiles', $context)) {
965         // no peaking here for students!!
966         return null;
967     }
969     $fs = get_file_storage();
970     $filepath = is_null($filepath) ? '/' : $filepath;
971     $filename = is_null($filename) ? '.' : $filename;
972     $urlbase = $CFG->wwwroot.'/pluginfile.php';
973     if (!$storedfile = $fs->get_file($context->id, 'mod_lesson', $filearea, $itemid, $filepath, $filename)) {
974         return null;
975     }
976     return new file_info_stored($browser, $context, $storedfile, $urlbase, $filearea, $itemid, true, true, false);