dc20f0b3be2c1e857002d0285cd69b56d1e3348d
[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);
169     if (!empty($scorm->completionexpected)) {
170         \core_completion\api::update_completion_date_event($cmid, 'scorm', $record, $scorm->completionexpected);
171     }
173     return $record->id;
176 /**
177  * Given an object containing all the necessary data,
178  * (defined by the form in mod_form.php) this function
179  * will update an existing instance with new data.
180  *
181  * @global stdClass
182  * @global object
183  * @uses CONTEXT_MODULE
184  * @uses SCORM_TYPE_LOCAL
185  * @uses SCORM_TYPE_LOCALSYNC
186  * @uses SCORM_TYPE_EXTERNAL
187  * @param object $scorm Form data
188  * @param object $mform
189  * @return bool
190  */
191 function scorm_update_instance($scorm, $mform=null) {
192     global $CFG, $DB;
194     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
196     if (empty($scorm->timeopen)) {
197         $scorm->timeopen = 0;
198     }
199     if (empty($scorm->timeclose)) {
200         $scorm->timeclose = 0;
201     }
202     if (empty($scorm->completionstatusallscos)) {
203         $scorm->completionstatusallscos = 0;
204     }
206     $cmid       = $scorm->coursemodule;
207     $cmidnumber = $scorm->cmidnumber;
208     $courseid   = $scorm->course;
210     $scorm->id = $scorm->instance;
212     $context = context_module::instance($cmid);
214     if ($scorm->scormtype === SCORM_TYPE_LOCAL) {
215         if (!empty($scorm->packagefile)) {
216             $fs = get_file_storage();
217             $fs->delete_area_files($context->id, 'mod_scorm', 'package');
218             file_save_draft_area_files($scorm->packagefile, $context->id, 'mod_scorm', 'package',
219                 0, array('subdirs' => 0, 'maxfiles' => 1));
220             // Get filename of zip that was uploaded.
221             $files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, '', false);
222             $file = reset($files);
223             $filename = $file->get_filename();
224             if ($filename !== false) {
225                 $scorm->reference = $filename;
226             }
227         }
229     } else if ($scorm->scormtype === SCORM_TYPE_LOCALSYNC) {
230         $scorm->reference = $scorm->packageurl;
231     } else if ($scorm->scormtype === SCORM_TYPE_EXTERNAL) {
232         $scorm->reference = $scorm->packageurl;
233     } else if ($scorm->scormtype === SCORM_TYPE_AICCURL) {
234         $scorm->reference = $scorm->packageurl;
235         $scorm->hidetoc = SCORM_TOC_DISABLED; // TOC is useless for direct AICCURL so disable it.
236     } else {
237         return false;
238     }
240     $scorm = scorm_option2text($scorm);
241     $scorm->width        = (int)str_replace('%', '', $scorm->width);
242     $scorm->height       = (int)str_replace('%', '', $scorm->height);
243     $scorm->timemodified = time();
245     if (!isset($scorm->whatgrade)) {
246         $scorm->whatgrade = 0;
247     }
249     $DB->update_record('scorm', $scorm);
250     // We need to find this out before we blow away the form data.
251     $completionexpected = (!empty($scorm->completionexpected)) ? $scorm->completionexpected : null;
253     $scorm = $DB->get_record('scorm', array('id' => $scorm->id));
255     // Extra fields required in grade related functions.
256     $scorm->course   = $courseid;
257     $scorm->idnumber = $cmidnumber;
258     $scorm->cmid     = $cmid;
260     scorm_parse($scorm, (bool)$scorm->updatefreq);
262     scorm_grade_item_update($scorm);
263     scorm_update_grades($scorm);
264     scorm_update_calendar($scorm, $cmid);
265     \core_completion\api::update_completion_date_event($cmid, 'scorm', $scorm, $completionexpected);
267     return true;
270 /**
271  * Given an ID of an instance of this module,
272  * this function will permanently delete the instance
273  * and any data that depends on it.
274  *
275  * @global stdClass
276  * @global object
277  * @param int $id Scorm instance id
278  * @return boolean
279  */
280 function scorm_delete_instance($id) {
281     global $CFG, $DB;
283     if (! $scorm = $DB->get_record('scorm', array('id' => $id))) {
284         return false;
285     }
287     $result = true;
289     // Delete any dependent records.
290     if (! $DB->delete_records('scorm_scoes_track', array('scormid' => $scorm->id))) {
291         $result = false;
292     }
293     if ($scoes = $DB->get_records('scorm_scoes', array('scorm' => $scorm->id))) {
294         foreach ($scoes as $sco) {
295             if (! $DB->delete_records('scorm_scoes_data', array('scoid' => $sco->id))) {
296                 $result = false;
297             }
298         }
299         $DB->delete_records('scorm_scoes', array('scorm' => $scorm->id));
300     }
301     if (! $DB->delete_records('scorm', array('id' => $scorm->id))) {
302         $result = false;
303     }
305     /*if (! $DB->delete_records('scorm_sequencing_controlmode', array('scormid'=>$scorm->id))) {
306         $result = false;
307     }
308     if (! $DB->delete_records('scorm_sequencing_rolluprules', array('scormid'=>$scorm->id))) {
309         $result = false;
310     }
311     if (! $DB->delete_records('scorm_sequencing_rolluprule', array('scormid'=>$scorm->id))) {
312         $result = false;
313     }
314     if (! $DB->delete_records('scorm_sequencing_rollupruleconditions', array('scormid'=>$scorm->id))) {
315         $result = false;
316     }
317     if (! $DB->delete_records('scorm_sequencing_rolluprulecondition', array('scormid'=>$scorm->id))) {
318         $result = false;
319     }
320     if (! $DB->delete_records('scorm_sequencing_rulecondition', array('scormid'=>$scorm->id))) {
321         $result = false;
322     }
323     if (! $DB->delete_records('scorm_sequencing_ruleconditions', array('scormid'=>$scorm->id))) {
324         $result = false;
325     }*/
327     scorm_grade_item_delete($scorm);
329     return $result;
332 /**
333  * Return a small object with summary information about what a
334  * user has done with a given particular instance of this module
335  * Used for user activity reports.
336  *
337  * @global stdClass
338  * @param int $course Course id
339  * @param int $user User id
340  * @param int $mod
341  * @param int $scorm The scorm id
342  * @return mixed
343  */
344 function scorm_user_outline($course, $user, $mod, $scorm) {
345     global $CFG;
346     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
348     require_once("$CFG->libdir/gradelib.php");
349     $grades = grade_get_grades($course->id, 'mod', 'scorm', $scorm->id, $user->id);
350     if (!empty($grades->items[0]->grades)) {
351         $grade = reset($grades->items[0]->grades);
352         $result = new stdClass();
353         $result->info = get_string('grade') . ': '. $grade->str_long_grade;
355         // Datesubmitted == time created. dategraded == time modified or time overridden
356         // if grade was last modified by the user themselves use date graded. Otherwise use date submitted.
357         // TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704.
358         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
359             $result->time = $grade->dategraded;
360         } else {
361             $result->time = $grade->datesubmitted;
362         }
364         return $result;
365     }
366     return null;
369 /**
370  * Print a detailed representation of what a user has done with
371  * a given particular instance of this module, for user activity reports.
372  *
373  * @global stdClass
374  * @global object
375  * @param object $course
376  * @param object $user
377  * @param object $mod
378  * @param object $scorm
379  * @return boolean
380  */
381 function scorm_user_complete($course, $user, $mod, $scorm) {
382     global $CFG, $DB, $OUTPUT;
383     require_once("$CFG->libdir/gradelib.php");
385     $liststyle = 'structlist';
386     $now = time();
387     $firstmodify = $now;
388     $lastmodify = 0;
389     $sometoreport = false;
390     $report = '';
392     // First Access and Last Access dates for SCOs.
393     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
394     $timetracks = scorm_get_sco_runtime($scorm->id, false, $user->id);
395     $firstmodify = $timetracks->start;
396     $lastmodify = $timetracks->finish;
398     $grades = grade_get_grades($course->id, 'mod', 'scorm', $scorm->id, $user->id);
399     if (!empty($grades->items[0]->grades)) {
400         $grade = reset($grades->items[0]->grades);
401         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
402         if ($grade->str_feedback) {
403             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
404         }
405     }
407     if ($orgs = $DB->get_records_select('scorm_scoes', 'scorm = ? AND '.
408                                          $DB->sql_isempty('scorm_scoes', 'launch', false, true).' AND '.
409                                          $DB->sql_isempty('scorm_scoes', 'organization', false, false),
410                                          array($scorm->id), 'sortorder, id', 'id, identifier, title')) {
411         if (count($orgs) <= 1) {
412             unset($orgs);
413             $orgs = array();
414             $org = new stdClass();
415             $org->identifier = '';
416             $orgs[] = $org;
417         }
418         $report .= html_writer::start_div('mod-scorm');
419         foreach ($orgs as $org) {
420             $conditions = array();
421             $currentorg = '';
422             if (!empty($org->identifier)) {
423                 $report .= html_writer::div($org->title, 'orgtitle');
424                 $currentorg = $org->identifier;
425                 $conditions['organization'] = $currentorg;
426             }
427             $report .= html_writer::start_tag('ul', array('id' => '0', 'class' => $liststyle));
428                 $conditions['scorm'] = $scorm->id;
429             if ($scoes = $DB->get_records('scorm_scoes', $conditions, "sortorder, id")) {
430                 // Drop keys so that we can access array sequentially.
431                 $scoes = array_values($scoes);
432                 $level = 0;
433                 $sublist = 1;
434                 $parents[$level] = '/';
435                 foreach ($scoes as $pos => $sco) {
436                     if ($parents[$level] != $sco->parent) {
437                         if ($level > 0 && $parents[$level - 1] == $sco->parent) {
438                             $report .= html_writer::end_tag('ul').html_writer::end_tag('li');
439                             $level--;
440                         } else {
441                             $i = $level;
442                             $closelist = '';
443                             while (($i > 0) && ($parents[$level] != $sco->parent)) {
444                                 $closelist .= html_writer::end_tag('ul').html_writer::end_tag('li');
445                                 $i--;
446                             }
447                             if (($i == 0) && ($sco->parent != $currentorg)) {
448                                 $report .= html_writer::start_tag('li');
449                                 $report .= html_writer::start_tag('ul', array('id' => $sublist, 'class' => $liststyle));
450                                 $level++;
451                             } else {
452                                 $report .= $closelist;
453                                 $level = $i;
454                             }
455                             $parents[$level] = $sco->parent;
456                         }
457                     }
458                     $report .= html_writer::start_tag('li');
459                     if (isset($scoes[$pos + 1])) {
460                         $nextsco = $scoes[$pos + 1];
461                     } else {
462                         $nextsco = false;
463                     }
464                     if (($nextsco !== false) && ($sco->parent != $nextsco->parent) &&
465                             (($level == 0) || (($level > 0) && ($nextsco->parent == $sco->identifier)))) {
466                         $sublist++;
467                     } else {
468                         $report .= $OUTPUT->spacer(array("height" => "12", "width" => "13"));
469                     }
471                     if ($sco->launch) {
472                         $score = '';
473                         $totaltime = '';
474                         if ($usertrack = scorm_get_tracks($sco->id, $user->id)) {
475                             if ($usertrack->status == '') {
476                                 $usertrack->status = 'notattempted';
477                             }
478                             $strstatus = get_string($usertrack->status, 'scorm');
479                             $report .= $OUTPUT->pix_icon($usertrack->status, $strstatus, 'scorm');
480                         } else {
481                             if ($sco->scormtype == 'sco') {
482                                 $report .= $OUTPUT->pix_icon('notattempted', get_string('notattempted', 'scorm'), 'scorm');
483                             } else {
484                                 $report .= $OUTPUT->pix_icon('asset', get_string('asset', 'scorm'), 'scorm');
485                             }
486                         }
487                         $report .= "&nbsp;$sco->title $score$totaltime".html_writer::end_tag('li');
488                         if ($usertrack !== false) {
489                             $sometoreport = true;
490                             $report .= html_writer::start_tag('li').html_writer::start_tag('ul', array('class' => $liststyle));
491                             foreach ($usertrack as $element => $value) {
492                                 if (substr($element, 0, 3) == 'cmi') {
493                                     $report .= html_writer::tag('li', $element.' => '.s($value));
494                                 }
495                             }
496                             $report .= html_writer::end_tag('ul').html_writer::end_tag('li');
497                         }
498                     } else {
499                         $report .= "&nbsp;$sco->title".html_writer::end_tag('li');
500                     }
501                 }
502                 for ($i = 0; $i < $level; $i++) {
503                     $report .= html_writer::end_tag('ul').html_writer::end_tag('li');
504                 }
505             }
506             $report .= html_writer::end_tag('ul').html_writer::empty_tag('br');
507         }
508         $report .= html_writer::end_div();
509     }
510     if ($sometoreport) {
511         if ($firstmodify < $now) {
512             $timeago = format_time($now - $firstmodify);
513             echo get_string('firstaccess', 'scorm').': '.userdate($firstmodify).' ('.$timeago.")".html_writer::empty_tag('br');
514         }
515         if ($lastmodify > 0) {
516             $timeago = format_time($now - $lastmodify);
517             echo get_string('lastaccess', 'scorm').': '.userdate($lastmodify).' ('.$timeago.")".html_writer::empty_tag('br');
518         }
519         echo get_string('report', 'scorm').":".html_writer::empty_tag('br');
520         echo $report;
521     } else {
522         print_string('noactivity', 'scorm');
523     }
525     return true;
528 /**
529  * Function to be run periodically according to the moodle Tasks API
530  * This function searches for things that need to be done, such
531  * as sending out mail, toggling flags etc ...
532  *
533  * @global stdClass
534  * @global object
535  * @return boolean
536  */
537 function scorm_cron_scheduled_task () {
538     global $CFG, $DB;
540     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
542     $sitetimezone = core_date::get_server_timezone();
543     // Now see if there are any scorm updates to be done.
545     if (!isset($CFG->scorm_updatetimelast)) {    // To catch the first time.
546         set_config('scorm_updatetimelast', 0);
547     }
549     $timenow = time();
550     $updatetime = usergetmidnight($timenow, $sitetimezone);
552     if ($CFG->scorm_updatetimelast < $updatetime and $timenow > $updatetime) {
554         set_config('scorm_updatetimelast', $timenow);
556         mtrace('Updating scorm packages which require daily update');// We are updating.
558         $scormsupdate = $DB->get_records('scorm', array('updatefreq' => SCORM_UPDATE_EVERYDAY));
559         foreach ($scormsupdate as $scormupdate) {
560             scorm_parse($scormupdate, true);
561         }
563         // Now clear out AICC session table with old session data.
564         $cfgscorm = get_config('scorm');
565         if (!empty($cfgscorm->allowaicchacp)) {
566             $expiretime = time() - ($cfgscorm->aicchacpkeepsessiondata * 24 * 60 * 60);
567             $DB->delete_records_select('scorm_aicc_session', 'timemodified < ?', array($expiretime));
568         }
569     }
571     return true;
574 /**
575  * Return grade for given user or all users.
576  *
577  * @global stdClass
578  * @global object
579  * @param int $scormid id of scorm
580  * @param int $userid optional user id, 0 means all users
581  * @return array array of grades, false if none
582  */
583 function scorm_get_user_grades($scorm, $userid=0) {
584     global $CFG, $DB;
585     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
587     $grades = array();
588     if (empty($userid)) {
589         $scousers = $DB->get_records_select('scorm_scoes_track', "scormid=? GROUP BY userid",
590                                             array($scorm->id), "", "userid,null");
591         if ($scousers) {
592             foreach ($scousers as $scouser) {
593                 $grades[$scouser->userid] = new stdClass();
594                 $grades[$scouser->userid]->id         = $scouser->userid;
595                 $grades[$scouser->userid]->userid     = $scouser->userid;
596                 $grades[$scouser->userid]->rawgrade = scorm_grade_user($scorm, $scouser->userid);
597             }
598         } else {
599             return false;
600         }
602     } else {
603         $preattempt = $DB->get_records_select('scorm_scoes_track', "scormid=? AND userid=? GROUP BY userid",
604                                                 array($scorm->id, $userid), "", "userid,null");
605         if (!$preattempt) {
606             return false; // No attempt yet.
607         }
608         $grades[$userid] = new stdClass();
609         $grades[$userid]->id         = $userid;
610         $grades[$userid]->userid     = $userid;
611         $grades[$userid]->rawgrade = scorm_grade_user($scorm, $userid);
612     }
614     return $grades;
617 /**
618  * Update grades in central gradebook
619  *
620  * @category grade
621  * @param object $scorm
622  * @param int $userid specific user only, 0 mean all
623  * @param bool $nullifnone
624  */
625 function scorm_update_grades($scorm, $userid=0, $nullifnone=true) {
626     global $CFG;
627     require_once($CFG->libdir.'/gradelib.php');
628     require_once($CFG->libdir.'/completionlib.php');
630     if ($grades = scorm_get_user_grades($scorm, $userid)) {
631         scorm_grade_item_update($scorm, $grades);
632         // Set complete.
633         scorm_set_completion($scorm, $userid, COMPLETION_COMPLETE, $grades);
634     } else if ($userid and $nullifnone) {
635         $grade = new stdClass();
636         $grade->userid   = $userid;
637         $grade->rawgrade = null;
638         scorm_grade_item_update($scorm, $grade);
639         // Set incomplete.
640         scorm_set_completion($scorm, $userid, COMPLETION_INCOMPLETE);
641     } else {
642         scorm_grade_item_update($scorm);
643     }
646 /**
647  * Update/create grade item for given scorm
648  *
649  * @category grade
650  * @uses GRADE_TYPE_VALUE
651  * @uses GRADE_TYPE_NONE
652  * @param object $scorm object with extra cmidnumber
653  * @param mixed $grades optional array/object of grade(s); 'reset' means reset grades in gradebook
654  * @return object grade_item
655  */
656 function scorm_grade_item_update($scorm, $grades=null) {
657     global $CFG, $DB;
658     require_once($CFG->dirroot.'/mod/scorm/locallib.php');
659     if (!function_exists('grade_update')) { // Workaround for buggy PHP versions.
660         require_once($CFG->libdir.'/gradelib.php');
661     }
663     $params = array('itemname' => $scorm->name);
664     if (isset($scorm->cmidnumber)) {
665         $params['idnumber'] = $scorm->cmidnumber;
666     }
668     if ($scorm->grademethod == GRADESCOES) {
669         $maxgrade = $DB->count_records_select('scorm_scoes', 'scorm = ? AND '.
670                                                 $DB->sql_isnotempty('scorm_scoes', 'launch', false, true), array($scorm->id));
671         if ($maxgrade) {
672             $params['gradetype'] = GRADE_TYPE_VALUE;
673             $params['grademax']  = $maxgrade;
674             $params['grademin']  = 0;
675         } else {
676             $params['gradetype'] = GRADE_TYPE_NONE;
677         }
678     } else {
679         $params['gradetype'] = GRADE_TYPE_VALUE;
680         $params['grademax']  = $scorm->maxgrade;
681         $params['grademin']  = 0;
682     }
684     if ($grades === 'reset') {
685         $params['reset'] = true;
686         $grades = null;
687     }
689     return grade_update('mod/scorm', $scorm->course, 'mod', 'scorm', $scorm->id, 0, $grades, $params);
692 /**
693  * Delete grade item for given scorm
694  *
695  * @category grade
696  * @param object $scorm object
697  * @return object grade_item
698  */
699 function scorm_grade_item_delete($scorm) {
700     global $CFG;
701     require_once($CFG->libdir.'/gradelib.php');
703     return grade_update('mod/scorm', $scorm->course, 'mod', 'scorm', $scorm->id, 0, null, array('deleted' => 1));
706 /**
707  * List the actions that correspond to a view of this module.
708  * This is used by the participation report.
709  *
710  * Note: This is not used by new logging system. Event with
711  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
712  *       be considered as view action.
713  *
714  * @return array
715  */
716 function scorm_get_view_actions() {
717     return array('pre-view', 'view', 'view all', 'report');
720 /**
721  * List the actions that correspond to a post of this module.
722  * This is used by the participation report.
723  *
724  * Note: This is not used by new logging system. Event with
725  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
726  *       will be considered as post action.
727  *
728  * @return array
729  */
730 function scorm_get_post_actions() {
731     return array();
734 /**
735  * @param object $scorm
736  * @return object $scorm
737  */
738 function scorm_option2text($scorm) {
739     $scormpopoupoptions = scorm_get_popup_options_array();
741     if (isset($scorm->popup)) {
742         if ($scorm->popup == 1) {
743             $optionlist = array();
744             foreach ($scormpopoupoptions as $name => $option) {
745                 if (isset($scorm->$name)) {
746                     $optionlist[] = $name.'='.$scorm->$name;
747                 } else {
748                     $optionlist[] = $name.'=0';
749                 }
750             }
751             $scorm->options = implode(',', $optionlist);
752         } else {
753             $scorm->options = '';
754         }
755     } else {
756         $scorm->popup = 0;
757         $scorm->options = '';
758     }
759     return $scorm;
762 /**
763  * Implementation of the function for printing the form elements that control
764  * whether the course reset functionality affects the scorm.
765  *
766  * @param object $mform form passed by reference
767  */
768 function scorm_reset_course_form_definition(&$mform) {
769     $mform->addElement('header', 'scormheader', get_string('modulenameplural', 'scorm'));
770     $mform->addElement('advcheckbox', 'reset_scorm', get_string('deleteallattempts', 'scorm'));
773 /**
774  * Course reset form defaults.
775  *
776  * @return array
777  */
778 function scorm_reset_course_form_defaults($course) {
779     return array('reset_scorm' => 1);
782 /**
783  * Removes all grades from gradebook
784  *
785  * @global stdClass
786  * @global object
787  * @param int $courseid
788  * @param string optional type
789  */
790 function scorm_reset_gradebook($courseid, $type='') {
791     global $CFG, $DB;
793     $sql = "SELECT s.*, cm.idnumber as cmidnumber, s.course as courseid
794               FROM {scorm} s, {course_modules} cm, {modules} m
795              WHERE m.name='scorm' AND m.id=cm.module AND cm.instance=s.id AND s.course=?";
797     if ($scorms = $DB->get_records_sql($sql, array($courseid))) {
798         foreach ($scorms as $scorm) {
799             scorm_grade_item_update($scorm, 'reset');
800         }
801     }
804 /**
805  * Actual implementation of the reset course functionality, delete all the
806  * scorm attempts for course $data->courseid.
807  *
808  * @global stdClass
809  * @global object
810  * @param object $data the data submitted from the reset course.
811  * @return array status array
812  */
813 function scorm_reset_userdata($data) {
814     global $CFG, $DB;
816     $componentstr = get_string('modulenameplural', 'scorm');
817     $status = array();
819     if (!empty($data->reset_scorm)) {
820         $scormssql = "SELECT s.id
821                          FROM {scorm} s
822                         WHERE s.course=?";
824         $DB->delete_records_select('scorm_scoes_track', "scormid IN ($scormssql)", array($data->courseid));
826         // Remove all grades from gradebook.
827         if (empty($data->reset_gradebook_grades)) {
828             scorm_reset_gradebook($data->courseid);
829         }
831         $status[] = array('component' => $componentstr, 'item' => get_string('deleteallattempts', 'scorm'), 'error' => false);
832     }
834     // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
835     // See MDL-9367.
836     shift_course_mod_dates('scorm', array('timeopen', 'timeclose'), $data->timeshift, $data->courseid);
838     return $status;
841 /**
842  * Returns all other caps used in module
843  *
844  * @return array
845  */
846 function scorm_get_extra_capabilities() {
847     return array('moodle/site:accessallgroups');
850 /**
851  * Lists all file areas current user may browse
852  *
853  * @param object $course
854  * @param object $cm
855  * @param object $context
856  * @return array
857  */
858 function scorm_get_file_areas($course, $cm, $context) {
859     $areas = array();
860     $areas['content'] = get_string('areacontent', 'scorm');
861     $areas['package'] = get_string('areapackage', 'scorm');
862     return $areas;
865 /**
866  * File browsing support for SCORM file areas
867  *
868  * @package  mod_scorm
869  * @category files
870  * @param file_browser $browser file browser instance
871  * @param array $areas file areas
872  * @param stdClass $course course object
873  * @param stdClass $cm course module object
874  * @param stdClass $context context object
875  * @param string $filearea file area
876  * @param int $itemid item ID
877  * @param string $filepath file path
878  * @param string $filename file name
879  * @return file_info instance or null if not found
880  */
881 function scorm_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
882     global $CFG;
884     if (!has_capability('moodle/course:managefiles', $context)) {
885         return null;
886     }
888     // No writing for now!
890     $fs = get_file_storage();
892     if ($filearea === 'content') {
894         $filepath = is_null($filepath) ? '/' : $filepath;
895         $filename = is_null($filename) ? '.' : $filename;
897         $urlbase = $CFG->wwwroot.'/pluginfile.php';
898         if (!$storedfile = $fs->get_file($context->id, 'mod_scorm', 'content', 0, $filepath, $filename)) {
899             if ($filepath === '/' and $filename === '.') {
900                 $storedfile = new virtual_root_file($context->id, 'mod_scorm', 'content', 0);
901             } else {
902                 // Not found.
903                 return null;
904             }
905         }
906         require_once("$CFG->dirroot/mod/scorm/locallib.php");
907         return new scorm_package_file_info($browser, $context, $storedfile, $urlbase, $areas[$filearea], true, true, false, false);
909     } else if ($filearea === 'package') {
910         $filepath = is_null($filepath) ? '/' : $filepath;
911         $filename = is_null($filename) ? '.' : $filename;
913         $urlbase = $CFG->wwwroot.'/pluginfile.php';
914         if (!$storedfile = $fs->get_file($context->id, 'mod_scorm', 'package', 0, $filepath, $filename)) {
915             if ($filepath === '/' and $filename === '.') {
916                 $storedfile = new virtual_root_file($context->id, 'mod_scorm', 'package', 0);
917             } else {
918                 // Not found.
919                 return null;
920             }
921         }
922         return new file_info_stored($browser, $context, $storedfile, $urlbase, $areas[$filearea], false, true, false, false);
923     }
925     // Scorm_intro handled in file_browser.
927     return false;
930 /**
931  * Serves scorm content, introduction images and packages. Implements needed access control ;-)
932  *
933  * @package  mod_scorm
934  * @category files
935  * @param stdClass $course course object
936  * @param stdClass $cm course module object
937  * @param stdClass $context context object
938  * @param string $filearea file area
939  * @param array $args extra arguments
940  * @param bool $forcedownload whether or not force download
941  * @param array $options additional options affecting the file serving
942  * @return bool false if file not found, does not return if found - just send the file
943  */
944 function scorm_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
945     global $CFG, $DB;
947     if ($context->contextlevel != CONTEXT_MODULE) {
948         return false;
949     }
951     require_login($course, true, $cm);
953     $canmanageactivity = has_capability('moodle/course:manageactivities', $context);
954     $lifetime = null;
956     // Check SCORM availability.
957     if (!$canmanageactivity) {
958         require_once($CFG->dirroot.'/mod/scorm/locallib.php');
960         $scorm = $DB->get_record('scorm', array('id' => $cm->instance), 'id, timeopen, timeclose', MUST_EXIST);
961         list($available, $warnings) = scorm_get_availability_status($scorm);
962         if (!$available) {
963             return false;
964         }
965     }
967     if ($filearea === 'content') {
968         $revision = (int)array_shift($args); // Prevents caching problems - ignored here.
969         $relativepath = implode('/', $args);
970         $fullpath = "/$context->id/mod_scorm/content/0/$relativepath";
971         // TODO: add any other access restrictions here if needed!
973     } else if ($filearea === 'package') {
974         // Check if the global setting for disabling package downloads is enabled.
975         $protectpackagedownloads = get_config('scorm', 'protectpackagedownloads');
976         if ($protectpackagedownloads and !$canmanageactivity) {
977             return false;
978         }
979         $revision = (int)array_shift($args); // Prevents caching problems - ignored here.
980         $relativepath = implode('/', $args);
981         $fullpath = "/$context->id/mod_scorm/package/0/$relativepath";
982         $lifetime = 0; // No caching here.
984     } else if ($filearea === 'imsmanifest') { // This isn't a real filearea, it's a url parameter for this type of package.
985         $revision = (int)array_shift($args); // Prevents caching problems - ignored here.
986         $relativepath = implode('/', $args);
988         // Get imsmanifest file.
989         $fs = get_file_storage();
990         $files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, '', false);
991         $file = reset($files);
993         // Check that the package file is an imsmanifest.xml file - if not then this method is not allowed.
994         $packagefilename = $file->get_filename();
995         if (strtolower($packagefilename) !== 'imsmanifest.xml') {
996             return false;
997         }
999         $file->send_relative_file($relativepath);
1000     } else {
1001         return false;
1002     }
1004     $fs = get_file_storage();
1005     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
1006         if ($filearea === 'content') { // Return file not found straight away to improve performance.
1007             send_header_404();
1008             die;
1009         }
1010         return false;
1011     }
1013     // Finally send the file.
1014     send_stored_file($file, $lifetime, 0, false, $options);
1017 /**
1018  * @uses FEATURE_GROUPS
1019  * @uses FEATURE_GROUPINGS
1020  * @uses FEATURE_MOD_INTRO
1021  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
1022  * @uses FEATURE_COMPLETION_HAS_RULES
1023  * @uses FEATURE_GRADE_HAS_GRADE
1024  * @uses FEATURE_GRADE_OUTCOMES
1025  * @param string $feature FEATURE_xx constant for requested feature
1026  * @return mixed True if module supports feature, false if not, null if doesn't know
1027  */
1028 function scorm_supports($feature) {
1029     switch($feature) {
1030         case FEATURE_GROUPS:                  return true;
1031         case FEATURE_GROUPINGS:               return true;
1032         case FEATURE_MOD_INTRO:               return true;
1033         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
1034         case FEATURE_COMPLETION_HAS_RULES:    return true;
1035         case FEATURE_GRADE_HAS_GRADE:         return true;
1036         case FEATURE_GRADE_OUTCOMES:          return true;
1037         case FEATURE_BACKUP_MOODLE2:          return true;
1038         case FEATURE_SHOW_DESCRIPTION:        return true;
1040         default: return null;
1041     }
1044 /**
1045  * Get the filename for a temp log file
1046  *
1047  * @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
1048  * @param integer $scoid - scoid of object this log entry is for
1049  * @return string The filename as an absolute path
1050  */
1051 function scorm_debug_log_filename($type, $scoid) {
1052     global $CFG, $USER;
1054     $logpath = $CFG->tempdir.'/scormlogs';
1055     $logfile = $logpath.'/'.$type.'debug_'.$USER->id.'_'.$scoid.'.log';
1056     return $logfile;
1059 /**
1060  * writes log output to a temp log file
1061  *
1062  * @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
1063  * @param string $text - text to be written to file.
1064  * @param integer $scoid - scoid of object this log entry is for.
1065  */
1066 function scorm_debug_log_write($type, $text, $scoid) {
1067     global $CFG;
1069     $debugenablelog = get_config('scorm', 'allowapidebug');
1070     if (!$debugenablelog || empty($text)) {
1071         return;
1072     }
1073     if (make_temp_directory('scormlogs/')) {
1074         $logfile = scorm_debug_log_filename($type, $scoid);
1075         @file_put_contents($logfile, date('Y/m/d H:i:s O')." DEBUG $text\r\n", FILE_APPEND);
1076         @chmod($logfile, $CFG->filepermissions);
1077     }
1080 /**
1081  * Remove debug log file
1082  *
1083  * @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
1084  * @param integer $scoid - scoid of object this log entry is for
1085  * @return boolean True if the file is successfully deleted, false otherwise
1086  */
1087 function scorm_debug_log_remove($type, $scoid) {
1089     $debugenablelog = get_config('scorm', 'allowapidebug');
1090     $logfile = scorm_debug_log_filename($type, $scoid);
1091     if (!$debugenablelog || !file_exists($logfile)) {
1092         return false;
1093     }
1095     return @unlink($logfile);
1098 /**
1099  * writes overview info for course_overview block - displays upcoming scorm objects that have a due date
1100  *
1101  * @deprecated since 3.3
1102  * @todo The final deprecation of this function will take place in Moodle 3.7 - see MDL-57487.
1103  * @param object $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
1104  * @param array $htmlarray
1105  * @return mixed
1106  */
1107 function scorm_print_overview($courses, &$htmlarray) {
1108     global $USER, $CFG;
1110     debugging('The function scorm_print_overview() is now deprecated.', DEBUG_DEVELOPER);
1112     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1113         return array();
1114     }
1116     if (!$scorms = get_all_instances_in_courses('scorm', $courses)) {
1117         return;
1118     }
1120     $strscorm   = get_string('modulename', 'scorm');
1121     $strduedate = get_string('duedate', 'scorm');
1123     foreach ($scorms as $scorm) {
1124         $time = time();
1125         $showattemptstatus = false;
1126         if ($scorm->timeopen) {
1127             $isopen = ($scorm->timeopen <= $time && $time <= $scorm->timeclose);
1128         }
1129         if ($scorm->displayattemptstatus == SCORM_DISPLAY_ATTEMPTSTATUS_ALL ||
1130                 $scorm->displayattemptstatus == SCORM_DISPLAY_ATTEMPTSTATUS_MY) {
1131             $showattemptstatus = true;
1132         }
1133         if ($showattemptstatus || !empty($isopen) || !empty($scorm->timeclose)) {
1134             $str = html_writer::start_div('scorm overview').html_writer::div($strscorm. ': '.
1135                     html_writer::link($CFG->wwwroot.'/mod/scorm/view.php?id='.$scorm->coursemodule, $scorm->name,
1136                                         array('title' => $strscorm, 'class' => $scorm->visible ? '' : 'dimmed')), 'name');
1137             if ($scorm->timeclose) {
1138                 $str .= html_writer::div($strduedate.': '.userdate($scorm->timeclose), 'info');
1139             }
1140             if ($showattemptstatus) {
1141                 require_once($CFG->dirroot.'/mod/scorm/locallib.php');
1142                 $str .= html_writer::div(scorm_get_attempt_status($USER, $scorm), 'details');
1143             }
1144             $str .= html_writer::end_div();
1145             if (empty($htmlarray[$scorm->course]['scorm'])) {
1146                 $htmlarray[$scorm->course]['scorm'] = $str;
1147             } else {
1148                 $htmlarray[$scorm->course]['scorm'] .= $str;
1149             }
1150         }
1151     }
1154 /**
1155  * Return a list of page types
1156  * @param string $pagetype current page type
1157  * @param stdClass $parentcontext Block's parent context
1158  * @param stdClass $currentcontext Current context of block
1159  */
1160 function scorm_page_type_list($pagetype, $parentcontext, $currentcontext) {
1161     $modulepagetype = array('mod-scorm-*' => get_string('page-mod-scorm-x', 'scorm'));
1162     return $modulepagetype;
1165 /**
1166  * Returns the SCORM version used.
1167  * @param string $scormversion comes from $scorm->version
1168  * @param string $version one of the defined vars SCORM_12, SCORM_13, SCORM_AICC (or empty)
1169  * @return Scorm version.
1170  */
1171 function scorm_version_check($scormversion, $version='') {
1172     $scormversion = trim(strtolower($scormversion));
1173     if (empty($version) || $version == SCORM_12) {
1174         if ($scormversion == 'scorm_12' || $scormversion == 'scorm_1.2') {
1175             return SCORM_12;
1176         }
1177         if (!empty($version)) {
1178             return false;
1179         }
1180     }
1181     if (empty($version) || $version == SCORM_13) {
1182         if ($scormversion == 'scorm_13' || $scormversion == 'scorm_1.3') {
1183             return SCORM_13;
1184         }
1185         if (!empty($version)) {
1186             return false;
1187         }
1188     }
1189     if (empty($version) || $version == SCORM_AICC) {
1190         if (strpos($scormversion, 'aicc')) {
1191             return SCORM_AICC;
1192         }
1193         if (!empty($version)) {
1194             return false;
1195         }
1196     }
1197     return false;
1200 /**
1201  * Obtains the automatic completion state for this scorm based on any conditions
1202  * in scorm settings.
1203  *
1204  * @param object $course Course
1205  * @param object $cm Course-module
1206  * @param int $userid User ID
1207  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
1208  * @return bool True if completed, false if not. (If no conditions, then return
1209  *   value depends on comparison type)
1210  */
1211 function scorm_get_completion_state($course, $cm, $userid, $type) {
1212     global $DB;
1214     $result = $type;
1216     // Get scorm.
1217     if (!$scorm = $DB->get_record('scorm', array('id' => $cm->instance))) {
1218         print_error('cannotfindscorm');
1219     }
1220     // Only check for existence of tracks and return false if completionstatusrequired or completionscorerequired
1221     // this means that if only view is required we don't end up with a false state.
1222     if ($scorm->completionstatusrequired !== null ||
1223         $scorm->completionscorerequired !== null) {
1224         // Get user's tracks data.
1225         $tracks = $DB->get_records_sql(
1226             "
1227             SELECT
1228                 id,
1229                 scoid,
1230                 element,
1231                 value
1232             FROM
1233                 {scorm_scoes_track}
1234             WHERE
1235                 scormid = ?
1236             AND userid = ?
1237             AND element IN
1238             (
1239                 'cmi.core.lesson_status',
1240                 'cmi.completion_status',
1241                 'cmi.success_status',
1242                 'cmi.core.score.raw',
1243                 'cmi.score.raw'
1244             )
1245             ",
1246             array($scorm->id, $userid)
1247         );
1249         if (!$tracks) {
1250             return completion_info::aggregate_completion_states($type, $result, false);
1251         }
1252     }
1254     // Check for status.
1255     if ($scorm->completionstatusrequired !== null) {
1257         // Get status.
1258         $statuses = array_flip(scorm_status_options());
1259         $nstatus = 0;
1260         // Check any track for these values.
1261         $scostatus = array();
1262         foreach ($tracks as $track) {
1263             if (!in_array($track->element, array('cmi.core.lesson_status', 'cmi.completion_status', 'cmi.success_status'))) {
1264                 continue;
1265             }
1266             if (array_key_exists($track->value, $statuses)) {
1267                 $scostatus[$track->scoid] = true;
1268                 $nstatus |= $statuses[$track->value];
1269             }
1270         }
1272         if (!empty($scorm->completionstatusallscos)) {
1273             // Iterate over all scos and make sure each has a lesson_status.
1274             $scos = $DB->get_records('scorm_scoes', array('scorm' => $scorm->id, 'scormtype' => 'sco'));
1275             foreach ($scos as $sco) {
1276                 if (empty($scostatus[$sco->id])) {
1277                     return completion_info::aggregate_completion_states($type, $result, false);
1278                 }
1279             }
1280             return completion_info::aggregate_completion_states($type, $result, true);
1281         } else if ($scorm->completionstatusrequired & $nstatus) {
1282             return completion_info::aggregate_completion_states($type, $result, true);
1283         } else {
1284             return completion_info::aggregate_completion_states($type, $result, false);
1285         }
1286     }
1288     // Check for score.
1289     if ($scorm->completionscorerequired !== null) {
1290         $maxscore = -1;
1292         foreach ($tracks as $track) {
1293             if (!in_array($track->element, array('cmi.core.score.raw', 'cmi.score.raw'))) {
1294                 continue;
1295             }
1297             if (strlen($track->value) && floatval($track->value) >= $maxscore) {
1298                 $maxscore = floatval($track->value);
1299             }
1300         }
1302         if ($scorm->completionscorerequired <= $maxscore) {
1303             return completion_info::aggregate_completion_states($type, $result, true);
1304         } else {
1305             return completion_info::aggregate_completion_states($type, $result, false);
1306         }
1307     }
1309     return $result;
1312 /**
1313  * Register the ability to handle drag and drop file uploads
1314  * @return array containing details of the files / types the mod can handle
1315  */
1316 function scorm_dndupload_register() {
1317     return array('files' => array(
1318         array('extension' => 'zip', 'message' => get_string('dnduploadscorm', 'scorm'))
1319     ));
1322 /**
1323  * Handle a file that has been uploaded
1324  * @param object $uploadinfo details of the file / content that has been uploaded
1325  * @return int instance id of the newly created mod
1326  */
1327 function scorm_dndupload_handle($uploadinfo) {
1329     $context = context_module::instance($uploadinfo->coursemodule);
1330     file_save_draft_area_files($uploadinfo->draftitemid, $context->id, 'mod_scorm', 'package', 0);
1331     $fs = get_file_storage();
1332     $files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, 'sortorder, itemid, filepath, filename', false);
1333     $file = reset($files);
1335     // Validate the file, make sure it's a valid SCORM package!
1336     $errors = scorm_validate_package($file);
1337     if (!empty($errors)) {
1338         return false;
1339     }
1340     // Create a default scorm object to pass to scorm_add_instance()!
1341     $scorm = get_config('scorm');
1342     $scorm->course = $uploadinfo->course->id;
1343     $scorm->coursemodule = $uploadinfo->coursemodule;
1344     $scorm->cmidnumber = '';
1345     $scorm->name = $uploadinfo->displayname;
1346     $scorm->scormtype = SCORM_TYPE_LOCAL;
1347     $scorm->reference = $file->get_filename();
1348     $scorm->intro = '';
1349     $scorm->width = $scorm->framewidth;
1350     $scorm->height = $scorm->frameheight;
1352     return scorm_add_instance($scorm, null);
1355 /**
1356  * Sets activity completion state
1357  *
1358  * @param object $scorm object
1359  * @param int $userid User ID
1360  * @param int $completionstate Completion state
1361  * @param array $grades grades array of users with grades - used when $userid = 0
1362  */
1363 function scorm_set_completion($scorm, $userid, $completionstate = COMPLETION_COMPLETE, $grades = array()) {
1364     $course = new stdClass();
1365     $course->id = $scorm->course;
1366     $completion = new completion_info($course);
1368     // Check if completion is enabled site-wide, or for the course.
1369     if (!$completion->is_enabled()) {
1370         return;
1371     }
1373     $cm = get_coursemodule_from_instance('scorm', $scorm->id, $scorm->course);
1374     if (empty($cm) || !$completion->is_enabled($cm)) {
1375             return;
1376     }
1378     if (empty($userid)) { // We need to get all the relevant users from $grades param.
1379         foreach ($grades as $grade) {
1380             $completion->update_state($cm, $completionstate, $grade->userid);
1381         }
1382     } else {
1383         $completion->update_state($cm, $completionstate, $userid);
1384     }
1387 /**
1388  * Check that a Zip file contains a valid SCORM package
1389  *
1390  * @param $file stored_file a Zip file.
1391  * @return array empty if no issue is found. Array of error message otherwise
1392  */
1393 function scorm_validate_package($file) {
1394     $packer = get_file_packer('application/zip');
1395     $errors = array();
1396     if ($file->is_external_file()) { // Get zip file so we can check it is correct.
1397         $file->import_external_file_contents();
1398     }
1399     $filelist = $file->list_files($packer);
1401     if (!is_array($filelist)) {
1402         $errors['packagefile'] = get_string('badarchive', 'scorm');
1403     } else {
1404         $aiccfound = false;
1405         $badmanifestpresent = false;
1406         foreach ($filelist as $info) {
1407             if ($info->pathname == 'imsmanifest.xml') {
1408                 return array();
1409             } else if (strpos($info->pathname, 'imsmanifest.xml') !== false) {
1410                 // This package has an imsmanifest file inside a folder of the package.
1411                 $badmanifestpresent = true;
1412             }
1413             if (preg_match('/\.cst$/', $info->pathname)) {
1414                 return array();
1415             }
1416         }
1417         if (!$aiccfound) {
1418             if ($badmanifestpresent) {
1419                 $errors['packagefile'] = get_string('badimsmanifestlocation', 'scorm');
1420             } else {
1421                 $errors['packagefile'] = get_string('nomanifest', 'scorm');
1422             }
1423         }
1424     }
1425     return $errors;
1428 /**
1429  * Check and set the correct mode and attempt when entering a SCORM package.
1430  *
1431  * @param object $scorm object
1432  * @param string $newattempt should a new attempt be generated here.
1433  * @param int $attempt the attempt number this is for.
1434  * @param int $userid the userid of the user.
1435  * @param string $mode the current mode that has been selected.
1436  */
1437 function scorm_check_mode($scorm, &$newattempt, &$attempt, $userid, &$mode) {
1438     global $DB;
1440     if (($mode == 'browse')) {
1441         if ($scorm->hidebrowse == 1) {
1442             // Prevent Browse mode if hidebrowse is set.
1443             $mode = 'normal';
1444         } else {
1445             // We don't need to check attempts as browse mode is set.
1446             return;
1447         }
1448     }
1449     // Check if the scorm module is incomplete (used to validate user request to start a new attempt).
1450     $incomplete = true;
1451     $sql = "SELECT sc.id, t.value
1452               FROM {scorm_scoes} sc
1453          LEFT JOIN {scorm_scoes_track} t ON sc.scorm = t.scormid AND sc.id = t.scoid
1454                    AND t.element = 'cmi.core.lesson_status' AND t.userid = ? AND t.attempt = ?
1455              WHERE sc.scormtype = 'sco' AND sc.scorm = ?";
1456     $tracks = $DB->get_recordset_sql($sql, array($userid, $attempt, $scorm->id));
1458     foreach ($tracks as $track) {
1459         if (($track->value == 'completed') || ($track->value == 'passed') || ($track->value == 'failed')) {
1460             $incomplete = false;
1461         } else {
1462             $incomplete = true;
1463             break; // Found an incomplete sco, so the result as a whole is incomplete.
1464         }
1465     }
1466     $tracks->close();
1468     // Validate user request to start a new attempt.
1469     if ($incomplete === true) {
1470         // The option to start a new attempt should never have been presented. Force false.
1471         $newattempt = 'off';
1472     } else if (!empty($scorm->forcenewattempt)) {
1473         // A new attempt should be forced for already completed attempts.
1474         $newattempt = 'on';
1475     }
1477     if (($newattempt == 'on') && (($attempt < $scorm->maxattempt) || ($scorm->maxattempt == 0))) {
1478         $attempt++;
1479         $mode = 'normal';
1480     } else { // Check if review mode should be set.
1481         if ($incomplete === true) {
1482             $mode = 'normal';
1483         } else {
1484             $mode = 'review';
1485         }
1486     }
1489 /**
1490  * Trigger the course_module_viewed event.
1491  *
1492  * @param  stdClass $scorm        scorm object
1493  * @param  stdClass $course     course object
1494  * @param  stdClass $cm         course module object
1495  * @param  stdClass $context    context object
1496  * @since Moodle 3.0
1497  */
1498 function scorm_view($scorm, $course, $cm, $context) {
1500     // Trigger course_module_viewed event.
1501     $params = array(
1502         'context' => $context,
1503         'objectid' => $scorm->id
1504     );
1506     $event = \mod_scorm\event\course_module_viewed::create($params);
1507     $event->add_record_snapshot('course_modules', $cm);
1508     $event->add_record_snapshot('course', $course);
1509     $event->add_record_snapshot('scorm', $scorm);
1510     $event->trigger();
1513 /**
1514  * Check if the module has any update that affects the current user since a given time.
1515  *
1516  * @param  cm_info $cm course module data
1517  * @param  int $from the time to check updates from
1518  * @param  array $filter  if we need to check only specific updates
1519  * @return stdClass an object with the different type of areas indicating if they were updated or not
1520  * @since Moodle 3.2
1521  */
1522 function scorm_check_updates_since(cm_info $cm, $from, $filter = array()) {
1523     global $DB, $USER, $CFG;
1524     require_once($CFG->dirroot . '/mod/scorm/locallib.php');
1526     $scorm = $DB->get_record($cm->modname, array('id' => $cm->instance), '*', MUST_EXIST);
1527     $updates = new stdClass();
1528     list($available, $warnings) = scorm_get_availability_status($scorm, true, $cm->context);
1529     if (!$available) {
1530         return $updates;
1531     }
1532     $updates = course_check_module_updates_since($cm, $from, array('package'), $filter);
1534     $updates->tracks = (object) array('updated' => false);
1535     $select = 'scormid = ? AND userid = ? AND timemodified > ?';
1536     $params = array($scorm->id, $USER->id, $from);
1537     $tracks = $DB->get_records_select('scorm_scoes_track', $select, $params, '', 'id');
1538     if (!empty($tracks)) {
1539         $updates->tracks->updated = true;
1540         $updates->tracks->itemids = array_keys($tracks);
1541     }
1543     // Now, teachers should see other students updates.
1544     if (has_capability('mod/scorm:viewreport', $cm->context)) {
1545         $select = 'scormid = ? AND timemodified > ?';
1546         $params = array($scorm->id, $from);
1548         if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
1549             $groupusers = array_keys(groups_get_activity_shared_group_members($cm));
1550             if (empty($groupusers)) {
1551                 return $updates;
1552             }
1553             list($insql, $inparams) = $DB->get_in_or_equal($groupusers);
1554             $select .= ' AND userid ' . $insql;
1555             $params = array_merge($params, $inparams);
1556         }
1558         $updates->usertracks = (object) array('updated' => false);
1559         $tracks = $DB->get_records_select('scorm_scoes_track', $select, $params, '', 'id');
1560         if (!empty($tracks)) {
1561             $updates->usertracks->updated = true;
1562             $updates->usertracks->itemids = array_keys($tracks);
1563         }
1564     }
1565     return $updates;
1568 /**
1569  * Get icon mapping for font-awesome.
1570  */
1571 function mod_scorm_get_fontawesome_icon_map() {
1572     return [
1573         'mod_scorm:assetc' => 'fa-file-archive-o',
1574         'mod_scorm:asset' => 'fa-file-archive-o',
1575         'mod_scorm:browsed' => 'fa-book',
1576         'mod_scorm:completed' => 'fa-check-square-o',
1577         'mod_scorm:failed' => 'fa-times',
1578         'mod_scorm:incomplete' => 'fa-pencil-square-o',
1579         'mod_scorm:minus' => 'fa-minus',
1580         'mod_scorm:notattempted' => 'fa-square-o',
1581         'mod_scorm:passed' => 'fa-check',
1582         'mod_scorm:plus' => 'fa-plus',
1583         'mod_scorm:popdown' => 'fa-window-close-o',
1584         'mod_scorm:popup' => 'fa-window-restore',
1585         'mod_scorm:suspend' => 'fa-pause',
1586         'mod_scorm:wait' => 'fa-clock-o',
1587     ];
1590 /**
1591  * This standard function will check all instances of this module
1592  * and make sure there are up-to-date events created for each of them.
1593  * If courseid = 0, then every scorm event in the site is checked, else
1594  * only scorm events belonging to the course specified are checked.
1595  *
1596  * @param int $courseid
1597  * @param int|stdClass $instance scorm module instance or ID.
1598  * @param int|stdClass $cm Course module object or ID.
1599  * @return bool
1600  */
1601 function scorm_refresh_events($courseid = 0, $instance = null, $cm = null) {
1602     global $CFG, $DB;
1604     require_once($CFG->dirroot . '/mod/scorm/locallib.php');
1606     // If we have instance information then we can just update the one event instead of updating all events.
1607     if (isset($instance)) {
1608         if (!is_object($instance)) {
1609             $instance = $DB->get_record('scorm', array('id' => $instance), '*', MUST_EXIST);
1610         }
1611         if (isset($cm)) {
1612             if (!is_object($cm)) {
1613                 $cm = (object)array('id' => $cm);
1614             }
1615         } else {
1616             $cm = get_coursemodule_from_instance('scorm', $instance->id);
1617         }
1618         scorm_update_calendar($instance, $cm->id);
1619         return true;
1620     }
1622     if ($courseid) {
1623         // Make sure that the course id is numeric.
1624         if (!is_numeric($courseid)) {
1625             return false;
1626         }
1627         if (!$scorms = $DB->get_records('scorm', array('course' => $courseid))) {
1628             return false;
1629         }
1630     } else {
1631         if (!$scorms = $DB->get_records('scorm')) {
1632             return false;
1633         }
1634     }
1636     foreach ($scorms as $scorm) {
1637         $cm = get_coursemodule_from_instance('scorm', $scorm->id);
1638         scorm_update_calendar($scorm, $cm->id);
1639     }
1641     return true;
1644 /**
1645  * This function receives a calendar event and returns the action associated with it, or null if there is none.
1646  *
1647  * This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
1648  * is not displayed on the block.
1649  *
1650  * @param calendar_event $event
1651  * @param \core_calendar\action_factory $factory
1652  * @return \core_calendar\local\event\entities\action_interface|null
1653  */
1654 function mod_scorm_core_calendar_provide_event_action(calendar_event $event,
1655                                                       \core_calendar\action_factory $factory) {
1656     global $CFG;
1658     require_once($CFG->dirroot . '/mod/scorm/locallib.php');
1660     $cm = get_fast_modinfo($event->courseid)->instances['scorm'][$event->instance];
1662     if (has_capability('mod/scorm:viewreport', $cm->context)) {
1663         // Teachers do not need to be reminded to complete a scorm.
1664         return null;
1665     }
1667     if (!empty($cm->customdata['timeclose']) && $cm->customdata['timeclose'] < time()) {
1668         // The scorm has closed so the user can no longer submit anything.
1669         return null;
1670     }
1672     // Restore scorm object from cached values in $cm, we only need id, timeclose and timeopen.
1673     $customdata = $cm->customdata ?: [];
1674     $customdata['id'] = $cm->instance;
1675     $scorm = (object)($customdata + ['timeclose' => 0, 'timeopen' => 0]);
1677     // Check that the SCORM activity is open.
1678     list($actionable, $warnings) = scorm_get_availability_status($scorm);
1680     return $factory->create_instance(
1681         get_string('enter', 'scorm'),
1682         new \moodle_url('/mod/scorm/view.php', array('id' => $cm->id)),
1683         1,
1684         $actionable
1685     );
1688 /**
1689  * Add a get_coursemodule_info function in case any SCORM type wants to add 'extra' information
1690  * for the course (see resource).
1691  *
1692  * Given a course_module object, this function returns any "extra" information that may be needed
1693  * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.
1694  *
1695  * @param stdClass $coursemodule The coursemodule object (record).
1696  * @return cached_cm_info An object on information that the courses
1697  *                        will know about (most noticeably, an icon).
1698  */
1699 function scorm_get_coursemodule_info($coursemodule) {
1700     global $DB;
1702     $dbparams = ['id' => $coursemodule->instance];
1703     $fields = 'id, name, intro, introformat, completionstatusrequired, completionscorerequired, completionstatusallscos, '.
1704         'timeopen, timeclose';
1705     if (!$scorm = $DB->get_record('scorm', $dbparams, $fields)) {
1706         return false;
1707     }
1709     $result = new cached_cm_info();
1710     $result->name = $scorm->name;
1712     if ($coursemodule->showdescription) {
1713         // Convert intro to html. Do not filter cached version, filters run at display time.
1714         $result->content = format_module_intro('scorm', $scorm, $coursemodule->id, false);
1715     }
1717     // Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.
1718     if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {
1719         $result->customdata['customcompletionrules']['completionstatusrequired'] = $scorm->completionstatusrequired;
1720         $result->customdata['customcompletionrules']['completionscorerequired'] = $scorm->completionscorerequired;
1721         $result->customdata['customcompletionrules']['completionstatusallscos'] = $scorm->completionstatusallscos;
1722     }
1723     // Populate some other values that can be used in calendar or on dashboard.
1724     if ($scorm->timeopen) {
1725         $result->customdata['timeopen'] = $scorm->timeopen;
1726     }
1727     if ($scorm->timeclose) {
1728         $result->customdata['timeclose'] = $scorm->timeclose;
1729     }
1731     return $result;
1734 /**
1735  * Callback which returns human-readable strings describing the active completion custom rules for the module instance.
1736  *
1737  * @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']
1738  * @return array $descriptions the array of descriptions for the custom rules.
1739  */
1740 function mod_scorm_get_completion_active_rule_descriptions($cm) {
1741     // Values will be present in cm_info, and we assume these are up to date.
1742     if (empty($cm->customdata['customcompletionrules'])
1743         || $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {
1744         return [];
1745     }
1747     $descriptions = [];
1748     foreach ($cm->customdata['customcompletionrules'] as $key => $val) {
1749         switch ($key) {
1750             case 'completionstatusrequired':
1751                 if (is_null($val)) {
1752                     continue;
1753                 }
1754                 // Determine the selected statuses using a bitwise operation.
1755                 $cvalues = array();
1756                 foreach (scorm_status_options(true) as $bit => $string) {
1757                     if (($val & $bit) == $bit) {
1758                         $cvalues[] = $string;
1759                     }
1760                 }
1761                 $statusstring = implode(', ', $cvalues);
1762                 $descriptions[] = get_string('completionstatusrequireddesc', 'scorm', $statusstring);
1763                 break;
1764             case 'completionscorerequired':
1765                 if (is_null($val)) {
1766                     continue;
1767                 }
1768                 $descriptions[] = get_string('completionscorerequireddesc', 'scorm', $val);
1769                 break;
1770             case 'completionstatusallscos':
1771                 if (empty($val)) {
1772                     continue;
1773                 }
1774                 $descriptions[] = get_string('completionstatusallscos', 'scorm');
1775                 break;
1776             default:
1777                 break;
1778         }
1779     }
1780     return $descriptions;