Merge branch 'scorm-task' of https://github.com/GanitGenius/moodle
[moodle.git] / mod / scorm / 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  * @package   mod_scorm
19  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
20  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
21  */
23 /** SCORM_TYPE_LOCAL = local */
24 define('SCORM_TYPE_LOCAL', 'local');
25 /** SCORM_TYPE_LOCALSYNC = localsync */
26 define('SCORM_TYPE_LOCALSYNC', 'localsync');
27 /** SCORM_TYPE_EXTERNAL = external */
28 define('SCORM_TYPE_EXTERNAL', 'external');
29 /** SCORM_TYPE_AICCURL = external AICC url */
30 define('SCORM_TYPE_AICCURL', 'aiccurl');
32 define('SCORM_TOC_SIDE', 0);
33 define('SCORM_TOC_HIDDEN', 1);
34 define('SCORM_TOC_POPUP', 2);
35 define('SCORM_TOC_DISABLED', 3);
37 // Used to show/hide navigation buttons and set their position.
38 define('SCORM_NAV_DISABLED', 0);
39 define('SCORM_NAV_UNDER_CONTENT', 1);
40 define('SCORM_NAV_FLOATING', 2);
42 // Used to check what SCORM version is being used.
43 define('SCORM_12', 1);
44 define('SCORM_13', 2);
45 define('SCORM_AICC', 3);
47 // List of possible attemptstatusdisplay options.
48 define('SCORM_DISPLAY_ATTEMPTSTATUS_NO', 0);
49 define('SCORM_DISPLAY_ATTEMPTSTATUS_ALL', 1);
50 define('SCORM_DISPLAY_ATTEMPTSTATUS_MY', 2);
51 define('SCORM_DISPLAY_ATTEMPTSTATUS_ENTRY', 3);
53 /**
54  * Return an array of status options
55  *
56  * Optionally with translated strings
57  *
58  * @param   bool    $with_strings   (optional)
59  * @return  array
60  */
61 function scorm_status_options($withstrings = false) {
62     // Id's are important as they are bits.
63     $options = array(
64         2 => 'passed',
65         4 => 'completed'
66     );
68     if ($withstrings) {
69         foreach ($options as $key => $value) {
70             $options[$key] = get_string('completionstatus_'.$value, 'scorm');
71         }
72     }
74     return $options;
75 }
78 /**
79  * Given an object containing all the necessary data,
80  * (defined by the form in mod_form.php) this function
81  * will create a new instance and return the id number
82  * of the new instance.
83  *
84  * @global stdClass
85  * @global object
86  * @uses CONTEXT_MODULE
87  * @uses SCORM_TYPE_LOCAL
88  * @uses SCORM_TYPE_LOCALSYNC
89  * @uses SCORM_TYPE_EXTERNAL
90  * @param object $scorm Form data
91  * @param object $mform
92  * @return int new instance id
93  */
94 function scorm_add_instance($scorm, $mform=null) {
95     global $CFG, $DB;
97     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
99     if (empty($scorm->timeopen)) {
100         $scorm->timeopen = 0;
101     }
102     if (empty($scorm->timeclose)) {
103         $scorm->timeclose = 0;
104     }
105     if (empty($scorm->completionstatusallscos)) {
106         $scorm->completionstatusallscos = 0;
107     }
108     $cmid       = $scorm->coursemodule;
109     $cmidnumber = $scorm->cmidnumber;
110     $courseid   = $scorm->course;
112     $context = context_module::instance($cmid);
114     $scorm = scorm_option2text($scorm);
115     $scorm->width  = (int)str_replace('%', '', $scorm->width);
116     $scorm->height = (int)str_replace('%', '', $scorm->height);
118     if (!isset($scorm->whatgrade)) {
119         $scorm->whatgrade = 0;
120     }
122     $id = $DB->insert_record('scorm', $scorm);
124     // Update course module record - from now on this instance properly exists and all function may be used.
125     $DB->set_field('course_modules', 'instance', $id, array('id' => $cmid));
127     // Reload scorm instance.
128     $record = $DB->get_record('scorm', array('id' => $id));
130     // Store the package and verify.
131     if ($record->scormtype === SCORM_TYPE_LOCAL) {
132         if (!empty($scorm->packagefile)) {
133             $fs = get_file_storage();
134             $fs->delete_area_files($context->id, 'mod_scorm', 'package');
135             file_save_draft_area_files($scorm->packagefile, $context->id, 'mod_scorm', 'package',
136                 0, array('subdirs' => 0, 'maxfiles' => 1));
137             // Get filename of zip that was uploaded.
138             $files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, '', false);
139             $file = reset($files);
140             $filename = $file->get_filename();
141             if ($filename !== false) {
142                 $record->reference = $filename;
143             }
144         }
146     } else if ($record->scormtype === SCORM_TYPE_LOCALSYNC) {
147         $record->reference = $scorm->packageurl;
148     } else if ($record->scormtype === SCORM_TYPE_EXTERNAL) {
149         $record->reference = $scorm->packageurl;
150     } else if ($record->scormtype === SCORM_TYPE_AICCURL) {
151         $record->reference = $scorm->packageurl;
152         $record->hidetoc = SCORM_TOC_DISABLED; // TOC is useless for direct AICCURL so disable it.
153     } else {
154         return false;
155     }
157     // Save reference.
158     $DB->update_record('scorm', $record);
160     // Extra fields required in grade related functions.
161     $record->course     = $courseid;
162     $record->cmidnumber = $cmidnumber;
163     $record->cmid       = $cmid;
165     scorm_parse($record, true);
167     scorm_grade_item_update($record);
168     scorm_update_calendar($record, $cmid);
170     return $record->id;
173 /**
174  * Given an object containing all the necessary data,
175  * (defined by the form in mod_form.php) this function
176  * will update an existing instance with new data.
177  *
178  * @global stdClass
179  * @global object
180  * @uses CONTEXT_MODULE
181  * @uses SCORM_TYPE_LOCAL
182  * @uses SCORM_TYPE_LOCALSYNC
183  * @uses SCORM_TYPE_EXTERNAL
184  * @param object $scorm Form data
185  * @param object $mform
186  * @return bool
187  */
188 function scorm_update_instance($scorm, $mform=null) {
189     global $CFG, $DB;
191     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
193     if (empty($scorm->timeopen)) {
194         $scorm->timeopen = 0;
195     }
196     if (empty($scorm->timeclose)) {
197         $scorm->timeclose = 0;
198     }
199     if (empty($scorm->completionstatusallscos)) {
200         $scorm->completionstatusallscos = 0;
201     }
203     $cmid       = $scorm->coursemodule;
204     $cmidnumber = $scorm->cmidnumber;
205     $courseid   = $scorm->course;
207     $scorm->id = $scorm->instance;
209     $context = context_module::instance($cmid);
211     if ($scorm->scormtype === SCORM_TYPE_LOCAL) {
212         if (!empty($scorm->packagefile)) {
213             $fs = get_file_storage();
214             $fs->delete_area_files($context->id, 'mod_scorm', 'package');
215             file_save_draft_area_files($scorm->packagefile, $context->id, 'mod_scorm', 'package',
216                 0, array('subdirs' => 0, 'maxfiles' => 1));
217             // Get filename of zip that was uploaded.
218             $files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, '', false);
219             $file = reset($files);
220             $filename = $file->get_filename();
221             if ($filename !== false) {
222                 $scorm->reference = $filename;
223             }
224         }
226     } else if ($scorm->scormtype === SCORM_TYPE_LOCALSYNC) {
227         $scorm->reference = $scorm->packageurl;
228     } else if ($scorm->scormtype === SCORM_TYPE_EXTERNAL) {
229         $scorm->reference = $scorm->packageurl;
230     } else if ($scorm->scormtype === SCORM_TYPE_AICCURL) {
231         $scorm->reference = $scorm->packageurl;
232         $scorm->hidetoc = SCORM_TOC_DISABLED; // TOC is useless for direct AICCURL so disable it.
233     } else {
234         return false;
235     }
237     $scorm = scorm_option2text($scorm);
238     $scorm->width        = (int)str_replace('%', '', $scorm->width);
239     $scorm->height       = (int)str_replace('%', '', $scorm->height);
240     $scorm->timemodified = time();
242     if (!isset($scorm->whatgrade)) {
243         $scorm->whatgrade = 0;
244     }
246     $DB->update_record('scorm', $scorm);
248     $scorm = $DB->get_record('scorm', array('id' => $scorm->id));
250     // Extra fields required in grade related functions.
251     $scorm->course   = $courseid;
252     $scorm->idnumber = $cmidnumber;
253     $scorm->cmid     = $cmid;
255     scorm_parse($scorm, (bool)$scorm->updatefreq);
257     scorm_grade_item_update($scorm);
258     scorm_update_grades($scorm);
259     scorm_update_calendar($scorm, $cmid);
261     return true;
264 /**
265  * Given an ID of an instance of this module,
266  * this function will permanently delete the instance
267  * and any data that depends on it.
268  *
269  * @global stdClass
270  * @global object
271  * @param int $id Scorm instance id
272  * @return boolean
273  */
274 function scorm_delete_instance($id) {
275     global $CFG, $DB;
277     if (! $scorm = $DB->get_record('scorm', array('id' => $id))) {
278         return false;
279     }
281     $result = true;
283     // Delete any dependent records.
284     if (! $DB->delete_records('scorm_scoes_track', array('scormid' => $scorm->id))) {
285         $result = false;
286     }
287     if ($scoes = $DB->get_records('scorm_scoes', array('scorm' => $scorm->id))) {
288         foreach ($scoes as $sco) {
289             if (! $DB->delete_records('scorm_scoes_data', array('scoid' => $sco->id))) {
290                 $result = false;
291             }
292         }
293         $DB->delete_records('scorm_scoes', array('scorm' => $scorm->id));
294     }
295     if (! $DB->delete_records('scorm', array('id' => $scorm->id))) {
296         $result = false;
297     }
299     /*if (! $DB->delete_records('scorm_sequencing_controlmode', array('scormid'=>$scorm->id))) {
300         $result = false;
301     }
302     if (! $DB->delete_records('scorm_sequencing_rolluprules', array('scormid'=>$scorm->id))) {
303         $result = false;
304     }
305     if (! $DB->delete_records('scorm_sequencing_rolluprule', array('scormid'=>$scorm->id))) {
306         $result = false;
307     }
308     if (! $DB->delete_records('scorm_sequencing_rollupruleconditions', array('scormid'=>$scorm->id))) {
309         $result = false;
310     }
311     if (! $DB->delete_records('scorm_sequencing_rolluprulecondition', array('scormid'=>$scorm->id))) {
312         $result = false;
313     }
314     if (! $DB->delete_records('scorm_sequencing_rulecondition', array('scormid'=>$scorm->id))) {
315         $result = false;
316     }
317     if (! $DB->delete_records('scorm_sequencing_ruleconditions', array('scormid'=>$scorm->id))) {
318         $result = false;
319     }*/
321     scorm_grade_item_delete($scorm);
323     return $result;
326 /**
327  * Return a small object with summary information about what a
328  * user has done with a given particular instance of this module
329  * Used for user activity reports.
330  *
331  * @global stdClass
332  * @param int $course Course id
333  * @param int $user User id
334  * @param int $mod
335  * @param int $scorm The scorm id
336  * @return mixed
337  */
338 function scorm_user_outline($course, $user, $mod, $scorm) {
339     global $CFG;
340     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
342     require_once("$CFG->libdir/gradelib.php");
343     $grades = grade_get_grades($course->id, 'mod', 'scorm', $scorm->id, $user->id);
344     if (!empty($grades->items[0]->grades)) {
345         $grade = reset($grades->items[0]->grades);
346         $result = new stdClass();
347         $result->info = get_string('grade') . ': '. $grade->str_long_grade;
349         // Datesubmitted == time created. dategraded == time modified or time overridden
350         // if grade was last modified by the user themselves use date graded. Otherwise use date submitted.
351         // TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704.
352         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
353             $result->time = $grade->dategraded;
354         } else {
355             $result->time = $grade->datesubmitted;
356         }
358         return $result;
359     }
360     return null;
363 /**
364  * Print a detailed representation of what a user has done with
365  * a given particular instance of this module, for user activity reports.
366  *
367  * @global stdClass
368  * @global object
369  * @param object $course
370  * @param object $user
371  * @param object $mod
372  * @param object $scorm
373  * @return boolean
374  */
375 function scorm_user_complete($course, $user, $mod, $scorm) {
376     global $CFG, $DB, $OUTPUT;
377     require_once("$CFG->libdir/gradelib.php");
379     $liststyle = 'structlist';
380     $now = time();
381     $firstmodify = $now;
382     $lastmodify = 0;
383     $sometoreport = false;
384     $report = '';
386     // First Access and Last Access dates for SCOs.
387     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
388     $timetracks = scorm_get_sco_runtime($scorm->id, false, $user->id);
389     $firstmodify = $timetracks->start;
390     $lastmodify = $timetracks->finish;
392     $grades = grade_get_grades($course->id, 'mod', 'scorm', $scorm->id, $user->id);
393     if (!empty($grades->items[0]->grades)) {
394         $grade = reset($grades->items[0]->grades);
395         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
396         if ($grade->str_feedback) {
397             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
398         }
399     }
401     if ($orgs = $DB->get_records_select('scorm_scoes', 'scorm = ? AND '.
402                                          $DB->sql_isempty('scorm_scoes', 'launch', false, true).' AND '.
403                                          $DB->sql_isempty('scorm_scoes', 'organization', false, false),
404                                          array($scorm->id), 'sortorder, id', 'id, identifier, title')) {
405         if (count($orgs) <= 1) {
406             unset($orgs);
407             $orgs = array();
408             $org = new stdClass();
409             $org->identifier = '';
410             $orgs[] = $org;
411         }
412         $report .= html_writer::start_div('mod-scorm');
413         foreach ($orgs as $org) {
414             $conditions = array();
415             $currentorg = '';
416             if (!empty($org->identifier)) {
417                 $report .= html_writer::div($org->title, 'orgtitle');
418                 $currentorg = $org->identifier;
419                 $conditions['organization'] = $currentorg;
420             }
421             $report .= html_writer::start_tag('ul', array('id' => '0', 'class' => $liststyle));
422                 $conditions['scorm'] = $scorm->id;
423             if ($scoes = $DB->get_records('scorm_scoes', $conditions, "sortorder, id")) {
424                 // Drop keys so that we can access array sequentially.
425                 $scoes = array_values($scoes);
426                 $level = 0;
427                 $sublist = 1;
428                 $parents[$level] = '/';
429                 foreach ($scoes as $pos => $sco) {
430                     if ($parents[$level] != $sco->parent) {
431                         if ($level > 0 && $parents[$level - 1] == $sco->parent) {
432                             $report .= html_writer::end_tag('ul').html_writer::end_tag('li');
433                             $level--;
434                         } else {
435                             $i = $level;
436                             $closelist = '';
437                             while (($i > 0) && ($parents[$level] != $sco->parent)) {
438                                 $closelist .= html_writer::end_tag('ul').html_writer::end_tag('li');
439                                 $i--;
440                             }
441                             if (($i == 0) && ($sco->parent != $currentorg)) {
442                                 $report .= html_writer::start_tag('li');
443                                 $report .= html_writer::start_tag('ul', array('id' => $sublist, 'class' => $liststyle));
444                                 $level++;
445                             } else {
446                                 $report .= $closelist;
447                                 $level = $i;
448                             }
449                             $parents[$level] = $sco->parent;
450                         }
451                     }
452                     $report .= html_writer::start_tag('li');
453                     if (isset($scoes[$pos + 1])) {
454                         $nextsco = $scoes[$pos + 1];
455                     } else {
456                         $nextsco = false;
457                     }
458                     if (($nextsco !== false) && ($sco->parent != $nextsco->parent) &&
459                             (($level == 0) || (($level > 0) && ($nextsco->parent == $sco->identifier)))) {
460                         $sublist++;
461                     } else {
462                         $report .= $OUTPUT->spacer(array("height" => "12", "width" => "13"));
463                     }
465                     if ($sco->launch) {
466                         $score = '';
467                         $totaltime = '';
468                         if ($usertrack = scorm_get_tracks($sco->id, $user->id)) {
469                             if ($usertrack->status == '') {
470                                 $usertrack->status = 'notattempted';
471                             }
472                             $strstatus = get_string($usertrack->status, 'scorm');
473                             $report .= $OUTPUT->pix_icon($usertrack->status, $strstatus, 'scorm');
474                         } else {
475                             if ($sco->scormtype == 'sco') {
476                                 $report .= $OUTPUT->pix_icon('notattempted', get_string('notattempted', 'scorm'), 'scorm');
477                             } else {
478                                 $report .= $OUTPUT->pix_icon('asset', get_string('asset', 'scorm'), 'scorm');
479                             }
480                         }
481                         $report .= "&nbsp;$sco->title $score$totaltime".html_writer::end_tag('li');
482                         if ($usertrack !== false) {
483                             $sometoreport = true;
484                             $report .= html_writer::start_tag('li').html_writer::start_tag('ul', array('class' => $liststyle));
485                             foreach ($usertrack as $element => $value) {
486                                 if (substr($element, 0, 3) == 'cmi') {
487                                     $report .= html_writer::tag('li', $element.' => '.s($value));
488                                 }
489                             }
490                             $report .= html_writer::end_tag('ul').html_writer::end_tag('li');
491                         }
492                     } else {
493                         $report .= "&nbsp;$sco->title".html_writer::end_tag('li');
494                     }
495                 }
496                 for ($i = 0; $i < $level; $i++) {
497                     $report .= html_writer::end_tag('ul').html_writer::end_tag('li');
498                 }
499             }
500             $report .= html_writer::end_tag('ul').html_writer::empty_tag('br');
501         }
502         $report .= html_writer::end_div();
503     }
504     if ($sometoreport) {
505         if ($firstmodify < $now) {
506             $timeago = format_time($now - $firstmodify);
507             echo get_string('firstaccess', 'scorm').': '.userdate($firstmodify).' ('.$timeago.")".html_writer::empty_tag('br');
508         }
509         if ($lastmodify > 0) {
510             $timeago = format_time($now - $lastmodify);
511             echo get_string('lastaccess', 'scorm').': '.userdate($lastmodify).' ('.$timeago.")".html_writer::empty_tag('br');
512         }
513         echo get_string('report', 'scorm').":".html_writer::empty_tag('br');
514         echo $report;
515     } else {
516         print_string('noactivity', 'scorm');
517     }
519     return true;
522 /**
523  * Function to be run periodically according to the moodle Tasks API
524  * This function searches for things that need to be done, such
525  * as sending out mail, toggling flags etc ...
526  *
527  * @global stdClass
528  * @global object
529  * @return boolean
530  */
531 function scorm_cron_scheduled_task () {
532     global $CFG, $DB;
534     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
536     $sitetimezone = core_date::get_server_timezone();
537     // Now see if there are any scorm updates to be done.
539     if (!isset($CFG->scorm_updatetimelast)) {    // To catch the first time.
540         set_config('scorm_updatetimelast', 0);
541     }
543     $timenow = time();
544     $updatetime = usergetmidnight($timenow, $sitetimezone);
546     if ($CFG->scorm_updatetimelast < $updatetime and $timenow > $updatetime) {
548         set_config('scorm_updatetimelast', $timenow);
550         mtrace('Updating scorm packages which require daily update');// We are updating.
552         $scormsupdate = $DB->get_records('scorm', array('updatefreq' => SCORM_UPDATE_EVERYDAY));
553         foreach ($scormsupdate as $scormupdate) {
554             scorm_parse($scormupdate, true);
555         }
557         // Now clear out AICC session table with old session data.
558         $cfgscorm = get_config('scorm');
559         if (!empty($cfgscorm->allowaicchacp)) {
560             $expiretime = time() - ($cfgscorm->aicchacpkeepsessiondata * 24 * 60 * 60);
561             $DB->delete_records_select('scorm_aicc_session', 'timemodified < ?', array($expiretime));
562         }
563     }
565     return true;
568 /**
569  * Return grade for given user or all users.
570  *
571  * @global stdClass
572  * @global object
573  * @param int $scormid id of scorm
574  * @param int $userid optional user id, 0 means all users
575  * @return array array of grades, false if none
576  */
577 function scorm_get_user_grades($scorm, $userid=0) {
578     global $CFG, $DB;
579     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
581     $grades = array();
582     if (empty($userid)) {
583         $scousers = $DB->get_records_select('scorm_scoes_track', "scormid=? GROUP BY userid",
584                                             array($scorm->id), "", "userid,null");
585         if ($scousers) {
586             foreach ($scousers as $scouser) {
587                 $grades[$scouser->userid] = new stdClass();
588                 $grades[$scouser->userid]->id         = $scouser->userid;
589                 $grades[$scouser->userid]->userid     = $scouser->userid;
590                 $grades[$scouser->userid]->rawgrade = scorm_grade_user($scorm, $scouser->userid);
591             }
592         } else {
593             return false;
594         }
596     } else {
597         $preattempt = $DB->get_records_select('scorm_scoes_track', "scormid=? AND userid=? GROUP BY userid",
598                                                 array($scorm->id, $userid), "", "userid,null");
599         if (!$preattempt) {
600             return false; // No attempt yet.
601         }
602         $grades[$userid] = new stdClass();
603         $grades[$userid]->id         = $userid;
604         $grades[$userid]->userid     = $userid;
605         $grades[$userid]->rawgrade = scorm_grade_user($scorm, $userid);
606     }
608     return $grades;
611 /**
612  * Update grades in central gradebook
613  *
614  * @category grade
615  * @param object $scorm
616  * @param int $userid specific user only, 0 mean all
617  * @param bool $nullifnone
618  */
619 function scorm_update_grades($scorm, $userid=0, $nullifnone=true) {
620     global $CFG;
621     require_once($CFG->libdir.'/gradelib.php');
622     require_once($CFG->libdir.'/completionlib.php');
624     if ($grades = scorm_get_user_grades($scorm, $userid)) {
625         scorm_grade_item_update($scorm, $grades);
626         // Set complete.
627         scorm_set_completion($scorm, $userid, COMPLETION_COMPLETE, $grades);
628     } else if ($userid and $nullifnone) {
629         $grade = new stdClass();
630         $grade->userid   = $userid;
631         $grade->rawgrade = null;
632         scorm_grade_item_update($scorm, $grade);
633         // Set incomplete.
634         scorm_set_completion($scorm, $userid, COMPLETION_INCOMPLETE);
635     } else {
636         scorm_grade_item_update($scorm);
637     }
640 /**
641  * Update/create grade item for given scorm
642  *
643  * @category grade
644  * @uses GRADE_TYPE_VALUE
645  * @uses GRADE_TYPE_NONE
646  * @param object $scorm object with extra cmidnumber
647  * @param mixed $grades optional array/object of grade(s); 'reset' means reset grades in gradebook
648  * @return object grade_item
649  */
650 function scorm_grade_item_update($scorm, $grades=null) {
651     global $CFG, $DB;
652     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
653     if (!function_exists('grade_update')) { // Workaround for buggy PHP versions.
654         require_once($CFG->libdir.'/gradelib.php');
655     }
657     $params = array('itemname' => $scorm->name);
658     if (isset($scorm->cmidnumber)) {
659         $params['idnumber'] = $scorm->cmidnumber;
660     }
662     if ($scorm->grademethod == GRADESCOES) {
663         $maxgrade = $DB->count_records_select('scorm_scoes', 'scorm = ? AND '.
664                                                 $DB->sql_isnotempty('scorm_scoes', 'launch', false, true), array($scorm->id));
665         if ($maxgrade) {
666             $params['gradetype'] = GRADE_TYPE_VALUE;
667             $params['grademax']  = $maxgrade;
668             $params['grademin']  = 0;
669         } else {
670             $params['gradetype'] = GRADE_TYPE_NONE;
671         }
672     } else {
673         $params['gradetype'] = GRADE_TYPE_VALUE;
674         $params['grademax']  = $scorm->maxgrade;
675         $params['grademin']  = 0;
676     }
678     if ($grades === 'reset') {
679         $params['reset'] = true;
680         $grades = null;
681     }
683     return grade_update('mod/scorm', $scorm->course, 'mod', 'scorm', $scorm->id, 0, $grades, $params);
686 /**
687  * Delete grade item for given scorm
688  *
689  * @category grade
690  * @param object $scorm object
691  * @return object grade_item
692  */
693 function scorm_grade_item_delete($scorm) {
694     global $CFG;
695     require_once($CFG->libdir.'/gradelib.php');
697     return grade_update('mod/scorm', $scorm->course, 'mod', 'scorm', $scorm->id, 0, null, array('deleted' => 1));
700 /**
701  * List the actions that correspond to a view of this module.
702  * This is used by the participation report.
703  *
704  * Note: This is not used by new logging system. Event with
705  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
706  *       be considered as view action.
707  *
708  * @return array
709  */
710 function scorm_get_view_actions() {
711     return array('pre-view', 'view', 'view all', 'report');
714 /**
715  * List the actions that correspond to a post of this module.
716  * This is used by the participation report.
717  *
718  * Note: This is not used by new logging system. Event with
719  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
720  *       will be considered as post action.
721  *
722  * @return array
723  */
724 function scorm_get_post_actions() {
725     return array();
728 /**
729  * @param object $scorm
730  * @return object $scorm
731  */
732 function scorm_option2text($scorm) {
733     $scormpopoupoptions = scorm_get_popup_options_array();
735     if (isset($scorm->popup)) {
736         if ($scorm->popup == 1) {
737             $optionlist = array();
738             foreach ($scormpopoupoptions as $name => $option) {
739                 if (isset($scorm->$name)) {
740                     $optionlist[] = $name.'='.$scorm->$name;
741                 } else {
742                     $optionlist[] = $name.'=0';
743                 }
744             }
745             $scorm->options = implode(',', $optionlist);
746         } else {
747             $scorm->options = '';
748         }
749     } else {
750         $scorm->popup = 0;
751         $scorm->options = '';
752     }
753     return $scorm;
756 /**
757  * Implementation of the function for printing the form elements that control
758  * whether the course reset functionality affects the scorm.
759  *
760  * @param object $mform form passed by reference
761  */
762 function scorm_reset_course_form_definition(&$mform) {
763     $mform->addElement('header', 'scormheader', get_string('modulenameplural', 'scorm'));
764     $mform->addElement('advcheckbox', 'reset_scorm', get_string('deleteallattempts', 'scorm'));
767 /**
768  * Course reset form defaults.
769  *
770  * @return array
771  */
772 function scorm_reset_course_form_defaults($course) {
773     return array('reset_scorm' => 1);
776 /**
777  * Removes all grades from gradebook
778  *
779  * @global stdClass
780  * @global object
781  * @param int $courseid
782  * @param string optional type
783  */
784 function scorm_reset_gradebook($courseid, $type='') {
785     global $CFG, $DB;
787     $sql = "SELECT s.*, cm.idnumber as cmidnumber, s.course as courseid
788               FROM {scorm} s, {course_modules} cm, {modules} m
789              WHERE m.name='scorm' AND m.id=cm.module AND cm.instance=s.id AND s.course=?";
791     if ($scorms = $DB->get_records_sql($sql, array($courseid))) {
792         foreach ($scorms as $scorm) {
793             scorm_grade_item_update($scorm, 'reset');
794         }
795     }
798 /**
799  * Actual implementation of the reset course functionality, delete all the
800  * scorm attempts for course $data->courseid.
801  *
802  * @global stdClass
803  * @global object
804  * @param object $data the data submitted from the reset course.
805  * @return array status array
806  */
807 function scorm_reset_userdata($data) {
808     global $CFG, $DB;
810     $componentstr = get_string('modulenameplural', 'scorm');
811     $status = array();
813     if (!empty($data->reset_scorm)) {
814         $scormssql = "SELECT s.id
815                          FROM {scorm} s
816                         WHERE s.course=?";
818         $DB->delete_records_select('scorm_scoes_track', "scormid IN ($scormssql)", array($data->courseid));
820         // Remove all grades from gradebook.
821         if (empty($data->reset_gradebook_grades)) {
822             scorm_reset_gradebook($data->courseid);
823         }
825         $status[] = array('component' => $componentstr, 'item' => get_string('deleteallattempts', 'scorm'), 'error' => false);
826     }
828     // No dates to shift here.
830     return $status;
833 /**
834  * Returns all other caps used in module
835  *
836  * @return array
837  */
838 function scorm_get_extra_capabilities() {
839     return array('moodle/site:accessallgroups');
842 /**
843  * Lists all file areas current user may browse
844  *
845  * @param object $course
846  * @param object $cm
847  * @param object $context
848  * @return array
849  */
850 function scorm_get_file_areas($course, $cm, $context) {
851     $areas = array();
852     $areas['content'] = get_string('areacontent', 'scorm');
853     $areas['package'] = get_string('areapackage', 'scorm');
854     return $areas;
857 /**
858  * File browsing support for SCORM file areas
859  *
860  * @package  mod_scorm
861  * @category files
862  * @param file_browser $browser file browser instance
863  * @param array $areas file areas
864  * @param stdClass $course course object
865  * @param stdClass $cm course module object
866  * @param stdClass $context context object
867  * @param string $filearea file area
868  * @param int $itemid item ID
869  * @param string $filepath file path
870  * @param string $filename file name
871  * @return file_info instance or null if not found
872  */
873 function scorm_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
874     global $CFG;
876     if (!has_capability('moodle/course:managefiles', $context)) {
877         return null;
878     }
880     // No writing for now!
882     $fs = get_file_storage();
884     if ($filearea === 'content') {
886         $filepath = is_null($filepath) ? '/' : $filepath;
887         $filename = is_null($filename) ? '.' : $filename;
889         $urlbase = $CFG->wwwroot.'/pluginfile.php';
890         if (!$storedfile = $fs->get_file($context->id, 'mod_scorm', 'content', 0, $filepath, $filename)) {
891             if ($filepath === '/' and $filename === '.') {
892                 $storedfile = new virtual_root_file($context->id, 'mod_scorm', 'content', 0);
893             } else {
894                 // Not found.
895                 return null;
896             }
897         }
898         require_once("$CFG->dirroot/mod/scorm/locallib.php");
899         return new scorm_package_file_info($browser, $context, $storedfile, $urlbase, $areas[$filearea], true, true, false, false);
901     } else if ($filearea === 'package') {
902         $filepath = is_null($filepath) ? '/' : $filepath;
903         $filename = is_null($filename) ? '.' : $filename;
905         $urlbase = $CFG->wwwroot.'/pluginfile.php';
906         if (!$storedfile = $fs->get_file($context->id, 'mod_scorm', 'package', 0, $filepath, $filename)) {
907             if ($filepath === '/' and $filename === '.') {
908                 $storedfile = new virtual_root_file($context->id, 'mod_scorm', 'package', 0);
909             } else {
910                 // Not found.
911                 return null;
912             }
913         }
914         return new file_info_stored($browser, $context, $storedfile, $urlbase, $areas[$filearea], false, true, false, false);
915     }
917     // Scorm_intro handled in file_browser.
919     return false;
922 /**
923  * Serves scorm content, introduction images and packages. Implements needed access control ;-)
924  *
925  * @package  mod_scorm
926  * @category files
927  * @param stdClass $course course object
928  * @param stdClass $cm course module object
929  * @param stdClass $context context object
930  * @param string $filearea file area
931  * @param array $args extra arguments
932  * @param bool $forcedownload whether or not force download
933  * @param array $options additional options affecting the file serving
934  * @return bool false if file not found, does not return if found - just send the file
935  */
936 function scorm_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
937     global $CFG, $DB;
939     if ($context->contextlevel != CONTEXT_MODULE) {
940         return false;
941     }
943     require_login($course, true, $cm);
945     $canmanageactivity = has_capability('moodle/course:manageactivities', $context);
946     $lifetime = null;
948     // Check SCORM availability.
949     if (!$canmanageactivity) {
950         require_once($CFG->dirroot.'/mod/scorm/locallib.php');
952         $scorm = $DB->get_record('scorm', array('id' => $cm->instance), 'id, timeopen, timeclose', MUST_EXIST);
953         list($available, $warnings) = scorm_get_availability_status($scorm);
954         if (!$available) {
955             return false;
956         }
957     }
959     if ($filearea === 'content') {
960         $revision = (int)array_shift($args); // Prevents caching problems - ignored here.
961         $relativepath = implode('/', $args);
962         $fullpath = "/$context->id/mod_scorm/content/0/$relativepath";
963         // TODO: add any other access restrictions here if needed!
965     } else if ($filearea === 'package') {
966         // Check if the global setting for disabling package downloads is enabled.
967         $protectpackagedownloads = get_config('scorm', 'protectpackagedownloads');
968         if ($protectpackagedownloads and !$canmanageactivity) {
969             return false;
970         }
971         $revision = (int)array_shift($args); // Prevents caching problems - ignored here.
972         $relativepath = implode('/', $args);
973         $fullpath = "/$context->id/mod_scorm/package/0/$relativepath";
974         $lifetime = 0; // No caching here.
976     } else if ($filearea === 'imsmanifest') { // This isn't a real filearea, it's a url parameter for this type of package.
977         $revision = (int)array_shift($args); // Prevents caching problems - ignored here.
978         $relativepath = implode('/', $args);
980         // Get imsmanifest file.
981         $fs = get_file_storage();
982         $files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, '', false);
983         $file = reset($files);
985         // Check that the package file is an imsmanifest.xml file - if not then this method is not allowed.
986         $packagefilename = $file->get_filename();
987         if (strtolower($packagefilename) !== 'imsmanifest.xml') {
988             return false;
989         }
991         $file->send_relative_file($relativepath);
992     } else {
993         return false;
994     }
996     $fs = get_file_storage();
997     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
998         if ($filearea === 'content') { // Return file not found straight away to improve performance.
999             send_header_404();
1000             die;
1001         }
1002         return false;
1003     }
1005     // Finally send the file.
1006     send_stored_file($file, $lifetime, 0, false, $options);
1009 /**
1010  * @uses FEATURE_GROUPS
1011  * @uses FEATURE_GROUPINGS
1012  * @uses FEATURE_MOD_INTRO
1013  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
1014  * @uses FEATURE_COMPLETION_HAS_RULES
1015  * @uses FEATURE_GRADE_HAS_GRADE
1016  * @uses FEATURE_GRADE_OUTCOMES
1017  * @param string $feature FEATURE_xx constant for requested feature
1018  * @return mixed True if module supports feature, false if not, null if doesn't know
1019  */
1020 function scorm_supports($feature) {
1021     switch($feature) {
1022         case FEATURE_GROUPS:                  return true;
1023         case FEATURE_GROUPINGS:               return true;
1024         case FEATURE_MOD_INTRO:               return true;
1025         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
1026         case FEATURE_COMPLETION_HAS_RULES:    return true;
1027         case FEATURE_GRADE_HAS_GRADE:         return true;
1028         case FEATURE_GRADE_OUTCOMES:          return true;
1029         case FEATURE_BACKUP_MOODLE2:          return true;
1030         case FEATURE_SHOW_DESCRIPTION:        return true;
1032         default: return null;
1033     }
1036 /**
1037  * Get the filename for a temp log file
1038  *
1039  * @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
1040  * @param integer $scoid - scoid of object this log entry is for
1041  * @return string The filename as an absolute path
1042  */
1043 function scorm_debug_log_filename($type, $scoid) {
1044     global $CFG, $USER;
1046     $logpath = $CFG->tempdir.'/scormlogs';
1047     $logfile = $logpath.'/'.$type.'debug_'.$USER->id.'_'.$scoid.'.log';
1048     return $logfile;
1051 /**
1052  * writes log output to a temp log file
1053  *
1054  * @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
1055  * @param string $text - text to be written to file.
1056  * @param integer $scoid - scoid of object this log entry is for.
1057  */
1058 function scorm_debug_log_write($type, $text, $scoid) {
1059     global $CFG;
1061     $debugenablelog = get_config('scorm', 'allowapidebug');
1062     if (!$debugenablelog || empty($text)) {
1063         return;
1064     }
1065     if (make_temp_directory('scormlogs/')) {
1066         $logfile = scorm_debug_log_filename($type, $scoid);
1067         @file_put_contents($logfile, date('Y/m/d H:i:s O')." DEBUG $text\r\n", FILE_APPEND);
1068         @chmod($logfile, $CFG->filepermissions);
1069     }
1072 /**
1073  * Remove debug log file
1074  *
1075  * @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
1076  * @param integer $scoid - scoid of object this log entry is for
1077  * @return boolean True if the file is successfully deleted, false otherwise
1078  */
1079 function scorm_debug_log_remove($type, $scoid) {
1081     $debugenablelog = get_config('scorm', 'allowapidebug');
1082     $logfile = scorm_debug_log_filename($type, $scoid);
1083     if (!$debugenablelog || !file_exists($logfile)) {
1084         return false;
1085     }
1087     return @unlink($logfile);
1090 /**
1091  * writes overview info for course_overview block - displays upcoming scorm objects that have a due date
1092  *
1093  * @deprecated since 3.3
1094  *
1095  * @param object $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
1096  * @param array $htmlarray
1097  * @return mixed
1098  */
1099 function scorm_print_overview($courses, &$htmlarray) {
1100     global $USER, $CFG;
1102     debugging('The function scorm_print_overview() is now deprecated.', DEBUG_DEVELOPER);
1104     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1105         return array();
1106     }
1108     if (!$scorms = get_all_instances_in_courses('scorm', $courses)) {
1109         return;
1110     }
1112     $strscorm   = get_string('modulename', 'scorm');
1113     $strduedate = get_string('duedate', 'scorm');
1115     foreach ($scorms as $scorm) {
1116         $time = time();
1117         $showattemptstatus = false;
1118         if ($scorm->timeopen) {
1119             $isopen = ($scorm->timeopen <= $time && $time <= $scorm->timeclose);
1120         }
1121         if ($scorm->displayattemptstatus == SCORM_DISPLAY_ATTEMPTSTATUS_ALL ||
1122                 $scorm->displayattemptstatus == SCORM_DISPLAY_ATTEMPTSTATUS_MY) {
1123             $showattemptstatus = true;
1124         }
1125         if ($showattemptstatus || !empty($isopen) || !empty($scorm->timeclose)) {
1126             $str = html_writer::start_div('scorm overview').html_writer::div($strscorm. ': '.
1127                     html_writer::link($CFG->wwwroot.'/mod/scorm/view.php?id='.$scorm->coursemodule, $scorm->name,
1128                                         array('title' => $strscorm, 'class' => $scorm->visible ? '' : 'dimmed')), 'name');
1129             if ($scorm->timeclose) {
1130                 $str .= html_writer::div($strduedate.': '.userdate($scorm->timeclose), 'info');
1131             }
1132             if ($showattemptstatus) {
1133                 require_once($CFG->dirroot.'/mod/scorm/locallib.php');
1134                 $str .= html_writer::div(scorm_get_attempt_status($USER, $scorm), 'details');
1135             }
1136             $str .= html_writer::end_div();
1137             if (empty($htmlarray[$scorm->course]['scorm'])) {
1138                 $htmlarray[$scorm->course]['scorm'] = $str;
1139             } else {
1140                 $htmlarray[$scorm->course]['scorm'] .= $str;
1141             }
1142         }
1143     }
1146 /**
1147  * Return a list of page types
1148  * @param string $pagetype current page type
1149  * @param stdClass $parentcontext Block's parent context
1150  * @param stdClass $currentcontext Current context of block
1151  */
1152 function scorm_page_type_list($pagetype, $parentcontext, $currentcontext) {
1153     $modulepagetype = array('mod-scorm-*' => get_string('page-mod-scorm-x', 'scorm'));
1154     return $modulepagetype;
1157 /**
1158  * Returns the SCORM version used.
1159  * @param string $scormversion comes from $scorm->version
1160  * @param string $version one of the defined vars SCORM_12, SCORM_13, SCORM_AICC (or empty)
1161  * @return Scorm version.
1162  */
1163 function scorm_version_check($scormversion, $version='') {
1164     $scormversion = trim(strtolower($scormversion));
1165     if (empty($version) || $version == SCORM_12) {
1166         if ($scormversion == 'scorm_12' || $scormversion == 'scorm_1.2') {
1167             return SCORM_12;
1168         }
1169         if (!empty($version)) {
1170             return false;
1171         }
1172     }
1173     if (empty($version) || $version == SCORM_13) {
1174         if ($scormversion == 'scorm_13' || $scormversion == 'scorm_1.3') {
1175             return SCORM_13;
1176         }
1177         if (!empty($version)) {
1178             return false;
1179         }
1180     }
1181     if (empty($version) || $version == SCORM_AICC) {
1182         if (strpos($scormversion, 'aicc')) {
1183             return SCORM_AICC;
1184         }
1185         if (!empty($version)) {
1186             return false;
1187         }
1188     }
1189     return false;
1192 /**
1193  * Obtains the automatic completion state for this scorm based on any conditions
1194  * in scorm settings.
1195  *
1196  * @param object $course Course
1197  * @param object $cm Course-module
1198  * @param int $userid User ID
1199  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
1200  * @return bool True if completed, false if not. (If no conditions, then return
1201  *   value depends on comparison type)
1202  */
1203 function scorm_get_completion_state($course, $cm, $userid, $type) {
1204     global $DB;
1206     $result = $type;
1208     // Get scorm.
1209     if (!$scorm = $DB->get_record('scorm', array('id' => $cm->instance))) {
1210         print_error('cannotfindscorm');
1211     }
1212     // Only check for existence of tracks and return false if completionstatusrequired or completionscorerequired
1213     // this means that if only view is required we don't end up with a false state.
1214     if ($scorm->completionstatusrequired !== null ||
1215         $scorm->completionscorerequired !== null) {
1216         // Get user's tracks data.
1217         $tracks = $DB->get_records_sql(
1218             "
1219             SELECT
1220                 id,
1221                 scoid,
1222                 element,
1223                 value
1224             FROM
1225                 {scorm_scoes_track}
1226             WHERE
1227                 scormid = ?
1228             AND userid = ?
1229             AND element IN
1230             (
1231                 'cmi.core.lesson_status',
1232                 'cmi.completion_status',
1233                 'cmi.success_status',
1234                 'cmi.core.score.raw',
1235                 'cmi.score.raw'
1236             )
1237             ",
1238             array($scorm->id, $userid)
1239         );
1241         if (!$tracks) {
1242             return completion_info::aggregate_completion_states($type, $result, false);
1243         }
1244     }
1246     // Check for status.
1247     if ($scorm->completionstatusrequired !== null) {
1249         // Get status.
1250         $statuses = array_flip(scorm_status_options());
1251         $nstatus = 0;
1252         // Check any track for these values.
1253         $scostatus = array();
1254         foreach ($tracks as $track) {
1255             if (!in_array($track->element, array('cmi.core.lesson_status', 'cmi.completion_status', 'cmi.success_status'))) {
1256                 continue;
1257             }
1258             if (array_key_exists($track->value, $statuses)) {
1259                 $scostatus[$track->scoid] = true;
1260                 $nstatus |= $statuses[$track->value];
1261             }
1262         }
1264         if (!empty($scorm->completionstatusallscos)) {
1265             // Iterate over all scos and make sure each has a lesson_status.
1266             $scos = $DB->get_records('scorm_scoes', array('scorm' => $scorm->id, 'scormtype' => 'sco'));
1267             foreach ($scos as $sco) {
1268                 if (empty($scostatus[$sco->id])) {
1269                     return completion_info::aggregate_completion_states($type, $result, false);
1270                 }
1271             }
1272             return completion_info::aggregate_completion_states($type, $result, true);
1273         } else if ($scorm->completionstatusrequired & $nstatus) {
1274             return completion_info::aggregate_completion_states($type, $result, true);
1275         } else {
1276             return completion_info::aggregate_completion_states($type, $result, false);
1277         }
1278     }
1280     // Check for score.
1281     if ($scorm->completionscorerequired !== null) {
1282         $maxscore = -1;
1284         foreach ($tracks as $track) {
1285             if (!in_array($track->element, array('cmi.core.score.raw', 'cmi.score.raw'))) {
1286                 continue;
1287             }
1289             if (strlen($track->value) && floatval($track->value) >= $maxscore) {
1290                 $maxscore = floatval($track->value);
1291             }
1292         }
1294         if ($scorm->completionscorerequired <= $maxscore) {
1295             return completion_info::aggregate_completion_states($type, $result, true);
1296         } else {
1297             return completion_info::aggregate_completion_states($type, $result, false);
1298         }
1299     }
1301     return $result;
1304 /**
1305  * Register the ability to handle drag and drop file uploads
1306  * @return array containing details of the files / types the mod can handle
1307  */
1308 function scorm_dndupload_register() {
1309     return array('files' => array(
1310         array('extension' => 'zip', 'message' => get_string('dnduploadscorm', 'scorm'))
1311     ));
1314 /**
1315  * Handle a file that has been uploaded
1316  * @param object $uploadinfo details of the file / content that has been uploaded
1317  * @return int instance id of the newly created mod
1318  */
1319 function scorm_dndupload_handle($uploadinfo) {
1321     $context = context_module::instance($uploadinfo->coursemodule);
1322     file_save_draft_area_files($uploadinfo->draftitemid, $context->id, 'mod_scorm', 'package', 0);
1323     $fs = get_file_storage();
1324     $files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, 'sortorder, itemid, filepath, filename', false);
1325     $file = reset($files);
1327     // Validate the file, make sure it's a valid SCORM package!
1328     $errors = scorm_validate_package($file);
1329     if (!empty($errors)) {
1330         return false;
1331     }
1332     // Create a default scorm object to pass to scorm_add_instance()!
1333     $scorm = get_config('scorm');
1334     $scorm->course = $uploadinfo->course->id;
1335     $scorm->coursemodule = $uploadinfo->coursemodule;
1336     $scorm->cmidnumber = '';
1337     $scorm->name = $uploadinfo->displayname;
1338     $scorm->scormtype = SCORM_TYPE_LOCAL;
1339     $scorm->reference = $file->get_filename();
1340     $scorm->intro = '';
1341     $scorm->width = $scorm->framewidth;
1342     $scorm->height = $scorm->frameheight;
1344     return scorm_add_instance($scorm, null);
1347 /**
1348  * Sets activity completion state
1349  *
1350  * @param object $scorm object
1351  * @param int $userid User ID
1352  * @param int $completionstate Completion state
1353  * @param array $grades grades array of users with grades - used when $userid = 0
1354  */
1355 function scorm_set_completion($scorm, $userid, $completionstate = COMPLETION_COMPLETE, $grades = array()) {
1356     $course = new stdClass();
1357     $course->id = $scorm->course;
1358     $completion = new completion_info($course);
1360     // Check if completion is enabled site-wide, or for the course.
1361     if (!$completion->is_enabled()) {
1362         return;
1363     }
1365     $cm = get_coursemodule_from_instance('scorm', $scorm->id, $scorm->course);
1366     if (empty($cm) || !$completion->is_enabled($cm)) {
1367             return;
1368     }
1370     if (empty($userid)) { // We need to get all the relevant users from $grades param.
1371         foreach ($grades as $grade) {
1372             $completion->update_state($cm, $completionstate, $grade->userid);
1373         }
1374     } else {
1375         $completion->update_state($cm, $completionstate, $userid);
1376     }
1379 /**
1380  * Check that a Zip file contains a valid SCORM package
1381  *
1382  * @param $file stored_file a Zip file.
1383  * @return array empty if no issue is found. Array of error message otherwise
1384  */
1385 function scorm_validate_package($file) {
1386     $packer = get_file_packer('application/zip');
1387     $errors = array();
1388     if ($file->is_external_file()) { // Get zip file so we can check it is correct.
1389         $file->import_external_file_contents();
1390     }
1391     $filelist = $file->list_files($packer);
1393     if (!is_array($filelist)) {
1394         $errors['packagefile'] = get_string('badarchive', 'scorm');
1395     } else {
1396         $aiccfound = false;
1397         $badmanifestpresent = false;
1398         foreach ($filelist as $info) {
1399             if ($info->pathname == 'imsmanifest.xml') {
1400                 return array();
1401             } else if (strpos($info->pathname, 'imsmanifest.xml') !== false) {
1402                 // This package has an imsmanifest file inside a folder of the package.
1403                 $badmanifestpresent = true;
1404             }
1405             if (preg_match('/\.cst$/', $info->pathname)) {
1406                 return array();
1407             }
1408         }
1409         if (!$aiccfound) {
1410             if ($badmanifestpresent) {
1411                 $errors['packagefile'] = get_string('badimsmanifestlocation', 'scorm');
1412             } else {
1413                 $errors['packagefile'] = get_string('nomanifest', 'scorm');
1414             }
1415         }
1416     }
1417     return $errors;
1420 /**
1421  * Check and set the correct mode and attempt when entering a SCORM package.
1422  *
1423  * @param object $scorm object
1424  * @param string $newattempt should a new attempt be generated here.
1425  * @param int $attempt the attempt number this is for.
1426  * @param int $userid the userid of the user.
1427  * @param string $mode the current mode that has been selected.
1428  */
1429 function scorm_check_mode($scorm, &$newattempt, &$attempt, $userid, &$mode) {
1430     global $DB;
1432     if (($mode == 'browse')) {
1433         if ($scorm->hidebrowse == 1) {
1434             // Prevent Browse mode if hidebrowse is set.
1435             $mode = 'normal';
1436         } else {
1437             // We don't need to check attempts as browse mode is set.
1438             return;
1439         }
1440     }
1441     // Check if the scorm module is incomplete (used to validate user request to start a new attempt).
1442     $incomplete = true;
1443     $sql = "SELECT sc.id, t.value
1444               FROM {scorm_scoes} sc
1445          LEFT JOIN {scorm_scoes_track} t ON sc.scorm = t.scormid AND sc.id = t.scoid
1446                    AND t.element = 'cmi.core.lesson_status' AND t.userid = ? AND t.attempt = ?
1447              WHERE sc.scormtype = 'sco' AND sc.scorm = ?";
1448     $tracks = $DB->get_recordset_sql($sql, array($userid, $attempt, $scorm->id));
1450     foreach ($tracks as $track) {
1451         if (($track->value == 'completed') || ($track->value == 'passed') || ($track->value == 'failed')) {
1452             $incomplete = false;
1453         } else {
1454             $incomplete = true;
1455             break; // Found an incomplete sco, so the result as a whole is incomplete.
1456         }
1457     }
1458     $tracks->close();
1460     // Validate user request to start a new attempt.
1461     if ($incomplete === true) {
1462         // The option to start a new attempt should never have been presented. Force false.
1463         $newattempt = 'off';
1464     } else if (!empty($scorm->forcenewattempt)) {
1465         // A new attempt should be forced for already completed attempts.
1466         $newattempt = 'on';
1467     }
1469     if (($newattempt == 'on') && (($attempt < $scorm->maxattempt) || ($scorm->maxattempt == 0))) {
1470         $attempt++;
1471         $mode = 'normal';
1472     } else { // Check if review mode should be set.
1473         if ($incomplete === true) {
1474             $mode = 'normal';
1475         } else {
1476             $mode = 'review';
1477         }
1478     }
1481 /**
1482  * Trigger the course_module_viewed event.
1483  *
1484  * @param  stdClass $scorm        scorm object
1485  * @param  stdClass $course     course object
1486  * @param  stdClass $cm         course module object
1487  * @param  stdClass $context    context object
1488  * @since Moodle 3.0
1489  */
1490 function scorm_view($scorm, $course, $cm, $context) {
1492     // Trigger course_module_viewed event.
1493     $params = array(
1494         'context' => $context,
1495         'objectid' => $scorm->id
1496     );
1498     $event = \mod_scorm\event\course_module_viewed::create($params);
1499     $event->add_record_snapshot('course_modules', $cm);
1500     $event->add_record_snapshot('course', $course);
1501     $event->add_record_snapshot('scorm', $scorm);
1502     $event->trigger();
1505 /**
1506  * Check if the module has any update that affects the current user since a given time.
1507  *
1508  * @param  cm_info $cm course module data
1509  * @param  int $from the time to check updates from
1510  * @param  array $filter  if we need to check only specific updates
1511  * @return stdClass an object with the different type of areas indicating if they were updated or not
1512  * @since Moodle 3.2
1513  */
1514 function scorm_check_updates_since(cm_info $cm, $from, $filter = array()) {
1515     global $DB, $USER, $CFG;
1516     require_once($CFG->dirroot . '/mod/scorm/locallib.php');
1518     $scorm = $DB->get_record($cm->modname, array('id' => $cm->instance), '*', MUST_EXIST);
1519     $updates = new stdClass();
1520     list($available, $warnings) = scorm_get_availability_status($scorm, true, $cm->context);
1521     if (!$available) {
1522         return $updates;
1523     }
1524     $updates = course_check_module_updates_since($cm, $from, array('package'), $filter);
1526     $updates->tracks = (object) array('updated' => false);
1527     $select = 'scormid = ? AND userid = ? AND timemodified > ?';
1528     $params = array($scorm->id, $USER->id, $from);
1529     $tracks = $DB->get_records_select('scorm_scoes_track', $select, $params, '', 'id');
1530     if (!empty($tracks)) {
1531         $updates->tracks->updated = true;
1532         $updates->tracks->itemids = array_keys($tracks);
1533     }
1535     // Now, teachers should see other students updates.
1536     if (has_capability('mod/scorm:viewreport', $cm->context)) {
1537         $select = 'scormid = ? AND timemodified > ?';
1538         $params = array($scorm->id, $from);
1540         if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
1541             $groupusers = array_keys(groups_get_activity_shared_group_members($cm));
1542             if (empty($groupusers)) {
1543                 return $updates;
1544             }
1545             list($insql, $inparams) = $DB->get_in_or_equal($groupusers);
1546             $select .= ' AND userid ' . $insql;
1547             $params = array_merge($params, $inparams);
1548         }
1550         $updates->usertracks = (object) array('updated' => false);
1551         $tracks = $DB->get_records_select('scorm_scoes_track', $select, $params, '', 'id');
1552         if (!empty($tracks)) {
1553             $updates->usertracks->updated = true;
1554             $updates->usertracks->itemids = array_keys($tracks);
1555         }
1556     }
1557     return $updates;
1560 /**
1561  * Get icon mapping for font-awesome.
1562  */
1563 function mod_scorm_get_fontawesome_icon_map() {
1564     return [
1565         'mod_scorm:assetc' => 'fa-archive-o',
1566         'mod_scorm:asset' => 'fa-archive-o',
1567         'mod_scorm:browsed' => 'fa-book',
1568         'mod_scorm:completed' => 'fa-check-square-o',
1569         'mod_scorm:failed' => 'fa-times',
1570         'mod_scorm:incomplete' => 'fa-pencil-square-o',
1571         'mod_scorm:minus' => 'fa-minus',
1572         'mod_scorm:notattempted' => 'fa-square-o',
1573         'mod_scorm:passed' => 'fa-check',
1574         'mod_scorm:plus' => 'fa-plus',
1575         'mod_scorm:popdown' => 'fa-window-close-o',
1576         'mod_scorm:popup' => 'fa-window-restore',
1577         'mod_scorm:suspend' => 'fa-pause',
1578         'mod_scorm:wait' => 'fa-clock-o',
1579     ];
1582 /**
1583  * This standard function will check all instances of this module
1584  * and make sure there are up-to-date events created for each of them.
1585  * If courseid = 0, then every scorm event in the site is checked, else
1586  * only scorm events belonging to the course specified are checked.
1587  *
1588  * @param int $courseid
1589  * @return bool
1590  */
1591 function scorm_refresh_events($courseid = 0) {
1592     global $CFG, $DB;
1594     require_once($CFG->dirroot . '/mod/scorm/locallib.php');
1596     if ($courseid) {
1597         // Make sure that the course id is numeric.
1598         if (!is_numeric($courseid)) {
1599             return false;
1600         }
1601         if (!$scorms = $DB->get_records('scorm', array('course' => $courseid))) {
1602             return false;
1603         }
1604     } else {
1605         if (!$scorms = $DB->get_records('scorm')) {
1606             return false;
1607         }
1608     }
1610     foreach ($scorms as $scorm) {
1611         $cm = get_coursemodule_from_instance('scorm', $scorm->id);
1612         scorm_update_calendar($scorm, $cm->id);
1613     }
1615     return true;
1618 /**
1619  * Handles creating actions for events.
1620  *
1621  * @param calendar_event $event
1622  * @param \core_calendar\action_factory $factory
1623  * @return \core_calendar\local\event\value_objects\action|\core_calendar\local\interfaces\action_interface|null
1624  */
1625 function mod_scorm_core_calendar_provide_event_action(calendar_event $event,
1626                                                       \core_calendar\action_factory $factory) {
1627     global $CFG, $DB;
1629     require_once($CFG->dirroot . '/mod/scorm/locallib.php');
1631     $cm = get_fast_modinfo($event->courseid)->instances['scorm'][$event->instance];
1632     $scorm = $DB->get_record('scorm', array('id' => $event->instance));
1634     // Check that the SCORM activity is open.
1635     list($actionable, $warnings) = scorm_get_availability_status($scorm);
1637     return $factory->create_instance(
1638         get_string('enter', 'scorm'),
1639         new \moodle_url('/mod/scorm/view.php', array('id' => $cm->id)),
1640         1,
1641         $actionable
1642     );