* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
require_once("$CFG->libdir/filelib.php");
/**
* Get an array with the languages
*
* @return array The array with each language.
*/
function jclic_get_languages(){
$tmplanglist = get_string_manager()->get_list_of_translations();
$langlist = array();
foreach ($tmplanglist as $lang=>$langname) {
if (substr($lang, -5) == '_utf8') { //Remove the _utf8 suffix from the lang to show
$lang = substr($lang, 0, -5);
}
$langlist[$lang]=$langname;
}
return $langlist;
}
/**
* Get an array with the skins
*
* @return array The array with each skin.
*/
function jclic_get_skins(){
return array('@default.xml' => 'default','@blue.xml' => 'blue','@orange.xml' => 'orange','@green.xml' => 'green','@simple.xml' => 'simple', '@mini.xml' => 'mini');
}
/**
* Get an array with the file types
*
* @return array The array with each file type
*/
function jclic_get_file_types(){
$filetypes = array(JCLIC_FILE_TYPE_LOCAL => get_string('filetypelocal', 'jclic'));
$filetypes[JCLIC_FILE_TYPE_EXTERNAL] = get_string('filetypeexternal', 'jclic');
return $filetypes;
}
/**
* Display the header and top of a page
*
* This is used by the view() method to print the header of view.php but
* it can be used on other pages in which case the string to denote the
* page in the navigation trail should be passed as an argument
*
* @global object
* @param string $subpage Description of subpage to be used in navigation trail
*/
function jclic_view_header($jclic, $cm, $course, $subpage='') {
global $CFG, $PAGE, $OUTPUT;
if ($subpage) {
$PAGE->navbar->add($subpage);
}
//$PAGE->set_title($jclic->name);
//$PAGE->set_heading($course->fullname);
echo $OUTPUT->header();
groups_print_activity_menu($cm, $CFG->wwwroot . '/mod/jclic/view.php?id=' . $cm->id);
echo ''.jclic_submittedlink().'
';
echo '';
}
/**
* Display the jclic intro
*
*/
function jclic_view_intro($jclic, $cm) {
global $OUTPUT;
echo $OUTPUT->box_start('generalbox boxaligncenter', 'intro');
echo format_module_intro('jclic', $jclic, $cm->id);
echo $OUTPUT->box_end();
}
/**
* Display the jclic dates
*
* Prints the jclic start and end dates in a box.
*/
function jclic_view_dates($jclic, $cm, $timenow=null) {
global $OUTPUT;
if (!$jclic->timeavailable && !$jclic->timedue) {
return;
}
if (is_null($timenow)) $timenow = time();
echo $OUTPUT->box_start('generalbox boxaligncenter jclicdates', 'dates');
if ($jclic->timeavailable) {
echo ''.get_string('availabledate','assignment').':
';
echo ''.userdate($jclic->timeavailable).'
';
}
if ($jclic->timedue) {
echo ''.get_string('duedate','assignment').':
';
echo ''.userdate($jclic->timedue).'
';
}
echo $OUTPUT->box_end();
}
/**
* Display the jclic applet
*
*/
function jclic_view_applet($jclic, $context, $ispreview=false, $timenow=null) {
global $OUTPUT, $PAGE, $CFG, $USER;
if (is_null($timenow)) $timenow = time();
$isopen = (empty($jclic->timeavailable) || $jclic->timeavailable < $timenow);
$isclosed = (!empty($jclic->timedue) && $jclic->timedue < $timenow);
$sessions = jclic_get_sessions($jclic->id,$USER->id);
$attempts=sizeof($sessions);
if ($ispreview) {
$url = new moodle_url('/mod/jclic/view.php', array('id' => $context->instanceid));
echo '
'.get_string('return_results', 'jclic').'';
} else if ( $attempts > 0 || $isopen ) {
echo '
'.get_string('show_my_results', 'jclic').'';
}
if (!$ispreview && !$isopen){
echo $OUTPUT->box(get_string('notopenyet', 'jclic', userdate($jclic->timeavailable)), 'generalbox boxaligncenter jclicdates');
} else if (!$ispreview && $isclosed ) {
echo $OUTPUT->box(get_string('expired', 'jclic', userdate($jclic->timedue)), 'generalbox boxaligncenter jclicdates');
} else {
if ($jclic->maxattempts<0 || $attempts < $jclic->maxattempts){
echo '';
echo '
';
$PAGE->requires->js('/mod/jclic/jclicplugin.js');
$PAGE->requires->js('/mod/jclic/jclic.js');
$params = get_object_vars($jclic);
$params['jclic_url'] = jclic_get_url($jclic, $context);
$params['jclic_path'] = jclic_get_server();
$params['jclic_service'] = jclic_get_path().'/mod/jclic/action/beans.php';
$params['jclic_user'] = $USER->id;
$params['jclic_jarbase'] = $CFG->jclic_jarbase;
$params['jclic_lap'] = $CFG->jclic_lap;
$params['jclic_protocol'] = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off' || $_SERVER['SERVER_PORT'] == 443) ? 'https' : 'http';
$PAGE->requires->js_init_call('M.mod_jclic.init', array($params));
}else{
echo $OUTPUT->box(get_string('msg_noattempts', 'jclic'), 'generalbox boxaligncenter');
}
jclic_view_dates($jclic, $context, $timenow);
}
}
function jclic_get_url($jclic, $context){
global $CFG;
$url = '';
if (jclic_is_valid_external_url($jclic->url)) {
$url = $jclic->url;
} else {
$fs = get_file_storage();
$files = $fs->get_area_files($context->id, 'mod_jclic', 'content', 0, 'sortorder DESC, id ASC', false);
if (count($files) < 1) {
//resource_print_filenotfound($resource, $cm, $course);
die;
} else {
$file = reset($files);
unset($files);
}
$path = '/'.$context->id.'/mod_jclic/content/0'.$file->get_filepath().$file->get_filename();
$url = file_encode_url($CFG->wwwroot.'/pluginfile.php', $path, false);
}
return $url;
}
/**
* Display the bottom and footer of a page
*
* This default method just prints the footer.
* This will be suitable for most assignment types
*/
function jclic_view_footer() {
global $OUTPUT;
echo $OUTPUT->footer();
}
/**
* Returns a link with info about the state of the jclic attempts
*
* This is used by view_header to put this link at the top right of the page.
* For teachers it gives the number of attempted jclics with a link
* For students it gives the time of their last attempt.
*
* @global object
* @global object
* @param bool $allgroup print all groups info if user can access all groups, suitable for index.php
* @return string
*/
function jclic_submittedlink($allgroups=false) {
global $USER;
global $CFG;
$submitted = '';
$urlbase = "{$CFG->wwwroot}/mod/jclic/";
/* $context = get_context_instance(CONTEXT_MODULE,$this->cm->id);
if (has_capability('mod/jclic:grade', $context)) {
if ($allgroups and has_capability('moodle/site:accessallgroups', $context)) {
$group = 0;
} else {
$group = groups_get_activity_group($this->cm);
}
$submitted = 'teacher';
} else {
if (isloggedin()) {
$submitted = 'student';
}
}
*/
return $submitted;
}
/**
* Get moodle server
*
* @return string myserver.com:port
*/
function jclic_get_server() {
global $CFG;
if (!empty($CFG->wwwroot)) {
$url = parse_url($CFG->wwwroot);
}
if (!empty($url['host'])) {
$hostname = $url['host'];
} else if (!empty($_SERVER['SERVER_NAME'])) {
$hostname = $_SERVER['SERVER_NAME'];
} else if (!empty($_ENV['SERVER_NAME'])) {
$hostname = $_ENV['SERVER_NAME'];
} else if (!empty($_SERVER['HTTP_HOST'])) {
$hostname = $_SERVER['HTTP_HOST'];
} else if (!empty($_ENV['HTTP_HOST'])) {
$hostname = $_ENV['HTTP_HOST'];
} else {
notify('Warning: could not find the name of this server!');
return false;
}
if (!empty($url['port'])) {
$hostname .= ':'.$url['port'];
} else if (!empty($_SERVER['SERVER_PORT'])) {
if ($_SERVER['SERVER_PORT'] != 80 && $_SERVER['SERVER_PORT'] != 443) {
$hostname .= ':'.$_SERVER['SERVER_PORT'];
}
}
return $hostname;
}
/**
* Get moodle path
*
* @return string /path_to_moodle
*/
function jclic_get_path() {
global $CFG;
$path = '/';
if (!empty($CFG->wwwroot)) {
$url = parse_url($CFG->wwwroot);
if (array_key_exists('path', $url)){
$path = $url['path'];
}
}
return $path;
}
function jclic_get_filemanager_options(){
$filemanager_options = array();
$filemanager_options['return_types'] = 3; // 3 == FILE_EXTERNAL & FILE_INTERNAL. These two constant names are defined in repository/lib.php
$filemanager_options['accepted_types'] = 'archive';
$filemanager_options['maxbytes'] = 0;
$filemanager_options['subdirs'] = 0;
$filemanager_options['maxfiles'] = 1;
return $filemanager_options;
}
function jclic_set_mainfile($data) {
$filename = null;
$fs = get_file_storage();
$cmid = $data->coursemodule;
$draftitemid = $data->url;
$context = get_context_instance(CONTEXT_MODULE, $cmid);
if ($draftitemid) {
file_save_draft_area_files($draftitemid, $context->id, 'mod_jclic', 'content', 0, jclic_get_filemanager_options());
}
$files = $fs->get_area_files($context->id, 'mod_jclic', 'content', 0, 'sortorder', false);
if (count($files) == 1) {
// only one file attached, set it as main file automatically
$file = reset($files);
file_set_sortorder($context->id, 'mod_jclic', 'content', 0, $file->get_filepath(), $file->get_filename(), 1);
$filename = $file->get_filename();
}
return $filename;
}
function jclic_is_valid_external_url($url){
return preg_match('/(http:\/\/|https:\/\/|www).*\/*.jclic.zip(\?[a-z+&\$_.-][a-z0-9;:@&%=+\/\$_.-]*)?$/i', $url);
}
function jclic_is_valid_file($filename){
return preg_match('/.jclic.zip$/i', $filename);
}
////////////////////////////////////////////////////////////////////////////////
// Activity sessions //
////////////////////////////////////////////////////////////////////////////////
/**
* Get user sessions
*
* @return array [0=>session1,1=>session2...] where session1 is an array with keys: id,score,totaltime,starttime,done,solved,attempts. First sessions are newest.
* @param object $jclicid The jclic to get sessions
* @param object $userid The user id to get sessions
*/
function jclic_get_sessions($jclicid, $userid) {
global $CFG, $DB;
$sessions=array();
jclic_normalize_date();
$sql = "SELECT js.*
FROM {jclic} j, {jclic_sessions} js
WHERE j.id=js.jclicid AND js.jclicid=? AND js.user_id=?
ORDER BY js.session_datetime";
$params = array($jclicid, $userid);
if($rs = $DB->get_records_sql($sql, $params)){
$i = 0;
foreach($rs as $session){
$activity = jclic_get_activity($session);
$activity->attempts=$i+1;
$sessions[$i++]=$activity;
}
}
return $sessions;
}
/**
* Get session activities
*
* @return array [0=>act0,1=>act1...] where act0 is an array with keys: activity_id,activity_name,num_actions,score,activity_solved,qualification, total_time. First activity are oldest.
* @param string $session_id The session id to get actitivies
*/
function jclic_get_activities($session_id) {
global $CFG, $DB;
$activities = array();
if($rs = $DB->get_records('jclic_activities', array('session_id'=>$session_id), 'activity_id')){
$i=0;
foreach($rs as $activity){
$activities[$i++]=$activity;
}
}
return $activities;
}
/**
* Get information about activities of specified session
*
* @return array Array has these keys id,score,totaltime,starttime,done,solved,attempts
* @param object $session The session object
*/
function jclic_get_activity($session) {
global $CFG, $DB;
$activity = new stdClass();
$activity->starttime=$session->session_datetime;
$activity->session_id=$session->session_id;
if($rs = $DB->get_record_sql("SELECT AVG(ja.qualification) as qualification, SUM(ja.total_time) as totaltime
FROM {jclic_activities} ja
WHERE ja.session_id='$session->session_id'")){
$activity->score = round($rs->qualification,0);
$activity->totaltime = jclic_format_time($rs->totaltime);
}
if ($rs = $DB->get_record_sql("SELECT COUNT(*) as done
FROM (SELECT DISTINCT ja.activity_name
FROM {jclic_activities} ja
WHERE ja.session_id='$session->session_id') t")){
$activity->done=$rs->done;
}
if ($rs = $DB->get_record_sql("SELECT COUNT(*) as solved
FROM (SELECT DISTINCT ja.activity_name
FROM {jclic_activities} ja
WHERE ja.session_id='$session->session_id' AND ja.activity_solved=1) t")){
$activity->solved=$rs->solved;
}
return $activity;
}
/**
* Print a table data with all session activities
*
* @param string $session_id The session identifier
*/
function jclic_get_session_activities_html($session_id){
$table_html='';
// Import language strings
$stractivity = get_string("activity", "jclic");
$strsolved = get_string("solved", "jclic");
$stractions = get_string("actions", "jclic");
$strtime = get_string("time", "jclic");
$strscore = get_string("score", "jclic");
$stryes = get_string("yes");
$strno = get_string("no");
// Print activities for each session
$activities = jclic_get_activities($session_id);
if (sizeof($activities)>0){
$table = new html_table();
$table->attributes = array('class'=>'jclic-activities-table');
$table->head = array($stractivity, $strsolved, $stractions, $strtime, $strscore);
foreach($activities as $activity){
$act_percent=$activity->num_actions>0?round(($activity->score/$activity->num_actions)*100,0):0;
$row = new html_table_row();
$row->attributes = array('class' => ($activity->activity_solved?'jclic-activity-solved':'jclic-activity-unsolved') ) ;
$row->cells = array($activity->activity_name, ($activity->activity_solved?$stryes:$strno), $activity->score.'/'.$activity->num_actions.' ('.$act_percent.'%)', jclic_time2str($activity->total_time), $activity->qualification.'%');
$table->data[] = $row;
}
$table_html = html_writer::table($table);
}
return $table_html;
}
/**
* Convert specified time (in milliseconds) to XX' YY'' format
*
* @param type $time time (in milliseconds) to format
*/
function jclic_format_time($time){
return floor($time/60000)."' ".round(fmod($time,60000)/1000,0)."''";
}
/**
* Get user activity summary
*
* @return object session object with score, totaltime, activities done and solved and attempts information
*/
function jclic_get_sessions_summary($jclicid, $userid) {
global $CFG, $DB;
jclic_normalize_date();
$sessions_summary = new stdClass();
$sessions_summary->attempts = '';
$sessions_summary->score = '';
$sessions_summary->totaltime = '';
$sessions_summary->starttime = '';
$sessions_summary->done = '';
$sessions_summary->solved = '';
if ($rs = $DB->get_record_sql("SELECT COUNT(*) AS attempts, AVG(t.qualification) AS qualification, SUM(t.totaltime) AS totaltime, MAX(t.starttime) AS starttime
FROM (SELECT AVG(ja.qualification) AS qualification, SUM(ja.total_time) AS totaltime, MAX(js.session_datetime) AS starttime
FROM {jclic} j, {jclic_sessions} js, {jclic_activities} ja
WHERE j.id=js.jclicid AND js.user_id='$userid' AND js.jclicid=$jclicid AND ja.session_id=js.session_id
GROUP BY js.session_id) t")){
$sessions_summary->attempts=$rs->attempts;
$sessions_summary->score=round($rs->qualification,0);
$sessions_summary->totaltime= jclic_format_time($rs->totaltime);
$sessions_summary->starttime=$rs->starttime;
}
if ($rs = $DB->get_record_sql("SELECT COUNT(*) as done
FROM (SELECT DISTINCT ja.activity_name
FROM {jclic} j, {jclic_sessions} js, {jclic_activities} ja
WHERE j.id=js.jclicid AND js.user_id='$userid' AND js.jclicid=$jclicid AND js.session_id=ja.session_id) t")){
$sessions_summary->done=$rs->done;
}
if ($rs = $DB->get_record_sql("SELECT COUNT(*) as solved
FROM (SELECT DISTINCT ja.activity_name
FROM {jclic} j, {jclic_sessions} js, {jclic_activities} ja
WHERE j.id=js.jclicid AND js.user_id='$userid' AND js.jclicid=$jclicid AND js.session_id=ja.session_id AND ja.activity_solved=1) t")){
$sessions_summary->solved=$rs->solved;
}
return $sessions_summary;
}
/**
* Format time from milliseconds to string
*
* @return string Formated string [x' y''], where x are the minutes and y are the seconds.
* @param int $time The time (in ms)
*/
function jclic_time2str($time){
return round($time/60000,0)."' ".round(fmod($time,60000)/1000,0)."''";
}
function jclic_print_results_table($jclic, $context, $cm, $course, $action){
global $CFG, $DB, $OUTPUT, $PAGE;
$PAGE->requires->js('/mod/jclic/jclic.js');
// View all/summary sessions link
if (isset($action) && $action != 'showall'){
$url = new moodle_url('/mod/jclic/view.php', array('id' => $context->instanceid, 'action' => 'showall'));
$text = get_string('showall', 'jclic');
} else{
$url = new moodle_url('/mod/jclic/view.php', array('id' => $context->instanceid));
$text = get_string('hideall', 'jclic');
}
echo '';
// Preview link to JClic activity
$url = new moodle_url('/mod/jclic/view.php', array('id' => $context->instanceid, 'action' => 'preview'));
echo '';
// Show students list with their results
require_once($CFG->libdir.'/gradelib.php');
$perpage = optional_param('perpage', 10, PARAM_INT);
$perpage = ($perpage <= 0) ? 10 : $perpage ;
$page = optional_param('page', 0, PARAM_INT);
/// find out current groups mode
$groupmode = groups_get_activity_groupmode($cm);
$currentgroup = groups_get_activity_group($cm, true);
/// Get all ppl that are allowed to submit jclic
list($esql, $params) = get_enrolled_sql($context, 'mod/jclic:submit', $currentgroup);
$sql = "SELECT u.id FROM {user} u ".
"LEFT JOIN ($esql) eu ON eu.id=u.id ".
"WHERE u.deleted = 0 AND eu.id=u.id ";
$users = $DB->get_records_sql($sql, $params);
if (!empty($users)) {
$users = array_keys($users);
}
// if groupmembersonly used, remove users who are not in any group
if ($users and !empty($CFG->enablegroupmembersonly) and $cm->groupmembersonly) {
if ($groupingusers = groups_get_grouping_members($cm->groupingid, 'u.id', 'u.id')) {
$users = array_intersect($users, array_keys($groupingusers));
}
}
// Create results table
if (function_exists('get_extra_user_fields') ) {
$extrafields = get_extra_user_fields($context);
} else{
$extrafields = array();
}
$tablecolumns = array_merge(array('picture', 'fullname'), $extrafields,
array('starttime', 'attempts', 'solveddone', 'totaltime', 'grade'));
$extrafieldnames = array();
foreach ($extrafields as $field) {
$extrafieldnames[] = get_user_field_name($field);
}
$strstarttime = ($action=='showall')?get_string('starttime', 'jclic'):get_string('lastaccess', 'jclic');
$tableheaders = array_merge(
array('', get_string('fullnameuser')),
$extrafieldnames,
array(
$strstarttime,
get_string('attempts', 'jclic'),
get_string('solveddone', 'jclic'),
get_string('totaltime', 'jclic'),
get_string('grade'),
));
require_once($CFG->libdir.'/tablelib.php');
$table = new flexible_table('mod-jclic-results');
$table->define_columns($tablecolumns);
$table->define_headers($tableheaders);
$table->define_baseurl($CFG->wwwroot.'/mod/jclic/view.php?id='.$cm->id.'¤tgroup='.$currentgroup.'&action='.$action);
$table->sortable(true, 'lastname'); //sorted by lastname by default
$table->collapsible(true);
$table->initialbars(true);
$table->column_suppress('picture');
$table->column_suppress('fullname');
$table->column_class('picture', 'picture');
$table->column_class('fullname', 'fullname');
foreach ($extrafields as $field) {
$table->column_class($field, $field);
}
$table->set_attribute('cellspacing', '0');
$table->set_attribute('id', 'attempts');
$table->set_attribute('class', 'results generaltable generalbox');
$table->set_attribute('width', '100%');
$table->no_sorting('starttime');
$table->no_sorting('solveddone');
$table->no_sorting('totaltime');
$table->no_sorting('attempts');
$table->no_sorting('grade');
// Start working -- this is necessary as soon as the niceties are over
$table->setup();
/// Construct the SQL
list($where, $params) = $table->get_sql_where();
if ($where) {
$where .= ' AND ';
}
if ($sort = $table->get_sql_sort()) {
$sort = ' ORDER BY '.$sort;
}
$ufields = user_picture::fields('u', $extrafields);
if (!empty($users)) {
$select = "SELECT $ufields ";
$sql = 'FROM {user} u '.
'WHERE '.$where.'u.id IN ('.implode(',',$users).') ';
$ausers = $DB->get_records_sql($select.$sql.$sort, $params, $table->get_page_start(), $table->get_page_size());
$table->pagesize($perpage, count($users));
$offset = $page * $perpage; //offset used to calculate index of student in that particular query, needed for the pop up to know who's next
if ($ausers !== false) {
//$grading_info = grade_get_grades($course->id, 'mod', 'jclic', $jclic->id, array_keys($ausers));
$endposition = $offset + $perpage;
$currentposition = $offset;
$ausersObj = new ArrayObject($ausers);
$iterator = $ausersObj->getIterator();
$iterator->seek($currentposition);
while ($iterator->valid() && $currentposition < $endposition ) {
$auser = $iterator->current();
$picture = $OUTPUT->user_picture($auser);
$userlink = '' . fullname($auser, has_capability('moodle/site:viewfullnames', $context)) . '';
$extradata = array();
foreach ($extrafields as $field) {
$extradata[] = $auser->{$field};
}
$sessions = array();
if ($action == 'showall'){
// Print sessions for each student
$sessions=jclic_get_sessions($jclic->id, $auser->id);
if (sizeof($sessions)>0){
$first_session=true;
foreach($sessions as $session){
// Print session information
$rowclass = null;
$starttime=''.date('d/m/Y H:i',strtotime($session->starttime)).'';
$solveddone = $session->solved. ' / '. $session->done;
$grade = $session->score;
$totaltime = $session->totaltime;
$attempts = $session->attempts;
$row = array_merge(array($picture, $userlink), $extradata,
array($starttime, $attempts, $solveddone, $totaltime, $grade));
$table->add_data($row, $rowclass);
// Print activities for each session
$html='';
$html.=' | ';
$html.= '';
$html.= jclic_get_session_activities_html($session->session_id);
$html.= ' |
';
echo $html;
// Remove user information (only showed in the first row)
if ($first_session){
$first_session = false;
$picture = null;
$userlink = null;
// Remove extradata fields to show them only once
foreach ($extradata as $key=>$value){
$extradata[$key] = '';
}
}
}
}
}
// Sessions summary
$sessions_summary = jclic_get_sessions_summary($jclic->id, $auser->id);
$starttime = (sizeof($sessions)>0)?get_string('totals', 'jclic'):(isset($sessions_summary->starttime)?date('d/m/Y H:i',strtotime($sessions_summary->starttime)):'-');
$solveddone = $sessions_summary->solved. ' / '. $sessions_summary->done;
$grade = $sessions_summary->score;
$totaltime = $sessions_summary->totaltime;
$attempts = $sessions_summary->attempts;
$row = array_merge(array($picture, $userlink), $extradata,
array($starttime, $attempts, $solveddone, $totaltime, $grade));
$rowclass = (sizeof($sessions)>0)?'summary-row':'';
$table->add_data($row, $rowclass);
// Forward iterator
$currentposition++;
$iterator->next();
}
$table->print_html(); /// Print the whole table
}
}
}
/**
* Workaround to fix an Oracle's bug when inserting a row with date
*/
function jclic_normalize_date () {
global $CFG, $DB;
if ($CFG->dbtype == 'oci'){
$sql = "ALTER SESSION SET NLS_DATE_FORMAT='YYYY-MM-DD HH24:MI:SS'";
$DB->execute($sql);
}
}
jclicmoodle-0.2.3/lib.php 0000644 0001750 0001750 00000065426 12216575042 015412 0 ustar demarchi demarchi .
/**
* Library of interface functions and constants for module jclic
*
* All the core Moodle functions, neeeded to allow the module to work
* integrated in Moodle should be placed here.
* All the jclic specific functions, needed to implement all the module
* logic, should go to locallib.php. This will help to save some memory when
* Moodle is performing actions across all modules.
*
* @package mod
* @subpackage jclic
* @copyright 2011 Departament d'Ensenyament de la Generalitat de Catalunya
* @author Sara Arjona Téllez
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
define('JCLIC_DEFAULT_JARBASE', 'http://clic.xtec.cat/dist/jclic');
define('JCLIC_DEFAULT_LAP', 5);
if (!isset($CFG->jclic_jarbase)) {
set_config('jclic_jarbase', JCLIC_DEFAULT_JARBASE);
}
if (!isset($CFG->jclic_lap)) {
set_config("jclic_lap", "5");
}
// JClic file types
define('JCLIC_FILE_TYPE_LOCAL', 'local');
define('JCLIC_FILE_TYPE_EXTERNAL', 'external');
/** Include eventslib.php */
require_once($CFG->libdir.'/eventslib.php');
/** Include formslib.php */
require_once($CFG->libdir.'/formslib.php');
/** Include calendar/lib.php */
require_once($CFG->dirroot.'/calendar/lib.php');
////////////////////////////////////////////////////////////////////////////////
// Moodle core API //
////////////////////////////////////////////////////////////////////////////////
/**
* Returns the information on whether the module supports a feature
*
* @todo: review features before publishing the module
*
* @see plugin_supports() in lib/moodlelib.php
* @param string $feature FEATURE_xx constant for requested feature
* @return mixed true if the feature is supported, null if unknown
*/
function jclic_supports($feature) {
switch($feature) {
case FEATURE_GROUPS: return true;
// case FEATURE_GROUPINGS: return true;
// case FEATURE_GROUPMEMBERSONLY: 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_RATE: return true;
case FEATURE_BACKUP_MOODLE2: return true;
// case FEATURE_SHOW_DESCRIPTION: return true;
// case FEATURE_ADVANCED_GRADING: return true;
default:
if (defined('FEATURE_SHOW_DESCRIPTION') && $feature==FEATURE_SHOW_DESCRIPTION) return true;
else return null;
}
}
/**
* Saves a new instance of the jclic into the database
*
* 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.
*
* @todo: create event (when timedue added)
*
* @param object $jclic An object from the form in mod_form.php
* @param mod_jclic_mod_form $mform
* @return int The id of the newly inserted jclic record
*/
function jclic_add_instance(stdClass $jclic, mod_jclic_mod_form $mform = null) {
global $DB;
$cmid = $jclic->coursemodule;
$jclic->timecreated = time();
if ($jclic->skin=='') $jclic->skin = "default";
if ($mform->get_data()->filetype === JCLIC_FILE_TYPE_LOCAL) {
$jclic->url = $mform->get_data()->jclicfile;
} else{
$jclic->url = $jclic->jclicurl;
}
if ($jclic->grade >=0 ) {
$jclic->maxgrade = $jclic->grade;
}
$jclic->id = $DB->insert_record('jclic', $jclic);
// we need to use context now, so we need to make sure all needed info is already in db
$DB->set_field('course_modules', 'instance', $jclic->id, array('id'=>$cmid));
// Store the JClic and verify
if ($mform->get_data()->filetype === JCLIC_FILE_TYPE_LOCAL) {
$filename = jclic_set_mainfile($jclic);
$jclic->url = $filename;
$DB->update_record('jclic', $jclic);
}
if ($jclic->timedue) {
$event = new stdClass();
$event->name = $jclic->name;
$event->description = format_module_intro('jclic', $jclic, $jclic->coursemodule);
$event->courseid = $jclic->course;
$event->groupid = 0;
$event->userid = 0;
$event->modulename = 'jclic';
$event->instance = $jclic->id;
$event->eventtype = 'due';
$event->timestart = $jclic->timedue;
$event->timeduration = 0;
calendar_event::create($event);
}
jclic_grade_item_update($jclic);
return $jclic->id;
}
/**
* Updates an instance of the jclic in the database
*
* 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.
*
* @param object $jclic An object from the form in mod_form.php
* @param mod_jclic_mod_form $mform
* @return boolean Success/Fail
*/
function jclic_update_instance(stdClass $jclic, mod_jclic_mod_form $mform = null) {
global $DB;
$jclic->timemodified = time();
$jclic->id = $jclic->instance;
if ($mform->get_data()->filetype === JCLIC_FILE_TYPE_LOCAL) {
$jclic->url = $mform->get_data()->jclicfile;
} else{
$jclic->url = $jclic->jclicurl;
}
if ($jclic->grade >=0 ) {
$jclic->maxgrade = $jclic->grade;
}
$result = $DB->update_record('jclic', $jclic);
if ($result && $mform->get_data()->filetype === JCLIC_FILE_TYPE_LOCAL) {
$filename = jclic_set_mainfile($jclic);
$jclic->url = $filename;
$result = $DB->update_record('jclic', $jclic);
}
if ($result && $jclic->timedue) {
$event = new stdClass();
if ($event->id = $DB->get_field('event', 'id', array('modulename'=>'jclic', 'instance'=>$jclic->id))) {
$event->name = $jclic->name;
$event->description = format_module_intro('jclic', $jclic, $jclic->coursemodule);
$event->timestart = $jclic->timedue;
$calendarevent = calendar_event::load($event->id);
$calendarevent->update($event);
} else {
$event = new stdClass();
$event->name = $jclic->name;
$event->description = format_module_intro('jclic', $jclic, $jclic->coursemodule);
$event->courseid = $jclic->course;
$event->groupid = 0;
$event->userid = 0;
$event->modulename = 'jclic';
$event->instance = $jclic->id;
$event->eventtype = 'due';
$event->timestart = $jclic->timedue;
$event->timeduration = 0;
calendar_event::create($event);
}
} else {
$DB->delete_records('event', array('modulename'=>'jclic', 'instance'=>$jclic->id));
}
if ($result){
// get existing grade item
$result = jclic_grade_item_update($jclic);
}
return $result;
}
/**
* Removes an instance of the jclic from the database
*
* Given an ID of an instance of this module,
* this function will permanently delete the instance
* and any data that depends on it.
*
* @todo: delete event records (after adding this feature to the module)
*
* @param int $id Id of the module instance
* @return boolean Success/Failure
*/
function jclic_delete_instance($id) {
global $DB;
if (!$jclic = $DB->get_record('jclic', array('id'=>$id))) {
return false;
}
$result = true;
// Delete any dependent records
$rs = $DB->get_records('jclic_sessions', array('jclicid' => $id));
foreach($rs as $session){
$DB->delete_records('jclic_activities', array('session_id' => $session->session_id));
}
$DB->delete_records('jclic_sessions', array('jclicid' => $id));
// delete items from the gradebook
if(!jclic_grade_item_delete($jclic)){
$result = false;
}
/** TODO: // delete files associated with this jclic
$fs = get_file_storage();
if (! $fs->delete_area_files($context->id) ) {
$result = false;
}
**/
// delete events related with this instance
$DB->delete_records('event', array('modulename'=>'jclic', 'instance'=>$id));
// delete the instance
$DB->delete_records('jclic', array('id' => $id));
return $result;
}
/**
* Returns 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.
* $return->time = the time they did it
* $return->info = a short text description
*
* @param object $course
* @param object $user
* @param object $mod
* @param object $jclic
* @return stdClass|null
*/
function jclic_user_outline($course, $user, $mod, $jclic) {
global $CFG;
require_once("$CFG->libdir/gradelib.php");
$result = null;
$grades = grade_get_grades($course->id, 'mod', 'jclic', $jclic->id, $user->id);
if (!empty($grades->items[0]->grades)) {
$grade = reset($grades->items[0]->grades);
$result = new stdClass();
$result->info = get_string('grade') . ': ' . $grade->str_long_grade;
//if grade was last modified by the user themselves use date graded. Otherwise use date submitted
if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
$result->time = $grade->dategraded;
} else {
$result->time = $grade->datesubmitted;
}
}
return $result;
}
/**
* Prints a detailed representation of what a user has done with
* a given particular instance of this module, for user activity reports.
*
* @todo: implement
*
* @return string HTML
*/
function jclic_user_complete($course, $user, $mod, $jclic) {
$outline = jclic_user_outline($course, $user, $mod, $jclic);
print_r($outline->info);
return true;
}
/**
* Given a course and a time, this module should find recent activity
* that has occurred in jclic activities and print it out.
* Return true if there was output, or false is there was none.
*
* @todo: implement
*
* @return boolean
*/
function jclic_print_recent_activity($course, $viewfullnames, $timestart) {
return false; // True if anything was printed, otherwise false
}
/**
* Returns all activity in jclics since a given time
*
* @todo: implement
*
* @param array $activities sequentially indexed array of objects
* @param int $index
* @param int $timestart
* @param int $courseid
* @param int $cmid
* @param int $userid defaults to 0
* @param int $groupid defaults to 0
* @return void adds items into $activities and increases $index
*/
function jclic_get_recent_mod_activity(&$activities, &$index, $timestart, $courseid, $cmid, $userid=0, $groupid=0) {
}
/**
* Prints single activity item prepared by {@see jclic_get_recent_mod_activity()}
*
* @todo: implement
*
* @return void
*/
function jclic_print_recent_mod_activity($activity, $courseid, $detail, $modnames, $viewfullnames) {
}
/**
* Function to be run periodically according to the moodle cron
* This function searches for things that need to be done, such
* as sending out mail, toggling flags etc ...
*
* @return boolean
* @todo Finish documenting this function
**/
function jclic_cron () {
return true;
}
/**
* Returns an array of users who are participanting in this jclic
*
* Must return an array of users who are participants for a given instance
* of jclic. Must include every user involved in the instance,
* independient of his role (student, teacher, admin...). The returned
* objects must contain at least id property.
* See other modules as example.
*
* @param int $jclicid ID of an instance of this module
* @return boolean|array false if no participants, array of objects otherwise
*/
function jclic_get_participants($jclicid) {
global $CFG, $DB;
//Get students
$students = $DB->get_records_sql("SELECT DISTINCT u.id, u.id as userid
FROM {user} u,
{jclic_sessions} js
WHERE js.jclicid = ? and
u.id = js.user_id", array($jclicid));
//Get teachers
$teachers = $DB->get_records_sql("SELECT DISTINCT u.id, u.id as userid
FROM {user} u,
{jclic_sessions} js
WHERE js.jclicid = ? and
u.id = js.user_id", array($jclicid));
//Add teachers to students
if ($teachers) {
foreach ($teachers as $teacher) {
$students[$teacher->id] = $teacher;
}
}
//Return students array (it contains an array of unique users)
return ($students);
}
/**
* Returns all other caps used in the module
*
* @example return array('moodle/site:accessallgroups');
* @return array
*/
function jclic_get_extra_capabilities() {
return array('moodle/site:accessallgroups', 'moodle/site:viewfullnames', 'moodle/grade:managegradingforms');
}
////////////////////////////////////////////////////////////////////////////////
// Gradebook API //
////////////////////////////////////////////////////////////////////////////////
/**
* Is a given scale used by the instance of jclic?
*
* This function returns if a scale is being used by one jclic
* if it has support for grading and scales. Commented code should be
* modified if necessary. See forum, glossary or journal modules
* as reference.
*
* @param int $jclicid ID of an instance of this module
* @return bool true if the scale is used by the given jclic instance
*/
function jclic_scale_used($jclicid, $scaleid) {
global $DB;
$return = false;
$rec = $DB->get_record('jclic', array('id'=>$jclicid,'grade'=>-$scaleid));
if (!empty($rec) && !empty($scaleid)) {
$return = true;
}
return $return;
}
/**
* Checks if scale is being used by any instance of jclic.
*
* This is used to find out if scale used anywhere.
*
* @param $scaleid int
* @return boolean true if the scale is used by any jclic instance
*/
function jclic_scale_used_anywhere($scaleid) {
global $DB;
if ($scaleid and $DB->record_exists('jclic', array('grade'=>-$scaleid))) {
return true;
} else {
return false;
}
}
/**
* Creates or updates grade item for the give jclic instance
*
* Needed by grade_update_mod_grades() in lib/gradelib.php
*
* @uses GRADE_TYPE_NONE
* @uses GRADE_TYPE_VALUE
* @uses GRADE_TYPE_SCALE
* @param stdClass $jclic instance object with extra cmidnumber and modname property
* @param mixed $grades optional array/object of grade(s); 'reset' means reset grades in gradebook
* @return int 0 if ok
*/
function jclic_grade_item_update(stdClass $jclic, $grades=NULL) {
global $CFG;
require_once($CFG->libdir.'/gradelib.php');
if (!isset($jclic->courseid)) {
$jclic->courseid = $jclic->course;
}
$params = array();
$params['itemname'] = clean_param($jclic->name, PARAM_NOTAGS);
$params['idnumber'] = $jclic->cmidnumber;
if ($jclic->grade > 0) {
$params['gradetype'] = GRADE_TYPE_VALUE;
$params['grademax'] = $jclic->grade;
$params['grademin'] = 0;
} else if ($jclic->grade < 0) {
$params['gradetype'] = GRADE_TYPE_SCALE;
$params['scaleid'] = -$jclic->grade;
} else {
$params['gradetype'] = GRADE_TYPE_NONE; // allow text comments only
}
if ($grades === 'reset') {
$params['reset'] = true;
$grades = NULL;
}
grade_update('mod/jclic', $jclic->courseid, 'mod', 'jclic', $jclic->id, 0, $grades, $params);
return true;
}
/**
* Delete grade item for given jclic
*
* @global object
* @param object $jclic object
* @return object grade_item
*/
function jclic_grade_item_delete($jclic) {
global $CFG;
require_once($CFG->libdir.'/gradelib.php');
return grade_update('mod/jclic', $jclic->course, 'mod', 'jclic', $jclic->id, 0, NULL, array('deleted'=>1)) == GRADE_UPDATE_OK;
}
/**
* Return grade for given user or all users.
*
* @todo: implement userid=0 (all users)
* @todo: optimize this function (to avoid call jclic_get_sessions_summary or update only mandatory info)
*
* @param object $jclic object
* @param int $userid optional user id, 0 means all users
* @return array array of grades, false if none
*/
function jclic_get_user_grades($jclic, $userid=0) {
global $CFG;
require_once($CFG->dirroot.'/mod/jclic/locallib.php');
// sanity check on $jclic->id
if (! isset($jclic->id)) {
return;
}
$grades[$userid] = new stdClass();
$sessions_summary = jclic_get_sessions_summary($jclic->id, $userid);
$grades[$userid]->userid = $userid;
$grades[$userid]->attempts = $sessions_summary->attempts;
$grades[$userid]->totaltime = $sessions_summary->totaltime;
$grades[$userid]->starttime = $sessions_summary->starttime;
$grades[$userid]->done = $sessions_summary->done;
$grades[$userid]->rawgrade = 0;
if ($jclic->avaluation=='score'){
$grades[$userid]->rawgrade = $sessions_summary->score;
}else{
$grades[$userid]->rawgrade = $sessions_summary->solved;
}
return $grades;
}
/**
* Update jclic grades in the gradebook
*
* Needed by grade_update_mod_grades() in lib/gradelib.php
*
* @todo: Fix some problems (this function is not working when is called from beans.php)
*
* @param stdClass $jclic instance object with extra cmidnumber and modname property
* @param int $userid update grade of specific user only, 0 means all participants
* @param boolean $nullifnone return null if grade does not exist
* @return void
*/
function jclic_update_grades(stdClass $jclic, $userid = 0, $nullifnone=true) {
global $CFG;
require_once($CFG->libdir.'/gradelib.php');
if ($jclic->grade == 0) {
jclic_grade_item_update($jclic);
} else if ($grades = jclic_get_user_grades($jclic, $userid)) {
foreach($grades as $k=>$v) {
if ($v->rawgrade == -1) {
$grades[$k]->rawgrade = null;
}
}
jclic_grade_item_update($jclic, $grades);
} else if ($userid and $nullifnone) {
$grade = new stdClass();
$grade->userid = $userid;
$grade->rawgrade = NULL;
jclic_grade_item_update($jclic, $grade);
} else {
jclic_grade_item_update($jclic);
}
}
////////////////////////////////////////////////////////////////////////////////
// File API //
////////////////////////////////////////////////////////////////////////////////
/**
* Returns the lists of all browsable file areas within the given module context
*
* The file area 'intro' for the activity introduction field is added automatically
* by {@link file_browser::get_file_info_context_module()}
*
* @param stdClass $course
* @param stdClass $cm
* @param stdClass $context
* @return array of [(string)filearea] => (string)description
*/
function jclic_get_file_areas($course, $cm, $context) {
return array(
'content' => get_string('urledit', 'jclic')
);
}
/**
* File browsing support for jclic module content area.
* @param object $browser
* @param object $areas
* @param object $course
* @param object $cm
* @param object $context
* @param string $filearea
* @param int $itemid
* @param string $filepath
* @param string $filename
* @return object file_info instance or null if not found
*/
function jclic_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
global $CFG;
if (!has_capability('moodle/course:managefiles', $context)) {
// students can not peak here!
return null;
}
$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_jclic', 'content', 0, $filepath, $filename)) {
if ($filepath === '/' and $filename === '.') {
$storedfile = new virtual_root_file($context->id, 'mod_jclic', 'content', 0);
} else {
// not found
return null;
}
}
return new file_info_stored($browser, $context, $storedfile, $urlbase, $areas[$filearea], false, true, false, false);
}
// note: jclic_intro handled in file_browser automatically
return null;
}
/**
* Serves the files from the jclic file areas
*
* @param stdClass $course
* @param stdClass $cm
* @param stdClass $context
* @param string $filearea
* @param array $args
* @param bool $forcedownload
* @return void this should never return to the caller
*/
function jclic_pluginfile($course, $cm, $context, $filearea, array $args, $forcedownload) {
global $DB, $CFG;
if ($context->contextlevel != CONTEXT_MODULE) {
send_file_not_found();
}
require_login($course, true, $cm);
if (!has_capability('mod/jclic:view', $context)) {
return false;
}
if ($filearea !== 'content') {
// intro is handled automatically in pluginfile.php
return false;
}
array_shift($args); // ignore revision - designed to prevent caching problems only
$fs = get_file_storage();
$relativepath = implode('/', $args);
$fullpath = rtrim("/$context->id/mod_jclic/$filearea/0/$relativepath", '/');
do {
if ($file = $fs->get_file_by_hash(sha1($fullpath))) {
break;
}
/*
$jclic = $DB->get_record('jclic', array('id'=>$cm->instance), 'id, legacyfiles', MUST_EXIST);
if (!$file = jcliclib_try_file_migration('/'.$relativepath, $cm->id, $cm->course, 'mod_jclic', 'content', 0)) {
return false;
}
// file migrate - update flag
$resource->legacyfileslast = time();
$DB->update_record('resource', $resource);
*/
} while (false);
// finally send the file
send_stored_file($file, 86400, 0, $forcedownload);
}
////////////////////////////////////////////////////////////////////////////////
// Navigation API //
////////////////////////////////////////////////////////////////////////////////
/**
* Extends the global navigation tree by adding jclic nodes if there is a relevant content
*
* This can be called by an AJAX request so do not rely on $PAGE as it might not be set up properly.
*
* @param navigation_node $navref An object representing the navigation tree node of the jclic module instance
* @param stdClass $course
* @param stdClass $module
* @param cm_info $cm
*/
function jclic_extend_navigation(navigation_node $navref, stdclass $course, stdclass $module, cm_info $cm) {
}
/**
* Extends the settings navigation with the jclic settings
*
* This function is called when the context for the page is a jclic module. This is not called by AJAX
* so it is safe to rely on the $PAGE.
*
* @param settings_navigation $settingsnav {@link settings_navigation}
* @param navigation_node $jclicnode {@link navigation_node}
*/
function jclic_extend_settings_navigation(settings_navigation $settingsnav, navigation_node $jclicnode=null) {
}
////////////////////////////////////////////////////////////////////////////////
// Reset //
////////////////////////////////////////////////////////////////////////////////
/**
* Removes all grades from gradebook
* @param int $courseid
* @param string optional type
*/
function jclic_reset_gradebook($courseid) {
global $CFG, $DB;
$params = array('courseid'=>$courseid);
$sql = "SELECT j.*, cm.idnumber as cmidnumber, j.course as courseid
FROM {jclic} j, {course_modules} cm, {modules} m
WHERE m.name='jclic' AND m.id=cm.module AND cm.instance=j.id AND j.course=:courseid ";
if ($jclics = $DB->get_records_sql($sql, $params)) {
foreach ($jclics as $jclic) {
jclic_grade_item_update($jclic, 'reset');
}
}
}
/**
* This function is used by the reset_course_userdata function in moodlelib.
* This function will remove all posts from the specified jclic
* and clean up any related data.
* @param $data the data submitted from the reset course.
* @return array status array
*/
function jclic_reset_userdata($data) {
global $CFG, $DB;
$componentstr = get_string('modulenameplural', 'choice');
$status = array();
if (!empty($data->reset_jclic_deleteallsessions)) {
$params = array('courseid' => $data->courseid);
$select = 'session_id IN'
. " (SELECT s.session_id FROM {jclic_sessions} s"
. " INNER JOIN {jclic} j ON s.jclicid = j.id"
. " WHERE j.course = :courseid)";
$DB->delete_records_select('jclic_activities', $select, $params);
$select = 'jclicid IN'
. " (SELECT j.id FROM {jclic} j"
. " WHERE j.course = :courseid)";
$DB->delete_records_select('jclic_sessions', $select, $params);
// remove all grades from gradebook
if (empty($data->reset_gradebook_grades)) {
jclic_reset_gradebook($data->courseid);
}
$status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallsessions', 'jclic'), 'error'=>false);
}
return $status;
}
/**
* Implementation of the function for printing the form elements that control
* whether the course reset functionality affects the jclic.
* @param $mform form passed by reference
*/
function jclic_reset_course_form_definition(&$mform) {
$mform->addElement('header', 'jclicheader', get_string('modulenameplural', 'jclic'));
$mform->addElement('checkbox', 'reset_jclic_deleteallsessions', get_string('deleteallsessions', 'jclic'));
}
/**
* Course reset form defaults.
*/
function jclic_reset_course_form_defaults($course) {
return array('reset_jclic_deleteallsessions' => 1);
}
jclicmoodle-0.2.3/README.txt 0000644 0001750 0001750 00000005261 12216575042 015620 0 ustar demarchi demarchi ##
# JClic module for Moodle
#
# @package mod
# @subpackage jclic
# @copyright 2008 Departament d'Ensenyament de la Generalitat de Catalunya
# @source https://github.com/projectestac/moodle-mod_jclic/
# @license http://www.gnu.org/licenses/gpl-2.0.txt
##
Clic [1] is a set of free software for the development of multimedia educational
activities.
This module allows the incorporation of JClic activities in Moodle. Its main
features are:
- Allows embedding easily JClic activities in some Moodle course.
- Facilitates students tracing because it stores the score, date and duration
of each of the attempts made by the users.
-----------------------------------------------------------------------------
This program 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.
This program 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 this program (in a file called COPYING); if not, go
to http://www.gnu.org/copyleft/gpl.html or write to
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307 USA
-----------------------------------------------------------------------------
REQUIREMENTS
Compatible with Moodle 2.X releases
-----------------------------------------------------------------------------
INSTALL
Follow the usual installation instructions
-----------------------------------------------------------------------------
CREDITS
Developers:
Sara Arjona Tellez (sarjona@xtec.cat)
With the support of:
Education Government of Catalonia [2]
Francesc Busquets Burguera (fbusquet@xtec.cat)
JClic community support:
Monica Grau
Translations:
Basque:
Abel Camacho - didaktika@santurtzieus.com
Pedro Lonbide - zuzen@santurtzieus.com
Brazilian
Kleber Calegario Batista - klebercal@gmail.com
Greek:
Yannis Kaskamanidis - kiolalis@gmail.com
Galician:
Xosé Luis Barreiro Cebey - xoseluis@edu.xunta.es
Hebrew:
Nadav Kavalerchik - nadavkav@gmail.com
Special Thanks:
Sandra Fernandez
Birgit Ferran
Pau Ferrer Ocana
Silvia Garcia Yague
Albert Gasset Romo
Eva Gea
Toni Ginard
David Monllao
Jaume Rocarias
-----------------------------------------------------------------------------
[1] http://clic.xtec.cat/
[2] http://www.gencat.cat/ensenyament
jclicmoodle-0.2.3/test/test_jclic_backup.php 0000644 0001750 0001750 00000001166 12216575042 021262 0 ustar demarchi demarchi dirroot . '/backup/util/includes/backup_includes.php');
// It's necessary to add $CFG->keeptempdirectoriesonbackup = true; to config.php
$course_module_to_backup = 86; // Set this to one existing choice cmid in your dev site home=86; work=39
$user_doing_the_backup = 2; // Set this to the id of your admin accouun
$bc = new backup_controller(backup::TYPE_1ACTIVITY, $course_module_to_backup, backup::FORMAT_MOODLE,
backup::INTERACTIVE_NO, backup::MODE_GENERAL, $user_doing_the_backup);
$bc->execute_plan();
jclicmoodle-0.2.3/test/test_jclic_convert.php 0000644 0001750 0001750 00000000315 12216575042 021470 0 ustar demarchi demarchi dirroot.'/backup/util/helper/convert_helper.class.php');
convert_helper::to_moodle2_format('refcourse', 'moodle1');
jclicmoodle-0.2.3/test/test_jclic_restore.php 0000644 0001750 0001750 00000001515 12216575042 021476 0 ustar demarchi demarchi dirroot . '/backup/util/includes/restore_includes.php');
$folder = '06199f4ab82d075d19672f3bb42a285a'; // home=06199f4ab82d075d19672f3bb42a285a :: work=b5dbb55e2e834b3132e915395ed6917f
$userid = 2;
$fullname = 'JClic restore';
$shortname = 'jclic_restore';
$categoryid = 1;
$courseid = 100;
// Transaction
$transaction = $DB->start_delegated_transaction();
// Create new course
$courseid = restore_dbops::create_new_course($fullname, $shortname, $categoryid);
// Restore backup into course
$controller = new restore_controller($folder, $courseid,
backup::INTERACTIVE_NO, backup::MODE_SAMESITE, $userid,
backup::TARGET_NEW_COURSE);
$controller->execute_precheck();
$controller->execute_plan();
// Commit
$transaction->allow_commit();
jclicmoodle-0.2.3/settings.php 0000644 0001750 0001750 00000002653 12216575042 016475 0 ustar demarchi demarchi .
/**
* @package mod
* @subpackage jclic
* @copyright 2011 Departament d'Ensenyament de la Generalitat de Catalunya
* @author Sara Arjona Téllez
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die;
if ($ADMIN->fulltree) {
require_once($CFG->dirroot.'/mod/jclic/lib.php');
$settings->add(new admin_setting_configtext('jclic_jarbase', get_string('jclicjarbase', 'jclic'),
get_string('jclicjarbase_help', 'jclic'), JCLIC_DEFAULT_JARBASE, PARAM_URL, 60));
$settings->add(new admin_setting_configtext('jclic_lap', get_string('lap', 'jclic'),
get_string('lap_help', 'jclic'), JCLIC_DEFAULT_LAP, PARAM_INT));
}
jclicmoodle-0.2.3/backup/moodle1/lib.php 0000644 0001750 0001750 00000012476 12216575042 020214 0 ustar demarchi demarchi .
/**
* Provides support for the conversion of moodle1 backup to the moodle2 format
*
* @package mod
* @subpackage jclic
* @copyright 2011 Departament d'Ensenyament de la Generalitat de Catalunya
* @author Sara Arjona Téllez
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
require_once($CFG->dirroot . '/mod/jclic/locallib.php');
/**
* JClic conversion handler
*/
class moodle1_mod_jclic_handler extends moodle1_mod_handler {
/**
* Declare the paths in moodle.xml we are able to convert
*
* The method returns list of {@link convert_path} instances. For each path returned,
* at least one of on_xxx_start(), process_xxx() and on_xxx_end() methods must be
* defined. The method process_xxx() is not executed if the associated path element is
* empty (i.e. it contains none elements or sub-paths only).
*
* Note that the path /MOODLE_BACKUP/COURSE/MODULES/MOD/JCLIC does not
* actually exist in the file. The last element with the module name was
* appended by the moodle1_converter class.
*
* @return array of {@link convert_path} instances
*/
public function get_paths() {
return array(
new convert_path(
'jclic', '/MOODLE_BACKUP/COURSE/MODULES/MOD/JCLIC',
array(
'renamefields' => array(
'description' => 'intro',
'format' => 'introformat',
),
'newfields' => array(
'introformat' => 0,
'grade' => 0,
'timeavailable' => 0,
'timedue' => 0,
),
)
),
);
}
/**
* This is executed every time we have one /MOODLE_BACKUP/COURSE/MODULES/MOD/JCLIC
* data available
*/
public function process_jclic($data) {
// get the course module id and context id
$instanceid = $data['id'];
$cminfo = $this->get_cminfo($instanceid);
$this->moduleid = $cminfo['id'];
$contextid = $this->converter->get_contextid(CONTEXT_MODULE, $this->moduleid);
// get a fresh new file manager for this instance
$this->fileman = $this->converter->get_file_manager($contextid, 'mod_jclic');
// convert course files embedded into the intro
$this->fileman->filearea = 'intro';
$this->fileman->itemid = 0;
$data['intro'] = moodle1_converter::migrate_referenced_files($data['intro'], $this->fileman);
// migrate jclic package file
$this->fileman->filearea = 'content';
$this->fileman->itemid = 0;
if (!jclic_is_valid_external_url($data['url']) ) {
// Migrate file
try{
$this->fileman->migrate_file('course_files/'.$data['url']);
} catch (Exception $e){
echo 'Caught exception: ', $e->getMessage(), ' File: \'',$data['url'], '\' on JClic activity \''.$data['name'].'\'
';
}
}
// To avoid problems if maxgrade is null
if ($data['maxgrade'] === NULL) $data['maxgrade'] = 100;
// get grade value from maxgrade
$data['grade'] = $data['maxgrade'];
// start writing jclic.xml
$this->open_xml_writer("activities/jclic_{$this->moduleid}/jclic.xml");
$this->xmlwriter->begin_tag('activity', array('id' => $instanceid, 'moduleid' => $this->moduleid,
'modulename' => 'jclic', 'contextid' => $contextid));
$this->xmlwriter->begin_tag('jclic', array('id' => $instanceid));
foreach ($data as $field => $value) {
if ($field <> 'id') {
$this->xmlwriter->full_tag($field, $value);
}
}
return $data;
}
/**
* This is executed when we reach the closing tag of our 'jclic' path
*/
public function on_jclic_end() {
// finalize jclic.xml
$this->xmlwriter->end_tag('jclic');
$this->xmlwriter->end_tag('activity');
$this->close_xml_writer();
// write inforef.xml
$this->open_xml_writer("activities/jclic_{$this->moduleid}/inforef.xml");
$this->xmlwriter->begin_tag('inforef');
$this->xmlwriter->begin_tag('fileref');
foreach ($this->fileman->get_fileids() as $fileid) {
$this->write_xml('file', array('id' => $fileid));
}
$this->xmlwriter->end_tag('fileref');
$this->xmlwriter->end_tag('inforef');
$this->close_xml_writer();
}
} jclicmoodle-0.2.3/backup/moodle2/restore_jclic_stepslib.php 0000644 0001750 0001750 00000007263 12216575042 024201 0 ustar demarchi demarchi .
/**
*
* Define all the restore steps that will be used by the restore_jclic_activity_task
*
* @package mod
* @subpackage jclic
* @copyright 2011 Departament d'Ensenyament de la Generalitat de Catalunya
* @author Sara Arjona Téllez
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/**
* Structure step to restore one jclic activity
*/
class restore_jclic_activity_structure_step extends restore_activity_structure_step {
protected function define_structure() {
$paths = array();
$userinfo = $this->get_setting_value('userinfo');
$paths[] = new restore_path_element('jclic', '/activity/jclic');
if ($userinfo) {
$paths[] = new restore_path_element('jclic_session', '/activity/jclic/sessions/session');
$paths[] = new restore_path_element('jclic_session_activity', '/activity/jclic/sessions/session/sessionactivities/sessionactivity');
}
// Return the paths wrapped into standard activity structure
return $this->prepare_activity_structure($paths);
}
protected function process_jclic($data) {
global $DB;
$data = (object)$data;
$oldid = $data->id;
$data->course = $this->get_courseid();
$data->timeavailable = $this->apply_date_offset($data->timeavailable);
$data->timedue = $this->apply_date_offset($data->timedue);
// insert the jclic record
$newitemid = $DB->insert_record('jclic', $data);
// immediately after inserting "activity" record, call this
$this->apply_activity_instance($newitemid);
}
protected function process_jclic_session($data) {
global $DB;
$data = (object)$data;
$oldid = $data->id;
$data->jclicid = $this->get_new_parentid('jclic');
$data->user_id = $this->get_mappingid('user', $data->user_id);
$data->session_datetime = date('Y-m-d h:i:s', $this->apply_date_offset(strtotime($data->session_datetime)));
$data->session_id = time();
$newitemid = $DB->insert_record('jclic_sessions', $data);
$data->id = $newitemid;
$data->session_id = $newitemid;
$DB->update_record('jclic_sessions', $data);
$this->set_mapping('jclic_session', $oldid, $newitemid);
}
protected function process_jclic_session_activity($data) {
global $DB;
$data = (object)$data;
$oldid = $data->id;
$oldsessionid = $data->session_id;
$data->session_id = $this->get_mappingid('jclic_session', $oldsessionid);
$newitemid = $DB->insert_record('jclic_activities', $data);
// No need to save this mapping as far as nothing depend on it
// (child paths, file areas nor links decoder)
}
protected function after_execute() {
// Add jclic related files, no need to match by itemname (just internally handled context)
$this->add_related_files('mod_jclic', 'intro', null);
$this->add_related_files('mod_jclic', 'content', null);
}
} jclicmoodle-0.2.3/backup/moodle2/backup_jclic_stepslib.php 0000644 0001750 0001750 00000006545 12216575042 023765 0 ustar demarchi demarchi .
/**
*
* Define all the backup steps that will be used by the backup_jclic_activity_task
*
* @package mod
* @subpackage jclic
* @copyright 2011 Departament d'Ensenyament de la Generalitat de Catalunya
* @author Sara Arjona Téllez
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/**
* Define the complete jclic structure for backup, with file and id annotations
*/
class backup_jclic_activity_structure_step extends backup_activity_structure_step {
protected function define_structure() {
// To know if we are including userinfo
$userinfo = $this->get_setting_value('userinfo');
// Define each element separated
$jclic = new backup_nested_element('jclic', array('id'), array(
'name', 'intro', 'introformat', 'url', 'skin', 'maxattempts',
'width', 'height', 'avaluation', 'maxgrade', 'grade', 'lang',
'exiturl', 'timeavailable', 'timedue'));
$sessions = new backup_nested_element('sessions');
$session = new backup_nested_element('session', array('id'), array(
'session_id', 'user_id', 'session_datetime', 'project_name',
'session_key', 'session_code', 'session_context'));
$activities = new backup_nested_element('sessionactivities');
$activity = new backup_nested_element('sessionactivity', array('id'), array(
'session_id', 'activity_id', 'activity_name', 'num_actions', 'score',
'activity_solved', 'qualification', 'total_time', 'activity_code'));
// Build the tree
$jclic->add_child($sessions);
$sessions->add_child($session);
$session->add_child($activities);
$activities->add_child($activity);
// Define sources
$jclic->set_source_table('jclic', array('id' => backup::VAR_ACTIVITYID));
// All the rest of elements only happen if we are including user info
if ($userinfo) {
$session->set_source_table('jclic_sessions', array('jclicid' => backup::VAR_PARENTID));
$activity->set_source_table('jclic_activities', array('session_id' => '../../session_id'));
}
// Define id annotations
$jclic->annotate_ids('scale', 'grade');
$session->annotate_ids('user', 'user_id');
// Define file annotations
$jclic->annotate_files('mod_jclic', 'intro', null); // This file area hasn't itemid
$jclic->annotate_files('mod_jclic', 'content', null); // This file area hasn't itemid
// Return the root element (jclic), wrapped into standard activity structure
return $this->prepare_activity_structure($jclic);
}
} jclicmoodle-0.2.3/backup/moodle2/backup_jclic_activity_task.class.php 0000644 0001750 0001750 00000004615 12216575042 026116 0 ustar demarchi demarchi .
/**
*
* @package mod
* @subpackage jclic
* @copyright 2011 Departament d'Ensenyament de la Generalitat de Catalunya
* @author Sara Arjona Téllez
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
require_once($CFG->dirroot . '/mod/jclic/locallib.php'); // Because it exists (must)
require_once($CFG->dirroot . '/mod/jclic/backup/moodle2/backup_jclic_stepslib.php'); // Because it exists (must)
/**
* jclic backup task that provides all the settings and steps to perform one
* complete backup of the activity
*/
class backup_jclic_activity_task extends backup_activity_task {
/**
* Define (add) particular settings this activity can have
*/
protected function define_my_settings() {
// No particular settings for this activity
}
/**
* Define (add) particular steps this activity can have
*/
protected function define_my_steps() {
jclic_normalize_date();
$this->add_step(new backup_jclic_activity_structure_step('jclic_structure', 'jclic.xml'));
}
/**
* Code the transformations to perform in the activity in
* order to get transportable (encoded) links
*/
static public function encode_content_links($content) {
global $CFG;
$base = preg_quote($CFG->wwwroot,"/");
// Link to the list of jclics
$search="/(".$base."\/mod\/jclic\/index.php\?id\=)([0-9]+)/";
$content= preg_replace($search, '$@JCLICINDEX*$2@$', $content);
// Link to jclic view by moduleid
$search="/(".$base."\/mod\/jclic\/view.php\?id\=)([0-9]+)/";
$content= preg_replace($search, '$@JCLICVIEWBYID*$2@$', $content);
return $content;
}
} jclicmoodle-0.2.3/backup/moodle2/restore_jclic_activity_task.class.php 0000644 0001750 0001750 00000010026 12216575042 026325 0 ustar demarchi demarchi .
/**
*
* @package mod
* @subpackage jclic
* @copyright 2011 Departament d'Ensenyament de la Generalitat de Catalunya
* @author Sara Arjona Téllez
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
require_once($CFG->dirroot . '/mod/jclic/locallib.php'); // Because it exists (must)
require_once($CFG->dirroot . '/mod/jclic/backup/moodle2/restore_jclic_stepslib.php'); // Because it exists (must)
/**
* jclic restore task that provides all the settings and steps to perform one
* complete restore of the activity
*/
class restore_jclic_activity_task extends restore_activity_task {
/**
* Define (add) particular settings this activity can have
*/
protected function define_my_settings() {
// No particular settings for this activity
}
/**
* Define (add) particular steps this activity can have
*/
protected function define_my_steps() {
jclic_normalize_date();
// JClic only has one structure step
$this->add_step(new restore_jclic_activity_structure_step('jclic_structure', 'jclic.xml'));
}
/**
* Define the contents in the activity that must be
* processed by the link decoder
*/
static public function define_decode_contents() {
$contents = array();
$contents[] = new restore_decode_content('jclic', array('intro'), 'jclic');
return $contents;
}
/**
* Define the decoding rules for links belonging
* to the activity to be executed by the link decoder
*/
static public function define_decode_rules() {
$rules = array();
$rules[] = new restore_decode_rule('JCLICVIEWBYID', '/mod/jclic/view.php?id=$1', 'course_module');
$rules[] = new restore_decode_rule('JCLICINDEX', '/mod/jclic/index.php?id=$1', 'course');
return $rules;
}
/**
* Define the restore log rules that will be applied
* by the {@link restore_logs_processor} when restoring
* jclic logs. It must return one array
* of {@link restore_log_rule} objects
*/
static public function define_restore_log_rules() {
$rules = array();
$rules[] = new restore_log_rule('jclic', 'add', 'view.php?id={course_module}', '{jclic}');
$rules[] = new restore_log_rule('jclic', 'update', 'view.php?id={course_module}', '{jclic}');
$rules[] = new restore_log_rule('jclic', 'view', 'view.php?id={course_module}', '{jclic}');
return $rules;
}
/**
* Define the restore log rules that will be applied
* by the {@link restore_logs_processor} when restoring
* course logs. It must return one array
* of {@link restore_log_rule} objects
*
* Note this rules are applied when restoring course logs
* by the restore final task, but are defined here at
* activity level. All them are rules not linked to any module instance (cmid = 0)
*/
static public function define_restore_log_rules_for_course() {
$rules = array();
// Fix old wrong uses (missing extension)
$rules[] = new restore_log_rule('jclic', 'view all', 'index?id={course}', null,
null, null, 'index.php?id={course}');
$rules[] = new restore_log_rule('jclic', 'view all', 'index.php?id={course}', null);
return $rules;
}
}