mirror of
https://github.com/moodle/moodle.git
synced 2025-08-06 17:36:38 +02:00
1fa95628f6
Made using the new goodies from the new pagelib, some really useful advice from "Backup Man" Eloy and lots of love.
1698 lines
68 KiB
PHP
1698 lines
68 KiB
PHP
<?php //$Id$
|
|
//This file contains all the function needed in the backup utility
|
|
//except the mod-related funtions that are into every backuplib.php inside
|
|
//every mod directory
|
|
|
|
//Insert necessary category ids to backup_ids table
|
|
function insert_category_ids ($course,$backup_unique_code) {
|
|
global $CFG;
|
|
|
|
//Create missing categories and reasign orphaned questions
|
|
fix_orphaned_questions($course);
|
|
|
|
//Detect used categories (by category in questions)
|
|
$status = execute_sql("INSERT INTO {$CFG->prefix}backup_ids
|
|
(backup_code, table_name, old_id)
|
|
SELECT DISTINCT $backup_unique_code,'quiz_categories',t.category
|
|
FROM {$CFG->prefix}quiz_questions t,
|
|
{$CFG->prefix}quiz_question_grades g,
|
|
{$CFG->prefix}quiz q
|
|
WHERE q.course = '$course' AND
|
|
g.quiz = q.id AND
|
|
g.question = t.id",false);
|
|
|
|
//Now, foreach detected category, we look for their parents upto 0 (top category)
|
|
$categories = get_records_sql("SELECT old_id, old_id
|
|
FROM {$CFG->prefix}backup_ids
|
|
WHERE backup_code = $backup_unique_code AND
|
|
table_name = 'quiz_categories'");
|
|
|
|
if ($categories) {
|
|
foreach ($categories as $category) {
|
|
if ($dbcat = get_record('quiz_categories','id',$category->old_id)) {
|
|
//echo $dbcat->name; //Debug
|
|
//Go up to 0
|
|
while ($dbcat->parent != 0) {
|
|
//echo '->'; //Debug
|
|
$current = $dbcat->id;
|
|
if ($dbcat = get_record('quiz_categories','id',$dbcat->parent)) {
|
|
//Found parent, add it to backup_ids (by using backup_putid
|
|
//we ensure no duplicates!)
|
|
$status = backup_putid($backup_unique_code,'quiz_categories',$dbcat->id,0);
|
|
//echo $dbcat->name; //Debug
|
|
} else {
|
|
//Parent not found, fix it (set its parent to 0)
|
|
set_field ('quiz_categories','parent',0,'id',$current);
|
|
//echo 'assigned to top!'; //Debug
|
|
}
|
|
}
|
|
//echo '<br />'; //Debug
|
|
}
|
|
}
|
|
}
|
|
|
|
return $status;
|
|
}
|
|
|
|
//This function is used to detect orphaned questions (pointing to a
|
|
//non existing category) and to recreate such category. This function
|
|
//is used by the backup process, to ensure consistency and should be
|
|
//executed in the upgrade process and, perhaps in the health center.
|
|
function fix_orphaned_questions ($course) {
|
|
|
|
global $CFG;
|
|
|
|
$categories = get_records_sql("SELECT DISTINCT t.category, t.category
|
|
FROM {$CFG->prefix}quiz_questions t,
|
|
{$CFG->prefix}quiz_question_grades g,
|
|
{$CFG->prefix}quiz q
|
|
WHERE q.course = '$course' AND
|
|
g.quiz = q.id AND
|
|
g.question = t.id",false);
|
|
if ($categories) {
|
|
foreach ($categories as $key => $category) {
|
|
$exist = get_record('quiz_categories','id', $key);
|
|
//If the category doesn't exist
|
|
if (!$exist) {
|
|
//Build a new category
|
|
$db_cat->course = $course;
|
|
$db_cat->name = get_string('recreatedcategory','',$key);
|
|
$db_cat->info = get_string('recreatedcategory','',$key);
|
|
$db_cat->publish = 1;
|
|
$db_cat->stamp = make_unique_id_code();
|
|
//Insert the new category
|
|
$catid = insert_record('quiz_categories',$db_cat);
|
|
unset ($db_cat);
|
|
if ($catid) {
|
|
//Reasign orphaned questions to their new category
|
|
set_field ('quiz_questions','category',$catid,'category',$key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Delete category ids from backup_ids table
|
|
function delete_category_ids ($backup_unique_code) {
|
|
global $CFG;
|
|
$status = true;
|
|
$status = execute_sql("DELETE FROM {$CFG->prefix}backup_ids
|
|
WHERE backup_code = '$backup_unique_code'",false);
|
|
return $status;
|
|
}
|
|
|
|
//Calculate the number of users to backup and put their ids in backup_ids
|
|
//Return an array of info (name,value)
|
|
function user_check_backup($course,$backup_unique_code,$backup_users,$backup_messages) {
|
|
//$backup_users=0-->all
|
|
// 1-->course (needed + enrolled)
|
|
// 2-->none
|
|
|
|
global $CFG;
|
|
global $db;
|
|
|
|
$count_users = 0;
|
|
|
|
//If we've selected none, simply return 0
|
|
if ($backup_users == 0 or $backup_users == 1) {
|
|
|
|
//Calculate needed users (calling every xxxx_get_participants function + scales users)
|
|
$needed_users = backup_get_needed_users($course, $backup_messages);
|
|
|
|
//Calculate enrolled users (students + teachers)
|
|
$enrolled_users = backup_get_enrolled_users($course);
|
|
|
|
//Calculate all users (every record in users table)
|
|
$all_users = backup_get_all_users();
|
|
|
|
//Calculate course users (needed + enrolled)
|
|
//First, needed
|
|
$course_users = $needed_users;
|
|
|
|
//Now, enrolled
|
|
if ($enrolled_users) {
|
|
foreach ($enrolled_users as $enrolled_user) {
|
|
$course_users[$enrolled_user->id]->id = $enrolled_user->id;
|
|
}
|
|
}
|
|
|
|
//Now, depending of parameters, create $backupable_users
|
|
if ($backup_users == 0) {
|
|
$backupable_users = $all_users;
|
|
} else {
|
|
$backupable_users = $course_users;
|
|
}
|
|
|
|
//If we have backupable users
|
|
if ($backupable_users) {
|
|
//Iterate over users putting their roles
|
|
foreach ($backupable_users as $backupable_user) {
|
|
$backupable_user->info = "";
|
|
//Is Admin in tables (not is_admin()) !!
|
|
if (record_exists("user_admins","userid",$backupable_user->id)) {
|
|
$backupable_user->info .= "admin";
|
|
}
|
|
//Is Course Creator in tables (not is_coursecreator()) !!
|
|
if (record_exists("user_coursecreators","userid",$backupable_user->id)) {
|
|
$backupable_user->info .= "coursecreator";
|
|
}
|
|
//Is Teacher in tables (not is_teacher()) !!
|
|
if (record_exists("user_teachers","course",$course,"userid",$backupable_user->id)) {
|
|
$backupable_user->info .= "teacher";
|
|
}
|
|
//Is Student in tables (not is_student()) !!
|
|
if (record_exists("user_students","course",$course,"userid",$backupable_user->id)) {
|
|
$backupable_user->info .= "student";
|
|
}
|
|
//Is needed user (exists in needed_users)
|
|
if (isset($needed_users[$backupable_user->id])) {
|
|
$backupable_user->info .= "needed";
|
|
}
|
|
//Now create the backup_id record
|
|
$backupids_rec->backup_code = $backup_unique_code;
|
|
$backupids_rec->table_name = "user";
|
|
$backupids_rec->old_id = $backupable_user->id;
|
|
$backupids_rec->info = $backupable_user->info;
|
|
|
|
//Insert the record id. backup_users decide it.
|
|
//When all users
|
|
$status = insert_record("backup_ids",$backupids_rec,false,"backup_code");
|
|
$count_users++;
|
|
}
|
|
//Do some output
|
|
backup_flush(30);
|
|
}
|
|
}
|
|
|
|
//Prepare Info
|
|
//Gets the user data
|
|
$info[0][0] = get_string("users");
|
|
$info[0][1] = $count_users;
|
|
|
|
return $info;
|
|
}
|
|
|
|
//Returns every needed user (participant) in a course
|
|
//It uses the xxxx_get_participants() function
|
|
//plus users needed to backup scales.
|
|
//WARNING: It returns only NEEDED users, not every
|
|
// every student and teacher in the course, so it
|
|
//must be merged with backup_get_enrrolled_users !!
|
|
|
|
function backup_get_needed_users ($courseid, $includemessages=false) {
|
|
|
|
global $CFG;
|
|
|
|
$result = false;
|
|
|
|
$course_modules = get_records_sql ("SELECT cm.id, m.name, cm.instance
|
|
FROM {$CFG->prefix}modules m,
|
|
{$CFG->prefix}course_modules cm
|
|
WHERE m.id = cm.module and
|
|
cm.course = '$courseid'");
|
|
|
|
if ($course_modules) {
|
|
//Iterate over each module
|
|
foreach ($course_modules as $course_module) {
|
|
$modlib = "$CFG->dirroot/mod/$course_module->name/lib.php";
|
|
$modgetparticipants = $course_module->name."_get_participants";
|
|
if (file_exists($modlib)) {
|
|
include_once($modlib);
|
|
if (function_exists($modgetparticipants)) {
|
|
$module_participants = $modgetparticipants($course_module->instance);
|
|
//Add them to result
|
|
if ($module_participants) {
|
|
foreach ($module_participants as $module_participant) {
|
|
$result[$module_participant->id]->id = $module_participant->id;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Now, add scale users (from site and course scales)
|
|
//Get users
|
|
$scaleusers = get_records_sql("SELECT DISTINCT userid,userid
|
|
FROM {$CFG->prefix}scale
|
|
WHERE courseid = '0' or courseid = '$courseid'");
|
|
//Add scale users to results
|
|
if ($scaleusers) {
|
|
foreach ($scaleusers as $scaleuser) {
|
|
//If userid != 0
|
|
if ($scaleuser->userid != 0) {
|
|
$result[$scaleuser->userid]->id = $scaleuser->userid;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Now, add message users if necessary
|
|
if ($includemessages) {
|
|
include_once("$CFG->dirroot/message/lib.php");
|
|
//Get users
|
|
$messageusers = message_get_participants();
|
|
//Add message users to results
|
|
if ($messageusers) {
|
|
foreach ($messageusers as $messageuser) {
|
|
//If id != 0
|
|
if ($messageuser->id !=0) {
|
|
$result[$messageuser->id]->id = $messageuser->id;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
|
|
}
|
|
|
|
//Returns every enrolled user (student and teacher) in a course
|
|
|
|
function backup_get_enrolled_users ($courseid) {
|
|
|
|
global $CFG;
|
|
|
|
$result = false;
|
|
|
|
//Get teachers
|
|
$teachers = get_records_sql("SELECT DISTINCT userid,userid
|
|
FROM {$CFG->prefix}user_teachers
|
|
WHERE course = '$courseid'");
|
|
//Get students
|
|
$students = get_records_sql("SELECT DISTINCT userid,userid
|
|
FROM {$CFG->prefix}user_students
|
|
WHERE course = '$courseid'");
|
|
//Add teachers
|
|
if ($teachers) {
|
|
foreach ($teachers as $teacher) {
|
|
$result[$teacher->userid]->id = $teacher->userid;
|
|
}
|
|
}
|
|
//Add students
|
|
if ($students) {
|
|
foreach ($students as $student) {
|
|
$result[$student->userid]->id = $student->userid;
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
//Returns all users (every record in users table)
|
|
|
|
function backup_get_all_users() {
|
|
|
|
global $CFG;
|
|
|
|
$result = false;
|
|
|
|
//Get users
|
|
$users = get_records_sql("SELECT DISTINCT id,id
|
|
FROM {$CFG->prefix}user");
|
|
//Add users
|
|
if ($users) {
|
|
foreach ($users as $user) {
|
|
$result[$user->id]->id = $user->id;
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
//Calculate the number of log entries to backup
|
|
//Return an array of info (name,value)
|
|
function log_check_backup($course) {
|
|
|
|
global $CFG;
|
|
|
|
//Now execute the count
|
|
$ids = count_records("log","course",$course);
|
|
|
|
//Gets the user data
|
|
$info[0][0] = get_string("logs");
|
|
if ($ids) {
|
|
$info[0][1] = $ids;
|
|
} else {
|
|
$info[0][1] = 0;
|
|
}
|
|
|
|
return $info;
|
|
}
|
|
|
|
//Calculate the number of user files to backup
|
|
//Under $CFG->dataroot/users
|
|
//and put them (their path) in backup_ids
|
|
//Return an array of info (name,value)
|
|
function user_files_check_backup($course,$backup_unique_code) {
|
|
|
|
global $CFG;
|
|
|
|
$rootdir = $CFG->dataroot."/users";
|
|
//Check if directory exists
|
|
if (is_dir($rootdir)) {
|
|
//Get directories without descend
|
|
$userdirs = get_directory_list($rootdir,"",false,true,false);
|
|
foreach ($userdirs as $dir) {
|
|
//Extracts user id from file path
|
|
$tok = strtok($dir,"/");
|
|
if ($tok) {
|
|
$userid = $tok;
|
|
} else {
|
|
$tok = "";
|
|
}
|
|
//Look it is a backupable user
|
|
$data = get_record ("backup_ids","backup_code","$backup_unique_code",
|
|
"table_name","user",
|
|
"old_id",$userid);
|
|
if ($data) {
|
|
//Insert them into backup_files
|
|
$status = execute_sql("INSERT INTO {$CFG->prefix}backup_files
|
|
(backup_code, file_type, path, old_id)
|
|
VALUES
|
|
('$backup_unique_code','user','$dir','$userid')",false);
|
|
}
|
|
//Do some output
|
|
backup_flush(30);
|
|
}
|
|
}
|
|
|
|
//Now execute the select
|
|
$ids = get_records_sql("SELECT DISTINCT b.path, b.old_id
|
|
FROM {$CFG->prefix}backup_files b
|
|
WHERE backup_code = '$backup_unique_code' AND
|
|
file_type = 'user'");
|
|
//Gets the user data
|
|
$info[0][0] = get_string("files");
|
|
if ($ids) {
|
|
$info[0][1] = count($ids);
|
|
} else {
|
|
$info[0][1] = 0;
|
|
}
|
|
|
|
return $info;
|
|
}
|
|
|
|
//Calculate the number of course files to backup
|
|
//under $CFG->dataroot/$course, except $CFG->moddata, and backupdata
|
|
//and put them (their path) in backup_ids
|
|
//Return an array of info (name,value)
|
|
function course_files_check_backup($course,$backup_unique_code) {
|
|
|
|
global $CFG;
|
|
|
|
$rootdir = $CFG->dataroot."/$course";
|
|
//Check if directory exists
|
|
if (is_dir($rootdir)) {
|
|
//Get files and directories without descend
|
|
$coursedirs = get_directory_list($rootdir,$CFG->moddata,false,true,true);
|
|
$backupdata_dir = "backupdata";
|
|
foreach ($coursedirs as $dir) {
|
|
//Check it isn't backupdata_dir
|
|
if (strpos($dir,$backupdata_dir)!==0) {
|
|
//Insert them into backup_files
|
|
$status = execute_sql("INSERT INTO {$CFG->prefix}backup_files
|
|
(backup_code, file_type, path)
|
|
VALUES
|
|
('$backup_unique_code','course','$dir')",false);
|
|
}
|
|
//Do some output
|
|
backup_flush(30);
|
|
}
|
|
}
|
|
|
|
//Now execute the select
|
|
$ids = get_records_sql("SELECT DISTINCT b.path, b.old_id
|
|
FROM {$CFG->prefix}backup_files b
|
|
WHERE backup_code = '$backup_unique_code' AND
|
|
file_type = 'course'");
|
|
//Gets the user data
|
|
$info[0][0] = get_string("files");
|
|
if ($ids) {
|
|
$info[0][1] = count($ids);
|
|
} else {
|
|
$info[0][1] = 0;
|
|
}
|
|
|
|
return $info;
|
|
}
|
|
|
|
//Function to check and create the needed moddata dir to
|
|
//save all the mod backup files. We always name it moddata
|
|
//to be able to restore it, but in restore we check for
|
|
//$CFG->moddata !!
|
|
function check_and_create_moddata_dir($backup_unique_code) {
|
|
|
|
global $CFG;
|
|
|
|
$status = check_dir_exists($CFG->dataroot."/temp/backup/".$backup_unique_code."/moddata",true);
|
|
|
|
return $status;
|
|
}
|
|
|
|
//Function to check and create the "user_files" dir to
|
|
//save all the user files we need from "users" dir
|
|
function check_and_create_user_files_dir($backup_unique_code) {
|
|
|
|
global $CFG;
|
|
|
|
$status = check_dir_exists($CFG->dataroot."/temp/backup/".$backup_unique_code."/user_files",true);
|
|
|
|
return $status;
|
|
}
|
|
|
|
//Function to check and create the "course_files" dir to
|
|
//save all the course files we need from "CFG->datadir/course" dir
|
|
function check_and_create_course_files_dir($backup_unique_code) {
|
|
|
|
global $CFG;
|
|
|
|
$status = check_dir_exists($CFG->dataroot."/temp/backup/".$backup_unique_code."/course_files",true);
|
|
|
|
return $status;
|
|
}
|
|
|
|
//Function to create, open and write header of the xml file
|
|
function backup_open_xml($backup_unique_code) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Open for writing
|
|
|
|
$file = $CFG->dataroot."/temp/backup/".$backup_unique_code."/moodle.xml";
|
|
$backup_file = fopen($file,"w");
|
|
//Writes the header
|
|
$status = fwrite ($backup_file,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
|
|
if ($status) {
|
|
$status = fwrite ($backup_file,start_tag("MOODLE_BACKUP",0,true));
|
|
}
|
|
if ($status) {
|
|
return $backup_file;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//Close the file
|
|
function backup_close_xml($backup_file) {
|
|
$status = fwrite ($backup_file,end_tag("MOODLE_BACKUP",0,true));
|
|
return fclose($backup_file);
|
|
}
|
|
|
|
//Return the xml start tag
|
|
function start_tag($tag,$level=0,$endline=false) {
|
|
if ($endline) {
|
|
$endchar = "\n";
|
|
} else {
|
|
$endchar = "";
|
|
}
|
|
return str_repeat(" ",$level*2)."<".strtoupper($tag).">".$endchar;
|
|
}
|
|
|
|
//Return the xml end tag
|
|
function end_tag($tag,$level=0,$endline=true) {
|
|
if ($endline) {
|
|
$endchar = "\n";
|
|
} else {
|
|
$endchar = "";
|
|
}
|
|
return str_repeat(" ",$level*2)."</".strtoupper($tag).">".$endchar;
|
|
}
|
|
|
|
//Return the start tag, the contents and the end tag
|
|
function full_tag($tag,$level=0,$endline=true,$content,$to_utf=true) {
|
|
//Here we encode absolute links
|
|
$content = backup_encode_absolute_links($content);
|
|
$st = start_tag($tag,$level,$endline);
|
|
$co="";
|
|
if ($to_utf) {
|
|
$co = preg_replace("/\r\n|\r/", "\n", utf8_encode(htmlspecialchars($content)));
|
|
} else {
|
|
$co = preg_replace("/\r\n|\r/", "\n", htmlspecialchars($content));
|
|
}
|
|
$et = end_tag($tag,0,true);
|
|
return $st.$co.$et;
|
|
}
|
|
|
|
//Prints General info about the course
|
|
//name, moodle_version (internal and release), backup_version, date, info in file...
|
|
function backup_general_info ($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
fwrite ($bf,start_tag("INFO",1,true));
|
|
|
|
//The name of the backup
|
|
fwrite ($bf,full_tag("NAME",2,false,$preferences->backup_name));
|
|
//The moodle_version
|
|
fwrite ($bf,full_tag("MOODLE_VERSION",2,false,$preferences->moodle_version));
|
|
fwrite ($bf,full_tag("MOODLE_RELEASE",2,false,$preferences->moodle_release));
|
|
//The backup_version
|
|
fwrite ($bf,full_tag("BACKUP_VERSION",2,false,$preferences->backup_version));
|
|
fwrite ($bf,full_tag("BACKUP_RELEASE",2,false,$preferences->backup_release));
|
|
//The date
|
|
fwrite ($bf,full_tag("DATE",2,false,$preferences->backup_unique_code));
|
|
//The original site wwwroot
|
|
fwrite ($bf,full_tag("ORIGINAL_WWWROOT",2,false,$CFG->wwwroot));
|
|
//The zip method used
|
|
if (!empty($CFG->zip)) {
|
|
$zipmethod = 'external';
|
|
} else {
|
|
$zipmethod = 'internal';
|
|
}
|
|
fwrite ($bf,full_tag("ZIP_METHOD",2,false,$zipmethod));
|
|
//Te includes tag
|
|
fwrite ($bf,start_tag("DETAILS",2,true));
|
|
//Now, go to mod element of preferences to print its status
|
|
foreach ($preferences->mods as $element) {
|
|
//Calculate info
|
|
$included = "false";
|
|
$userinfo = "false";
|
|
if ($element->backup) {
|
|
$included = "true";
|
|
if ($element->userinfo) {
|
|
$userinfo = "true";
|
|
}
|
|
}
|
|
//Prints the mod start
|
|
fwrite ($bf,start_tag("MOD",3,true));
|
|
fwrite ($bf,full_tag("NAME",4,false,$element->name));
|
|
fwrite ($bf,full_tag("INCLUDED",4,false,$included));
|
|
fwrite ($bf,full_tag("USERINFO",4,false,$userinfo));
|
|
|
|
//Print the end
|
|
fwrite ($bf,end_tag("MOD",3,true));
|
|
}
|
|
//The metacourse in backup
|
|
if ($preferences->backup_metacourse == 1) {
|
|
fwrite ($bf,full_tag("METACOURSE",3,false,"true"));
|
|
} else {
|
|
fwrite ($bf,full_tag("METACOURSE",3,false,"false"));
|
|
}
|
|
//The user in backup
|
|
if ($preferences->backup_users == 1) {
|
|
fwrite ($bf,full_tag("USERS",3,false,"course"));
|
|
} else if ($preferences->backup_users == 0) {
|
|
fwrite ($bf,full_tag("USERS",3,false,"all"));
|
|
} else {
|
|
fwrite ($bf,full_tag("USERS",3,false,"none"));
|
|
}
|
|
//The logs in backup
|
|
if ($preferences->backup_logs == 1) {
|
|
fwrite ($bf,full_tag("LOGS",3,false,"true"));
|
|
} else {
|
|
fwrite ($bf,full_tag("LOGS",3,false,"false"));
|
|
}
|
|
//The user files
|
|
if ($preferences->backup_user_files == 1) {
|
|
fwrite ($bf,full_tag("USERFILES",3,false,"true"));
|
|
} else {
|
|
fwrite ($bf,full_tag("USERFILES",3,false,"false"));
|
|
}
|
|
//The course files
|
|
if ($preferences->backup_course_files == 1) {
|
|
fwrite ($bf,full_tag("COURSEFILES",3,false,"true"));
|
|
} else {
|
|
fwrite ($bf,full_tag("COURSEFILES",3,false,"false"));
|
|
}
|
|
//The messages in backup
|
|
if ($preferences->backup_messages == 1 && $preferences->backup_course == SITEID) {
|
|
fwrite ($bf,full_tag("MESSAGES",3,false,"true"));
|
|
} else {
|
|
fwrite ($bf,full_tag("MESSAGES",3,false,"false"));
|
|
}
|
|
//The mode of writing the block data
|
|
fwrite ($bf,full_tag('BLOCKFORMAT',3,false,'instances'));
|
|
|
|
fwrite ($bf,end_tag("DETAILS",2,true));
|
|
|
|
|
|
$status = fwrite ($bf,end_tag("INFO",1,true));
|
|
|
|
return $status;
|
|
}
|
|
|
|
//Prints course's general info (table course)
|
|
function backup_course_start ($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Course open tag
|
|
fwrite ($bf,start_tag("COURSE",1,true));
|
|
//Header open tag
|
|
fwrite ($bf,start_tag("HEADER",2,true));
|
|
|
|
//Get info from course
|
|
$course = get_record("course","id",$preferences->backup_course);
|
|
if ($course) {
|
|
//Prints course info
|
|
fwrite ($bf,full_tag("ID",3,false,$course->id));
|
|
//Obtain the category
|
|
$category = get_record("course_categories","id","$course->category");
|
|
if ($category) {
|
|
//Prints category info
|
|
fwrite ($bf,start_tag("CATEGORY",3,true));
|
|
fwrite ($bf,full_tag("ID",4,false,$course->category));
|
|
fwrite ($bf,full_tag("NAME",4,false,$category->name));
|
|
fwrite ($bf,end_tag("CATEGORY",3,true));
|
|
}
|
|
//Continues with the course
|
|
fwrite ($bf,full_tag("PASSWORD",3,false,$course->password));
|
|
fwrite ($bf,full_tag("FULLNAME",3,false,$course->fullname));
|
|
fwrite ($bf,full_tag("SHORTNAME",3,false,$course->shortname));
|
|
fwrite ($bf,full_tag("IDNUMBER",3,false,$course->idnumber));
|
|
fwrite ($bf,full_tag("SUMMARY",3,false,$course->summary));
|
|
fwrite ($bf,full_tag("FORMAT",3,false,$course->format));
|
|
fwrite ($bf,full_tag("SHOWGRADES",3,false,$course->showgrades));
|
|
fwrite ($bf,full_tag("NEWSITEMS",3,false,$course->newsitems));
|
|
fwrite ($bf,full_tag("TEACHER",3,false,$course->teacher));
|
|
fwrite ($bf,full_tag("TEACHERS",3,false,$course->teachers));
|
|
fwrite ($bf,full_tag("STUDENT",3,false,$course->student));
|
|
fwrite ($bf,full_tag("STUDENTS",3,false,$course->students));
|
|
fwrite ($bf,full_tag("GUEST",3,false,$course->guest));
|
|
fwrite ($bf,full_tag("STARTDATE",3,false,$course->startdate));
|
|
fwrite ($bf,full_tag("ENROLPERIOD",3,false,$course->enrolperiod));
|
|
fwrite ($bf,full_tag("NUMSECTIONS",3,false,$course->numsections));
|
|
//fwrite ($bf,full_tag("SHOWRECENT",3,false,$course->showrecent)); INFO: This is out in 1.3
|
|
fwrite ($bf,full_tag("MAXBYTES",3,false,$course->maxbytes));
|
|
fwrite ($bf,full_tag("SHOWREPORTS",3,false,$course->showreports));
|
|
fwrite ($bf,full_tag("GROUPMODE",3,false,$course->groupmode));
|
|
fwrite ($bf,full_tag("GROUPMODEFORCE",3,false,$course->groupmodeforce));
|
|
fwrite ($bf,full_tag("LANG",3,false,$course->lang));
|
|
fwrite ($bf,full_tag("THEME",3,false,$course->theme));
|
|
fwrite ($bf,full_tag("COST",3,false,$course->cost));
|
|
fwrite ($bf,full_tag("MARKER",3,false,$course->marker));
|
|
fwrite ($bf,full_tag("VISIBLE",3,false,$course->visible));
|
|
fwrite ($bf,full_tag("HIDDENSECTIONS",3,false,$course->hiddensections));
|
|
fwrite ($bf,full_tag("TIMECREATED",3,false,$course->timecreated));
|
|
fwrite ($bf,full_tag("TIMEMODIFIED",3,false,$course->timemodified));
|
|
//If not selected, force metacourse to 0
|
|
if (!$preferences->backup_metacourse) {
|
|
$status = fwrite ($bf,full_tag("METACOURSE",3,false,'0'));
|
|
//else, export the field as is in DB
|
|
} else {
|
|
$status = fwrite ($bf,full_tag("METACOURSE",3,false,$course->metacourse));
|
|
}
|
|
//Print header end
|
|
fwrite ($bf,end_tag("HEADER",2,true));
|
|
} else {
|
|
$status = false;
|
|
}
|
|
|
|
return $status;
|
|
}
|
|
|
|
//Prints course's end tag
|
|
function backup_course_end ($bf,$preferences) {
|
|
|
|
//Course end tag
|
|
$status = fwrite ($bf,end_tag("COURSE",1,true));
|
|
|
|
return $status;
|
|
|
|
}
|
|
|
|
//Prints course's metacourse info (table course_meta)
|
|
function backup_course_metacourse ($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Get info from meta
|
|
$parents = get_records_sql ("SELECT m.*, c.idnumber, c.shortname
|
|
FROM {$CFG->prefix}course_meta m,
|
|
{$CFG->prefix}course c
|
|
WHERE m.child_course = '$preferences->backup_course' AND
|
|
m.parent_course = c.id");
|
|
$childs = get_records_sql ("SELECT m.*, c.idnumber, c.shortname
|
|
FROM {$CFG->prefix}course_meta m,
|
|
{$CFG->prefix}course c
|
|
WHERE m.parent_course = '$preferences->backup_course' AND
|
|
m.child_course = c.id");
|
|
|
|
if ($parents || $childs) {
|
|
//metacourse open tag
|
|
fwrite ($bf,start_tag("METACOURSE",2,true));
|
|
if ($parents) {
|
|
fwrite($bf, start_tag("PARENTS",3,true));
|
|
//Iterate over every parent
|
|
foreach ($parents as $parent) {
|
|
//Begin parent
|
|
fwrite ($bf,start_tag("PARENT",4,true));
|
|
fwrite ($bf,full_tag("ID",5,false,$parent->parent_course));
|
|
fwrite ($bf,full_tag("IDNUMBER",5,false,$parent->idnumber));
|
|
fwrite ($bf,full_tag("SHORTNAME",5,false,$parent->shortname));
|
|
//End parent
|
|
fwrite ($bf,end_tag("PARENT",4,true));
|
|
}
|
|
fwrite ($bf,end_tag("PARENTS",3,true));
|
|
}
|
|
if ($childs) {
|
|
fwrite($bf, start_tag("CHILDS",3,true));
|
|
//Iterate over every child
|
|
foreach ($childs as $child) {
|
|
//Begin parent
|
|
fwrite ($bf,start_tag("CHILD",4,true));
|
|
fwrite ($bf,full_tag("ID",5,false,$child->child_course));
|
|
fwrite ($bf,full_tag("IDNUMBER",5,false,$child->idnumber));
|
|
fwrite ($bf,full_tag("SHORTNAME",5,false,$child->shortname));
|
|
//End parent
|
|
fwrite ($bf,end_tag("CHILD",4,true));
|
|
}
|
|
fwrite ($bf,end_tag("CHILDS",3,true));
|
|
}
|
|
//metacourse close tag
|
|
$status = fwrite ($bf,end_tag("METACOURSE",3,true));
|
|
}
|
|
|
|
return $status;
|
|
|
|
}
|
|
|
|
//Prints course's messages info (tables message, message_read and message_contacts)
|
|
function backup_messages ($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Get info from messages
|
|
$unreads = get_records ('message');
|
|
$reads = get_records ('message_read');
|
|
$contacts= get_records ('message_contacts');
|
|
|
|
if ($unreads || $reads || $contacts) {
|
|
$counter = 0;
|
|
//message open tag
|
|
fwrite ($bf,start_tag("MESSAGES",2,true));
|
|
if ($unreads) {
|
|
//Iterate over every unread
|
|
foreach ($unreads as $unread) {
|
|
//start message
|
|
fwrite($bf, start_tag("MESSAGE",3,true));
|
|
fwrite ($bf,full_tag("ID",4,false,$unread->id));
|
|
fwrite ($bf,full_tag("STATUS",4,false,"UNREAD"));
|
|
fwrite ($bf,full_tag("USERIDFROM",4,false,$unread->useridfrom));
|
|
fwrite ($bf,full_tag("USERIDTO",4,false,$unread->useridto));
|
|
fwrite ($bf,full_tag("MESSAGE",4,false,$unread->message));
|
|
fwrite ($bf,full_tag("FORMAT",4,false,$unread->format));
|
|
fwrite ($bf,full_tag("TIMECREATED",4,false,$unread->timecreated));
|
|
fwrite ($bf,full_tag("MESSAGETYPE",4,false,$unread->messagetype));
|
|
//end message
|
|
fwrite ($bf,end_tag("MESSAGE",3,true));
|
|
|
|
//Do some output
|
|
$counter++;
|
|
if ($counter % 20 == 0) {
|
|
echo ".";
|
|
if ($counter % 400 == 0) {
|
|
echo "<br />";
|
|
}
|
|
backup_flush(300);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($reads) {
|
|
//Iterate over every read
|
|
foreach ($reads as $read) {
|
|
//start message
|
|
fwrite($bf, start_tag("MESSAGE",3,true));
|
|
fwrite ($bf,full_tag("ID",4,false,$read->id));
|
|
fwrite ($bf,full_tag("STATUS",4,false,"READ"));
|
|
fwrite ($bf,full_tag("USERIDFROM",4,false,$read->useridfrom));
|
|
fwrite ($bf,full_tag("USERIDTO",4,false,$read->useridto));
|
|
fwrite ($bf,full_tag("MESSAGE",4,false,$read->message));
|
|
fwrite ($bf,full_tag("FORMAT",4,false,$read->format));
|
|
fwrite ($bf,full_tag("TIMECREATED",4,false,$read->timecreated));
|
|
fwrite ($bf,full_tag("MESSAGETYPE",4,false,$read->messagetype));
|
|
fwrite ($bf,full_tag("TIMEREAD",4,false,$read->timeread));
|
|
fwrite ($bf,full_tag("MAILED",4,false,$read->mailed));
|
|
//end message
|
|
fwrite ($bf,end_tag("MESSAGE",3,true));
|
|
|
|
//Do some output
|
|
$counter++;
|
|
if ($counter % 20 == 0) {
|
|
echo ".";
|
|
if ($counter % 400 == 0) {
|
|
echo "<br />";
|
|
}
|
|
backup_flush(300);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($contacts) {
|
|
fwrite($bf, start_tag("CONTACTS",3,true));
|
|
//Iterate over every contact
|
|
foreach ($contacts as $contact) {
|
|
//start contact
|
|
fwrite($bf, start_tag("CONTACT",4,true));
|
|
fwrite ($bf,full_tag("ID",5,false,$contact->id));
|
|
fwrite ($bf,full_tag("USERID",5,false,$contact->userid));
|
|
fwrite ($bf,full_tag("CONTACTID",5,false,$contact->contactid));
|
|
fwrite ($bf,full_tag("BLOCKED",5,false,$contact->blocked));
|
|
//end contact
|
|
fwrite ($bf,end_tag("CONTACT",4,true));
|
|
|
|
//Do some output
|
|
$counter++;
|
|
if ($counter % 20 == 0) {
|
|
echo ".";
|
|
if ($counter % 400 == 0) {
|
|
echo "<br />";
|
|
}
|
|
backup_flush(300);
|
|
}
|
|
}
|
|
fwrite($bf, end_tag("CONTACTS",3,true));
|
|
}
|
|
//messages close tag
|
|
$status = fwrite ($bf,end_tag("MESSAGES",2,true));
|
|
}
|
|
|
|
return $status;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Prints course's blocks info (table block_instance)
|
|
function backup_course_blocks ($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
// Read all of the block table
|
|
$blocks = blocks_get_record();
|
|
|
|
$pages = array();
|
|
$pages[] = page_create_object(PAGE_COURSE_VIEW, $preferences->backup_course);
|
|
|
|
// Let's see if we have to backup blocks from modules
|
|
$modulerecords = get_records_sql('SELECT name, id FROM '.$CFG->prefix.'modules');
|
|
|
|
foreach($preferences->mods as $module) {
|
|
if(!$module->backup) {
|
|
continue;
|
|
}
|
|
|
|
$cmods = get_records_select('course_modules', 'course = '.$preferences->backup_course.' AND module = '.$modulerecords[$module->name]->id);
|
|
if(empty($cmods)) {
|
|
continue;
|
|
}
|
|
|
|
$pagetypes = page_import_types('mod/'.$module->name.'/');
|
|
if(empty($pagetypes)) {
|
|
continue;
|
|
}
|
|
|
|
foreach($pagetypes as $pagetype) {
|
|
foreach($cmods as $cmod) {
|
|
$pages[] = page_create_object($pagetype, $cmod->instance);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Blocks open tag
|
|
fwrite ($bf,start_tag('BLOCKS',2,true));
|
|
|
|
while($page = array_pop($pages)) {
|
|
if ($instances = blocks_get_by_page($page)) {
|
|
//Iterate over every block
|
|
foreach ($instances as $position) {
|
|
foreach ($position as $instance) {
|
|
//If we somehow have a block with an invalid id, skip it
|
|
if(empty($blocks[$instance->blockid]->name)) {
|
|
continue;
|
|
}
|
|
//Begin Block
|
|
fwrite ($bf,start_tag('BLOCK',3,true));
|
|
fwrite ($bf,full_tag('NAME',4,false,$blocks[$instance->blockid]->name));
|
|
fwrite ($bf,full_tag('PAGEID',4,false,$instance->pageid));
|
|
fwrite ($bf,full_tag('PAGETYPE',4,false,$instance->pagetype));
|
|
fwrite ($bf,full_tag('POSITION',4,false,$instance->position));
|
|
fwrite ($bf,full_tag('WEIGHT',4,false,$instance->weight));
|
|
fwrite ($bf,full_tag('VISIBLE',4,false,$instance->visible));
|
|
fwrite ($bf,full_tag('CONFIGDATA',4,false,$instance->configdata));
|
|
//End Block
|
|
fwrite ($bf,end_tag('BLOCK',3,true));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Blocks close tag
|
|
$status = fwrite ($bf,end_tag('BLOCKS',2,true));
|
|
|
|
return $status;
|
|
|
|
}
|
|
|
|
//Prints course's sections info (table course_sections)
|
|
function backup_course_sections ($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
|
|
//Get info from sections
|
|
$section=false;
|
|
if ($sections = get_records("course_sections","course",$preferences->backup_course,"section")) {
|
|
//Section open tag
|
|
fwrite ($bf,start_tag("SECTIONS",2,true));
|
|
//Iterate over every section (ordered by section)
|
|
foreach ($sections as $section) {
|
|
//Begin Section
|
|
fwrite ($bf,start_tag("SECTION",3,true));
|
|
fwrite ($bf,full_tag("ID",4,false,$section->id));
|
|
fwrite ($bf,full_tag("NUMBER",4,false,$section->section));
|
|
fwrite ($bf,full_tag("SUMMARY",4,false,$section->summary));
|
|
fwrite ($bf,full_tag("VISIBLE",4,false,$section->visible));
|
|
//Now print the mods in section
|
|
backup_course_modules ($bf,$preferences,$section);
|
|
//End section
|
|
fwrite ($bf,end_tag("SECTION",3,true));
|
|
}
|
|
//Section close tag
|
|
$status = fwrite ($bf,end_tag("SECTIONS",2,true));
|
|
}
|
|
|
|
return $status;
|
|
|
|
}
|
|
|
|
//Prints course's modules info (table course_modules)
|
|
//Only for selected mods in preferences
|
|
function backup_course_modules ($bf,$preferences,$section) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
$first_record = true;
|
|
|
|
//Now print the mods in section
|
|
//Extracts mod id from sequence
|
|
$tok = strtok($section->sequence,",");
|
|
while ($tok) {
|
|
//Get module's type
|
|
$moduletype = get_module_type ($preferences->backup_course,$tok);
|
|
//Check if we've selected to backup that type
|
|
if ($moduletype and $preferences->mods[$moduletype]->backup) {
|
|
$selected = true;
|
|
} else {
|
|
$selected = false;
|
|
}
|
|
|
|
if ($selected) {
|
|
//Gets course_module data from db
|
|
$course_module = get_records ("course_modules","id",$tok);
|
|
//If it's the first, pring MODS tag
|
|
if ($first_record) {
|
|
fwrite ($bf,start_tag("MODS",4,true));
|
|
$first_record = false;
|
|
}
|
|
//Print mod info from course_modules
|
|
fwrite ($bf,start_tag("MOD",5,true));
|
|
//Save neccesary info to backup_ids
|
|
fwrite ($bf,full_tag("ID",6,false,$tok));
|
|
fwrite ($bf,full_tag("TYPE",6,false,$moduletype));
|
|
fwrite ($bf,full_tag("INSTANCE",6,false,$course_module[$tok]->instance));
|
|
fwrite ($bf,full_tag("ADDED",6,false,$course_module[$tok]->added));
|
|
fwrite ($bf,full_tag("DELETED",6,false,$course_module[$tok]->deleted));
|
|
fwrite ($bf,full_tag("SCORE",6,false,$course_module[$tok]->score));
|
|
fwrite ($bf,full_tag("INDENT",6,false,$course_module[$tok]->indent));
|
|
fwrite ($bf,full_tag("VISIBLE",6,false,$course_module[$tok]->visible));
|
|
fwrite ($bf,full_tag("GROUPMODE",6,false,$course_module[$tok]->groupmode));
|
|
fwrite ($bf,end_tag("MOD",5,true));
|
|
}
|
|
//check for next
|
|
$tok = strtok(",");
|
|
}
|
|
|
|
//Si ha habido modulos, final de MODS
|
|
if (!$first_record) {
|
|
$status =fwrite ($bf,end_tag("MODS",4,true));
|
|
}
|
|
|
|
return $status;
|
|
}
|
|
|
|
//Print users to xml
|
|
//Only users previously calculated in backup_ids will output
|
|
//
|
|
function backup_user_info ($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
$users = get_records_sql("SELECT u.old_id, u.table_name,u.info
|
|
FROM {$CFG->prefix}backup_ids u
|
|
WHERE u.backup_code = '$preferences->backup_unique_code' AND
|
|
u.table_name = 'user'");
|
|
|
|
//If we have users to backup
|
|
if ($users) {
|
|
//Begin Users tag
|
|
fwrite ($bf,start_tag("USERS",2,true));
|
|
$counter = 0;
|
|
//With every user
|
|
foreach ($users as $user) {
|
|
//Get user data from table
|
|
$user_data = get_record("user","id",$user->old_id);
|
|
//Begin User tag
|
|
fwrite ($bf,start_tag("USER",3,true));
|
|
//Output all user data
|
|
fwrite ($bf,full_tag("ID",4,false,$user_data->id));
|
|
fwrite ($bf,full_tag("AUTH",4,false,$user_data->auth));
|
|
fwrite ($bf,full_tag("GUID",4,false,$user_data->guid));
|
|
fwrite ($bf,full_tag("CONFIRMED",4,false,$user_data->confirmed));
|
|
fwrite ($bf,full_tag("POLICYAGREED",4,false,$user_data->policyagreed));
|
|
fwrite ($bf,full_tag("DELETED",4,false,$user_data->deleted));
|
|
fwrite ($bf,full_tag("USERNAME",4,false,$user_data->username));
|
|
fwrite ($bf,full_tag("PASSWORD",4,false,$user_data->password));
|
|
fwrite ($bf,full_tag("IDNUMBER",4,false,$user_data->idnumber));
|
|
fwrite ($bf,full_tag("FIRSTNAME",4,false,$user_data->firstname));
|
|
fwrite ($bf,full_tag("LASTNAME",4,false,$user_data->lastname));
|
|
fwrite ($bf,full_tag("EMAIL",4,false,$user_data->email));
|
|
fwrite ($bf,full_tag("EMAILSTOP",4,false,$user_data->emailstop));
|
|
fwrite ($bf,full_tag("ICQ",4,false,$user_data->icq));
|
|
fwrite ($bf,full_tag("PHONE1",4,false,$user_data->phone1));
|
|
fwrite ($bf,full_tag("PHONE2",4,false,$user_data->phone2));
|
|
fwrite ($bf,full_tag("INSTITUTION",4,false,$user_data->institution));
|
|
fwrite ($bf,full_tag("DEPARTMENT",4,false,$user_data->department));
|
|
fwrite ($bf,full_tag("ADDRESS",4,false,$user_data->address));
|
|
fwrite ($bf,full_tag("CITY",4,false,$user_data->city));
|
|
fwrite ($bf,full_tag("COUNTRY",4,false,$user_data->country));
|
|
fwrite ($bf,full_tag("LANG",4,false,$user_data->lang));
|
|
fwrite ($bf,full_tag("THEME",4,false,$user_data->theme));
|
|
fwrite ($bf,full_tag("TIMEZONE",4,false,$user_data->timezone));
|
|
fwrite ($bf,full_tag("FIRSTACCESS",4,false,$user_data->firstaccess));
|
|
fwrite ($bf,full_tag("LASTACCESS",4,false,$user_data->lastaccess));
|
|
fwrite ($bf,full_tag("LASTLOGIN",4,false,$user_data->lastlogin));
|
|
fwrite ($bf,full_tag("CURRENTLOGIN",4,false,$user_data->currentlogin));
|
|
fwrite ($bf,full_tag("LASTIP",4,false,$user_data->lastIP));
|
|
fwrite ($bf,full_tag("SECRET",4,false,$user_data->secret));
|
|
fwrite ($bf,full_tag("PICTURE",4,false,$user_data->picture));
|
|
fwrite ($bf,full_tag("URL",4,false,$user_data->url));
|
|
fwrite ($bf,full_tag("DESCRIPTION",4,false,$user_data->description));
|
|
fwrite ($bf,full_tag("MAILFORMAT",4,false,$user_data->mailformat));
|
|
fwrite ($bf,full_tag("MAILDIGEST",4,false,$user_data->maildigest));
|
|
fwrite ($bf,full_tag("MAILDISPLAY",4,false,$user_data->maildisplay));
|
|
fwrite ($bf,full_tag("HTMLEDITOR",4,false,$user_data->htmleditor));
|
|
fwrite ($bf,full_tag("AUTOSUBSCRIBE",4,false,$user_data->autosubscribe));
|
|
fwrite ($bf,full_tag("TIMEMODIFIED",4,false,$user_data->timemodified));
|
|
|
|
//Output every user role (with its associated info)
|
|
$user->isadmin = strpos($user->info,"admin");
|
|
$user->iscoursecreator = strpos($user->info,"coursecreator");
|
|
$user->isteacher = strpos($user->info,"teacher");
|
|
$user->isstudent = strpos($user->info,"student");
|
|
$user->isneeded = strpos($user->info,"needed");
|
|
if ($user->isadmin!==false or
|
|
$user->iscoursecreator!==false or
|
|
$user->isteacher!==false or
|
|
$user->isstudent!==false or
|
|
$user->isneeded!==false) {
|
|
//Begin ROLES tag
|
|
fwrite ($bf,start_tag("ROLES",4,true));
|
|
//PRINT ROLE INFO
|
|
//Admins
|
|
if ($user->isadmin!==false) {
|
|
//Print ROLE start
|
|
fwrite ($bf,start_tag("ROLE",5,true));
|
|
//Print Role info
|
|
fwrite ($bf,full_tag("TYPE",6,false,"admin"));
|
|
//Print ROLE end
|
|
fwrite ($bf,end_tag("ROLE",5,true));
|
|
}
|
|
//CourseCreator
|
|
if ($user->iscoursecreator!==false) {
|
|
//Print ROLE start
|
|
fwrite ($bf,start_tag("ROLE",5,true));
|
|
//Print Role info
|
|
fwrite ($bf,full_tag("TYPE",6,false,"coursecreator"));
|
|
//Print ROLE end
|
|
fwrite ($bf,end_tag("ROLE",5,true));
|
|
}
|
|
//Teacher
|
|
if ($user->isteacher!==false) {
|
|
//Print ROLE start
|
|
fwrite ($bf,start_tag("ROLE",5,true));
|
|
//Print Role info
|
|
fwrite ($bf,full_tag("TYPE",6,false,"teacher"));
|
|
//Get specific info for teachers
|
|
$tea = get_record("user_teachers","userid",$user->old_id,"course",$preferences->backup_course);
|
|
fwrite ($bf,full_tag("AUTHORITY",6,false,$tea->authority));
|
|
fwrite ($bf,full_tag("TEA_ROLE",6,false,$tea->role));
|
|
fwrite ($bf,full_tag("EDITALL",6,false,$tea->editall));
|
|
fwrite ($bf,full_tag("TIMESTART",6,false,$tea->timestart));
|
|
fwrite ($bf,full_tag("TIMEEND",6,false,$tea->timeend));
|
|
fwrite ($bf,full_tag("TIMEMODIFIED",6,false,$tea->timemodified));
|
|
fwrite ($bf,full_tag("TIMEACCESS",6,false,$tea->timeaccess));
|
|
fwrite ($bf,full_tag("ENROL",6,false,$tea->enrol));
|
|
//Print ROLE end
|
|
fwrite ($bf,end_tag("ROLE",5,true));
|
|
}
|
|
//Student
|
|
if ($user->isstudent!==false) {
|
|
//Print ROLE start
|
|
fwrite ($bf,start_tag("ROLE",5,true));
|
|
//Print Role info
|
|
fwrite ($bf,full_tag("TYPE",6,false,"student"));
|
|
//Get specific info for students
|
|
$stu = get_record("user_students","userid",$user->old_id,"course",$preferences->backup_course);
|
|
fwrite ($bf,full_tag("TIMESTART",6,false,$stu->timestart));
|
|
fwrite ($bf,full_tag("TIMEEND",6,false,$stu->timeend));
|
|
fwrite ($bf,full_tag("TIME",6,false,$stu->time));
|
|
fwrite ($bf,full_tag("TIMEACCESS",6,false,$stu->timeaccess));
|
|
fwrite ($bf,full_tag("ENROL",6,false,$stu->enrol));
|
|
//Print ROLE end
|
|
fwrite ($bf,end_tag("ROLE",5,true));
|
|
}
|
|
//Needed
|
|
if ($user->isneeded!==false) {
|
|
//Print ROLE start
|
|
fwrite ($bf,start_tag("ROLE",5,true));
|
|
//Print Role info
|
|
fwrite ($bf,full_tag("TYPE",6,false,"needed"));
|
|
//Print ROLE end
|
|
fwrite ($bf,end_tag("ROLE",5,true));
|
|
}
|
|
|
|
//End ROLES tag
|
|
fwrite ($bf,end_tag("ROLES",4,true));
|
|
|
|
//Check if we have user_preferences to backup
|
|
if ($preferences_data = get_records("user_preferences","userid",$user->old_id)) {
|
|
//Start USER_PREFERENCES tag
|
|
fwrite ($bf,start_tag("USER_PREFERENCES",4,true));
|
|
//Write each user_preference
|
|
foreach ($preferences_data as $user_preference) {
|
|
fwrite ($bf,start_tag("USER_PREFERENCE",5,true));
|
|
fwrite ($bf,full_tag("NAME",6,false,$user_preference->name));
|
|
fwrite ($bf,full_tag("VALUE",6,false,$user_preference->value));
|
|
fwrite ($bf,end_tag("USER_PREFERENCE",5,true));
|
|
}
|
|
//End USER_PREFERENCES tag
|
|
fwrite ($bf,end_tag("USER_PREFERENCES",4,true));
|
|
}
|
|
|
|
}
|
|
//End User tag
|
|
fwrite ($bf,end_tag("USER",3,true));
|
|
//Do some output
|
|
$counter++;
|
|
if ($counter % 10 == 0) {
|
|
echo ".";
|
|
if ($counter % 200 == 0) {
|
|
echo "<br />";
|
|
}
|
|
backup_flush(300);
|
|
}
|
|
}
|
|
//End Users tag
|
|
fwrite ($bf,end_tag("USERS",2,true));
|
|
} else {
|
|
// There aren't any users.
|
|
$status = true;
|
|
}
|
|
|
|
return $status;
|
|
}
|
|
|
|
//Backup log info (time ordered)
|
|
function backup_log_info($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
//Number of records to get in every chunk
|
|
$recordset_size = 1000;
|
|
|
|
$status = true;
|
|
|
|
//Counter, points to current record
|
|
$counter = 0;
|
|
|
|
//Count records
|
|
$count_logs = count_records("log","course",$preferences->backup_course);
|
|
|
|
//Pring logs header
|
|
if ($count_logs > 0 ) {
|
|
fwrite ($bf,start_tag("LOGS",2,true));
|
|
}
|
|
while ($counter < $count_logs) {
|
|
//Get a chunk of records
|
|
$logs = get_records ("log","course",$preferences->backup_course,"time","*",$counter,$recordset_size);
|
|
|
|
//We have logs
|
|
if ($logs) {
|
|
//Iterate
|
|
foreach ($logs as $log) {
|
|
//See if it is a valid module to backup
|
|
if ($log->module == "course" or
|
|
$log->module == "user" or
|
|
$preferences->mods[$log->module]->backup == 1) {
|
|
//Begin log tag
|
|
fwrite ($bf,start_tag("LOG",3,true));
|
|
|
|
//Output log tag
|
|
fwrite ($bf,full_tag("ID",4,false,$log->id));
|
|
fwrite ($bf,full_tag("TIME",4,false,$log->time));
|
|
fwrite ($bf,full_tag("USERID",4,false,$log->userid));
|
|
fwrite ($bf,full_tag("IP",4,false,$log->ip));
|
|
fwrite ($bf,full_tag("MODULE",4,false,$log->module));
|
|
fwrite ($bf,full_tag("CMID",4,false,$log->cmid));
|
|
fwrite ($bf,full_tag("ACTION",4,false,$log->action));
|
|
fwrite ($bf,full_tag("URL",4,false,$log->url));
|
|
fwrite ($bf,full_tag("INFO",4,false,$log->info));
|
|
|
|
//End log tag
|
|
fwrite ($bf,end_tag("LOG",3,true));
|
|
}
|
|
//Do some output
|
|
$counter++;
|
|
if ($counter % 20 == 0) {
|
|
echo ".";
|
|
if ($counter % 400 == 0) {
|
|
echo "<br />";
|
|
}
|
|
backup_flush(300);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//End logs tag
|
|
if ($count_logs > 0 ) {
|
|
$status = fwrite ($bf,end_tag("LOGS",2,true));
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
|
|
//Backup scales info (common and course scales)
|
|
function backup_scales_info($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Counter, points to current record
|
|
$counter = 0;
|
|
|
|
//Get scales (common and course scales)
|
|
$scales = get_records_sql("SELECT id, courseid, userid, name, scale, description, timemodified
|
|
FROM {$CFG->prefix}scale
|
|
WHERE courseid = '0' or courseid = $preferences->backup_course");
|
|
|
|
//Copy only used scales to $backupscales. They will be in backup (unused no). See Bug 1223.
|
|
$backupscales = array();
|
|
if ($scales) {
|
|
foreach ($scales as $scale) {
|
|
if (course_scale_used($preferences->backup_course, $scale->id)) {
|
|
$backupscales[] = $scale;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Pring scales header
|
|
if ($backupscales) {
|
|
//Pring scales header
|
|
fwrite ($bf,start_tag("SCALES",2,true));
|
|
//Iterate
|
|
foreach ($backupscales as $scale) {
|
|
//Begin scale tag
|
|
fwrite ($bf,start_tag("SCALE",3,true));
|
|
//Output scale tag
|
|
fwrite ($bf,full_tag("ID",4,false,$scale->id));
|
|
fwrite ($bf,full_tag("COURSEID",4,false,$scale->courseid));
|
|
fwrite ($bf,full_tag("USERID",4,false,$scale->userid));
|
|
fwrite ($bf,full_tag("NAME",4,false,$scale->name));
|
|
fwrite ($bf,full_tag("SCALETEXT",4,false,$scale->scale));
|
|
fwrite ($bf,full_tag("DESCRIPTION",4,false,$scale->description));
|
|
fwrite ($bf,full_tag("TIMEMODIFIED",4,false,$scale->timemodified));
|
|
//End scale tag
|
|
fwrite ($bf,end_tag("SCALE",3,true));
|
|
}
|
|
//End scales tag
|
|
$status = fwrite ($bf,end_tag("SCALES",2,true));
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
//Backup events info (course events)
|
|
function backup_events_info($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Counter, points to current record
|
|
$counter = 0;
|
|
|
|
//Get events (course events)
|
|
$events = get_records_select("event","courseid='$preferences->backup_course' AND instance='0'","id");
|
|
|
|
//Pring events header
|
|
if ($events) {
|
|
//Pring events header
|
|
fwrite ($bf,start_tag("EVENTS",2,true));
|
|
//Iterate
|
|
foreach ($events as $event) {
|
|
//Begin event tag
|
|
fwrite ($bf,start_tag("EVENT",3,true));
|
|
//Output event tag
|
|
fwrite ($bf,full_tag("ID",4,false,$event->id));
|
|
fwrite ($bf,full_tag("NAME",4,false,$event->name));
|
|
fwrite ($bf,full_tag("DESCRIPTION",4,false,$event->description));
|
|
fwrite ($bf,full_tag("FORMAT",4,false,$event->format));
|
|
fwrite ($bf,full_tag("GROUPID",4,false,$event->groupid));
|
|
fwrite ($bf,full_tag("USERID",4,false,$event->userid));
|
|
fwrite ($bf,full_tag("EVENTTYPE",4,false,$event->eventtype));
|
|
fwrite ($bf,full_tag("TIMESTART",4,false,$event->timestart));
|
|
fwrite ($bf,full_tag("TIMEDURATION",4,false,$event->timeduration));
|
|
fwrite ($bf,full_tag("VISIBLE",4,false,$event->visible));
|
|
fwrite ($bf,full_tag("TIMEMODIFIED",4,false,$event->timemodified));
|
|
//End event tag
|
|
fwrite ($bf,end_tag("EVENT",3,true));
|
|
}
|
|
//End events tag
|
|
$status = fwrite ($bf,end_tag("EVENTS",2,true));
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
//Backup groups info
|
|
function backup_groups_info($bf,$preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
$status2 = true;
|
|
|
|
//Get groups
|
|
$groups = get_records("groups","courseid",$preferences->backup_course);
|
|
|
|
//Pring groups header
|
|
if ($groups) {
|
|
//Pring groups header
|
|
fwrite ($bf,start_tag("GROUPS",2,true));
|
|
//Iterate
|
|
foreach ($groups as $group) {
|
|
//Begin group tag
|
|
fwrite ($bf,start_tag("GROUP",3,true));
|
|
//Output group contents
|
|
fwrite ($bf,full_tag("ID",4,false,$group->id));
|
|
fwrite ($bf,full_tag("COURSEID",4,false,$group->courseid));
|
|
fwrite ($bf,full_tag("NAME",4,false,$group->name));
|
|
fwrite ($bf,full_tag("DESCRIPTION",4,false,$group->description));
|
|
fwrite ($bf,full_tag("PASSWORD",4,false,$group->password));
|
|
fwrite ($bf,full_tag("LANG",4,false,$group->lang));
|
|
fwrite ($bf,full_tag("THEME",4,false,$group->theme));
|
|
fwrite ($bf,full_tag("PICTURE",4,false,$group->picture));
|
|
fwrite ($bf,full_tag("HIDEPICTURE",4,false,$group->hidepicture));
|
|
fwrite ($bf,full_tag("TIMECREATED",4,false,$group->timecreated));
|
|
fwrite ($bf,full_tag("TIMEMODIFIED",4,false,$group->timemodified));
|
|
|
|
//Now, backup groups_members, only if users are included
|
|
if ($preferences->backup_users != 2) {
|
|
$status2 = backup_groups_members_info($bf,$preferences,$group->id);
|
|
}
|
|
|
|
//End group tag
|
|
fwrite ($bf,end_tag("GROUP",3,true));
|
|
}
|
|
//End groups tag
|
|
$status = fwrite ($bf,end_tag("GROUPS",2,true));
|
|
}
|
|
return ($status && $status2);
|
|
}
|
|
|
|
//Backup groups_members info
|
|
function backup_groups_members_info($bf,$preferences,$groupid) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Get groups_members
|
|
$groups_members = get_records("groups_members","groupid",$groupid);
|
|
|
|
//Pring groups_members header
|
|
if ($groups_members) {
|
|
//Pring groups_members header
|
|
fwrite ($bf,start_tag("MEMBERS",4,true));
|
|
//Iterate
|
|
foreach ($groups_members as $group_member) {
|
|
//Begin group_member tag
|
|
fwrite ($bf,start_tag("MEMBER",5,true));
|
|
//Output group_member contents
|
|
fwrite ($bf,full_tag("USERID",6,false,$group_member->userid));
|
|
fwrite ($bf,full_tag("TIMEADDED",6,false,$group_member->timeadded));
|
|
//End group_member tag
|
|
fwrite ($bf,end_tag("MEMBER",5,true));
|
|
}
|
|
//End groups_members tag
|
|
$status = fwrite ($bf,end_tag("MEMBERS",4,true));
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
//Start the modules tag
|
|
function backup_modules_start ($bf,$preferences) {
|
|
|
|
return fwrite ($bf,start_tag("MODULES",2,true));
|
|
}
|
|
|
|
//End the modules tag
|
|
function backup_modules_end ($bf,$preferences) {
|
|
|
|
return fwrite ($bf,end_tag("MODULES",2,true));
|
|
}
|
|
|
|
//This function makes all the necesary calls to every mod
|
|
//to export itself and its files !!!
|
|
function backup_module($bf,$preferences,$module) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//First, re-check if necessary functions exists
|
|
$modbackup = $module."_backup_mods";
|
|
if (function_exists($modbackup)) {
|
|
//Call the function
|
|
$status = $modbackup($bf,$preferences);
|
|
} else {
|
|
//Something was wrong. Function should exist.
|
|
$status = false;
|
|
}
|
|
|
|
return $status;
|
|
|
|
}
|
|
|
|
//This function encode things to make backup multi-site fully functional
|
|
//It does this conversions:
|
|
// - $CFG->wwwroot/file.php/courseid ------------------> $@FILEPHP@$ (slasharguments links)
|
|
// - $CFG->wwwroot/file.php?file=/courseid ------------> $@FILEPHP@$ (non-slasharguments links)
|
|
// - Every module xxxx_encode_content_links() is executed too
|
|
//
|
|
function backup_encode_absolute_links($content) {
|
|
|
|
global $CFG,$preferences;
|
|
|
|
//Check if preferences is ok. If it isn't set, we are
|
|
//in a scheduled_backup to we are able to get a copy
|
|
//from CFG->backup_preferences
|
|
if (!isset($preferences)) {
|
|
$mypreferences = $CFG->backup_preferences;
|
|
} else {
|
|
//We are in manual backups so global preferences must exist!!
|
|
$mypreferences = $preferences;
|
|
}
|
|
|
|
//First, we check for every call to file.php inside the course
|
|
$search = array($CFG->wwwroot.'/file.php/'.$mypreferences->backup_course,
|
|
$CFG->wwwroot.'/file.php?file=/'.$mypreferences->backup_course);
|
|
|
|
$replace = array('$@FILEPHP@$','$@FILEPHP@$');
|
|
|
|
$result = str_replace($search,$replace,$content);
|
|
|
|
foreach ($mypreferences->mods as $name => $info) {
|
|
//Check if the xxxx_encode_content_links exists
|
|
$function_name = $name."_encode_content_links";
|
|
if (function_exists($function_name)) {
|
|
$result = $function_name($result,$mypreferences);
|
|
}
|
|
}
|
|
|
|
if ($result != $content && $CFG->debug>7) { //Debug
|
|
echo "<br /><hr />".$content."<br />changed to<br />".$result."<hr /><br />"; //Debug
|
|
} //Debug
|
|
|
|
return $result;
|
|
}
|
|
|
|
//This function copies all the needed files under the "users" directory to the "user_files"
|
|
//directory under temp/backup
|
|
function backup_copy_user_files ($preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//First we check to "user_files" exists and create it as necessary
|
|
//in temp/backup/$backup_code dir
|
|
$status = check_and_create_user_files_dir($preferences->backup_unique_code);
|
|
|
|
//Now iterate over directories under "users" to check if that user must be
|
|
//copied to backup
|
|
|
|
$rootdir = $CFG->dataroot."/users";
|
|
//Check if directory exists
|
|
if (is_dir($rootdir)) {
|
|
$list = list_directories ($rootdir);
|
|
if ($list) {
|
|
//Iterate
|
|
foreach ($list as $dir) {
|
|
//Look for dir like username in backup_ids
|
|
$data = get_record ("backup_ids","backup_code",$preferences->backup_unique_code,
|
|
"table_name","user",
|
|
"old_id",$dir);
|
|
//If exists, copy it
|
|
if ($data) {
|
|
$status = backup_copy_file($rootdir."/".$dir,
|
|
$CFG->dataroot."/temp/backup/".$preferences->backup_unique_code."/user_files/".$dir);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
//This function copies all the course files under the course directory (except the moddata
|
|
//directory to the "course_files" directory under temp/backup
|
|
function backup_copy_course_files ($preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//First we check to "course_files" exists and create it as necessary
|
|
//in temp/backup/$backup_code dir
|
|
$status = check_and_create_course_files_dir($preferences->backup_unique_code);
|
|
|
|
//Now iterate over files and directories except $CFG->moddata and backupdata to be
|
|
//copied to backup
|
|
|
|
$rootdir = $CFG->dataroot."/".$preferences->backup_course;
|
|
|
|
$name_moddata = $CFG->moddata;
|
|
$name_backupdata = "backupdata";
|
|
//Check if directory exists
|
|
if (is_dir($rootdir)) {
|
|
$list = list_directories_and_files ($rootdir);
|
|
if ($list) {
|
|
//Iterate
|
|
foreach ($list as $dir) {
|
|
if ($dir !== $name_moddata and $dir !== $name_backupdata) {
|
|
$status = backup_copy_file($rootdir."/".$dir,
|
|
$CFG->dataroot."/temp/backup/".$preferences->backup_unique_code."/course_files/".$dir);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
//This function creates the zip file containing all the backup info
|
|
//moodle.xml, moddata, user_files, course_files.
|
|
//The zipped file is created in the backup directory and named with
|
|
//the "oficial" name of the backup
|
|
//It uses "pclzip" if available or system "zip" (unix only)
|
|
function backup_zip ($preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Base dir where everything happens
|
|
$basedir = cleardoubleslashes($CFG->dataroot."/temp/backup/".$preferences->backup_unique_code);
|
|
//Backup zip file name
|
|
$name = $preferences->backup_name;
|
|
//List of files and directories
|
|
$filelist = list_directories_and_files ($basedir);
|
|
|
|
//Convert them to full paths
|
|
$files = array();
|
|
foreach ($filelist as $file) {
|
|
$files[] = "$basedir/$file";
|
|
}
|
|
|
|
$status = zip_files($files, "$basedir/$name");
|
|
|
|
//echo "<br>Status: ".$status; //Debug
|
|
return $status;
|
|
|
|
}
|
|
|
|
//This function copies the final zip to the course dir
|
|
function copy_zip_to_course_dir ($preferences) {
|
|
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
//Define zip location (from)
|
|
$from_zip_file = $CFG->dataroot."/temp/backup/".$preferences->backup_unique_code."/".$preferences->backup_name;
|
|
|
|
//Initialise $to_zip_file
|
|
$to_zip_file="";
|
|
|
|
//If $preferences->backup_destination isn't empty, then copy to custom directory
|
|
if (!empty($preferences->backup_destination)) {
|
|
$to_zip_file = $preferences->backup_destination."/".$preferences->backup_name;
|
|
} else {
|
|
//Define zip destination (course dir)
|
|
$to_zip_file = $CFG->dataroot."/".$preferences->backup_course;
|
|
|
|
//echo "<p>From: ".$from_zip_file."<br />"; //Debug
|
|
|
|
//echo "<p>Checking: ".$to_zip_file."<br />"; //Debug
|
|
|
|
//Checks course dir exists
|
|
$status = check_dir_exists($to_zip_file,true);
|
|
|
|
//Define zip destination (backup dir)
|
|
$to_zip_file = $to_zip_file."/backupdata";
|
|
|
|
//echo "<p>Checking: ".$to_zip_file."<br />"; //Debug
|
|
|
|
//Checks backup dir exists
|
|
$status = check_dir_exists($to_zip_file,true);
|
|
|
|
//Define zip destination (zip file)
|
|
$to_zip_file = $to_zip_file."/".$preferences->backup_name;
|
|
}
|
|
|
|
//echo "<p>To: ".$to_zip_file."<br />"; //Debug
|
|
|
|
//Copy zip file
|
|
if ($status) {
|
|
$status = backup_copy_file ($from_zip_file,$to_zip_file);
|
|
}
|
|
|
|
return $status;
|
|
}
|
|
?>
|