c4540e081eaf2546b8d45b208686dae5d1b0cdcb
[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 $DB;
160     global $CFG;
161     require_once("$CFG->libdir/gradelib.php");
162     $grades = grade_get_grades($course->id, 'mod', 'lesson', $lesson->id, $user->id);
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 object();
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     if ($rs = $DB->get_recordset_sql($sql)) {
433         $pbar = new progress_bar('lessonupgradegrades', 500, true);
434         $i=0;
435         foreach ($rs as $lesson) {
436             $i++;
437             upgrade_set_timeout(60*5); // set up timeout, may also abort execution
438             lesson_update_grades($lesson, 0, false);
439             $pbar->update($i, $count, "Updating Lesson grades ($i/$count).");
440         }
441         $rs->close();
442     }
445 /**
446  * Create grade item for given lesson
447  *
448  * @global stdClass
449  * @uses GRADE_TYPE_VALUE
450  * @uses GRADE_TYPE_NONE
451  * @param object $lesson object with extra cmidnumber
452  * @param array|object $grades optional array/object of grade(s); 'reset' means reset grades in gradebook
453  * @return int 0 if ok, error code otherwise
454  */
455 function lesson_grade_item_update($lesson, $grades=NULL) {
456     global $CFG;
457     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
458         require_once($CFG->libdir.'/gradelib.php');
459     }
461     if (array_key_exists('cmidnumber', $lesson)) { //it may not be always present
462         $params = array('itemname'=>$lesson->name, 'idnumber'=>$lesson->cmidnumber);
463     } else {
464         $params = array('itemname'=>$lesson->name);
465     }
467     if ($lesson->grade > 0) {
468         $params['gradetype']  = GRADE_TYPE_VALUE;
469         $params['grademax']   = $lesson->grade;
470         $params['grademin']   = 0;
471     } else {
472         $params['gradetype']  = GRADE_TYPE_NONE;
473     }
475     if ($grades  === 'reset') {
476         $params['reset'] = true;
477         $grades = NULL;
478     } else if (!empty($grades)) {
479         // Need to calculate raw grade (Note: $grades has many forms)
480         if (is_object($grades)) {
481             $grades = array($grades->userid => $grades);
482         } else if (array_key_exists('userid', $grades)) {
483             $grades = array($grades['userid'] => $grades);
484         }
485         foreach ($grades as $key => $grade) {
486             if (!is_array($grade)) {
487                 $grades[$key] = $grade = (array) $grade;
488             }
489             $grades[$key]['rawgrade'] = ($grade['rawgrade'] * $lesson->grade / 100);
490         }
491     }
493     return grade_update('mod/lesson', $lesson->course, 'mod', 'lesson', $lesson->id, 0, $grades, $params);
496 /**
497  * Delete grade item for given lesson
498  *
499  * @global stdClass
500  * @param object $lesson object
501  * @return object lesson
502  */
503 function lesson_grade_item_delete($lesson) {
504     global $CFG;
509 /**
510  * Must return an array of user records (all data) who are participants
511  * for a given instance of lesson. Must include every user involved
512  * in the instance, independent of his role (student, teacher, admin...)
513  *
514  * @global stdClass
515  * @global object
516  * @param int $lessonid
517  * @return array
518  */
519 function lesson_get_participants($lessonid) {
520     global $CFG, $DB;
522     //Get students
523     $params = array ("lessonid" => $lessonid);
524     $students = $DB->get_records_sql("SELECT DISTINCT u.id, u.id
525                                  FROM {user} u,
526                                       {lesson_attempts} a
527                                  WHERE a.lessonid = :lessonid and
528                                        u.id = a.userid", $params);
530     //Return students array (it contains an array of unique users)
531     return ($students);
534 /**
535  * @return array
536  */
537 function lesson_get_view_actions() {
538     return array('view','view all');
541 /**
542  * @return array
543  */
544 function lesson_get_post_actions() {
545     return array('end','start');
548 /**
549  * Runs any processes that must run before
550  * a lesson insert/update
551  *
552  * @global object
553  * @param object $lesson Lesson form data
554  * @return void
555  **/
556 function lesson_process_pre_save(&$lesson) {
557     global $DB;
559     $lesson->timemodified = time();
561     if (empty($lesson->timed)) {
562         $lesson->timed = 0;
563     }
564     if (empty($lesson->timespent) or !is_numeric($lesson->timespent) or $lesson->timespent < 0) {
565         $lesson->timespent = 0;
566     }
567     if (!isset($lesson->completed)) {
568         $lesson->completed = 0;
569     }
570     if (empty($lesson->gradebetterthan) or !is_numeric($lesson->gradebetterthan) or $lesson->gradebetterthan < 0) {
571         $lesson->gradebetterthan = 0;
572     } else if ($lesson->gradebetterthan > 100) {
573         $lesson->gradebetterthan = 100;
574     }
576     if (empty($lesson->width)) {
577         $lesson->width = 640;
578     }
579     if (empty($lesson->height)) {
580         $lesson->height = 480;
581     }
582     if (empty($lesson->bgcolor)) {
583         $lesson->bgcolor = '#FFFFFF';
584     }
586     // Conditions for dependency
587     $conditions = new stdClass;
588     $conditions->timespent = $lesson->timespent;
589     $conditions->completed = $lesson->completed;
590     $conditions->gradebetterthan = $lesson->gradebetterthan;
591     $lesson->conditions = serialize($conditions);
592     unset($lesson->timespent);
593     unset($lesson->completed);
594     unset($lesson->gradebetterthan);
596     if (empty($lesson->password)) {
597         unset($lesson->password);
598     }
601 /**
602  * Runs any processes that must be run
603  * after a lesson insert/update
604  *
605  * @global object
606  * @param object $lesson Lesson form data
607  * @return void
608  **/
609 function lesson_process_post_save(&$lesson) {
610     global $DB, $CFG;
611     require_once($CFG->dirroot.'/calendar/lib.php');
612     require_once($CFG->dirroot . '/mod/lesson/locallib.php');
614     if ($events = $DB->get_records('event', array('modulename'=>'lesson', 'instance'=>$lesson->id))) {
615         foreach($events as $event) {
616             $event = calendar_event::load($event->id);
617             $event->delete();
618         }
619     }
621     $event = new stdClass;
622     $event->description = $lesson->name;
623     $event->courseid    = $lesson->course;
624     $event->groupid     = 0;
625     $event->userid      = 0;
626     $event->modulename  = 'lesson';
627     $event->instance    = $lesson->id;
628     $event->eventtype   = 'open';
629     $event->timestart   = $lesson->available;
631     $event->visible     = instance_is_visible('lesson', $lesson);
633     $event->timeduration = ($lesson->deadline - $lesson->available);
635     if ($lesson->deadline and $lesson->available and $event->timeduration <= LESSON_MAX_EVENT_LENGTH) {
636         // Single event for the whole lesson.
637         $event->name = $lesson->name;
638         calendar_event::create(clone($event));
639     } else {
640         // Separate start and end events.
641         $event->timeduration  = 0;
642         if ($lesson->available) {
643             $event->name = $lesson->name.' ('.get_string('lessonopens', 'lesson').')';
644             calendar_event::create(clone($event));
645         } else if ($lesson->deadline) {
646             $event->name      = $lesson->name.' ('.get_string('lessoncloses', 'lesson').')';
647             $event->timestart = $lesson->deadline;
648             $event->eventtype = 'close';
649             calendar_event::create(clone($event));
650         }
651     }
655 /**
656  * Implementation of the function for printing the form elements that control
657  * whether the course reset functionality affects the lesson.
658  *
659  * @param $mform form passed by reference
660  */
661 function lesson_reset_course_form_definition(&$mform) {
662     $mform->addElement('header', 'lessonheader', get_string('modulenameplural', 'lesson'));
663     $mform->addElement('advcheckbox', 'reset_lesson', get_string('deleteallattempts','lesson'));
666 /**
667  * Course reset form defaults.
668  * @param object $course
669  * @return array
670  */
671 function lesson_reset_course_form_defaults($course) {
672     return array('reset_lesson'=>1);
675 /**
676  * Removes all grades from gradebook
677  *
678  * @global stdClass
679  * @global object
680  * @param int $courseid
681  * @param string optional type
682  */
683 function lesson_reset_gradebook($courseid, $type='') {
684     global $CFG, $DB;
686     $sql = "SELECT l.*, cm.idnumber as cmidnumber, l.course as courseid
687               FROM {lesson} l, {course_modules} cm, {modules} m
688              WHERE m.name='lesson' AND m.id=cm.module AND cm.instance=l.id AND l.course=:course";
689     $params = array ("course" => $courseid);
690     if ($lessons = $DB->get_records_sql($sql,$params)) {
691         foreach ($lessons as $lesson) {
692             lesson_grade_item_update($lesson, 'reset');
693         }
694     }
697 /**
698  * Actual implementation of the reset course functionality, delete all the
699  * lesson attempts for course $data->courseid.
700  *
701  * @global stdClass
702  * @global object
703  * @param object $data the data submitted from the reset course.
704  * @return array status array
705  */
706 function lesson_reset_userdata($data) {
707     global $CFG, $DB;
709     $componentstr = get_string('modulenameplural', 'lesson');
710     $status = array();
712     if (!empty($data->reset_lesson)) {
713         $lessonssql = "SELECT l.id
714                          FROM {lesson} l
715                         WHERE l.course=:course";
717         $params = array ("course" => $data->courseid);
718         $DB->delete_records_select('lesson_timer', "lessonid IN ($lessonssql)", $params);
719         $DB->delete_records_select('lesson_high_scores', "lessonid IN ($lessonssql)", $params);
720         $DB->delete_records_select('lesson_grades', "lessonid IN ($lessonssql)", $params);
721         $DB->delete_records_select('lesson_attempts', "lessonid IN ($lessonssql)", $params);
723         // remove all grades from gradebook
724         if (empty($data->reset_gradebook_grades)) {
725             lesson_reset_gradebook($data->courseid);
726         }
728         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallattempts', 'lesson'), 'error'=>false);
729     }
731     /// updating dates - shift may be negative too
732     if ($data->timeshift) {
733         shift_course_mod_dates('lesson', array('available', 'deadline'), $data->timeshift, $data->courseid);
734         $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
735     }
737     return $status;
740 /**
741  * Returns all other caps used in module
742  * @return array
743  */
744 function lesson_get_extra_capabilities() {
745     return array('moodle/site:accessallgroups');
748 /**
749  * @uses FEATURE_GROUPS
750  * @uses FEATURE_GROUPINGS
751  * @uses FEATURE_GROUPMEMBERSONLY
752  * @uses FEATURE_MOD_INTRO
753  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
754  * @uses FEATURE_GRADE_HAS_GRADE
755  * @uses FEATURE_GRADE_OUTCOMES
756  * @param string $feature FEATURE_xx constant for requested feature
757  * @return mixed True if module supports feature, false if not, null if doesn't know
758  */
759 function lesson_supports($feature) {
760     switch($feature) {
761         case FEATURE_GROUPS:                  return false;
762         case FEATURE_GROUPINGS:               return false;
763         case FEATURE_GROUPMEMBERSONLY:        return true;
764         case FEATURE_MOD_INTRO:               return false;
765         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
766         case FEATURE_GRADE_HAS_GRADE:         return true;
767         case FEATURE_GRADE_OUTCOMES:          return true;
768         case FEATURE_BACKUP_MOODLE2:          return true;
769         default: return null;
770     }
773 /**
774  * This function extends the global navigation for the site.
775  * It is important to note that you should not rely on PAGE objects within this
776  * body of code as there is no guarantee that during an AJAX request they are
777  * available
778  *
779  * @param navigation_node $navigation The lesson node within the global navigation
780  * @param stdClass $course The course object returned from the DB
781  * @param stdClass $module The module object returned from the DB
782  * @param stdClass $cm The course module instance returned from the DB
783  */
784 function lesson_extend_navigation($navigation, $course, $module, $cm) {
785     /**
786      * This is currently just a stub so  that it can be easily expanded upon.
787      * When expanding just remove this comment and the line below and then add
788      * you content.
789      */
790     $navigation->nodetype = navigation_node::NODETYPE_LEAF;
793 /**
794  * This function extends the settings navigation block for the site.
795  *
796  * It is safe to rely on PAGE here as we will only ever be within the module
797  * context when this is called
798  *
799  * @param settings_navigation $settings
800  * @param navigation_node $lessonnode
801  */
802 function lesson_extend_settings_navigation($settings, $lessonnode) {
803     global $PAGE, $DB;
805     $canedit = has_capability('mod/lesson:edit', $PAGE->cm->context);
807     $url = new moodle_url('/mod/lesson/view.php', array('id'=>$PAGE->cm->id));
808     $lessonnode->add(get_string('preview', 'lesson'), $url);
810     if ($canedit) {
811         $url = new moodle_url('/mod/lesson/edit.php', array('id'=>$PAGE->cm->id));
812         $lessonnode->add(get_string('edit', 'lesson'), $url);
813     }
815     if (has_capability('mod/lesson:manage', $PAGE->cm->context)) {
816         $reportsnode = $lessonnode->add(get_string('reports', 'lesson'));
817         $url = new moodle_url('/mod/lesson/report.php', array('id'=>$PAGE->cm->id, 'action'=>'reportoverview'));
818         $reportsnode->add(get_string('overview', 'lesson'), $url);
819         $url = new moodle_url('/mod/lesson/report.php', array('id'=>$PAGE->cm->id, 'action'=>'reportdetail'));
820         $reportsnode->add(get_string('detailedstats', 'lesson'), $url);
821     }
823     if ($canedit) {
824         $url = new moodle_url('/mod/lesson/essay.php', array('id'=>$PAGE->cm->id));
825         $lessonnode->add(get_string('manualgrading', 'lesson'), $url);
826     }
828     if ($PAGE->activityrecord->highscores) {
829         $url = new moodle_url('/mod/lesson/highscores.php', array('id'=>$PAGE->cm->id));
830         $lessonnode->add(get_string('highscores', 'lesson'), $url);
831     }
834 /**
835  * Get list of available import or export formats
836  *
837  * Copied and modified from lib/questionlib.php
838  *
839  * @param string $type 'import' if import list, otherwise export list assumed
840  * @return array sorted list of import/export formats available
841  */
842 function lesson_get_import_export_formats($type) {
843     global $CFG;
844     $fileformats = get_plugin_list("qformat");
846     $fileformatname=array();
847     foreach ($fileformats as $fileformat=>$fdir) {
848         $format_file = "$fdir/format.php";
849         if (file_exists($format_file) ) {
850             require_once($format_file);
851         } else {
852             continue;
853         }
854         $classname = "qformat_$fileformat";
855         $format_class = new $classname();
856         if ($type=='import') {
857             $provided = $format_class->provide_import();
858         } else {
859             $provided = $format_class->provide_export();
860         }
861         if ($provided) {
862             //TODO: do NOT rely on [[]] any more!!
863             $formatname = get_string($fileformat, 'quiz');
864             if ($formatname == "[[$fileformat]]") {
865                 $formatname = get_string($fileformat, 'qformat_'.$fileformat);
866                 if ($formatname == "[[$fileformat]]") {
867                     $formatname = $fileformat;  // Just use the raw folder name
868                 }
869             }
870             $fileformatnames[$fileformat] = $formatname;
871         }
872     }
873     natcasesort($fileformatnames);
875     return $fileformatnames;
878 /**
879  * Serves the lesson attachments. Implements needed access control ;-)
880  *
881  * @param object $course
882  * @param object $cm
883  * @param object $context
884  * @param string $filearea
885  * @param array $args
886  * @param bool $forcedownload
887  * @return bool false if file not found, does not return if found - justsend the file
888  */
889 function lesson_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload) {
890     global $CFG, $DB;
892     if ($context->contextlevel != CONTEXT_MODULE) {
893         return false;
894     }
896     $fileareas = lesson_get_file_areas();
897     if (!array_key_exists($filearea, $fileareas)) {
898         return false;
899     }
901     if (!$lesson = $DB->get_record('lesson', array('id'=>$cm->instance))) {
902         return false;
903     }
905     require_course_login($course, true, $cm);
907     if ($filearea === 'page_contents') {
908         $pageid = (int)array_shift($args);
909         if (!$page = $DB->get_record('lesson_pages', array('id'=>$pageid))) {
910             return false;
911         }
912         $fullpath = "/$context->id/mod_lesson/$filearea/$pageid/".implode('/', $args);
914     } else if ($filearea === 'mediafile') {
915         array_shift($args); // ignore itemid - caching only
916         $fullpath = "/$context->id/mod_lesson/$filearea/0/".implode('/', $args);
918     } else {
919         return false;
920     }
922     $fs = get_file_storage();
923     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
924         return false;
925     }
927     // finally send the file
928     send_stored_file($file, 0, 0, $forcedownload); // download MUST be forced - security!
931 /**
932  * Returns an array of file areas
933  * @return array
934  */
935 function lesson_get_file_areas() {
936     $areas = array();
937     $areas['page_contents'] = 'Page contents'; //TODO: localize!!!!
938     $areas['mediafile'] = 'Media file'; //TODO: localize!!!!
940     return $areas;
943 /**
944  * Returns a file_info_stored object for the file being requested here
945  *
946  * @global <type> $CFG
947  * @param file_browse $browser
948  * @param array $areas
949  * @param object $course
950  * @param object $cm
951  * @param object $context
952  * @param string $filearea
953  * @param int $itemid
954  * @param string $filepath
955  * @param string $filename
956  * @return file_info_stored
957  */
958 function lesson_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
959     global $CFG;
960     if (has_capability('moodle/course:managefiles', $context)) {
961         // no peaking here for students!!
962         return null;
963     }
965     $fs = get_file_storage();
966     $filepath = is_null($filepath) ? '/' : $filepath;
967     $filename = is_null($filename) ? '.' : $filename;
968     $urlbase = $CFG->wwwroot.'/pluginfile.php';
969     if (!$storedfile = $fs->get_file($context->id, 'mod_lesson', $filearea, $itemid, $filepath, $filename)) {
970         return null;
971     }
972     return new file_info_stored($browser, $context, $storedfile, $urlbase, $filearea, $itemid, true, true, false);