function schedule_inc_backup_course_configure($course, $starttime = 0)
{
global $CFG;
$status = true;
backup_add_to_log($starttime, $course->id, " checking parameters", 'incrementalbackup');
//Check the required variable
if (empty($course->id)) {
$status = false;
}
//Get scheduled backup preferences
$incremental_config = backup_get_config();
//Checks backup_config pairs exist
if ($status) {
if (!isset($incremental_config->backup_inc_modules)) {
$incremental_config->backup_inc_modules = 1;
}
if (!isset($incremental_config->backup_inc_withuserdata)) {
$incremental_config->backup_inc_withuserdata = 1;
}
if (!isset($incremental_config->backup_inc_metacourse)) {
$incremental_config->backup_inc_metacourse = 1;
}
if (!isset($incremental_config->backup_inc_users)) {
$incremental_config->backup_inc_users = 1;
}
if (!isset($incremental_config->backup_inc_logs)) {
$incremental_config->backup_inc_logs = 0;
}
if (!isset($incremental_config->backup_inc_userfiles)) {
$incremental_config->backup_inc_userfiles = 1;
}
if (!isset($incremental_config->backup_inc_coursefiles)) {
$incremental_config->backup_inc_coursefiles = 1;
}
if (!isset($incremental_config->backup_inc_sitefiles)) {
$incremental_config->backup_inc_sitefiles = 1;
}
if (!isset($incremental_config->backup_inc_messages)) {
$incremental_config->backup_inc_messages = 0;
}
if (!isset($incremental_config->backup_inc_weekdays)) {
$incremental_config->backup_inc_weekdays = "0000000";
}
if (!isset($incremental_config->backup_inc_hour)) {
$incremental_config->backup_inc_hour = 00;
}
if (!isset($incremental_config->backup_inc_minute)) {
$incremental_config->backup_inc_minute = 00;
}
if (!isset($incremental_config->backup_inc_destination)) {
$incremental_config->backup_inc_destination = "";
}
if (!isset($incremental_config->backup_inc_keep)) {
$incremental_config->backup_inc_keep = 1;
}
if (!isset($incremental_config->backup_sche_incrementals)) {
$incremental_config->backup_sche_incrementals = 0;
}
if (!isset($incremental_config->backup_inc_privatedata)) {
$incremental_config->backup_inc_privatedata = 0;
}
}
if ($status) {
//Checks for the required files/functions to backup every mod
//And check if there is data about it
//use the configured modules to backup.
$count = 0;
if (!empty($incremental_config->backup_inc_modules)) {
$moduleselect = 'id=' . str_replace(',', ' OR id=', $incremental_config->backup_inc_modules);
if ($allmods = get_records_select("modules", $moduleselect)) {
foreach ($allmods as $mod) {
$modname = $mod->name;
$modfile = "{$CFG->dirroot}/mod/{$modname}/backuplib.php";
$modbackup = $modname . "_backup_mods";
$modcheckbackup = $modname . "_check_backup_mods";
if (file_exists($modfile)) {
include_once $modfile;
if (function_exists($modbackup) and function_exists($modcheckbackup)) {
$var = "exists_" . $modname;
${$var} = true;
$count++;
// PENNY NOTES: I have moved from here to the closing brace inside
// by two sets of ifs()
// to avoid the backup failing on a non existant backup.
// If the file/function/whatever doesn't exist, we don't want to set this
// this module in backup preferences at all.
//Check data
//Check module info
$var = "backup_" . $modname;
if (!isset(${$var})) {
${$var} = $incremental_config->backup_inc_modules;
}
//Now stores all the mods preferences into an array into preferences
$preferences->mods[$modname]->backup = ${$var};
//Check include user info
$var = "backup_user_info_" . $modname;
if (!isset(${$var})) {
${$var} = $incremental_config->backup_inc_withuserdata;
}
//Now stores all the mods preferences into an array into preferences
$preferences->mods[$modname]->userinfo = ${$var};
//And the name of the mod
$preferences->mods[$modname]->name = $modname;
}
}
}
}
}
// now set instances
if ($coursemods = get_course_mods($course->id)) {
foreach ($coursemods as $mod) {
if (array_key_exists($mod->modname, $preferences->mods)) {
// we are to backup this module
if (empty($preferences->mods[$mod->modname]->instances)) {
$preferences->mods[$mod->modname]->instances = array();
// avoid warnings
}
$preferences->mods[$mod->modname]->instances[$mod->instance]->backup = $preferences->mods[$mod->modname]->backup;
$preferences->mods[$mod->modname]->instances[$mod->instance]->userinfo = $preferences->mods[$mod->modname]->userinfo;
// there isn't really a nice way to do this...
$preferences->mods[$mod->modname]->instances[$mod->instance]->name = get_field($mod->modname, 'name', 'id', $mod->instance);
}
}
}
// finally, clean all the $preferences->mods[] not having instances. Nothing to backup about them
if (!empty($preferences->mods)) {
foreach ($preferences->mods as $modname => $mod) {
if (!isset($mod->instances)) {
unset($preferences->mods[$modname]);
}
}
}
}
//Convert other parameters
if ($status) {
$preferences->backup_metacourse = $incremental_config->backup_inc_metacourse;
$preferences->backup_users = $incremental_config->backup_inc_users;
$preferences->backup_logs = $incremental_config->backup_inc_logs;
$preferences->backup_user_files = $incremental_config->backup_inc_userfiles;
$preferences->backup_course_files = $incremental_config->backup_inc_coursefiles;
$preferences->backup_site_files = $incremental_config->backup_inc_sitefiles;
$preferences->backup_messages = $incremental_config->backup_inc_messages;
$preferences->backup_gradebook_history = 1;
$preferences->backup_course = $course->id;
$preferences->backup_private_user_data = $incremental_config->backup_inc_privatedata;
if (!empty($incremental_config->backup_inc_destination)) {
if (!check_dir_exists($incremental_config->backup_inc_destination . '/' . $course->id, true, true)) {
error('failed to create backup destination directory');
} else {
$preferences->backup_destination = $incremental_config->backup_inc_destination . '/' . $course->id;
}
}
$preferences->backup_keep = $incremental_config->backup_inc_keep;
$preferences->backup_sche_incrementals = $incremental_config->backup_sche_incrementals;
}
//Calculate various backup preferences
if ($status) {
backup_add_to_log($starttime, $course->id, " calculating backup name", 'incrementalbackup');
//Calculate the backup file name
$backup_name = backup_get_zipfile_name($course);
//Calculate the string to match the keep preference
$keep_name = backup_get_keep_name($course);
//Set them
$preferences->backup_name = $backup_name;
$preferences->keep_name = $keep_name;
//Roleasignments
$roles = get_records('role', '', '', 'sortorder');
foreach ($roles as $role) {
$preferences->backuproleassignments[$role->id] = $role;
}
//Another Info
backup_add_static_preferences($preferences);
}
//Calculate the backup unique code to allow simultaneus backups (to define
//the temp-directory name and records in backup temp tables
if ($status) {
$backup_unique_code = time();
$preferences->backup_unique_code = $backup_unique_code;
}
//Calculate necesary info to backup modules
if ($status) {
backup_add_to_log($starttime, $course->id, " calculating modules data", 'incrementalbackup');
if ($allmods = get_records("modules")) {
foreach ($allmods as $mod) {
$modname = $mod->name;
$modbackup = $modname . "_backup_mods";
//If exists the lib & function
$var = "exists_" . $modname;
if (isset(${$var}) && ${$var}) {
//Add hidden fields
$var = "backup_" . $modname;
//Only if selected
if (${$var} == 1) {
$var = "backup_user_info_" . $modname;
//Call the check function to show more info
$modcheckbackup = $modname . "_check_backup_mods";
backup_add_to_log($starttime, $course->id, " {$modname}", 'incrementalbackup');
$modcheckbackup($course->id, ${$var}, $backup_unique_code);
}
}
}
}
}
//Now calculate the users
if ($status) {
backup_add_to_log($starttime, $course->id, " calculating users", 'incrementalbackup');
//Decide about include users with messages, based on SITEID
if ($preferences->backup_messages && $preferences->backup_course == SITEID) {
$include_message_users = true;
} else {
$include_message_users = false;
}
//Decide about include users with blogs, based on SITEID
if (isset($preferences->backup_blogs) && isset($preferences->backup_course) && $preferences->backup_blogs && $preferences->backup_course == SITEID) {
$include_blog_users = true;
} else {
$include_blog_users = false;
}
user_check_backup($course->id, $backup_unique_code, $preferences->backup_users, $include_message_users, $include_blog_users);
}
//Now calculate the logs
if ($status) {
if ($preferences->backup_logs) {
backup_add_to_log($starttime, $course->id, " calculating logs", 'incrementalbackup');
log_check_backup($course->id);
}
}
//Now calculate the userfiles
if ($status) {
if ($preferences->backup_user_files) {
backup_add_to_log($starttime, $course->id, " calculating user files", 'incrementalbackup');
user_files_check_backup($course->id, $preferences->backup_unique_code);
}
}
//Now calculate the coursefiles
if ($status) {
if ($preferences->backup_course_files) {
backup_add_to_log($starttime, $course->id, " calculating course files", 'incrementalbackup');
course_files_check_backup($course->id, $preferences->backup_unique_code);
}
}
//Now calculate the sitefiles
if ($status) {
if ($preferences->backup_site_files) {
backup_add_to_log($starttime, $course->id, " calculating site files", 'incrementalbackup');
site_files_check_backup($course->id, $preferences->backup_unique_code);
}
}
//If everything is ok, return calculated preferences
if ($status) {
$status = $preferences;
}
return $status;
}
/**
* Function to generate the $preferences variable that
* backup uses. This will back up all modules and instances in a course.
*
* @param object $course course object
* @param array $prefs can contain:
backup_metacourse
backup_users
backup_logs
backup_user_files
backup_course_files
backup_site_files
backup_messages
* and if not provided, they will not be included.
*/
function backup_generate_preferences_artificially($course, $prefs)
{
global $CFG, $DB;
$preferences = new StdClass();
$preferences->backup_unique_code = time();
$preferences->backup_users = isset($prefs['backup_users']) ? $prefs['backup_users'] : 0;
$preferences->backup_name = backup_get_zipfile_name($course, $preferences->backup_unique_code);
$count = 0;
if ($allmods = $DB->get_records("modules")) {
foreach ($allmods as $mod) {
$modname = $mod->name;
$modfile = "{$CFG->dirroot}/mod/{$modname}/backuplib.php";
$modbackup = $modname . "_backup_mods";
$modbackupone = $modname . "_backup_one_mod";
$modcheckbackup = $modname . "_check_backup_mods";
if (!file_exists($modfile)) {
continue;
}
include_once $modfile;
if (!function_exists($modbackup) || !function_exists($modcheckbackup)) {
continue;
}
$modcheckbackup($course->id, $preferences->backup_users, $preferences->backup_unique_code);
$var = "exists_" . $modname;
$preferences->{$var} = true;
$count++;
// check that there are instances and we can back them up individually
if (!$DB->count_records('course_modules', array('course' => $course->id), array('module' => $mod->id)) || !function_exists($modbackupone)) {
continue;
}
$var = 'exists_one_' . $modname;
$preferences->{$var} = true;
$varname = $modname . '_instances';
$preferences->{$varname} = get_all_instances_in_course($modname, $course, NULL, true);
foreach ($preferences->{$varname} as $instance) {
$preferences->mods[$modname]->instances[$instance->id]->name = $instance->name;
$var = 'backup_' . $modname . '_instance_' . $instance->id;
$preferences->{$var} = true;
$preferences->mods[$modname]->instances[$instance->id]->backup = true;
$var = 'backup_user_info_' . $modname . '_instance_' . $instance->id;
$preferences->{$var} = true;
$preferences->mods[$modname]->instances[$instance->id]->userinfo = true;
$var = 'backup_' . $modname . '_instances';
$preferences->{$var} = 1;
// we need this later to determine what to display in modcheckbackup.
}
//Check data
//Check module info
$preferences->mods[$modname]->name = $modname;
$var = "backup_" . $modname;
$preferences->{$var} = true;
$preferences->mods[$modname]->backup = true;
//Check include user info
$var = "backup_user_info_" . $modname;
$preferences->{$var} = true;
$preferences->mods[$modname]->userinfo = true;
}
}
//Check other parameters
$preferences->backup_metacourse = isset($prefs['backup_metacourse']) ? $prefs['backup_metacourse'] : 0;
$preferences->backup_logs = isset($prefs['backup_logs']) ? $prefs['backup_logs'] : 0;
$preferences->backup_user_files = isset($prefs['backup_user_files']) ? $prefs['backup_user_files'] : 0;
$preferences->backup_course_files = isset($prefs['backup_course_files']) ? $prefs['backup_course_files'] : 0;
$preferences->backup_site_files = isset($prefs['backup_site_files']) ? $prefs['backup_site_files'] : 0;
$preferences->backup_messages = isset($prefs['backup_messages']) ? $prefs['backup_messages'] : 0;
$preferences->backup_gradebook_history = isset($prefs['backup_gradebook_history']) ? $prefs['backup_gradebook_history'] : 0;
$preferences->backup_blogs = isset($prefs['backup_blogs']) ? $prefs['backup_blogs'] : 0;
$preferences->backup_course = $course->id;
//Check users
user_check_backup($course->id, $preferences->backup_unique_code, $preferences->backup_users, $preferences->backup_messages, $preferences->backup_blogs);
//Check logs
log_check_backup($course->id);
//Check user files
user_files_check_backup($course->id, $preferences->backup_unique_code);
//Check course files
course_files_check_backup($course->id, $preferences->backup_unique_code);
//Check site files
site_files_check_backup($course->id, $preferences->backup_unique_code);
//Role assignments
$roles = get_records('role', '', '', 'sortorder');
foreach ($roles as $role) {
$preferences->backuproleassignments[$role->id] = $role;
}
backup_add_static_preferences($preferences);
return $preferences;
}
function schedule_backup_course_configure($course, $starttime = 0)
{
global $CFG;
$status = true;
schedule_backup_log($starttime, $course->id, " checking parameters");
//Check the required variable
if (empty($course->id)) {
$status = false;
}
//Get scheduled backup preferences
$backup_config = backup_get_config();
//Checks backup_config pairs exist
if ($status) {
if (!isset($backup_config->backup_sche_modules)) {
$backup_config->backup_sche_modules = 1;
}
if (!isset($backup_config->backup_sche_withuserdata)) {
$backup_config->backup_sche_withuserdata = 1;
}
if (!isset($backup_config->backup_sche_metacourse)) {
$backup_config->backup_sche_metacourse = 1;
}
if (!isset($backup_config->backup_sche_users)) {
$backup_config->backup_sche_users = 1;
}
if (!isset($backup_config->backup_sche_logs)) {
$backup_config->backup_sche_logs = 0;
}
if (!isset($backup_config->backup_sche_userfiles)) {
$backup_config->backup_sche_userfiles = 1;
}
if (!isset($backup_config->backup_sche_coursefiles)) {
$backup_config->backup_sche_coursefiles = 1;
}
if (!isset($backup_config->backup_sche_messages)) {
$backup_config->backup_sche_messages = 0;
}
if (!isset($backup_config->backup_sche_active)) {
$backup_config->backup_sche_active = 0;
}
if (!isset($backup_config->backup_sche_weekdays)) {
$backup_config->backup_sche_weekdays = "0000000";
}
if (!isset($backup_config->backup_sche_hour)) {
$backup_config->backup_sche_hour = 00;
}
if (!isset($backup_config->backup_sche_minute)) {
$backup_config->backup_sche_minute = 00;
}
if (!isset($backup_config->backup_sche_destination)) {
$backup_config->backup_sche_destination = "";
}
if (!isset($backup_config->backup_sche_keep)) {
$backup_config->backup_sche_keep = 1;
}
}
if ($status) {
//Checks for the required files/functions to backup every mod
//And check if there is data about it
$count = 0;
if ($allmods = get_records("modules")) {
foreach ($allmods as $mod) {
$modname = $mod->name;
$modfile = "{$CFG->dirroot}/mod/{$modname}/backuplib.php";
$modbackup = $modname . "_backup_mods";
$modcheckbackup = $modname . "_check_backup_mods";
if (file_exists($modfile)) {
include_once $modfile;
if (function_exists($modbackup) and function_exists($modcheckbackup)) {
$var = "exists_" . $modname;
${$var} = true;
$count++;
// PENNY NOTES: I have moved from here to the closing brace inside
// by two sets of ifs()
// to avoid the backup failing on a non existant backup.
// If the file/function/whatever doesn't exist, we don't want to set this
// this module in backup preferences at all.
//Check data
//Check module info
$var = "backup_" . $modname;
if (!isset(${$var})) {
${$var} = $backup_config->backup_sche_modules;
}
//Now stores all the mods preferences into an array into preferences
$preferences->mods[$modname]->backup = ${$var};
//Check include user info
$var = "backup_user_info_" . $modname;
if (!isset(${$var})) {
${$var} = $backup_config->backup_sche_withuserdata;
}
//Now stores all the mods preferences into an array into preferences
$preferences->mods[$modname]->userinfo = ${$var};
//And the name of the mod
$preferences->mods[$modname]->name = $modname;
}
}
}
}
// now set instances
if ($coursemods = get_course_mods($course->id)) {
foreach ($coursemods as $mod) {
if (array_key_exists($mod->modname, $preferences->mods)) {
// we are to backup this module
if (empty($preferences->mods[$mod->modname]->instances)) {
$preferences->mods[$mod->modname]->instances = array();
// avoid warnings
}
$preferences->mods[$mod->modname]->instances[$mod->instance]->backup = $preferences->mods[$mod->modname]->backup;
$preferences->mods[$mod->modname]->instances[$mod->instance]->userinfo = $preferences->mods[$mod->modname]->userinfo;
// there isn't really a nice way to do this...
$preferences->mods[$mod->modname]->instances[$mod->instance]->name = get_field($mod->modname, 'name', 'id', $mod->instance);
}
}
}
// finally, clean all the $preferences->mods[] not having instances. Nothing to backup about them
foreach ($preferences->mods as $modname => $mod) {
if (!isset($mod->instances)) {
unset($preferences->mods[$modname]);
}
}
}
//Convert other parameters
if ($status) {
$preferences->backup_metacourse = $backup_config->backup_sche_metacourse;
$preferences->backup_users = $backup_config->backup_sche_users;
$preferences->backup_logs = $backup_config->backup_sche_logs;
$preferences->backup_user_files = $backup_config->backup_sche_userfiles;
$preferences->backup_course_files = $backup_config->backup_sche_coursefiles;
$preferences->backup_messages = $backup_config->backup_sche_messages;
$preferences->backup_course = $course->id;
$preferences->backup_destination = $backup_config->backup_sche_destination;
$preferences->backup_keep = $backup_config->backup_sche_keep;
}
//Calculate the backup string
if ($status) {
schedule_backup_log($starttime, $course->id, " calculating backup name");
//Calculate the backup word
//Take off some characters in the filename !!
$takeoff = array(" ", ":", "/", "\\", "|");
$backup_word = str_replace($takeoff, "_", moodle_strtolower(get_string("backupfilename")));
//If non-translated, use "backup"
if (substr($backup_word, 0, 1) == "[") {
$backup_word = "backup";
}
//Calculate the date format string
$backup_date_format = str_replace(" ", "_", get_string("backupnameformat"));
//If non-translated, use "%Y%m%d-%H%M"
if (substr($backup_date_format, 0, 1) == "[") {
$backup_date_format = "%%Y%%m%%d-%%H%%M";
}
//Calculate the shortname
$backup_shortname = clean_filename($course->shortname);
if (empty($backup_shortname) or $backup_shortname == '_') {
$backup_shortname = $course->id;
}
//Calculate the final backup filename
//The backup word
$backup_name = $backup_word . "-";
//The shortname
$backup_name .= moodle_strtolower($backup_shortname) . "-";
//The date format
$backup_name .= userdate(time(), $backup_date_format, 99, false);
//The extension
$backup_name .= ".zip";
//And finally, clean everything
$backup_name = clean_filename($backup_name);
//Calculate the string to match the keep preference
$keep_name = $backup_word . "-";
//The shortname
$keep_name .= moodle_strtolower($backup_shortname) . "-";
//And finally, clean everything
$keep_name = clean_filename($keep_name);
$preferences->backup_name = $backup_name;
$preferences->keep_name = $keep_name;
}
//Calculate the backup unique code to allow simultaneus backups (to define
//the temp-directory name and records in backup temp tables
if ($status) {
$backup_unique_code = time();
$preferences->backup_unique_code = $backup_unique_code;
}
//Calculate necesary info to backup modules
if ($status) {
schedule_backup_log($starttime, $course->id, " calculating modules data");
if ($allmods = get_records("modules")) {
foreach ($allmods as $mod) {
$modname = $mod->name;
$modbackup = $modname . "_backup_mods";
//If exists the lib & function
$var = "exists_" . $modname;
if (isset(${$var}) && ${$var}) {
//Add hidden fields
$var = "backup_" . $modname;
//Only if selected
if (${$var} == 1) {
$var = "backup_user_info_" . $modname;
//Call the check function to show more info
$modcheckbackup = $modname . "_check_backup_mods";
schedule_backup_log($starttime, $course->id, " {$modname}");
$modcheckbackup($course->id, ${$var}, $backup_unique_code);
}
}
}
}
}
//Now calculate the users
if ($status) {
schedule_backup_log($starttime, $course->id, " calculating users");
//Decide about include users with messages, based on SITEID
if ($preferences->backup_messages && $preferences->backup_course == SITEID) {
$include_message_users = true;
} else {
$include_message_users = false;
}
user_check_backup($course->id, $backup_unique_code, $preferences->backup_users, $include_message_users);
}
//Now calculate the logs
if ($status) {
if ($preferences->backup_logs) {
schedule_backup_log($starttime, $course->id, " calculating logs");
log_check_backup($course->id);
}
}
//Now calculate the userfiles
if ($status) {
if ($preferences->backup_user_files) {
schedule_backup_log($starttime, $course->id, " calculating user files");
user_files_check_backup($course->id, $preferences->backup_unique_code);
}
}
//Now calculate the coursefiles
if ($status) {
if ($preferences->backup_course_files) {
schedule_backup_log($starttime, $course->id, " calculating course files");
course_files_check_backup($course->id, $preferences->backup_unique_code);
}
}
//If everything is ok, return calculated preferences
if ($status) {
$status = $preferences;
}
return $status;
}