backup/backuplib.php

   1 <?PHP //$Id$
   2     //This file contains all the function needed in the backup utility
   3     //except the mod-related funtions that are into every backuplib.php inside
   4     //every mod directory
   5
   6     //Insert necessary category ids to backup_ids table
   7     function insert_category_ids ($course,$backup_unique_code) {
   8         global $CFG;
   9         $status = true;
  10         $status = execute_sql("INSERT INTO {$CFG->prefix}backup_ids
  11                                    (backup_code, table_name, old_id)
  12                                SELECT DISTINCT '$backup_unique_code','quiz_categories',t.category
  13                                FROM {$CFG->prefix}quiz_questions t,
  14                                     {$CFG->prefix}quiz_question_grades g,
  15                                     {$CFG->prefix}quiz q
  16                                WHERE q.course = '$course' AND
  17                                      g.quiz = q.id AND
  18                                      g.question = t.id",false);
  19         return $status;
  20     }
  21
  22     //Delete category ids from backup_ids table
  23     function delete_category_ids ($backup_unique_code) {
  24         global $CFG;
  25         $status = true;
  26         $status = execute_sql("DELETE FROM {$CFG->prefix}backup_ids
  27                                WHERE backup_code = '$backup_unique_code'",false);
  28         return $status;
  29     }
  30
  31     //Calculate the number of users to backup and put their ids in backup_ids
  32     //Return an array of info (name,value)
  33     function user_check_backup($course,$backup_unique_code,$backup_users) {
  34         //$backup_users=0-->all
  35         //              1-->course (needed + enrolled)
  36
  37         global $CFG;
  38         global $db;
  39
  40         $count_users = 0;
  41
  42         //Calculate needed users (calling every xxxx_get_participants function + scales users)
  43         $needed_users = backup_get_needed_users($course);
  44
  45         //Calculate enrolled users (students + teachers)
  46         $enrolled_users = backup_get_enrolled_users($course);
  47
  48         //Calculate all users (every record in users table)
  49         $all_users = backup_get_all_users();
  50
  51         //Calculate course users (needed + enrolled)
  52         //First, needed
  53         $course_users = $needed_users;
  54
  55         //Now, enrolled
  56         if ($enrolled_users) {
  57             foreach ($enrolled_users as $enrolled_user) {
  58                 $course_users[$enrolled_user->id]->id = $enrolled_user->id;
  59             }
  60         }
  61
  62         //Now, depending of parameters, create $backupable_users
  63         if ($backup_users == 0) {
  64             $backupable_users = $all_users;
  65         } else {
  66             $backupable_users = $course_users;
  67         }
  68
  69         //If we have backupable users
  70         if ($backupable_users) {
  71             //Iterate over users putting their roles
  72             foreach ($backupable_users as $backupable_user) {
  73                 $backupable_user->info = "";
  74                 //Is Admin in tables (not is_admin()) !!
  75                 if (record_exists("user_admins","userid",$backupable_user->id)) {
  76                     $backupable_user->info .= "admin";
  77                 }
  78                 //Is Course Creator in tables (not is_coursecreator()) !!
  79                 if (record_exists("user_coursecreators","userid",$backupable_user->id)) {
  80                     $backupable_user->info .= "coursecreator";
  81                 }
  82                 //Is Teacher in tables (not is_teacher()) !!
  83                 if (record_exists("user_teachers","course",$course,"userid",$backupable_user->id)) {
  84                     $backupable_user->info .= "teacher";
  85                 }
  86                 //Is Student in tables (not is_student()) !!
  87                 if (record_exists("user_students","course",$course,"userid",$backupable_user->id)) {
  88                     $backupable_user->info .= "student";
  89                 }
  90                 //Is needed user (exists in needed_users)
  91                 if (isset($needed_users[$backupable_user->id])) {
  92                     $backupable_user->info .= "needed";
  93                 }
  94                 //Now create the backup_id record
  95                 $backupids_rec->backup_code = $backup_unique_code;
  96                 $backupids_rec->table_name = "user";
  97                 $backupids_rec->old_id = $backupable_user->id;
  98                 $backupids_rec->info = $backupable_user->info;
  99
 100                 //Insert the record id. backup_users decide it.
 101                 //When all users
 102                 $status = insert_record("backup_ids",$backupids_rec,false,"backup_code");
 103                 $count_users++;
 104             }
 105             //Do some output
 106             backup_flush(30);
 107         }
 108
 109         //Prepare Info
 110         //Gets the user data
 111         $info[0][0] = get_string("users");
 112         $info[0][1] = $count_users;
 113
 114         return $info;
 115     }
 116
 117     //Returns every needed user (participant) in a course
 118     //It uses the xxxx_get_participants() function
 119     //plus users needed to backup scales.
 120     //WARNING: It returns only NEEDED users, not every
 121     //   every student and teacher in the course, so it
 122     //must be merged with backup_get_enrrolled_users !!
 123
 124     function backup_get_needed_users ($courseid) {
 125
 126         global $CFG;
 127
 128         $result = false;
 129
 130         $course_modules = get_records_sql ("SELECT cm.id, m.name, cm.instance
 131                                             FROM {$CFG->prefix}modules m,
 132                                                  {$CFG->prefix}course_modules cm
 133                                             WHERE m.id = cm.module and
 134                                                   cm.course = '$courseid'");
 135
 136         if ($course_modules) {
 137             //Iterate over each module
 138             foreach ($course_modules as $course_module) {
 139                 $modlib = "$CFG->dirroot/mod/$course_module->name/lib.php";
 140                 $modgetparticipants = $course_module->name."_get_participants";
 141                 if (file_exists($modlib)) {
 142                     include_once($modlib);
 143                     if (function_exists($modgetparticipants)) {
 144                         $module_participants = $modgetparticipants($course_module->instance);
 145                         //Add them to result
 146                         if ($module_participants) {
 147                             foreach ($module_participants as $module_participant) {
 148                                 $result[$module_participant->id]->id = $module_participant->id;
 149                             }
 150                         }
 151                     }
 152                  }
 153             }
 154         }
 155
 156         //Now, add scales users (from site and course scales)
 157         //Get users
 158         $scaleusers = get_records_sql("SELECT DISTINCT userid,userid
 159                                        FROM {$CFG->prefix}scale
 160                                        WHERE courseid = '0' or courseid = '$courseid'");
 161         //Add scale users to results
 162         if ($scaleusers) {
 163             foreach ($scaleusers as $scaleuser) {
 164                 //If userid != 0
 165                 if ($scaleuser->userid != 0) {
 166                     $result[$scaleuser->userid]->id = $scaleuser->userid;
 167                 }
 168             }
 169         }
 170
 171         return $result;
 172
 173     }
 174
 175     //Returns every enrolled user (student and teacher) in a course
 176
 177     function backup_get_enrolled_users ($courseid) {
 178
 179         global $CFG;
 180
 181         $result = false;
 182
 183         //Get teachers
 184         $teachers = get_records_sql("SELECT DISTINCT userid,userid
 185                      FROM {$CFG->prefix}user_teachers
 186                      WHERE course = '$courseid'");
 187         //Get students
 188         $students = get_records_sql("SELECT DISTINCT userid,userid
 189                      FROM {$CFG->prefix}user_students
 190                      WHERE course = '$courseid'");
 191         //Add teachers
 192         if ($teachers) {
 193             foreach ($teachers as $teacher) {
 194                 $result[$teacher->userid]->id = $teacher->userid;
 195             }
 196         }
 197         //Add students
 198         if ($students) {
 199             foreach ($students as $student) {
 200                 $result[$student->userid]->id = $student->userid;
 201             }
 202         }
 203
 204         return $result;
 205     }
 206
 207     //Returns all users (every record in users table)
 208
 209     function backup_get_all_users() {
 210
 211         global $CFG;
 212
 213         $result = false;
 214
 215         //Get users
 216         $users = get_records_sql("SELECT DISTINCT id,id
 217                                   FROM {$CFG->prefix}user");
 218         //Add users
 219         if ($users) {
 220             foreach ($users as $user) {
 221                 $result[$user->id]->id = $user->id;
 222             }
 223         }
 224
 225         return $result;
 226     }
 227
 228     //Calculate the number of log entries to backup
 229     //Return an array of info (name,value)
 230     function log_check_backup($course) {
 231
 232         global $CFG;
 233
 234         //Now execute the count
 235         $ids = count_records("log","course",$course);
 236
 237         //Gets the user data
 238         $info[0][0] = get_string("logs");
 239         if ($ids) {
 240             $info[0][1] = $ids;
 241         } else {
 242             $info[0][1] = 0;
 243         }
 244
 245         return $info;
 246     }
 247
 248     //Calculate the number of user files to backup
 249     //Under $CFG->dataroot/users
 250     //and put them (their path) in backup_ids
 251     //Return an array of info (name,value)
 252     function user_files_check_backup($course,$backup_unique_code) {
 253
 254         global $CFG;
 255
 256         $rootdir = $CFG->dataroot."/users";
 257         //Check if directory exists
 258         if (is_dir($rootdir)) {
 259             $coursedirs = get_directory_list($rootdir);
 260             foreach ($coursedirs as $dir) {
 261                 //Extracts user id from file path
 262                 $tok = strtok($dir,"/");
 263                 if ($tok) {
 264                    $userid = $tok;
 265                 } else {
 266                    $tok = "";
 267                 }
 268                 //Look it is a backupable user
 269                 $data = get_record ("backup_ids","backup_code","$backup_unique_code",
 270                                                  "table_name","user",
 271                                                  "old_id",$userid);
 272                 if ($data) {
 273                     //Insert them into backup_files
 274                     $status = execute_sql("INSERT INTO {$CFG->prefix}backup_files
 275                                                (backup_code, file_type, path, old_id)
 276                                            VALUES
 277                                                ('$backup_unique_code','user','$dir','$userid')",false);
 278                 }
 279                 //Do some output
 280                 backup_flush(30);
 281             }
 282         }
 283
 284         //Now execute the select
 285         $ids = get_records_sql("SELECT DISTINCT b.path, b.old_id
 286                                 FROM {$CFG->prefix}backup_files b
 287                                 WHERE backup_code = '$backup_unique_code' AND
 288                                       file_type = 'user'");
 289         //Gets the user data
 290         $info[0][0] = get_string("files");
 291         if ($ids) {
 292             $info[0][1] = count($ids);
 293         } else {
 294             $info[0][1] = 0;
 295         }
 296
 297         return $info;
 298     }
 299
 300     //Calculate the number of course files to backup
 301     //under $CFG->dataroot/$course, except $CFG->moddata, and backupdata
 302     //and put them (their path) in backup_ids
 303     //Return an array of info (name,value)
 304     function course_files_check_backup($course,$backup_unique_code) {
 305
 306         global $CFG;
 307
 308         $rootdir = $CFG->dataroot."/$course";
 309         //Check if directory exists
 310         if (is_dir($rootdir)) {
 311             $coursedirs = get_directory_list($rootdir,$CFG->moddata);
 312             $backupdata_dir = "backupdata";
 313             foreach ($coursedirs as $dir) {
 314                 //Check it isn't backupdata_dir
 315                 if (strpos($dir,$backupdata_dir)!==0) {
 316                     //Insert them into backup_files
 317                     $status = execute_sql("INSERT INTO {$CFG->prefix}backup_files
 318                                                   (backup_code, file_type, path)
 319                                            VALUES
 320                                               ('$backup_unique_code','course','$dir')",false);
 321                 }
 322             //Do some output
 323             backup_flush(30);
 324             }
 325         }
 326
 327         //Now execute the select
 328         $ids = get_records_sql("SELECT DISTINCT b.path, b.old_id
 329                                 FROM {$CFG->prefix}backup_files b
 330                                 WHERE backup_code = '$backup_unique_code' AND
 331                                       file_type = 'course'");
 332         //Gets the user data
 333         $info[0][0] = get_string("files");
 334         if ($ids) {
 335             $info[0][1] = count($ids);
 336         } else {
 337             $info[0][1] = 0;
 338         }
 339
 340         return $info;
 341     }
 342
 343     //Function to check and create the needed moddata dir to
 344     //save all the mod backup files. We always name it moddata
 345     //to be able to restore it, but in restore we check for
 346     //$CFG->moddata !!
 347     function check_and_create_moddata_dir($backup_unique_code) {
 348
 349         global $CFG;
 350
 351             $status = check_dir_exists($CFG->dataroot."/temp/backup/".$backup_unique_code."/moddata",true);
 352
 353         return $status;
 354     }
 355
 356     //Function to check and create the "user_files" dir to
 357     //save all the user files we need from "users" dir
 358     function check_and_create_user_files_dir($backup_unique_code) {
 359
 360         global $CFG;
 361
 362             $status = check_dir_exists($CFG->dataroot."/temp/backup/".$backup_unique_code."/user_files",true);
 363
 364         return $status;
 365     }
 366
 367     //Function to check and create the "course_files" dir to
 368     //save all the course files we need from "CFG->datadir/course" dir
 369     function check_and_create_course_files_dir($backup_unique_code) {
 370
 371         global $CFG;
 372
 373             $status = check_dir_exists($CFG->dataroot."/temp/backup/".$backup_unique_code."/course_files",true);
 374
 375         return $status;
 376     }
 377
 378     //Function to create, open and write header of the xml file
 379     function backup_open_xml($backup_unique_code) {
 380
 381         global $CFG;
 382
 383         $status = true;
 384
 385         //Open for writing
 386
 387         $file = $CFG->dataroot."/temp/backup/".$backup_unique_code."/moodle.xml";
 388         $backup_file = fopen($file,"w");
 389         //Writes the header
 390         $status = fwrite ($backup_file,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 391         if ($status) {
 392             $status = fwrite ($backup_file,start_tag("MOODLE_BACKUP",0,true));
 393         }
 394         if ($status) {
 395             return $backup_file;
 396         } else {
 397             return false;
 398         }
 399     }
 400
 401     //Close the file
 402     function backup_close_xml($backup_file) {
 403         $status = fwrite ($backup_file,end_tag("MOODLE_BACKUP",0,true));
 404         return fclose($backup_file);
 405     }
 406
 407     //Return the xml start tag
 408     function start_tag($tag,$level=0,$endline=false) {
 409         if ($endline) {
 410            $endchar = "\n";
 411         } else {
 412            $endchar = "";
 413         }
 414         return str_repeat(" ",$level*2)."<".strtoupper($tag).">".$endchar;
 415     }
 416
 417     //Return the xml end tag
 418     function end_tag($tag,$level=0,$endline=true) {
 419         if ($endline) {
 420            $endchar = "\n";
 421         } else {
 422            $endchar = "";
 423         }
 424         return str_repeat(" ",$level*2)."</".strtoupper($tag).">".$endchar;
 425     }
 426
 427     //Return the start tag, the contents and the end tag
 428     function full_tag($tag,$level=0,$endline=true,$content,$to_utf=true) {
 429         $st = start_tag($tag,$level,$endline);
 430         $co="";
 431         if ($to_utf) {
 432             $co = preg_replace("/\r\n|\r/", "\n", utf8_encode(htmlspecialchars($content)));
 433         } else {
 434             $co = preg_replace("/\r\n|\r/", "\n", htmlspecialchars($content));
 435         }
 436         $et = end_tag($tag,0,true);
 437         return $st.$co.$et;
 438     }
 439
 440     //Prints General info about the course
 441     //name, moodle_version (internal and release), backup_version, date, info in file...
 442     function backup_general_info ($bf,$preferences) {
 443
 444         global $CFG;
 445
 446         fwrite ($bf,start_tag("INFO",1,true));
 447
 448         //The name of the backup
 449         fwrite ($bf,full_tag("NAME",2,false,$preferences->backup_name));
 450         //The moodle_version
 451         fwrite ($bf,full_tag("MOODLE_VERSION",2,false,$preferences->moodle_version));
 452         fwrite ($bf,full_tag("MOODLE_RELEASE",2,false,$preferences->moodle_release));
 453         //The backup_version
 454         fwrite ($bf,full_tag("BACKUP_VERSION",2,false,$preferences->backup_version));
 455         fwrite ($bf,full_tag("BACKUP_RELEASE",2,false,$preferences->backup_release));
 456         //The date
 457         fwrite ($bf,full_tag("DATE",2,false,$preferences->backup_unique_code));
 458         //Te includes tag
 459         fwrite ($bf,start_tag("DETAILS",2,true));
 460         //Now, go to mod element of preferences to print its status
 461         foreach ($preferences->mods as $element) {
 462             //Calculate info
 463             $included = "false";
 464             $userinfo = "false";
 465             if ($element->backup) {
 466                 $included = "true";
 467                 if ($element->userinfo) {
 468                     $userinfo = "true";
 469                 }
 470             }
 471             //Prints the mod start
 472             fwrite ($bf,start_tag("MOD",3,true));
 473             fwrite ($bf,full_tag("NAME",4,false,$element->name));
 474             fwrite ($bf,full_tag("INCLUDED",4,false,$included));
 475             fwrite ($bf,full_tag("USERINFO",4,false,$userinfo));
 476
 477             //Print the end
 478             fwrite ($bf,end_tag("MOD",3,true));
 479         }
 480         //The user in backup
 481         if ($preferences->backup_users == 1) {
 482             fwrite ($bf,full_tag("USERS",3,false,"course"));
 483         } else {
 484             fwrite ($bf,full_tag("USERS",3,false,"all"));
 485         }
 486         //The logs in backup
 487         if ($preferences->backup_logs == 1) {
 488             fwrite ($bf,full_tag("LOGS",3,false,"true"));
 489         } else {
 490             fwrite ($bf,full_tag("LOGS",3,false,"false"));
 491         }
 492         //The user files
 493         if ($preferences->backup_user_files == 1) {
 494             fwrite ($bf,full_tag("USERFILES",3,false,"true"));
 495         } else {
 496             fwrite ($bf,full_tag("USERFILES",3,false,"false"));
 497         }
 498         //The course files
 499         if ($preferences->backup_course_files == 1) {
 500             fwrite ($bf,full_tag("COURSEFILES",3,false,"true"));
 501         } else {
 502             fwrite ($bf,full_tag("COURSEFILES",3,false,"false"));
 503         }
 504
 505         fwrite ($bf,end_tag("DETAILS",2,true));
 506
 507
 508         $status = fwrite ($bf,end_tag("INFO",1,true));
 509
 510         return $status;
 511     }
 512
 513     //Prints course's general info (table course)
 514     function backup_course_start ($bf,$preferences) {
 515
 516         global $CFG;
 517
 518         $status = true;
 519
 520         //Course open tag
 521         fwrite ($bf,start_tag("COURSE",1,true));
 522         //Header open tag
 523         fwrite ($bf,start_tag("HEADER",2,true));
 524
 525         //Get info from course
 526         $course=false;
 527         if ($courses = get_records("course","id",$preferences->backup_course)) {
 528             $course = $courses[$preferences->backup_course];
 529         }
 530         if ($course) {
 531             //Prints course info
 532             fwrite ($bf,full_tag("ID",3,false,$course->id));
 533             //Obtain the category
 534             $category = false;
 535             if ($categories = get_records("course_categories","id","$course->category")) {
 536                 $category = $categories[$course->category];
 537             }
 538             if ($category) {
 539                 //Prints category info
 540                 fwrite ($bf,start_tag("CATEGORY",3,true));
 541                 fwrite ($bf,full_tag("ID",4,false,$course->category));
 542                 fwrite ($bf,full_tag("NAME",4,false,$category->name));
 543                 fwrite ($bf,end_tag("CATEGORY",3,true));
 544             }
 545             //Continues with the course
 546             fwrite ($bf,full_tag("PASSWORD",3,false,$course->password));
 547             fwrite ($bf,full_tag("FULLNAME",3,false,$course->fullname));
 548             fwrite ($bf,full_tag("SHORTNAME",3,false,$course->shortname));
 549             fwrite ($bf,full_tag("SUMMARY",3,false,$course->summary));
 550             fwrite ($bf,full_tag("FORMAT",3,false,$course->format));
 551             fwrite ($bf,full_tag("SHOWGRADES",3,false,$course->showgrades));
 552             fwrite ($bf,full_tag("NEWSITEMS",3,false,$course->newsitems));
 553             fwrite ($bf,full_tag("TEACHER",3,false,$course->teacher));
 554             fwrite ($bf,full_tag("TEACHERS",3,false,$course->teachers));
 555             fwrite ($bf,full_tag("STUDENT",3,false,$course->student));
 556             fwrite ($bf,full_tag("STUDENTS",3,false,$course->students));
 557             fwrite ($bf,full_tag("GUEST",3,false,$course->guest));
 558             fwrite ($bf,full_tag("STARTDATE",3,false,$course->startdate));
 559             fwrite ($bf,full_tag("NUMSECTIONS",3,false,$course->numsections));
 560             fwrite ($bf,full_tag("SHOWRECENT",3,false,$course->showrecent));
 561             fwrite ($bf,full_tag("MAXBYTES",3,false,$course->maxbytes));
 562             fwrite ($bf,full_tag("SHOWREPORTS",3,false,$course->showreports));
 563             fwrite ($bf,full_tag("GROUPMODE",3,false,$course->groupmode));
 564             fwrite ($bf,full_tag("GROUPMODEFORCE",3,false,$course->groupmodeforce));
 565             fwrite ($bf,full_tag("MARKER",3,false,$course->marker));
 566             fwrite ($bf,full_tag("VISIBLE",3,false,$course->visible));
 567             fwrite ($bf,full_tag("TIMECREATED",3,false,$course->timecreated));
 568             $status = fwrite ($bf,full_tag("TIMEMODIFIED",3,false,$course->timemodified));
 569             //Print header end
 570             fwrite ($bf,end_tag("HEADER",2,true));
 571         } else {
 572            $status = false;
 573         }
 574
 575        return $status;
 576     }
 577
 578     //Prints course's end tag
 579     function backup_course_end ($bf,$preferences) {
 580
 581         //Course end tag
 582         $status = fwrite ($bf,end_tag("COURSE",1,true));
 583
 584         return $status;
 585
 586     }
 587
 588     //Prints course's sections info (table course_sections)
 589     function backup_course_sections ($bf,$preferences) {
 590
 591         global $CFG;
 592
 593         $status = true;
 594
 595
 596         //Get info from sections
 597         $section=false;
 598         if ($sections = get_records("course_sections","course",$preferences->backup_course,"section")) {
 599             //Section open tag
 600             fwrite ($bf,start_tag("SECTIONS",2,true));
 601             //Iterate over every section (ordered by section)
 602             foreach ($sections as $section) {
 603                 //Begin Section
 604                 fwrite ($bf,start_tag("SECTION",3,true));
 605                 fwrite ($bf,full_tag("ID",4,false,$section->id));
 606                 fwrite ($bf,full_tag("NUMBER",4,false,$section->section));
 607                 fwrite ($bf,full_tag("SUMMARY",4,false,$section->summary));
 608                 fwrite ($bf,full_tag("VISIBLE",4,false,$section->visible));
 609                 //Now print the mods in section
 610                 backup_course_modules ($bf,$preferences,$section);
 611                 //End section
 612                 fwrite ($bf,end_tag("SECTION",3,true));
 613             }
 614             //Section close tag
 615             $status = fwrite ($bf,end_tag("SECTIONS",2,true));
 616         }
 617
 618         return $status;
 619
 620     }
 621
 622     //Prints course's modules info (table course_modules)
 623     //Only for selected mods in preferences
 624     function backup_course_modules ($bf,$preferences,$section) {
 625
 626         global $CFG;
 627
 628         $status = true;
 629
 630         $first_record = true;
 631
 632         //Now print the mods in section
 633         //Extracts mod id from sequence
 634         $tok = strtok($section->sequence,",");
 635         while ($tok) {
 636            //Get module's type
 637            $moduletype = get_module_type ($preferences->backup_course,$tok);
 638            //Check if we've selected to backup that type
 639            if ($moduletype and $preferences->mods[$moduletype]->backup) {
 640                $selected = true;
 641            } else {
 642                $selected = false;
 643            }
 644
 645            if ($selected) {
 646                //Gets course_module data from db
 647                $course_module = get_records ("course_modules","id",$tok);
 648                //If it's the first, pring MODS tag
 649                if ($first_record) {
 650                    fwrite ($bf,start_tag("MODS",4,true));
 651                    $first_record = false;
 652                }
 653                //Print mod info from course_modules
 654                fwrite ($bf,start_tag("MOD",5,true));
 655                //Save neccesary info to backup_ids
 656                fwrite ($bf,full_tag("ID",6,false,$tok));
 657                fwrite ($bf,full_tag("TYPE",6,false,$moduletype));
 658                fwrite ($bf,full_tag("INSTANCE",6,false,$course_module[$tok]->instance));
 659                fwrite ($bf,full_tag("ADDED",6,false,$course_module[$tok]->added));
 660                fwrite ($bf,full_tag("DELETED",6,false,$course_module[$tok]->deleted));
 661                fwrite ($bf,full_tag("SCORE",6,false,$course_module[$tok]->score));
 662                fwrite ($bf,full_tag("INDENT",6,false,$course_module[$tok]->indent));
 663                fwrite ($bf,full_tag("VISIBLE",6,false,$course_module[$tok]->visible));
 664                fwrite ($bf,full_tag("GROUPMODE",6,false,$course_module[$tok]->groupmode));
 665                fwrite ($bf,end_tag("MOD",5,true));
 666             }
 667            //check for next
 668            $tok = strtok(",");
 669         }
 670
 671         //Si ha habido modulos, final de MODS
 672         if (!$first_record) {
 673             $status =fwrite ($bf,end_tag("MODS",4,true));
 674         }
 675
 676         return $status;
 677     }
 678
 679     //Print users to xml
 680     //Only users previously calculated in backup_ids will output
 681     //
 682     function backup_user_info ($bf,$preferences) {
 683
 684         global $CFG;
 685
 686         $status = true;
 687
 688         $users = get_records_sql("SELECT u.old_id, u.table_name,u.info
 689                               FROM {$CFG->prefix}backup_ids u
 690                               WHERE u.backup_code = '$preferences->backup_unique_code' AND
 691                                     u.table_name = 'user'");
 692
 693         //If we have users to backup
 694         if ($users) {
 695             //Begin Users tag
 696             fwrite ($bf,start_tag("USERS",2,true));
 697             $counter = 0;
 698             //With every user
 699             foreach ($users as $user) {
 700                 //Get user data from table
 701                 $user_data = get_record("user","id",$user->old_id);
 702                 //Begin User tag
 703                 fwrite ($bf,start_tag("USER",3,true));
 704                 //Output all user data
 705                 fwrite ($bf,full_tag("ID",4,false,$user_data->id));
 706                 fwrite ($bf,full_tag("CONFIRMED",4,false,$user_data->confirmed));
 707                 fwrite ($bf,full_tag("DELETED",4,false,$user_data->deleted));
 708                 fwrite ($bf,full_tag("USERNAME",4,false,$user_data->username));
 709                 fwrite ($bf,full_tag("PASSWORD",4,false,$user_data->password));
 710                 fwrite ($bf,full_tag("IDNUMBER",4,false,$user_data->idnumber));
 711                 fwrite ($bf,full_tag("FIRSTNAME",4,false,$user_data->firstname));
 712                 fwrite ($bf,full_tag("LASTNAME",4,false,$user_data->lastname));
 713                 fwrite ($bf,full_tag("EMAIL",4,false,$user_data->email));
 714                 fwrite ($bf,full_tag("ICQ",4,false,$user_data->icq));
 715                 fwrite ($bf,full_tag("PHONE1",4,false,$user_data->phone1));
 716                 fwrite ($bf,full_tag("PHONE2",4,false,$user_data->phone2));
 717                 fwrite ($bf,full_tag("INSTITUTION",4,false,$user_data->institution));
 718                 fwrite ($bf,full_tag("DEPARTMENT",4,false,$user_data->department));
 719                 fwrite ($bf,full_tag("ADDRESS",4,false,$user_data->address));
 720                 fwrite ($bf,full_tag("CITY",4,false,$user_data->city));
 721                 fwrite ($bf,full_tag("COUNTRY",4,false,$user_data->country));
 722                 fwrite ($bf,full_tag("LANG",4,false,$user_data->lang));
 723                 fwrite ($bf,full_tag("TIMEZONE",4,false,$user_data->timezone));
 724                 fwrite ($bf,full_tag("FIRSTACCESS",4,false,$user_data->firstaccess));
 725                 fwrite ($bf,full_tag("LASTACCESS",4,false,$user_data->lastaccess));
 726                 fwrite ($bf,full_tag("LASTLOGIN",4,false,$user_data->lastlogin));
 727                 fwrite ($bf,full_tag("CURRENTLOGIN",4,false,$user_data->currentlogin));
 728                 fwrite ($bf,full_tag("LASTIP",4,false,$user_data->lastIP));
 729                 fwrite ($bf,full_tag("SECRET",4,false,$user_data->secret));
 730                 fwrite ($bf,full_tag("PICTURE",4,false,$user_data->picture));
 731                 fwrite ($bf,full_tag("URL",4,false,$user_data->url));
 732                 fwrite ($bf,full_tag("DESCRIPTION",4,false,$user_data->description));
 733                 fwrite ($bf,full_tag("MAILFORMAT",4,false,$user_data->mailformat));
 734                 fwrite ($bf,full_tag("MAILDISPLAY",4,false,$user_data->maildisplay));
 735                 fwrite ($bf,full_tag("HTMLEDITOR",4,false,$user_data->htmleditor));
 736                 fwrite ($bf,full_tag("AUTOSUBSCRIBE",4,false,$user_data->autosubscribe));
 737                 fwrite ($bf,full_tag("TIMEMODIFIED",4,false,$user_data->timemodified));
 738
 739                 //Output every user role (with its associated info)
 740                 $user->isadmin = strpos($user->info,"admin");
 741                 $user->iscoursecreator = strpos($user->info,"coursecreator");
 742                 $user->isteacher = strpos($user->info,"teacher");
 743                 $user->isstudent = strpos($user->info,"student");
 744                 $user->isneeded = strpos($user->info,"needed");
 745                 if ($user->isadmin!==false or
 746                     $user->iscoursecreator!==false or
 747                     $user->isteacher!==false or
 748                     $user->isstudent!==false or
 749                     $user->isneeded!==false) {
 750                     //Begin ROLES tag
 751                     fwrite ($bf,start_tag("ROLES",4,true));
 752                     //PRINT ROLE INFO
 753                     //Admins
 754                     if ($user->isadmin!==false) {
 755                         //Print ROLE start
 756                         fwrite ($bf,start_tag("ROLE",5,true));
 757                         //Print Role info
 758                         fwrite ($bf,full_tag("TYPE",6,false,"admin"));
 759                         //Print ROLE end
 760                         fwrite ($bf,end_tag("ROLE",5,true));
 761                     }
 762                     //CourseCreator
 763                     if ($user->iscoursecreator!==false) {
 764                         //Print ROLE start
 765                         fwrite ($bf,start_tag("ROLE",5,true));
 766                         //Print Role info
 767                         fwrite ($bf,full_tag("TYPE",6,false,"coursecreator"));
 768                         //Print ROLE end
 769                         fwrite ($bf,end_tag("ROLE",5,true));
 770                     }
 771                     //Teacher
 772                     if ($user->isteacher!==false) {
 773                         //Print ROLE start
 774                         fwrite ($bf,start_tag("ROLE",5,true));
 775                         //Print Role info
 776                         fwrite ($bf,full_tag("TYPE",6,false,"teacher"));
 777                         //Get specific info for teachers
 778                         $tea = get_record("user_teachers","userid",$user->old_id,"course",$preferences->backup_course);
 779                         fwrite ($bf,full_tag("AUTHORITY",6,false,$tea->authority));
 780                         fwrite ($bf,full_tag("TEA_ROLE",6,false,$tea->role));
 781                         fwrite ($bf,full_tag("EDITALL",6,false,$tea->editall));
 782                         fwrite ($bf,full_tag("TIMEMODIFIED",6,false,$tea->timemodified));
 783                         fwrite ($bf,full_tag("TIMEACCESS",6,false,$tea->timeaccess));
 784                         //Print ROLE end
 785                         fwrite ($bf,end_tag("ROLE",5,true));
 786                     }
 787                     //Student
 788                     if ($user->isstudent!==false) {
 789                         //Print ROLE start
 790                         fwrite ($bf,start_tag("ROLE",5,true));
 791                         //Print Role info
 792                         fwrite ($bf,full_tag("TYPE",6,false,"student"));
 793                         //Get specific info for students
 794                         $stu = get_record("user_students","userid",$user->old_id,"course",$preferences->backup_course);
 795                         fwrite ($bf,full_tag("TIMESTART",6,false,$stu->timestart));
 796                         fwrite ($bf,full_tag("TIMEEND",6,false,$stu->timeend));
 797                         fwrite ($bf,full_tag("TIME",6,false,$stu->time));
 798                         fwrite ($bf,full_tag("TIMEACCESS",6,false,$stu->timeaccess));
 799                         //Print ROLE end
 800                         fwrite ($bf,end_tag("ROLE",5,true));
 801                     }
 802                     //Needed
 803                     if ($user->isneeded!==false) {
 804                         //Print ROLE start
 805                         fwrite ($bf,start_tag("ROLE",5,true));
 806                         //Print Role info
 807                         fwrite ($bf,full_tag("TYPE",6,false,"needed"));
 808                         //Print ROLE end
 809                         fwrite ($bf,end_tag("ROLE",5,true));
 810                     }
 811
 812                     //End ROLES tag
 813                     fwrite ($bf,end_tag("ROLES",4,true));
 814
 815                     //Check if we have user_preferences to backup
 816                     if ($preferences_data = get_records("user_preferences","userid",$user->old_id)) {
 817                         //Start USER_PREFERENCES tag
 818                         fwrite ($bf,start_tag("USER_PREFERENCES",4,true));
 819                         //Write each user_preference
 820                         foreach ($preferences_data as $user_preference) {
 821                             fwrite ($bf,start_tag("USER_PREFERENCE",5,true));
 822                             fwrite ($bf,full_tag("NAME",6,false,$user_preference->name));
 823                             fwrite ($bf,full_tag("VALUE",6,false,$user_preference->value));
 824                             fwrite ($bf,end_tag("USER_PREFERENCE",5,true));
 825                         }
 826                         //End USER_PREFERENCES tag
 827                         fwrite ($bf,end_tag("USER_PREFERENCES",4,true));
 828                     }
 829
 830                 }
 831                 //End User tag
 832                 fwrite ($bf,end_tag("USER",3,true));
 833                 //Do some output
 834                 $counter++;
 835                 if ($counter % 10 == 0) {
 836                     echo ".";
 837                     if ($counter % 200 == 0) {
 838                         echo "<br>";
 839                     }
 840                     backup_flush(300);
 841                 }
 842             }
 843             //End Users tag
 844             fwrite ($bf,end_tag("USERS",2,true));
 845         } else {
 846             // There aren't any users.
 847             $status = true;
 848         }
 849
 850         return $status;
 851     }
 852
 853     //Backup log info (time ordered)
 854     function backup_log_info($bf,$preferences) {
 855
 856         global $CFG;
 857
 858         //Number of records to get in every chunk
 859         $recordset_size = 1000;
 860
 861         $status = true;
 862
 863         //Counter, points to current record
 864         $counter = 0;
 865
 866         //Count records
 867         $count_logs = count_records("log","course",$preferences->backup_course);
 868
 869         //Pring logs header
 870         if ($count_logs > 0 ) {
 871             fwrite ($bf,start_tag("LOGS",2,true));
 872         }
 873         while ($counter < $count_logs) {
 874             //Get a chunk of records
 875             $logs = get_records ("log","course",$preferences->backup_course,"time","*",$counter,$recordset_size);
 876
 877             //We have logs
 878             if ($logs) {
 879                 //Iterate
 880                 foreach ($logs as $log) {
 881                     //See if it is a valid module to backup
 882                     if ($log->module == "course" or
 883                         $log->module == "user" or
 884                         $preferences->mods[$log->module]->backup == 1) {
 885                         //Begin log tag
 886                          fwrite ($bf,start_tag("LOG",3,true));
 887
 888                         //Output log tag
 889                         fwrite ($bf,full_tag("ID",4,false,$log->id));
 890                         fwrite ($bf,full_tag("TIME",4,false,$log->time));
 891                         fwrite ($bf,full_tag("USERID",4,false,$log->userid));
 892                         fwrite ($bf,full_tag("IP",4,false,$log->ip));
 893                         fwrite ($bf,full_tag("MODULE",4,false,$log->module));
 894                         fwrite ($bf,full_tag("CMID",4,false,$log->cmid));
 895                         fwrite ($bf,full_tag("ACTION",4,false,$log->action));
 896                         fwrite ($bf,full_tag("URL",4,false,$log->url));
 897                         fwrite ($bf,full_tag("INFO",4,false,$log->info));
 898
 899                         //End log tag
 900                          fwrite ($bf,end_tag("LOG",3,true));
 901                     }
 902                     //Do some output
 903                     $counter++;
 904                     if ($counter % 10 == 0) {
 905                         echo ".";
 906                         if ($counter % 200 == 0) {
 907                             echo "<br>";
 908                         }
 909                         backup_flush(300);
 910                     }
 911                 }
 912             }
 913         }
 914         //End logs tag
 915         if ($count_logs > 0 ) {
 916             $status = fwrite ($bf,end_tag("LOGS",2,true));
 917         }
 918         return $status;
 919     }
 920
 921
 922     //Backup scales info (common and course scales)
 923     function backup_scales_info($bf,$preferences) {
 924
 925         global $CFG;
 926
 927         $status = true;
 928
 929         //Counter, points to current record
 930         $counter = 0;
 931
 932         //Get scales (common and course scales)
 933         $scales = get_records_sql("SELECT id, courseid, userid, name, scale, description, timemodified
 934                                    FROM {$CFG->prefix}scale
 935                                    WHERE courseid = '0' or courseid = $preferences->backup_course");
 936
 937         //Pring scales header
 938         if ($scales) {
 939             //Pring scales header
 940             fwrite ($bf,start_tag("SCALES",2,true));
 941             //Iterate
 942             foreach ($scales as $scale) {
 943                 //Begin scale tag
 944                 fwrite ($bf,start_tag("SCALE",3,true));
 945                 //Output scale tag
 946                 fwrite ($bf,full_tag("ID",4,false,$scale->id));
 947                 fwrite ($bf,full_tag("COURSEID",4,false,$scale->courseid));
 948                 fwrite ($bf,full_tag("USERID",4,false,$scale->userid));
 949                 fwrite ($bf,full_tag("NAME",4,false,$scale->name));
 950                 fwrite ($bf,full_tag("SCALETEXT",4,false,$scale->scale));
 951                 fwrite ($bf,full_tag("DESCRIPTION",4,false,$scale->description));
 952                 fwrite ($bf,full_tag("TIMEMODIFIED",4,false,$scale->timemodified));
 953                 //End scale tag
 954                 fwrite ($bf,end_tag("SCALE",3,true));
 955             }
 956             //End scales tag
 957             $status = fwrite ($bf,end_tag("SCALES",2,true));
 958         }
 959         return $status;
 960     }
 961
 962     //Backup groups info
 963     function backup_groups_info($bf,$preferences) {
 964
 965         global $CFG;
 966
 967         $status = true;
 968         $status2 = true;
 969
 970         //Get groups
 971         $groups = get_records("groups","courseid",$preferences->backup_course);
 972
 973         //Pring groups header
 974         if ($groups) {
 975             //Pring groups header
 976             fwrite ($bf,start_tag("GROUPS",2,true));
 977             //Iterate
 978             foreach ($groups as $group) {
 979                 //Begin group tag
 980                 fwrite ($bf,start_tag("GROUP",3,true));
 981                 //Output group contents
 982                 fwrite ($bf,full_tag("ID",4,false,$group->id));
 983                 fwrite ($bf,full_tag("COURSEID",4,false,$group->courseid));
 984                 fwrite ($bf,full_tag("NAME",4,false,$group->name));
 985                 fwrite ($bf,full_tag("DESCRIPTION",4,false,$group->description));
 986                 fwrite ($bf,full_tag("LANG",4,false,$group->lang));
 987                 fwrite ($bf,full_tag("PICTURE",4,false,$group->picture));
 988                 fwrite ($bf,full_tag("TIMECREATED",4,false,$group->timecreated));
 989                 fwrite ($bf,full_tag("TIMEMODIFIED",4,false,$group->timemodified));
 990
 991                 //Now, backup groups_members
 992                 $status2 = backup_groups_members_info($bf,$preferences,$group->id);
 993
 994                 //End group tag
 995                 fwrite ($bf,end_tag("GROUP",3,true));
 996             }
 997             //End groups tag
 998             $status = fwrite ($bf,end_tag("GROUPS",2,true));
 999         }
1000         return ($status && $status2);
1001     }
1002
1003     //Backup groups_members info
1004     function backup_groups_members_info($bf,$preferences,$groupid) {
1005
1006         global $CFG;
1007
1008         $status = true;
1009
1010         //Get groups_members
1011         $groups_members = get_records("groups_members","groupid",$groupid);
1012
1013         //Pring groups_members header
1014         if ($groups_members) {
1015             //Pring groups_members header
1016             fwrite ($bf,start_tag("MEMBERS",4,true));
1017             //Iterate
1018             foreach ($groups_members as $group_member) {
1019                 //Begin group_member tag
1020                 fwrite ($bf,start_tag("MEMBER",5,true));
1021                 //Output group_member contents
1022                 fwrite ($bf,full_tag("USERID",6,false,$group_member->userid));
1023                 fwrite ($bf,full_tag("TIMEADDED",6,false,$group_member->timeadded));
1024                 //End group_member tag
1025                 fwrite ($bf,end_tag("MEMBER",5,true));
1026             }
1027             //End groups_members tag
1028             $status = fwrite ($bf,end_tag("MEMBERS",4,true));
1029         }
1030         return $status;
1031     }
1032
1033     //Start the modules tag
1034     function backup_modules_start ($bf,$preferences) {
1035
1036         return fwrite ($bf,start_tag("MODULES",2,true));
1037     }
1038
1039     //End the modules tag
1040     function backup_modules_end ($bf,$preferences) {
1041
1042         return fwrite ($bf,end_tag("MODULES",2,true));
1043     }
1044
1045     //This function makes all the necesary calls to every mod
1046     //to export itself and its files !!!
1047     function backup_module($bf,$preferences,$module) {
1048
1049         global $CFG;
1050
1051         $status = true;
1052
1053         //First, re-check if necessary functions exists
1054         $modbackup = $module."_backup_mods";
1055         if (function_exists($modbackup)) {
1056             //Call the function
1057             $status = $modbackup($bf,$preferences);
1058         } else {
1059             //Something was wrong. Function should exist.
1060             $status = false;
1061         }
1062
1063         return $status;
1064
1065     }
1066
1067     //This function copies all the needed files under the "users" directory to the "user_files"
1068     //directory under temp/backup
1069     function backup_copy_user_files ($preferences) {
1070
1071         global $CFG;
1072
1073         $status = true;
1074
1075         //First we check to "user_files" exists and create it as necessary
1076         //in temp/backup/$backup_code  dir
1077         $status = check_and_create_user_files_dir($preferences->backup_unique_code);
1078
1079         //Now iterate over directories under "users" to check if that user must be
1080         //copied to backup
1081
1082         $rootdir = $CFG->dataroot."/users";
1083         //Check if directory exists
1084         if (is_dir($rootdir)) {
1085             $list = list_directories ($rootdir);
1086             if ($list) {
1087                 //Iterate
1088                 foreach ($list as $dir) {
1089                     //Look for dir like username in backup_ids
1090                     $data = get_record ("backup_ids","backup_code",$preferences->backup_unique_code,
1091                                                      "table_name","user",
1092                                                      "old_id",$dir);
1093                     //If exists, copy it
1094                     if ($data) {
1095                         $status = backup_copy_file($rootdir."/".$dir,
1096                                        $CFG->dataroot."/temp/backup/".$preferences->backup_unique_code."/user_files/".$dir);
1097                     }
1098                 }
1099             }
1100         }
1101         return $status;
1102     }
1103
1104     //This function copies all the course files under the course directory (except the moddata
1105     //directory to the "course_files" directory under temp/backup
1106     function backup_copy_course_files ($preferences) {
1107
1108         global $CFG;
1109
1110         $status = true;
1111
1112         //First we check to "course_files" exists and create it as necessary
1113         //in temp/backup/$backup_code  dir
1114         $status = check_and_create_course_files_dir($preferences->backup_unique_code);
1115
1116         //Now iterate over files and directories except $CFG->moddata and backupdata to be
1117         //copied to backup
1118
1119         $rootdir = $CFG->dataroot."/".$preferences->backup_course;
1120
1121         $name_moddata = $CFG->moddata;
1122         $name_backupdata = "backupdata";
1123         //Check if directory exists
1124         if (is_dir($rootdir)) {
1125             $list = list_directories_and_files ($rootdir);
1126             if ($list) {
1127                 //Iterate
1128                 foreach ($list as $dir) {
1129                     if ($dir !== $name_moddata and $dir !== $name_backupdata) {
1130                         $status = backup_copy_file($rootdir."/".$dir,
1131                                        $CFG->dataroot."/temp/backup/".$preferences->backup_unique_code."/course_files/".$dir);
1132                     }
1133                 }
1134             }
1135         }
1136         return $status;
1137     }
1138
1139     //This function creates the zip file containing all the backup info
1140     //moodle.xml, moddata, user_files, course_files.
1141     //The zipped file is created in the backup directory and named with
1142     //the "oficial" name of the backup
1143     //It uses "pclzip" if available or system "zip" (unix only)
1144     function backup_zip ($preferences) {
1145
1146         global $CFG;
1147
1148         $status = true;
1149
1150         //Base dir where everything happens
1151         $basedir = $CFG->dataroot."/temp/backup/".$preferences->backup_unique_code;
1152         //Backup zip file name
1153         $name = $preferences->backup_name;
1154         //List base_dir files and directories
1155         $filelist = list_directories_and_files ($basedir);
1156
1157         if (empty($CFG->zip)) {    // Use built-in php-based zip function
1158             //echo "<br>Using pclzip";                                    //Debug
1159             $files = array();
1160             foreach ($filelist as $file) {
1161                 //If directory, append "/"
1162                 //Commented. Not needed wit version 2.0 of pclzip !!
1163                 //if (is_dir($basedir."/".$file)) {
1164                 //    $file = $file."/";
1165                 //}
1166                 //Include into array
1167                 //echo "<br>Adding file/dir ".$file;                       //Debug
1168                 $files[] = $basedir."/".$file;
1169             }
1170             include_once("$CFG->dirroot/lib/pclzip/pclzip.lib.php");
1171             //include_once("$CFG->dirroot/lib/pclzip/pclerror.lib.php");   //Debug
1172             //include_once("$CFG->dirroot/lib/pclzip/pcltrace.lib.php");   //Debug
1173             //PclTraceOn(2);                                               //Debug
1174             $archive = new PclZip("$basedir/$name");
1175             if (($list = $archive->create($files,PCLZIP_OPT_REMOVE_PATH,$basedir)) == 0) {
1176                 error($archive->errorInfo(true));
1177                 $status = false;
1178             }
1179             //PclTraceDisplay();                                           //Debug
1180             //PclTraceOff();                                               //Debug
1181         } else {                   // Use external zip program
1182             //echo "<br>Using external zip";                               //Debug
1183             $files = "";
1184             foreach ($filelist as $file) {
1185                 $files .= basename($file);
1186                 $files .= " ";
1187             }
1188             $command = "cd $basedir ; $CFG->zip -r $name $files";
1189             //echo "<br>Executing command: ".$command;                     //Debug
1190             $status = Exec($command);
1191         }
1192
1193         //echo "<br>Status: ".$status;                                     //Debug
1194         return $status;
1195
1196     }
1197
1198     //This function copies the final zip to the course dir
1199     function copy_zip_to_course_dir ($preferences) {
1200
1201         global $CFG;
1202
1203         $status = true;
1204
1205         //Define zip location (from)
1206         $from_zip_file = $CFG->dataroot."/temp/backup/".$preferences->backup_unique_code."/".$preferences->backup_name;
1207
1208         //Initialise $to_zip_file
1209         $to_zip_file="";
1210
1211         //If $preferences->backup_destination isn't empty, then copy to custom directory
1212         if (!empty($preferences->backup_destination)) {
1213             $to_zip_file = $preferences->backup_destination."/".$preferences->backup_name;
1214         } else {
1215             //Define zip destination (course dir)
1216             $to_zip_file = $CFG->dataroot."/".$preferences->backup_course;
1217
1218             //echo "<p>From: ".$from_zip_file."<br>";                                              //Debug
1219
1220             //echo "<p>Checking: ".$to_zip_file."<br>";                                          //Debug
1221
1222             //Checks course dir exists
1223             $status = check_dir_exists($to_zip_file,true);
1224
1225             //Define zip destination (backup dir)
1226             $to_zip_file = $to_zip_file."/backupdata";
1227
1228             //echo "<p>Checking: ".$to_zip_file."<br>";                                          //Debug
1229
1230             //Checks backup dir exists
1231             $status = check_dir_exists($to_zip_file,true);
1232
1233             //Define zip destination (zip file)
1234             $to_zip_file = $to_zip_file."/".$preferences->backup_name;
1235         }
1236
1237         //echo "<p>To: ".$to_zip_file."<br>";                                              //Debug
1238
1239         //Copy zip file
1240         if ($status) {
1241             $status = backup_copy_file ($from_zip_file,$to_zip_file);
1242         }
1243
1244         return $status;
1245     }
1246 ?>