ILB
/
moodle
9
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
47 MiB
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
moodle/mod/scorm/lib.php

1938 lines
68 KiB
Raw Permalink Normal View History

Migrando Repositório
2 years ago
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* @package mod_scorm
* @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/** SCORM_TYPE_LOCAL = local */
define('SCORM_TYPE_LOCAL', 'local');
/** SCORM_TYPE_LOCALSYNC = localsync */
define('SCORM_TYPE_LOCALSYNC', 'localsync');
/** SCORM_TYPE_EXTERNAL = external */
define('SCORM_TYPE_EXTERNAL', 'external');
/** SCORM_TYPE_AICCURL = external AICC url */
define('SCORM_TYPE_AICCURL', 'aiccurl');
define('SCORM_TOC_SIDE', 0);
define('SCORM_TOC_HIDDEN', 1);
define('SCORM_TOC_POPUP', 2);
define('SCORM_TOC_DISABLED', 3);
// Used to show/hide navigation buttons and set their position.
define('SCORM_NAV_DISABLED', 0);
define('SCORM_NAV_UNDER_CONTENT', 1);
define('SCORM_NAV_FLOATING', 2);
// Used to check what SCORM version is being used.
define('SCORM_12', 1);
define('SCORM_13', 2);
define('SCORM_AICC', 3);
// List of possible attemptstatusdisplay options.
define('SCORM_DISPLAY_ATTEMPTSTATUS_NO', 0);
define('SCORM_DISPLAY_ATTEMPTSTATUS_ALL', 1);
define('SCORM_DISPLAY_ATTEMPTSTATUS_MY', 2);
define('SCORM_DISPLAY_ATTEMPTSTATUS_ENTRY', 3);
define('SCORM_EVENT_TYPE_OPEN', 'open');
define('SCORM_EVENT_TYPE_CLOSE', 'close');
/**
* Return an array of status options
*
* Optionally with translated strings
*
* @param bool $with_strings (optional)
* @return array
*/
function scorm_status_options($withstrings = false) {
// Id's are important as they are bits.
$options = array(
2 => 'passed',
4 => 'completed'
);
if ($withstrings) {
foreach ($options as $key => $value) {
$options[$key] = get_string('completionstatus_'.$value, 'scorm');
}
}
return $options;
}
/**
* Given an object containing all the necessary data,
* (defined by the form in mod_form.php) this function
* will create a new instance and return the id number
* of the new instance.
*
* @global stdClass
* @global object
* @uses CONTEXT_MODULE
* @uses SCORM_TYPE_LOCAL
* @uses SCORM_TYPE_LOCALSYNC
* @uses SCORM_TYPE_EXTERNAL
* @param object $scorm Form data
* @param object $mform
* @return int new instance id
*/
function scorm_add_instance($scorm, $mform=null) {
global $CFG, $DB;
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
if (empty($scorm->timeopen)) {
$scorm->timeopen = 0;
}
if (empty($scorm->timeclose)) {
$scorm->timeclose = 0;
}
if (empty($scorm->completionstatusallscos)) {
$scorm->completionstatusallscos = 0;
}
$cmid = $scorm->coursemodule;
$cmidnumber = $scorm->cmidnumber;
$courseid = $scorm->course;
$context = context_module::instance($cmid);
$scorm = scorm_option2text($scorm);
$scorm->width = (int)str_replace('%', '', $scorm->width);
$scorm->height = (int)str_replace('%', '', $scorm->height);
if (!isset($scorm->whatgrade)) {
$scorm->whatgrade = 0;
}
$id = $DB->insert_record('scorm', $scorm);
// Update course module record - from now on this instance properly exists and all function may be used.
$DB->set_field('course_modules', 'instance', $id, array('id' => $cmid));
// Reload scorm instance.
$record = $DB->get_record('scorm', array('id' => $id));
// Store the package and verify.
if ($record->scormtype === SCORM_TYPE_LOCAL) {
if (!empty($scorm->packagefile)) {
$fs = get_file_storage();
$fs->delete_area_files($context->id, 'mod_scorm', 'package');
file_save_draft_area_files($scorm->packagefile, $context->id, 'mod_scorm', 'package',
0, array('subdirs' => 0, 'maxfiles' => 1));
// Get filename of zip that was uploaded.
$files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, '', false);
$file = reset($files);
$filename = $file->get_filename();
if ($filename !== false) {
$record->reference = $filename;
}
}
} else if ($record->scormtype === SCORM_TYPE_LOCALSYNC) {
$record->reference = $scorm->packageurl;
} else if ($record->scormtype === SCORM_TYPE_EXTERNAL) {
$record->reference = $scorm->packageurl;
} else if ($record->scormtype === SCORM_TYPE_AICCURL) {
$record->reference = $scorm->packageurl;
$record->hidetoc = SCORM_TOC_DISABLED; // TOC is useless for direct AICCURL so disable it.
} else {
return false;
}
// Save reference.
$DB->update_record('scorm', $record);
// Extra fields required in grade related functions.
$record->course = $courseid;
$record->cmidnumber = $cmidnumber;
$record->cmid = $cmid;
scorm_parse($record, true);
scorm_grade_item_update($record);
scorm_update_calendar($record, $cmid);
if (!empty($scorm->completionexpected)) {
\core_completion\api::update_completion_date_event($cmid, 'scorm', $record, $scorm->completionexpected);
}
return $record->id;
}
/**
* Given an object containing all the necessary data,
* (defined by the form in mod_form.php) this function
* will update an existing instance with new data.
*
* @global stdClass
* @global object
* @uses CONTEXT_MODULE
* @uses SCORM_TYPE_LOCAL
* @uses SCORM_TYPE_LOCALSYNC
* @uses SCORM_TYPE_EXTERNAL
* @param object $scorm Form data
* @param object $mform
* @return bool
*/
function scorm_update_instance($scorm, $mform=null) {
global $CFG, $DB;
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
if (empty($scorm->timeopen)) {
$scorm->timeopen = 0;
}
if (empty($scorm->timeclose)) {
$scorm->timeclose = 0;
}
if (empty($scorm->completionstatusallscos)) {
$scorm->completionstatusallscos = 0;
}
$cmid = $scorm->coursemodule;
$cmidnumber = $scorm->cmidnumber;
$courseid = $scorm->course;
$scorm->id = $scorm->instance;
$context = context_module::instance($cmid);
if ($scorm->scormtype === SCORM_TYPE_LOCAL) {
if (!empty($scorm->packagefile)) {
$fs = get_file_storage();
$fs->delete_area_files($context->id, 'mod_scorm', 'package');
file_save_draft_area_files($scorm->packagefile, $context->id, 'mod_scorm', 'package',
0, array('subdirs' => 0, 'maxfiles' => 1));
// Get filename of zip that was uploaded.
$files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, '', false);
$file = reset($files);
$filename = $file->get_filename();
if ($filename !== false) {
$scorm->reference = $filename;
}
}
} else if ($scorm->scormtype === SCORM_TYPE_LOCALSYNC) {
$scorm->reference = $scorm->packageurl;
} else if ($scorm->scormtype === SCORM_TYPE_EXTERNAL) {
$scorm->reference = $scorm->packageurl;
} else if ($scorm->scormtype === SCORM_TYPE_AICCURL) {
$scorm->reference = $scorm->packageurl;
$scorm->hidetoc = SCORM_TOC_DISABLED; // TOC is useless for direct AICCURL so disable it.
} else {
return false;
}
$scorm = scorm_option2text($scorm);
$scorm->width = (int)str_replace('%', '', $scorm->width);
$scorm->height = (int)str_replace('%', '', $scorm->height);
$scorm->timemodified = time();
if (!isset($scorm->whatgrade)) {
$scorm->whatgrade = 0;
}
$DB->update_record('scorm', $scorm);
// We need to find this out before we blow away the form data.
$completionexpected = (!empty($scorm->completionexpected)) ? $scorm->completionexpected : null;
$scorm = $DB->get_record('scorm', array('id' => $scorm->id));
// Extra fields required in grade related functions.
$scorm->course = $courseid;
$scorm->idnumber = $cmidnumber;
$scorm->cmid = $cmid;
scorm_parse($scorm, (bool)$scorm->updatefreq);
scorm_grade_item_update($scorm);
scorm_update_grades($scorm);
scorm_update_calendar($scorm, $cmid);
\core_completion\api::update_completion_date_event($cmid, 'scorm', $scorm, $completionexpected);
return true;
}
/**
* Given an ID of an instance of this module,
* this function will permanently delete the instance
* and any data that depends on it.
*
* @global stdClass
* @global object
* @param int $id Scorm instance id
* @return boolean
*/
function scorm_delete_instance($id) {
global $CFG, $DB;
if (! $scorm = $DB->get_record('scorm', array('id' => $id))) {
return false;
}
$result = true;
// Delete any dependent records.
if (! $DB->delete_records('scorm_scoes_track', array('scormid' => $scorm->id))) {
$result = false;
}
if ($scoes = $DB->get_records('scorm_scoes', array('scorm' => $scorm->id))) {
foreach ($scoes as $sco) {
if (! $DB->delete_records('scorm_scoes_data', array('scoid' => $sco->id))) {
$result = false;
}
}
$DB->delete_records('scorm_scoes', array('scorm' => $scorm->id));
}
scorm_grade_item_delete($scorm);
// We must delete the module record after we delete the grade item.
if (! $DB->delete_records('scorm', array('id' => $scorm->id))) {
$result = false;
}
/*if (! $DB->delete_records('scorm_sequencing_controlmode', array('scormid'=>$scorm->id))) {
$result = false;
}
if (! $DB->delete_records('scorm_sequencing_rolluprules', array('scormid'=>$scorm->id))) {
$result = false;
}
if (! $DB->delete_records('scorm_sequencing_rolluprule', array('scormid'=>$scorm->id))) {
$result = false;
}
if (! $DB->delete_records('scorm_sequencing_rollupruleconditions', array('scormid'=>$scorm->id))) {
$result = false;
}
if (! $DB->delete_records('scorm_sequencing_rolluprulecondition', array('scormid'=>$scorm->id))) {
$result = false;
}
if (! $DB->delete_records('scorm_sequencing_rulecondition', array('scormid'=>$scorm->id))) {
$result = false;
}
if (! $DB->delete_records('scorm_sequencing_ruleconditions', array('scormid'=>$scorm->id))) {
$result = false;
}*/
return $result;
}
/**
* Return a small object with summary information about what a
* user has done with a given particular instance of this module
* Used for user activity reports.
*
* @global stdClass
* @param int $course Course id
* @param int $user User id
* @param int $mod
* @param int $scorm The scorm id
* @return mixed
*/
function scorm_user_outline($course, $user, $mod, $scorm) {
global $CFG;
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
require_once("$CFG->libdir/gradelib.php");
$grades = grade_get_grades($course->id, 'mod', 'scorm', $scorm->id, $user->id);
if (!empty($grades->items[0]->grades)) {
$grade = reset($grades->items[0]->grades);
$result = new stdClass();
if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
$result->info = get_string('grade') . ': '. $grade->str_long_grade;
} else {
$result->info = get_string('grade') . ': ' . get_string('hidden', 'grades');
}
// Datesubmitted == time created. dategraded == time modified or time overridden
// if grade was last modified by the user themselves use date graded. Otherwise use date submitted.
// TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704.
if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
$result->time = $grade->dategraded;
} else {
$result->time = $grade->datesubmitted;
}
return $result;
}
return null;
}
/**
* Print a detailed representation of what a user has done with
* a given particular instance of this module, for user activity reports.
*
* @global stdClass
* @global object
* @param object $course
* @param object $user
* @param object $mod
* @param object $scorm
* @return boolean
*/
function scorm_user_complete($course, $user, $mod, $scorm) {
global $CFG, $DB, $OUTPUT;
require_once("$CFG->libdir/gradelib.php");
$liststyle = 'structlist';
$now = time();
$firstmodify = $now;
$lastmodify = 0;
$sometoreport = false;
$report = '';
// First Access and Last Access dates for SCOs.
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
$timetracks = scorm_get_sco_runtime($scorm->id, false, $user->id);
$firstmodify = $timetracks->start;
$lastmodify = $timetracks->finish;
$grades = grade_get_grades($course->id, 'mod', 'scorm', $scorm->id, $user->id);
if (!empty($grades->items[0]->grades)) {
$grade = reset($grades->items[0]->grades);
if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
if ($grade->str_feedback) {
echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
}
} else {
echo $OUTPUT->container(get_string('grade') . ': ' . get_string('hidden', 'grades'));
}
}
if ($orgs = $DB->get_records_select('scorm_scoes', 'scorm = ? AND '.
$DB->sql_isempty('scorm_scoes', 'launch', false, true).' AND '.
$DB->sql_isempty('scorm_scoes', 'organization', false, false),
array($scorm->id), 'sortorder, id', 'id, identifier, title')) {
if (count($orgs) <= 1) {
unset($orgs);
$orgs = array();
$org = new stdClass();
$org->identifier = '';
$orgs[] = $org;
}
$report .= html_writer::start_div('mod-scorm');
foreach ($orgs as $org) {
$conditions = array();
$currentorg = '';
if (!empty($org->identifier)) {
$report .= html_writer::div($org->title, 'orgtitle');
$currentorg = $org->identifier;
$conditions['organization'] = $currentorg;
}
$report .= html_writer::start_tag('ul', array('id' => '0', 'class' => $liststyle));
$conditions['scorm'] = $scorm->id;
if ($scoes = $DB->get_records('scorm_scoes', $conditions, "sortorder, id")) {
// Drop keys so that we can access array sequentially.
$scoes = array_values($scoes);
$level = 0;
$sublist = 1;
$parents[$level] = '/';
foreach ($scoes as $pos => $sco) {
if ($parents[$level] != $sco->parent) {
if ($level > 0 && $parents[$level - 1] == $sco->parent) {
$report .= html_writer::end_tag('ul').html_writer::end_tag('li');
$level--;
} else {
$i = $level;
$closelist = '';
while (($i > 0) && ($parents[$level] != $sco->parent)) {
$closelist .= html_writer::end_tag('ul').html_writer::end_tag('li');
$i--;
}
if (($i == 0) && ($sco->parent != $currentorg)) {
$report .= html_writer::start_tag('li');
$report .= html_writer::start_tag('ul', array('id' => $sublist, 'class' => $liststyle));
$level++;
} else {
$report .= $closelist;
$level = $i;
}
$parents[$level] = $sco->parent;
}
}
$report .= html_writer::start_tag('li');
if (isset($scoes[$pos + 1])) {
$nextsco = $scoes[$pos + 1];
} else {
$nextsco = false;
}
if (($nextsco !== false) && ($sco->parent != $nextsco->parent) &&
(($level == 0) || (($level > 0) && ($nextsco->parent == $sco->identifier)))) {
$sublist++;
} else {
$report .= $OUTPUT->spacer(array("height" => "12", "width" => "13"));
}
if ($sco->launch) {
$score = '';
$totaltime = '';
if ($usertrack = scorm_get_tracks($sco->id, $user->id)) {
if ($usertrack->status == '') {
$usertrack->status = 'notattempted';
}
$strstatus = get_string($usertrack->status, 'scorm');
$report .= $OUTPUT->pix_icon($usertrack->status, $strstatus, 'scorm');
} else {
if ($sco->scormtype == 'sco') {
$report .= $OUTPUT->pix_icon('notattempted', get_string('notattempted', 'scorm'), 'scorm');
} else {
$report .= $OUTPUT->pix_icon('asset', get_string('asset', 'scorm'), 'scorm');
}
}
$report .= "&nbsp;$sco->title $score$totaltime".html_writer::end_tag('li');
if ($usertrack !== false) {
$sometoreport = true;
$report .= html_writer::start_tag('li').html_writer::start_tag('ul', array('class' => $liststyle));
foreach ($usertrack as $element => $value) {
if (substr($element, 0, 3) == 'cmi') {
$report .= html_writer::tag('li', $element.' => '.s($value));
}
}
$report .= html_writer::end_tag('ul').html_writer::end_tag('li');
}
} else {
$report .= "&nbsp;$sco->title".html_writer::end_tag('li');
}
}
for ($i = 0; $i < $level; $i++) {
$report .= html_writer::end_tag('ul').html_writer::end_tag('li');
}
}
$report .= html_writer::end_tag('ul').html_writer::empty_tag('br');
}
$report .= html_writer::end_div();
}
if ($sometoreport) {
if ($firstmodify < $now) {
$timeago = format_time($now - $firstmodify);
echo get_string('firstaccess', 'scorm').': '.userdate($firstmodify).' ('.$timeago.")".html_writer::empty_tag('br');
}
if ($lastmodify > 0) {
$timeago = format_time($now - $lastmodify);
echo get_string('lastaccess', 'scorm').': '.userdate($lastmodify).' ('.$timeago.")".html_writer::empty_tag('br');
}
echo get_string('report', 'scorm').":".html_writer::empty_tag('br');
echo $report;
} else {
print_string('noactivity', 'scorm');
}
return true;
}
/**
* Function to be run periodically according to the moodle Tasks API
* This function searches for things that need to be done, such
* as sending out mail, toggling flags etc ...
*
* @global stdClass
* @global object
* @return boolean
*/
function scorm_cron_scheduled_task () {
global $CFG, $DB;
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
$sitetimezone = core_date::get_server_timezone();
// Now see if there are any scorm updates to be done.
if (!isset($CFG->scorm_updatetimelast)) { // To catch the first time.
set_config('scorm_updatetimelast', 0);
}
$timenow = time();
$updatetime = usergetmidnight($timenow, $sitetimezone);
if ($CFG->scorm_updatetimelast < $updatetime and $timenow > $updatetime) {
set_config('scorm_updatetimelast', $timenow);
mtrace('Updating scorm packages which require daily update');// We are updating.
$scormsupdate = $DB->get_records('scorm', array('updatefreq' => SCORM_UPDATE_EVERYDAY));
foreach ($scormsupdate as $scormupdate) {
scorm_parse($scormupdate, true);
}
// Now clear out AICC session table with old session data.
$cfgscorm = get_config('scorm');
if (!empty($cfgscorm->allowaicchacp)) {
$expiretime = time() - ($cfgscorm->aicchacpkeepsessiondata * 24 * 60 * 60);
$DB->delete_records_select('scorm_aicc_session', 'timemodified < ?', array($expiretime));
}
}
return true;
}
/**
* Return grade for given user or all users.
*
* @global stdClass
* @global object
* @param int $scormid id of scorm
* @param int $userid optional user id, 0 means all users
* @return array array of grades, false if none
*/
function scorm_get_user_grades($scorm, $userid=0) {
global $CFG, $DB;
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
$grades = array();
if (empty($userid)) {
$scousers = $DB->get_records_select('scorm_scoes_track', "scormid=? GROUP BY userid",
array($scorm->id), "", "userid,null");
if ($scousers) {
foreach ($scousers as $scouser) {
$grades[$scouser->userid] = new stdClass();
$grades[$scouser->userid]->id = $scouser->userid;
$grades[$scouser->userid]->userid = $scouser->userid;
$grades[$scouser->userid]->rawgrade = scorm_grade_user($scorm, $scouser->userid);
}
} else {
return false;
}
} else {
$preattempt = $DB->get_records_select('scorm_scoes_track', "scormid=? AND userid=? GROUP BY userid",
array($scorm->id, $userid), "", "userid,null");
if (!$preattempt) {
return false; // No attempt yet.
}
$grades[$userid] = new stdClass();
$grades[$userid]->id = $userid;
$grades[$userid]->userid = $userid;
$grades[$userid]->rawgrade = scorm_grade_user($scorm, $userid);
}
return $grades;
}
/**
* Update grades in central gradebook
*
* @category grade
* @param object $scorm
* @param int $userid specific user only, 0 mean all
* @param bool $nullifnone
*/
function scorm_update_grades($scorm, $userid=0, $nullifnone=true) {
global $CFG;
require_once($CFG->libdir.'/gradelib.php');
require_once($CFG->libdir.'/completionlib.php');
if ($grades = scorm_get_user_grades($scorm, $userid)) {
scorm_grade_item_update($scorm, $grades);
// Set complete.
scorm_set_completion($scorm, $userid, COMPLETION_COMPLETE, $grades);
} else if ($userid and $nullifnone) {
$grade = new stdClass();
$grade->userid = $userid;
$grade->rawgrade = null;
scorm_grade_item_update($scorm, $grade);
// Set incomplete.
scorm_set_completion($scorm, $userid, COMPLETION_INCOMPLETE);
} else {
scorm_grade_item_update($scorm);
}
}
/**
* Update/create grade item for given scorm
*
* @category grade
* @uses GRADE_TYPE_VALUE
* @uses GRADE_TYPE_NONE
* @param object $scorm object with extra cmidnumber
* @param mixed $grades optional array/object of grade(s); 'reset' means reset grades in gradebook
* @return object grade_item
*/
function scorm_grade_item_update($scorm, $grades=null) {
global $CFG, $DB;
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
if (!function_exists('grade_update')) { // Workaround for buggy PHP versions.
require_once($CFG->libdir.'/gradelib.php');
}
$params = array('itemname' => $scorm->name);
if (isset($scorm->cmidnumber)) {
$params['idnumber'] = $scorm->cmidnumber;
}
if ($scorm->grademethod == GRADESCOES) {
$maxgrade = $DB->count_records_select('scorm_scoes', 'scorm = ? AND '.
$DB->sql_isnotempty('scorm_scoes', 'launch', false, true), array($scorm->id));
if ($maxgrade) {
$params['gradetype'] = GRADE_TYPE_VALUE;
$params['grademax'] = $maxgrade;
$params['grademin'] = 0;
} else {
$params['gradetype'] = GRADE_TYPE_NONE;
}
} else {
$params['gradetype'] = GRADE_TYPE_VALUE;
$params['grademax'] = $scorm->maxgrade;
$params['grademin'] = 0;
}
if ($grades === 'reset') {
$params['reset'] = true;
$grades = null;
}
return grade_update('mod/scorm', $scorm->course, 'mod', 'scorm', $scorm->id, 0, $grades, $params);
}
/**
* Delete grade item for given scorm
*
* @category grade
* @param object $scorm object
* @return object grade_item
*/
function scorm_grade_item_delete($scorm) {
global $CFG;
require_once($CFG->libdir.'/gradelib.php');
return grade_update('mod/scorm', $scorm->course, 'mod', 'scorm', $scorm->id, 0, null, array('deleted' => 1));
}
/**
* List the actions that correspond to a view of this module.
* This is used by the participation report.
*
* Note: This is not used by new logging system. Event with
* crud = 'r' and edulevel = LEVEL_PARTICIPATING will
* be considered as view action.
*
* @return array
*/
function scorm_get_view_actions() {
return array('pre-view', 'view', 'view all', 'report');
}
/**
* List the actions that correspond to a post of this module.
* This is used by the participation report.
*
* Note: This is not used by new logging system. Event with
* crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
* will be considered as post action.
*
* @return array
*/
function scorm_get_post_actions() {
return array();
}
/**
* @param object $scorm
* @return object $scorm
*/
function scorm_option2text($scorm) {
$scormpopoupoptions = scorm_get_popup_options_array();
if (isset($scorm->popup)) {
if ($scorm->popup == 1) {
$optionlist = array();
foreach ($scormpopoupoptions as $name => $option) {
if (isset($scorm->$name)) {
$optionlist[] = $name.'='.$scorm->$name;
} else {
$optionlist[] = $name.'=0';
}
}
$scorm->options = implode(',', $optionlist);
} else {
$scorm->options = '';
}
} else {
$scorm->popup = 0;
$scorm->options = '';
}
return $scorm;
}
/**
* Implementation of the function for printing the form elements that control
* whether the course reset functionality affects the scorm.
*
* @param object $mform form passed by reference
*/
function scorm_reset_course_form_definition(&$mform) {
$mform->addElement('header', 'scormheader', get_string('modulenameplural', 'scorm'));
$mform->addElement('advcheckbox', 'reset_scorm', get_string('deleteallattempts', 'scorm'));
}
/**
* Course reset form defaults.
*
* @return array
*/
function scorm_reset_course_form_defaults($course) {
return array('reset_scorm' => 1);
}
/**
* Removes all grades from gradebook
*
* @global stdClass
* @global object
* @param int $courseid
* @param string optional type
*/
function scorm_reset_gradebook($courseid, $type='') {
global $CFG, $DB;
$sql = "SELECT s.*, cm.idnumber as cmidnumber, s.course as courseid
FROM {scorm} s, {course_modules} cm, {modules} m
WHERE m.name='scorm' AND m.id=cm.module AND cm.instance=s.id AND s.course=?";
if ($scorms = $DB->get_records_sql($sql, array($courseid))) {
foreach ($scorms as $scorm) {
scorm_grade_item_update($scorm, 'reset');
}
}
}
/**
* Actual implementation of the reset course functionality, delete all the
* scorm attempts for course $data->courseid.
*
* @global stdClass
* @global object
* @param object $data the data submitted from the reset course.
* @return array status array
*/
function scorm_reset_userdata($data) {
global $CFG, $DB;
$componentstr = get_string('modulenameplural', 'scorm');
$status = array();
if (!empty($data->reset_scorm)) {
$scormssql = "SELECT s.id
FROM {scorm} s
WHERE s.course=?";
$DB->delete_records_select('scorm_scoes_track', "scormid IN ($scormssql)", array($data->courseid));
// Remove all grades from gradebook.
if (empty($data->reset_gradebook_grades)) {
scorm_reset_gradebook($data->courseid);
}
$status[] = array('component' => $componentstr, 'item' => get_string('deleteallattempts', 'scorm'), 'error' => false);
}
// Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
// See MDL-9367.
shift_course_mod_dates('scorm', array('timeopen', 'timeclose'), $data->timeshift, $data->courseid);
$status[] = array('component' => $componentstr, 'item' => get_string('datechanged'), 'error' => false);
return $status;
}
/**
* Lists all file areas current user may browse
*
* @param object $course
* @param object $cm
* @param object $context
* @return array
*/
function scorm_get_file_areas($course, $cm, $context) {
$areas = array();
$areas['content'] = get_string('areacontent', 'scorm');
$areas['package'] = get_string('areapackage', 'scorm');
return $areas;
}
/**
* File browsing support for SCORM file areas
*
* @package mod_scorm
* @category files
* @param file_browser $browser file browser instance
* @param array $areas file areas
* @param stdClass $course course object
* @param stdClass $cm course module object
* @param stdClass $context context object
* @param string $filearea file area
* @param int $itemid item ID
* @param string $filepath file path
* @param string $filename file name
* @return file_info instance or null if not found
*/
function scorm_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
global $CFG;
if (!has_capability('moodle/course:managefiles', $context)) {
return null;
}
// No writing for now!
$fs = get_file_storage();
if ($filearea === 'content') {
$filepath = is_null($filepath) ? '/' : $filepath;
$filename = is_null($filename) ? '.' : $filename;
$urlbase = $CFG->wwwroot.'/pluginfile.php';
if (!$storedfile = $fs->get_file($context->id, 'mod_scorm', 'content', 0, $filepath, $filename)) {
if ($filepath === '/' and $filename === '.') {
$storedfile = new virtual_root_file($context->id, 'mod_scorm', 'content', 0);
} else {
// Not found.
return null;
}
}
require_once("$CFG->dirroot/mod/scorm/locallib.php");
return new scorm_package_file_info($browser, $context, $storedfile, $urlbase, $areas[$filearea], true, true, false, false);
} else if ($filearea === 'package') {
$filepath = is_null($filepath) ? '/' : $filepath;
$filename = is_null($filename) ? '.' : $filename;
$urlbase = $CFG->wwwroot.'/pluginfile.php';
if (!$storedfile = $fs->get_file($context->id, 'mod_scorm', 'package', 0, $filepath, $filename)) {
if ($filepath === '/' and $filename === '.') {
$storedfile = new virtual_root_file($context->id, 'mod_scorm', 'package', 0);
} else {
// Not found.
return null;
}
}
return new file_info_stored($browser, $context, $storedfile, $urlbase, $areas[$filearea], false, true, false, false);
}
// Scorm_intro handled in file_browser.
return false;
}
/**
* Serves scorm content, introduction images and packages. Implements needed access control ;-)
*
* @package mod_scorm
* @category files
* @param stdClass $course course object
* @param stdClass $cm course module object
* @param stdClass $context context object
* @param string $filearea file area
* @param array $args extra arguments
* @param bool $forcedownload whether or not force download
* @param array $options additional options affecting the file serving
* @return bool false if file not found, does not return if found - just send the file
*/
function scorm_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
global $CFG, $DB;
if ($context->contextlevel != CONTEXT_MODULE) {
return false;
}
require_login($course, true, $cm);
$canmanageactivity = has_capability('moodle/course:manageactivities', $context);
$lifetime = null;
// Check SCORM availability.
if (!$canmanageactivity) {
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
$scorm = $DB->get_record('scorm', array('id' => $cm->instance), 'id, timeopen, timeclose', MUST_EXIST);
list($available, $warnings) = scorm_get_availability_status($scorm);
if (!$available) {
return false;
}
}
if ($filearea === 'content') {
$revision = (int)array_shift($args); // Prevents caching problems - ignored here.
$relativepath = implode('/', $args);
$fullpath = "/$context->id/mod_scorm/content/0/$relativepath";
$options['immutable'] = true; // Add immutable option, $relativepath changes on file update.
} else if ($filearea === 'package') {
// Check if the global setting for disabling package downloads is enabled.
$protectpackagedownloads = get_config('scorm', 'protectpackagedownloads');
if ($protectpackagedownloads and !$canmanageactivity) {
return false;
}
$revision = (int)array_shift($args); // Prevents caching problems - ignored here.
$relativepath = implode('/', $args);
$fullpath = "/$context->id/mod_scorm/package/0/$relativepath";
$lifetime = 0; // No caching here.
} else if ($filearea === 'imsmanifest') { // This isn't a real filearea, it's a url parameter for this type of package.
$revision = (int)array_shift($args); // Prevents caching problems - ignored here.
$relativepath = implode('/', $args);
// Get imsmanifest file.
$fs = get_file_storage();
$files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, '', false);
$file = reset($files);
// Check that the package file is an imsmanifest.xml file - if not then this method is not allowed.
$packagefilename = $file->get_filename();
if (strtolower($packagefilename) !== 'imsmanifest.xml') {
return false;
}
$file->send_relative_file($relativepath);
} else {
return false;
}
$fs = get_file_storage();
if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
if ($filearea === 'content') { // Return file not found straight away to improve performance.
send_header_404();
die;
}
return false;
}
// Finally send the file.
send_stored_file($file, $lifetime, 0, false, $options);
}
/**
* @uses FEATURE_GROUPS
* @uses FEATURE_GROUPINGS
* @uses FEATURE_MOD_INTRO
* @uses FEATURE_COMPLETION_TRACKS_VIEWS
* @uses FEATURE_COMPLETION_HAS_RULES
* @uses FEATURE_GRADE_HAS_GRADE
* @uses FEATURE_GRADE_OUTCOMES
* @param string $feature FEATURE_xx constant for requested feature
* @return mixed True if module supports feature, false if not, null if doesn't know
*/
function scorm_supports($feature) {
switch($feature) {
case FEATURE_GROUPS: return true;
case FEATURE_GROUPINGS: return true;
case FEATURE_MOD_INTRO: return true;
case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
case FEATURE_COMPLETION_HAS_RULES: return true;
case FEATURE_GRADE_HAS_GRADE: return true;
case FEATURE_GRADE_OUTCOMES: return true;
case FEATURE_BACKUP_MOODLE2: return true;
case FEATURE_SHOW_DESCRIPTION: return true;
default: return null;
}
}
/**
* Get the filename for a temp log file
*
* @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
* @param integer $scoid - scoid of object this log entry is for
* @return string The filename as an absolute path
*/
function scorm_debug_log_filename($type, $scoid) {
global $CFG, $USER;
$logpath = $CFG->tempdir.'/scormlogs';
$logfile = $logpath.'/'.$type.'debug_'.$USER->id.'_'.$scoid.'.log';
return $logfile;
}
/**
* writes log output to a temp log file
*
* @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
* @param string $text - text to be written to file.
* @param integer $scoid - scoid of object this log entry is for.
*/
function scorm_debug_log_write($type, $text, $scoid) {
global $CFG;
$debugenablelog = get_config('scorm', 'allowapidebug');
if (!$debugenablelog || empty($text)) {
return;
}
if (make_temp_directory('scormlogs/')) {
$logfile = scorm_debug_log_filename($type, $scoid);
@file_put_contents($logfile, date('Y/m/d H:i:s O')." DEBUG $text\r\n", FILE_APPEND);
@chmod($logfile, $CFG->filepermissions);
}
}
/**
* Remove debug log file
*
* @param string $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
* @param integer $scoid - scoid of object this log entry is for
* @return boolean True if the file is successfully deleted, false otherwise
*/
function scorm_debug_log_remove($type, $scoid) {
$debugenablelog = get_config('scorm', 'allowapidebug');
$logfile = scorm_debug_log_filename($type, $scoid);
if (!$debugenablelog || !file_exists($logfile)) {
return false;
}
return @unlink($logfile);
}
/**
* writes overview info for course_overview block - displays upcoming scorm objects that have a due date
*
* @deprecated since 3.3
* @todo The final deprecation of this function will take place in Moodle 3.7 - see MDL-57487.
* @param object $type - type of log(aicc,scorm12,scorm13) used as prefix for filename
* @param array $htmlarray
* @return mixed
*/
function scorm_print_overview($courses, &$htmlarray) {
global $USER, $CFG;
debugging('The function scorm_print_overview() is now deprecated.', DEBUG_DEVELOPER);
if (empty($courses) || !is_array($courses) || count($courses) == 0) {
return array();
}
if (!$scorms = get_all_instances_in_courses('scorm', $courses)) {
return;
}
$strscorm = get_string('modulename', 'scorm');
$strduedate = get_string('duedate', 'scorm');
foreach ($scorms as $scorm) {
$time = time();
$showattemptstatus = false;
if ($scorm->timeopen) {
$isopen = ($scorm->timeopen <= $time && $time <= $scorm->timeclose);
}
if ($scorm->displayattemptstatus == SCORM_DISPLAY_ATTEMPTSTATUS_ALL ||
$scorm->displayattemptstatus == SCORM_DISPLAY_ATTEMPTSTATUS_MY) {
$showattemptstatus = true;
}
if ($showattemptstatus || !empty($isopen) || !empty($scorm->timeclose)) {
$str = html_writer::start_div('scorm overview').html_writer::div($strscorm. ': '.
html_writer::link($CFG->wwwroot.'/mod/scorm/view.php?id='.$scorm->coursemodule, $scorm->name,
array('title' => $strscorm, 'class' => $scorm->visible ? '' : 'dimmed')), 'name');
if ($scorm->timeclose) {
$str .= html_writer::div($strduedate.': '.userdate($scorm->timeclose), 'info');
}
if ($showattemptstatus) {
require_once($CFG->dirroot.'/mod/scorm/locallib.php');
$str .= html_writer::div(scorm_get_attempt_status($USER, $scorm), 'details');
}
$str .= html_writer::end_div();
if (empty($htmlarray[$scorm->course]['scorm'])) {
$htmlarray[$scorm->course]['scorm'] = $str;
} else {
$htmlarray[$scorm->course]['scorm'] .= $str;
}
}
}
}
/**
* Return a list of page types
* @param string $pagetype current page type
* @param stdClass $parentcontext Block's parent context
* @param stdClass $currentcontext Current context of block
*/
function scorm_page_type_list($pagetype, $parentcontext, $currentcontext) {
$modulepagetype = array('mod-scorm-*' => get_string('page-mod-scorm-x', 'scorm'));
return $modulepagetype;
}
/**
* Returns the SCORM version used.
* @param string $scormversion comes from $scorm->version
* @param string $version one of the defined vars SCORM_12, SCORM_13, SCORM_AICC (or empty)
* @return Scorm version.
*/
function scorm_version_check($scormversion, $version='') {
$scormversion = trim(strtolower($scormversion));
if (empty($version) || $version == SCORM_12) {
if ($scormversion == 'scorm_12' || $scormversion == 'scorm_1.2') {
return SCORM_12;
}
if (!empty($version)) {
return false;
}
}
if (empty($version) || $version == SCORM_13) {
if ($scormversion == 'scorm_13' || $scormversion == 'scorm_1.3') {
return SCORM_13;
}
if (!empty($version)) {
return false;
}
}
if (empty($version) || $version == SCORM_AICC) {
if (strpos($scormversion, 'aicc')) {
return SCORM_AICC;
}
if (!empty($version)) {
return false;
}
}
return false;
}
/**
* Obtains the automatic completion state for this scorm based on any conditions
* in scorm settings.
*
* @param object $course Course
* @param object $cm Course-module
* @param int $userid User ID
* @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
* @return bool True if completed, false if not. (If no conditions, then return
* value depends on comparison type)
*/
function scorm_get_completion_state($course, $cm, $userid, $type) {
global $DB;
$result = $type;
// Get scorm.
if (!$scorm = $DB->get_record('scorm', array('id' => $cm->instance))) {
print_error('cannotfindscorm');
}
// Only check for existence of tracks and return false if completionstatusrequired or completionscorerequired
// this means that if only view is required we don't end up with a false state.
if ($scorm->completionstatusrequired !== null ||
$scorm->completionscorerequired !== null) {
// Get user's tracks data.
$tracks = $DB->get_records_sql(
"
SELECT
id,
scoid,
element,
value
FROM
{scorm_scoes_track}
WHERE
scormid = ?
AND userid = ?
AND element IN
(
'cmi.core.lesson_status',
'cmi.completion_status',
'cmi.success_status',
'cmi.core.score.raw',
'cmi.score.raw'
)
",
array($scorm->id, $userid)
);
if (!$tracks) {
return completion_info::aggregate_completion_states($type, $result, false);
}
}
// Check for status.
if ($scorm->completionstatusrequired !== null) {
// Get status.
$statuses = array_flip(scorm_status_options());
$nstatus = 0;
// Check any track for these values.
$scostatus = array();
foreach ($tracks as $track) {
if (!in_array($track->element, array('cmi.core.lesson_status', 'cmi.completion_status', 'cmi.success_status'))) {
continue;
}
if (array_key_exists($track->value, $statuses)) {
$scostatus[$track->scoid] = true;
$nstatus |= $statuses[$track->value];
}
}
if (!empty($scorm->completionstatusallscos)) {
// Iterate over all scos and make sure each has a lesson_status.
$scos = $DB->get_records('scorm_scoes', array('scorm' => $scorm->id, 'scormtype' => 'sco'));
foreach ($scos as $sco) {
if (empty($scostatus[$sco->id])) {
return completion_info::aggregate_completion_states($type, $result, false);
}
}
return completion_info::aggregate_completion_states($type, $result, true);
} else if ($scorm->completionstatusrequired & $nstatus) {
return completion_info::aggregate_completion_states($type, $result, true);
} else {
return completion_info::aggregate_completion_states($type, $result, false);
}
}
// Check for score.
if ($scorm->completionscorerequired !== null) {
$maxscore = -1;
foreach ($tracks as $track) {
if (!in_array($track->element, array('cmi.core.score.raw', 'cmi.score.raw'))) {
continue;
}
if (strlen($track->value) && floatval($track->value) >= $maxscore) {
$maxscore = floatval($track->value);
}
}
if ($scorm->completionscorerequired <= $maxscore) {
return completion_info::aggregate_completion_states($type, $result, true);
} else {
return completion_info::aggregate_completion_states($type, $result, false);
}
}
return $result;
}
/**
* Register the ability to handle drag and drop file uploads
* @return array containing details of the files / types the mod can handle
*/
function scorm_dndupload_register() {
return array('files' => array(
array('extension' => 'zip', 'message' => get_string('dnduploadscorm', 'scorm'))
));
}
/**
* Handle a file that has been uploaded
* @param object $uploadinfo details of the file / content that has been uploaded
* @return int instance id of the newly created mod
*/
function scorm_dndupload_handle($uploadinfo) {
$context = context_module::instance($uploadinfo->coursemodule);
file_save_draft_area_files($uploadinfo->draftitemid, $context->id, 'mod_scorm', 'package', 0);
$fs = get_file_storage();
$files = $fs->get_area_files($context->id, 'mod_scorm', 'package', 0, 'sortorder, itemid, filepath, filename', false);
$file = reset($files);
// Validate the file, make sure it's a valid SCORM package!
$errors = scorm_validate_package($file);
if (!empty($errors)) {
return false;
}
// Create a default scorm object to pass to scorm_add_instance()!
$scorm = get_config('scorm');
$scorm->course = $uploadinfo->course->id;
$scorm->coursemodule = $uploadinfo->coursemodule;
$scorm->cmidnumber = '';
$scorm->name = $uploadinfo->displayname;
$scorm->scormtype = SCORM_TYPE_LOCAL;
$scorm->reference = $file->get_filename();
$scorm->intro = '';
$scorm->width = $scorm->framewidth;
$scorm->height = $scorm->frameheight;
return scorm_add_instance($scorm, null);
}
/**
* Sets activity completion state
*
* @param object $scorm object
* @param int $userid User ID
* @param int $completionstate Completion state
* @param array $grades grades array of users with grades - used when $userid = 0
*/
function scorm_set_completion($scorm, $userid, $completionstate = COMPLETION_COMPLETE, $grades = array()) {
$course = new stdClass();
$course->id = $scorm->course;
$completion = new completion_info($course);
// Check if completion is enabled site-wide, or for the course.
if (!$completion->is_enabled()) {
return;
}
$cm = get_coursemodule_from_instance('scorm', $scorm->id, $scorm->course);
if (empty($cm) || !$completion->is_enabled($cm)) {
return;
}
if (empty($userid)) { // We need to get all the relevant users from $grades param.
foreach ($grades as $grade) {
$completion->update_state($cm, $completionstate, $grade->userid);
}
} else {
$completion->update_state($cm, $completionstate, $userid);
}
}
/**
* Check that a Zip file contains a valid SCORM package
*
* @param $file stored_file a Zip file.
* @return array empty if no issue is found. Array of error message otherwise
*/
function scorm_validate_package($file) {
$packer = get_file_packer('application/zip');
$errors = array();
if ($file->is_external_file()) { // Get zip file so we can check it is correct.
$file->import_external_file_contents();
}
$filelist = $file->list_files($packer);
if (!is_array($filelist)) {
$errors['packagefile'] = get_string('badarchive', 'scorm');
} else {
$aiccfound = false;
$badmanifestpresent = false;
foreach ($filelist as $info) {
if ($info->pathname == 'imsmanifest.xml') {
return array();
} else if (strpos($info->pathname, 'imsmanifest.xml') !== false) {
// This package has an imsmanifest file inside a folder of the package.
$badmanifestpresent = true;
}
if (preg_match('/\.cst$/', $info->pathname)) {
return array();
}
}
if (!$aiccfound) {
if ($badmanifestpresent) {
$errors['packagefile'] = get_string('badimsmanifestlocation', 'scorm');
} else {
$errors['packagefile'] = get_string('nomanifest', 'scorm');
}
}
}
return $errors;
}
/**
* Check and set the correct mode and attempt when entering a SCORM package.
*
* @param object $scorm object
* @param string $newattempt should a new attempt be generated here.
* @param int $attempt the attempt number this is for.
* @param int $userid the userid of the user.
* @param string $mode the current mode that has been selected.
*/
function scorm_check_mode($scorm, &$newattempt, &$attempt, $userid, &$mode) {
global $DB;
if (($mode == 'browse')) {
if ($scorm->hidebrowse == 1) {
// Prevent Browse mode if hidebrowse is set.
$mode = 'normal';
} else {
// We don't need to check attempts as browse mode is set.
return;
}
}
if ($scorm->forcenewattempt == SCORM_FORCEATTEMPT_ALWAYS) {
// This SCORM is configured to force a new attempt on every re-entry.
$newattempt = 'on';
$mode = 'normal';
if ($attempt == 1) {
// Check if the user has any existing data or if this is really the first attempt.
$exists = $DB->record_exists('scorm_scoes_track', array('userid' => $userid, 'scormid' => $scorm->id));
if (!$exists) {
// No records yet - Attempt should == 1.
return;
}
}
$attempt++;
return;
}
// Check if the scorm module is incomplete (used to validate user request to start a new attempt).
$incomplete = true;
// Note - in SCORM_13 the cmi-core.lesson_status field was split into
// 'cmi.completion_status' and 'cmi.success_status'.
// 'cmi.completion_status' can only contain values 'completed', 'incomplete', 'not attempted' or 'unknown'.
// This means the values 'passed' or 'failed' will never be reported for a track in SCORM_13 and
// the only status that will be treated as complete is 'completed'.
$completionelements = array(
SCORM_12 => 'cmi.core.lesson_status',
SCORM_13 => 'cmi.completion_status',
SCORM_AICC => 'cmi.core.lesson_status'
);
$scormversion = scorm_version_check($scorm->version);
if($scormversion===false) {
$scormversion = SCORM_12;
}
$completionelement = $completionelements[$scormversion];
$sql = "SELECT sc.id, t.value
FROM {scorm_scoes} sc
LEFT JOIN {scorm_scoes_track} t ON sc.scorm = t.scormid AND sc.id = t.scoid
AND t.element = ? AND t.userid = ? AND t.attempt = ?
WHERE sc.scormtype = 'sco' AND sc.scorm = ?";
$tracks = $DB->get_recordset_sql($sql, array($completionelement, $userid, $attempt, $scorm->id));
foreach ($tracks as $track) {
if (($track->value == 'completed') || ($track->value == 'passed') || ($track->value == 'failed')) {
$incomplete = false;
} else {
$incomplete = true;
break; // Found an incomplete sco, so the result as a whole is incomplete.
}
}
$tracks->close();
// Validate user request to start a new attempt.
if ($incomplete === true) {
// The option to start a new attempt should never have been presented. Force false.
$newattempt = 'off';
} else if (!empty($scorm->forcenewattempt)) {
// A new attempt should be forced for already completed attempts.
$newattempt = 'on';
}
if (($newattempt == 'on') && (($attempt < $scorm->maxattempt) || ($scorm->maxattempt == 0))) {
$attempt++;
$mode = 'normal';
} else { // Check if review mode should be set.
if ($incomplete === true) {
$mode = 'normal';
} else {
$mode = 'review';
}
}
}
/**
* Trigger the course_module_viewed event.
*
* @param stdClass $scorm scorm object
* @param stdClass $course course object
* @param stdClass $cm course module object
* @param stdClass $context context object
* @since Moodle 3.0
*/
function scorm_view($scorm, $course, $cm, $context) {
// Trigger course_module_viewed event.
$params = array(
'context' => $context,
'objectid' => $scorm->id
);
$event = \mod_scorm\event\course_module_viewed::create($params);
$event->add_record_snapshot('course_modules', $cm);
$event->add_record_snapshot('course', $course);
$event->add_record_snapshot('scorm', $scorm);
$event->trigger();
}
/**
* Check if the module has any update that affects the current user since a given time.
*
* @param cm_info $cm course module data
* @param int $from the time to check updates from
* @param array $filter if we need to check only specific updates
* @return stdClass an object with the different type of areas indicating if they were updated or not
* @since Moodle 3.2
*/
function scorm_check_updates_since(cm_info $cm, $from, $filter = array()) {
global $DB, $USER, $CFG;
require_once($CFG->dirroot . '/mod/scorm/locallib.php');
$scorm = $DB->get_record($cm->modname, array('id' => $cm->instance), '*', MUST_EXIST);
$updates = new stdClass();
list($available, $warnings) = scorm_get_availability_status($scorm, true, $cm->context);
if (!$available) {
return $updates;
}
$updates = course_check_module_updates_since($cm, $from, array('package'), $filter);
$updates->tracks = (object) array('updated' => false);
$select = 'scormid = ? AND userid = ? AND timemodified > ?';
$params = array($scorm->id, $USER->id, $from);
$tracks = $DB->get_records_select('scorm_scoes_track', $select, $params, '', 'id');
if (!empty($tracks)) {
$updates->tracks->updated = true;
$updates->tracks->itemids = array_keys($tracks);
}
// Now, teachers should see other students updates.
if (has_capability('mod/scorm:viewreport', $cm->context)) {
$select = 'scormid = ? AND timemodified > ?';
$params = array($scorm->id, $from);
if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
$groupusers = array_keys(groups_get_activity_shared_group_members($cm));
if (empty($groupusers)) {
return $updates;
}
list($insql, $inparams) = $DB->get_in_or_equal($groupusers);
$select .= ' AND userid ' . $insql;
$params = array_merge($params, $inparams);
}
$updates->usertracks = (object) array('updated' => false);
$tracks = $DB->get_records_select('scorm_scoes_track', $select, $params, '', 'id');
if (!empty($tracks)) {
$updates->usertracks->updated = true;
$updates->usertracks->itemids = array_keys($tracks);
}
}
return $updates;
}
/**
* Get icon mapping for font-awesome.
*/
function mod_scorm_get_fontawesome_icon_map() {
return [
'mod_scorm:assetc' => 'fa-file-archive-o',
'mod_scorm:asset' => 'fa-file-archive-o',
'mod_scorm:browsed' => 'fa-book',
'mod_scorm:completed' => 'fa-check-square-o',
'mod_scorm:failed' => 'fa-times',
'mod_scorm:incomplete' => 'fa-pencil-square-o',
'mod_scorm:minus' => 'fa-minus',
'mod_scorm:notattempted' => 'fa-square-o',
'mod_scorm:passed' => 'fa-check',
'mod_scorm:plus' => 'fa-plus',
'mod_scorm:popdown' => 'fa-window-close-o',
'mod_scorm:popup' => 'fa-window-restore',
'mod_scorm:suspend' => 'fa-pause',
'mod_scorm:wait' => 'fa-clock-o',
];
}
/**
* This standard function will check all instances of this module
* and make sure there are up-to-date events created for each of them.
* If courseid = 0, then every scorm event in the site is checked, else
* only scorm events belonging to the course specified are checked.
*
* @param int $courseid
* @param int|stdClass $instance scorm module instance or ID.
* @param int|stdClass $cm Course module object or ID.
* @return bool
*/
function scorm_refresh_events($courseid = 0, $instance = null, $cm = null) {
global $CFG, $DB;
require_once($CFG->dirroot . '/mod/scorm/locallib.php');
// If we have instance information then we can just update the one event instead of updating all events.
if (isset($instance)) {
if (!is_object($instance)) {
$instance = $DB->get_record('scorm', array('id' => $instance), '*', MUST_EXIST);
}
if (isset($cm)) {
if (!is_object($cm)) {
$cm = (object)array('id' => $cm);
}
} else {
$cm = get_coursemodule_from_instance('scorm', $instance->id);
}
scorm_update_calendar($instance, $cm->id);
return true;
}
if ($courseid) {
// Make sure that the course id is numeric.
if (!is_numeric($courseid)) {
return false;
}
if (!$scorms = $DB->get_records('scorm', array('course' => $courseid))) {
return false;
}
} else {
if (!$scorms = $DB->get_records('scorm')) {
return false;
}
}
foreach ($scorms as $scorm) {
$cm = get_coursemodule_from_instance('scorm', $scorm->id);
scorm_update_calendar($scorm, $cm->id);
}
return true;
}
/**
* This function receives a calendar event and returns the action associated with it, or null if there is none.
*
* This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
* is not displayed on the block.
*
* @param calendar_event $event
* @param \core_calendar\action_factory $factory
* @param int $userid User id override
* @return \core_calendar\local\event\entities\action_interface|null
*/
function mod_scorm_core_calendar_provide_event_action(calendar_event $event,
\core_calendar\action_factory $factory, $userid = null) {
global $CFG, $USER;
require_once($CFG->dirroot . '/mod/scorm/locallib.php');
if (empty($userid)) {
$userid = $USER->id;
}
$cm = get_fast_modinfo($event->courseid, $userid)->instances['scorm'][$event->instance];
if (has_capability('mod/scorm:viewreport', $cm->context, $userid)) {
// Teachers do not need to be reminded to complete a scorm.
return null;
}
if (!empty($cm->customdata['timeclose']) && $cm->customdata['timeclose'] < time()) {
// The scorm has closed so the user can no longer submit anything.
return null;
}
// Restore scorm object from cached values in $cm, we only need id, timeclose and timeopen.
$customdata = $cm->customdata ?: [];
$customdata['id'] = $cm->instance;
$scorm = (object)($customdata + ['timeclose' => 0, 'timeopen' => 0]);
// Check that the SCORM activity is open.
list($actionable, $warnings) = scorm_get_availability_status($scorm, false, null, $userid);
return $factory->create_instance(
get_string('enter', 'scorm'),
new \moodle_url('/mod/scorm/view.php', array('id' => $cm->id)),
1,
$actionable
);
}
/**
* Add a get_coursemodule_info function in case any SCORM type wants to add 'extra' information
* for the course (see resource).
*
* Given a course_module object, this function returns any "extra" information that may be needed
* when printing this activity in a course listing. See get_array_of_activities() in course/lib.php.
*
* @param stdClass $coursemodule The coursemodule object (record).
* @return cached_cm_info An object on information that the courses
* will know about (most noticeably, an icon).
*/
function scorm_get_coursemodule_info($coursemodule) {
global $DB;
$dbparams = ['id' => $coursemodule->instance];
$fields = 'id, name, intro, introformat, completionstatusrequired, completionscorerequired, completionstatusallscos, '.
'timeopen, timeclose';
if (!$scorm = $DB->get_record('scorm', $dbparams, $fields)) {
return false;
}
$result = new cached_cm_info();
$result->name = $scorm->name;
if ($coursemodule->showdescription) {
// Convert intro to html. Do not filter cached version, filters run at display time.
$result->content = format_module_intro('scorm', $scorm, $coursemodule->id, false);
}
// Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.
if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {
$result->customdata['customcompletionrules']['completionstatusrequired'] = $scorm->completionstatusrequired;
$result->customdata['customcompletionrules']['completionscorerequired'] = $scorm->completionscorerequired;
$result->customdata['customcompletionrules']['completionstatusallscos'] = $scorm->completionstatusallscos;
}
// Populate some other values that can be used in calendar or on dashboard.
if ($scorm->timeopen) {
$result->customdata['timeopen'] = $scorm->timeopen;
}
if ($scorm->timeclose) {
$result->customdata['timeclose'] = $scorm->timeclose;
}
return $result;
}
/**
* Callback which returns human-readable strings describing the active completion custom rules for the module instance.
*
* @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']
* @return array $descriptions the array of descriptions for the custom rules.
*/
function mod_scorm_get_completion_active_rule_descriptions($cm) {
// Values will be present in cm_info, and we assume these are up to date.
if (empty($cm->customdata['customcompletionrules'])
|| $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {
return [];
}
$descriptions = [];
foreach ($cm->customdata['customcompletionrules'] as $key => $val) {
switch ($key) {
case 'completionstatusrequired':
if (!is_null($val)) {
// Determine the selected statuses using a bitwise operation.
$cvalues = array();
foreach (scorm_status_options(true) as $bit => $string) {
if (($val & $bit) == $bit) {
$cvalues[] = $string;
}
}
$statusstring = implode(', ', $cvalues);
$descriptions[] = get_string('completionstatusrequireddesc', 'scorm', $statusstring);
}
break;
case 'completionscorerequired':
if (!is_null($val)) {
$descriptions[] = get_string('completionscorerequireddesc', 'scorm', $val);
}
break;
case 'completionstatusallscos':
if (!empty($val)) {
$descriptions[] = get_string('completionstatusallscos', 'scorm');
}
break;
default:
break;
}
}
return $descriptions;
}
/**
* This function will update the scorm module according to the
* event that has been modified.
*
* It will set the timeopen or timeclose value of the scorm instance
* according to the type of event provided.
*
* @throws \moodle_exception
* @param \calendar_event $event
* @param stdClass $scorm The module instance to get the range from
*/
function mod_scorm_core_calendar_event_timestart_updated(\calendar_event $event, \stdClass $scorm) {
global $DB;
if (empty($event->instance) || $event->modulename != 'scorm') {
return;
}
if ($event->instance != $scorm->id) {
return;
}
if (!in_array($event->eventtype, [SCORM_EVENT_TYPE_OPEN, SCORM_EVENT_TYPE_CLOSE])) {
return;
}
$courseid = $event->courseid;
$modulename = $event->modulename;
$instanceid = $event->instance;
$modified = false;
$coursemodule = get_fast_modinfo($courseid)->instances[$modulename][$instanceid];
$context = context_module::instance($coursemodule->id);
// The user does not have the capability to modify this activity.
if (!has_capability('moodle/course:manageactivities', $context)) {
return;
}
if ($event->eventtype == SCORM_EVENT_TYPE_OPEN) {
// If the event is for the scorm activity opening then we should
// set the start time of the scorm activity to be the new start
// time of the event.
if ($scorm->timeopen != $event->timestart) {
$scorm->timeopen = $event->timestart;
$scorm->timemodified = time();
$modified = true;
}
} else if ($event->eventtype == SCORM_EVENT_TYPE_CLOSE) {
// If the event is for the scorm activity closing then we should
// set the end time of the scorm activity to be the new start
// time of the event.
if ($scorm->timeclose != $event->timestart) {
$scorm->timeclose = $event->timestart;
$modified = true;
}
}
if ($modified) {
$scorm->timemodified = time();
$DB->update_record('scorm', $scorm);
$event = \core\event\course_module_updated::create_from_cm($coursemodule, $context);
$event->trigger();
}
}
/**
* This function calculates the minimum and maximum cutoff values for the timestart of
* the given event.
*
* It will return an array with two values, the first being the minimum cutoff value and
* the second being the maximum cutoff value. Either or both values can be null, which
* indicates there is no minimum or maximum, respectively.
*
* If a cutoff is required then the function must return an array containing the cutoff
* timestamp and error string to display to the user if the cutoff value is violated.
*
* A minimum and maximum cutoff return value will look like:
* [
* [1505704373, 'The date must be after this date'],
* [1506741172, 'The date must be before this date']
* ]
*
* @param \calendar_event $event The calendar event to get the time range for
* @param \stdClass $instance The module instance to get the range from
* @return array Returns an array with min and max date.
*/
function mod_scorm_core_calendar_get_valid_event_timestart_range(\calendar_event $event, \stdClass $instance) {
$mindate = null;
$maxdate = null;
if ($event->eventtype == SCORM_EVENT_TYPE_OPEN) {
// The start time of the open event can't be equal to or after the
// close time of the scorm activity.
if (!empty($instance->timeclose)) {
$maxdate = [
$instance->timeclose,
get_string('openafterclose', 'scorm')
];
}
} else if ($event->eventtype == SCORM_EVENT_TYPE_CLOSE) {
// The start time of the close event can't be equal to or earlier than the
// open time of the scorm activity.
if (!empty($instance->timeopen)) {
$mindate = [
$instance->timeopen,
get_string('closebeforeopen', 'scorm')
];
}
}
return [$mindate, $maxdate];
}