PHP csv_import_reader::get_new_iid方法代碼示例

 /**
  * Load up the above text through the csv import.
  *
  * @param string $content Text to be imported into the gradebook.
  * @return array All text separated by commas now in an array.
  */
 protected function csv_load($content)
 {
     // Import the csv strings.
     $this->iid = csv_import_reader::get_new_iid('grade');
     $this->csvimport = new csv_import_reader($this->iid, 'grade');
     $this->csvimport->load_csv_content($content, 'utf8', 'comma');
     $this->columns = $this->csvimport->get_columns();
     $this->csvimport->init();
     while ($line = $this->csvimport->next()) {
         $testarray[] = $line;
     }
     return $testarray;
 }

 public function execute()
 {
     global $CFG, $DB;
     require_once $CFG->libdir . '/csvlib.class.php';
     require_once $CFG->libdir . '/moodlelib.php';
     $csvfilepath = $this->arguments[0];
     if ($csvfilepath[0] != '/') {
         $csvfilepath = $this->cwd . DIRECTORY_SEPARATOR . $csvfilepath;
     }
     $iid = \csv_import_reader::get_new_iid('userprofile');
     $type = 'userprofile';
     $csvreader = new \csv_import_reader($iid, $type);
     if (false === ($csvfile = file_get_contents($csvfilepath))) {
         cli_error('Unable to load csv file. ' . error_get_last()['message']);
     }
     if (!$csvreader->load_csv_content($csvfile, 'utf-8', 'comma')) {
         cli_error('Unalbe to parse csv file. ' . $csvreader->get_error());
     }
     if (!$csvreader->init()) {
         cli_error('Unable to initialise csv reading');
     }
     $columns = $csvreader->get_columns();
     $columnsids = array_flip($columns);
     while (false !== ($row = $csvreader->next())) {
         $category = $this->get_or_create_category($row[$columnsids['categoryname']], $row[$columnsids['categorysortorder']]);
         $userfield = new \stdClass();
         $userfield->shortname = $row[$columnsids['shortname']];
         $userfield->name = $row[$columnsids['name']];
         $userfield->datatype = $row[$columnsids['datatype']];
         $userfield->description = $row[$columnsids['description']];
         $userfield->descriptionformat = $row[$columnsids['descriptionformat']];
         $userfield->categoryid = $category->id;
         $userfield->sortorder = $row[$columnsids['sortorder']];
         $userfield->required = $row[$columnsids['required']];
         $userfield->locked = $row[$columnsids['locked']];
         $userfield->visible = $row[$columnsids['visible']];
         $userfield->forceunique = $row[$columnsids['forceunique']];
         $userfield->signup = $row[$columnsids['signup']];
         $userfield->defaultdata = $row[$columnsids['defaultdata']];
         $userfield->defaultdataformat = $row[$columnsids['defaultdataformat']];
         $userfield->param1 = $row[$columnsids['param1']];
         $userfield->param2 = $row[$columnsids['param2']];
         $userfield->param3 = $row[$columnsids['param3']];
         $userfield->param4 = $row[$columnsids['param4']];
         $userfield->param5 = $row[$columnsids['param5']];
         $this->get_or_create_userfield($userfield);
     }
 }

 /**
  * Load CSV content for previewing.
  *
  * @param string $text The grade data being imported.
  * @param string $encoding The type of encoding the file uses.
  * @param string $separator The separator being used to define each field.
  * @param int $previewrows How many rows are being previewed.
  */
 public function load_csv_content($text, $encoding, $separator, $previewrows)
 {
     $this->raise_limits();
     $this->iid = csv_import_reader::get_new_iid('grade');
     $csvimport = new csv_import_reader($this->iid, 'grade');
     $csvimport->load_csv_content($text, $encoding, $separator);
     $this->error = $csvimport->get_error();
     // Get header (field names).
     $this->headers = $csvimport->get_columns();
     $this->trim_headers();
     $csvimport->init();
     $this->previewdata = array();
     for ($numlines = 0; $numlines <= $previewrows; $numlines++) {
         $lines = $csvimport->next();
         if ($lines) {
             $this->previewdata[] = $lines;
         }
     }
 }

 function validation($data, $files)
 {
     global $CFG;
     $errors = array();
     // Use csv importer from Moodle
     $iid = csv_import_reader::get_new_iid('emarking-predefined-comments');
     $reader = new csv_import_reader($iid, 'emarking-predefined-comments');
     $content = $data['comments'];
     $reader->load_csv_content($content, 'utf8', "tab");
     // Validate columns, minimum number and first two to be userid and attemptid
     if (count($reader->get_columns()) < 0) {
         $errors['comments'] = get_string('onecolumnrequired', 'mod_emarking');
     }
     $reader->init();
     $current = 0;
     while ($line = $reader->next()) {
         $current++;
     }
     if ($current < 1) {
         $errors['comments'] = get_string('twolinesrequired', 'mod_emarking');
     }
     return $errors;
 }

$exams = $DB->get_records_sql($sql);
foreach ($exams as $exam) {
    $exam->examtype = strtolower($exam->examtype);
    $exam->lecturetype = strtolower($exam->lecturetype);
    $cname = $DB->get_field('local_clclasses', 'fullname', array('id' => $exam->csid));
    $cname = strtolower($cname);
    $PRF_FIELDS[$exam->csid . ':' . $exam->eid . ':' . $exam->lid] = $cname . ':' . $exam->examtype . ':' . $exam->lecturetype;
}
// print_object( $PRF_FIELDS);
//-------- if variable $iid equal to zero,it allows enter into the form-----------------------------------
if (empty($iid)) {
    $mform1 = new admin_grades_form1();
    if ($mform1->is_cancelled())
        redirect($returnurl);
    if ($formdata = $mform1->get_data()) {
        $iid = csv_import_reader::get_new_iid('uploadgrades');
        $cir = new csv_import_reader($iid, 'uploadgrades'); //this class fromcsvlib.php(includes csv methods and clclasses)
        $content = $mform1->get_file_content('gradesfile');
        $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
        unset($content);
        if ($readcount === false) {
            print_error('csvloaderror', '', $returnurl);
        } else if ($readcount == 0) {
            print_error('csvemptyfile', 'error', $returnurl);
        }
        // test if columns ok(to validate the csv file content)
        $filecolumns = uu_validate_grades_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
        // continue to form2
    } else {
        echo $OUTPUT->header();
        echo $OUTPUT->heading(get_string('managegradesubmission', 'local_gradesubmission'));

echo html_writer::end_tag('div');
$mform->display();
*/
if (!$iid) {
    // If the import form has been submitted.
    if ($mform->is_cancelled()) {
        redirect($url);
    } else {
        if ($formdata = $mform->get_data()) {
            // Large files are likely to take their time and memory. Let PHP know
            // that we'll take longer, and that the process should be recycled soon
            // to free up memory.
            @set_time_limit(0);
            raise_memory_limit(MEMORY_EXTRA);
            $text = $mform->get_file_content('userfile');
            $iid = csv_import_reader::get_new_iid('rooms');
            $csvimport = new csv_import_reader($iid, 'rooms');
            $csvimport->load_csv_content($text, $formdata->encoding, $separator);
            // --- get header (field names) ---
            $header = $csvimport->get_columns();
            // Print a preview of the data.
            $numlines = 0;
            // 0 lines previewed so far.
            echo $OUTPUT->heading(get_string('importpreview', 'grades'));
            foreach ($header as $i => $h) {
                $h = trim($h);
                // Remove whitespace.
                $h = clean_param($h, PARAM_RAW);
                // Clean the header.
                $header[$i] = $h;
            }

 $table->head = array(get_string('comment', 'mod_emarking'), get_string('creator', 'mod_emarking'), get_string('actions', 'mod_emarking'));
 foreach ($predefinedcomments as $predefinedcomment) {
     $deleteurlcomment = new moodle_url('', array('action' => 'delete', 'id' => $cm->id, 'commentid' => $predefinedcomment->id));
     $deleteiconcomment = new pix_icon('t/delete', get_string('delete'));
     $deleteactioncomment = $OUTPUT->action_icon($deleteurlcomment, $deleteiconcomment, new confirm_action(get_string('questiondeletecomment', 'mod_emarking')));
     $editurlcomment = new moodle_url('', array('action' => 'edit', 'id' => $cm->id, 'commentid' => $predefinedcomment->id));
     $editiconcomment = new pix_icon('i/edit', get_string('edit'));
     $editactioncomment = $OUTPUT->action_icon($editurlcomment, $editiconcomment);
     $creatorname = $DB->get_record('user', array('id' => $predefinedcomment->markerid));
     $table->data[] = array($predefinedcomment->text, $creatorname->username, $editactioncomment . $deleteactioncomment);
 }
 // Form display.
 $predefinedform = new emarking_import_excel_form(null, array('cmid' => $cm->id));
 if ($predefinedform->get_data()) {
     // Use csv importer from Moodle.
     $iid = csv_import_reader::get_new_iid('emarking-predefined-comments');
     $reader = new csv_import_reader($iid, 'emarking-predefined-comments');
     $content = $predefinedform->get_data()->comments;
     $reader->load_csv_content($content, 'utf8', "tab");
     $data = array();
     if (isset($predefinedform->get_data()->headers)) {
         $columns = $reader->get_columns()[0];
     } else {
         $columns = get_string("comment", "mod_emarking");
         $data[] = array($reader->get_columns()[0]);
     }
     $reader->init();
     $current = 0;
     while ($line = $reader->next()) {
         if (count($line) > 0) {
             $data[] = array($line[0]);

 public function test_preview()
 {
     global $DB;
     $this->resetAfterTest(true);
     $content = array("shortname,fullname,summary", "c1,Course 1,Course 1 summary", "c2,Course 2,Course 2 summary");
     $content = implode("\n", $content);
     $iid = csv_import_reader::get_new_iid('uploadcourse');
     $cir = new csv_import_reader($iid, 'uploadcourse');
     $cir->load_csv_content($content, 'utf-8', 'comma');
     $cir->init();
     $options = array('mode' => tool_uploadcourse_processor::MODE_CREATE_ALL);
     $defaults = array('category' => '1');
     $p = new tool_uploadcourse_processor($cir, $options, $defaults);
     // Nothing special to expect here, just make sure no exceptions are thrown.
     $p->preview();
 }

 public function test_csv_functions()
 {
     global $CFG;
     $csvexport = new csv_export_writer();
     $csvexport->set_filename('unittest');
     foreach ($this->testdata as $data) {
         $csvexport->add_data($data);
     }
     $csvoutput = $csvexport->print_csv_data(true);
     $this->assertEquals($csvoutput, $this->teststring);
     $test_data = csv_export_writer::print_array($this->testdata, 'comma', '"', true);
     $this->assertEquals($test_data, $this->teststring);
     // Testing that the content is imported correctly.
     $iid = csv_import_reader::get_new_iid('lib');
     $csvimport = new csv_import_reader($iid, 'lib');
     $contentcount = $csvimport->load_csv_content($this->teststring, 'utf-8', 'comma');
     $csvimport->init();
     $dataset = array();
     $dataset[] = $csvimport->get_columns();
     while ($record = $csvimport->next()) {
         $dataset[] = $record;
     }
     $csvimport->cleanup();
     $csvimport->close();
     $this->assertEquals($dataset, $this->testdata);
     // Testing for the wrong count of columns.
     $errortext = get_string('csvweirdcolumns', 'error');
     $iid = csv_import_reader::get_new_iid('lib');
     $csvimport = new csv_import_reader($iid, 'lib');
     $contentcount = $csvimport->load_csv_content($this->teststring2, 'utf-8', 'comma');
     $importerror = $csvimport->get_error();
     $csvimport->cleanup();
     $csvimport->close();
     $this->assertEquals($importerror, $errortext);
     // Testing for empty content
     $errortext = get_string('csvemptyfile', 'error');
     $iid = csv_import_reader::get_new_iid('lib');
     $csvimport = new csv_import_reader($iid, 'lib');
     $contentcount = $csvimport->load_csv_content($this->teststring3, 'utf-8', 'comma');
     $importerror = $csvimport->get_error();
     $csvimport->cleanup();
     $csvimport->close();
     $this->assertEquals($importerror, $errortext);
     // Testing for a tab separated file.
     // The tab separated file has a trailing tab and extra blank lines at the end of the file.
     $filename = $CFG->dirroot . '/lib/tests/fixtures/tabfile.csv';
     $fp = fopen($filename, 'r');
     $tabdata = fread($fp, filesize($filename));
     fclose($fp);
     $iid = csv_import_reader::get_new_iid('tab');
     $csvimport = new csv_import_reader($iid, 'tab');
     $contentcount = $csvimport->load_csv_content($tabdata, 'utf-8', 'tab');
     // This should import four rows including the headings.
     $this->assertEquals($contentcount, 4);
     // Testing for empty lines.
     $iid = csv_import_reader::get_new_iid('blanklines');
     $csvimport = new csv_import_reader($iid, 'blanklines');
     $contentcount = $csvimport->load_csv_content($this->teststring4, 'utf-8', 'comma');
     // Five lines including the headings should be imported.
     $this->assertEquals($contentcount, 5);
 }

 /**
  * return content for mass unenrolment page.
  */
 public function page_mass_unenrol()
 {
     global $CFG, $USER;
     require_once $CFG->libdir . '/csvlib.class.php';
     require_once $CFG->dirroot . '/local/mass_enroll/mass_unenroll_form.php';
     require_once $CFG->dirroot . '/local/mass_enroll/lib.php';
     $course = $this->page->course;
     $context = $this->page->context;
     $mform = new mass_unenroll_form(new moodle_url($CFG->wwwroot . '/local/mass_enroll/mass_unenroll.php'), array('course' => $course, 'context' => $context));
     $currenttab = 'mass_unenroll';
     $out = '';
     $strinscriptions = get_string('mass_unenroll', 'local_mass_enroll');
     if ($mform->is_cancelled()) {
         redirect(new moodle_url('/course/view.php', array('id' => $course->id)));
     } else {
         if ($data = $mform->get_data(false)) {
             $content = $mform->get_file_content('attachment');
             $iid = csv_import_reader::get_new_iid('uploaduser');
             $cir = new csv_import_reader($iid, 'uploaduser');
             $readcount = $cir->load_csv_content($content, $data->encoding, $data->delimiter_name);
             unset($content);
             $returnurl = $this->page->url;
             if ($readcount === false) {
                 print_error('csvloaderror', '', $returnurl);
             } else {
                 if ($readcount == 0) {
                     print_error('csvemptyfile', 'error', $returnurl);
                 }
             }
             $result = mass_unenroll($cir, $course, $context, $data);
             $cir->close();
             $cir->cleanup(false);
             // Only currently uploaded CSV file.
             if ($data->mailreport) {
                 $a = new stdClass();
                 $a->course = $course->fullname;
                 $a->report = $result;
                 email_to_user($USER, $USER, get_string('mail_unenrolment_subject', 'local_mass_enroll', $CFG->wwwroot), get_string('mail_unenrolment', 'local_mass_enroll', $a));
                 $result .= "\n" . get_string('email_sent', 'local_mass_enroll', $USER->email);
             }
             $out .= $this->header();
             $out .= $this->get_tabs($context, $currenttab, array('id' => $course->id));
             $out .= $this->heading($strinscriptions);
             $out .= $this->box(nl2br($result), 'center');
             $out .= $this->continue_button($this->page->url);
             // Back to this page.
             $out .= $this->footer($course);
             return $out;
         }
     }
     $out .= $this->header();
     $out .= $this->get_tabs($context, $currenttab, array('id' => $course->id));
     $out .= $this->heading_with_help($strinscriptions, 'mass_unenroll', 'local_mass_enroll', 'icon', get_string('mass_unenroll', 'local_mass_enroll'));
     $out .= $this->box(get_string('mass_unenroll_info', 'local_mass_enroll'), 'center');
     $out .= $mform->render();
     $out .= $this->footer($course);
     return $out;
 }

 public function execute()
 {
     global $CFG, $DB, $USER;
     require_once $CFG->dirroot . '/course/lib.php';
     require_once $CFG->libdir . '/gradelib.php';
     require_once $CFG->dirroot . '/grade/lib.php';
     require_once $CFG->dirroot . '/grade/import/lib.php';
     require_once $CFG->libdir . '/csvlib.class.php';
     $options = $this->expandedOptions;
     $USER = $this->user;
     $text = file_get_contents($this->arguments[0]);
     if (!$text) {
         cli_error("No data in file '{$this->arguments[0]}''");
     }
     if ($options['course-idnumber']) {
         $course = $DB->get_record('course', array('idnumber' => $this->arguments[1]), '*', MUST_EXIST);
     } else {
         $course = $DB->get_record('course', array('id' => $this->arguments[1]), '*', MUST_EXIST);
     }
     $iid = \csv_import_reader::get_new_iid('moosh-gradebook');
     $csvimport = new \csv_import_reader($iid, 'moosh-gradebook');
     $csvimport->load_csv_content($text, 'utf-8', 'comma');
     $header = $csvimport->get_columns();
     //use "Email address" or "ID number" for mapping users
     if ($options['map-users-by'] == 'idnumber') {
         $usermap = array_search('ID number', $header);
         if ($usermap === false) {
             cli_error("Didn't find column called 'ID number' for mapping users");
         }
     } elseif ($options['map-users-by'] == 'email') {
         $usermap = array_search('Email address', $header);
         if ($usermap === false) {
             cli_error("Didn't find column called 'Email address' for mapping users");
         }
     } else {
         cli_error(' Wrong map-users-by value');
     }
     $map = array();
     //Try to automatically map columns in CSV file onto activities with the same name
     $grade_items = \grade_item::fetch_all(array('courseid' => $course->id));
     foreach ($grade_items as $grade_item) {
         // Skip course type and category type.
         if ($grade_item->itemtype == 'course' || $grade_item->itemtype == 'category') {
             continue;
         }
         $displaystring = null;
         if (!empty($grade_item->itemmodule)) {
             $displaystring = get_string('modulename', $grade_item->itemmodule) . ': ' . $grade_item->get_name();
         } else {
             $displaystring = $grade_item->get_name();
         }
         //echo $displaystring . "\n";
         $pos = array_search($displaystring, $header);
         if ($pos !== false) {
             $map[$pos] = $grade_item->id;
             echo "CSV column '{$header[$pos]}' will be mapped to grade item '{$displaystring}'\n";
         } else {
             echo "No mapping for gradebook item '{$displaystring}'\n";
         }
     }
     //iterate over all CSV records
     $csvimport->init();
     $newgrades = array();
     while ($line = $csvimport->next()) {
         //first find user
         if ($options['map-users-by'] == 'idnumber') {
             if (!($user = $DB->get_record('user', array('idnumber' => $line[$usermap])))) {
                 cli_error("Couldn't find user with idnumber '{$line[$usermap]}'");
             }
         } elseif ($options['map-users-by'] == 'email') {
             if (!($user = $DB->get_record('user', array('email' => $line[$usermap])))) {
                 cli_error("Couldn't find user with email '{$line[$usermap]}'");
             }
         }
         echo "Processing user {$user->email} ({$user->id},{$user->idnumber})\n";
         foreach ($map as $k => $v) {
             $gradeitem = $grade_items[$v];
             $value = $line[$k];
             $newgrade = new \stdClass();
             $newgrade->itemid = $gradeitem->id;
             //handle scales
             if ($gradeitem->gradetype == GRADE_TYPE_SCALE) {
                 $scale = $gradeitem->load_scale();
                 $scales = explode(',', $scale->scale);
                 $scales = array_map('trim', $scales);
                 //hack - trim whitespace around scale options
                 array_unshift($scales, '-');
                 // scales start at key 1
                 $key = array_search($value, $scales);
                 if ($key === false) {
                     echo "\tThe correct scale value '{$value}' for item '{$gradeitem->get_name()}' could not be found.\n";
                 } else {
                     echo "\tMapped value '{$value}' to '{$key}' as scale is used for '{$gradeitem->get_name()}'\n";
                     $value = $key;
                 }
             } else {
                 if ($value === '' or $value == '-') {
                     $value = null;
                     // no grade
                 }
//.........這裏部分代碼省略.........

 /**
  * @param stored_file $file
  * @param string $encoding
  * @param string $delimiter
  * @param context $defaultcontext
  * @return array
  */
 protected function process_upload_file($file, $encoding, $delimiter, $defaultcontext)
 {
     global $CFG, $DB;
     require_once $CFG->libdir . '/csvlib.class.php';
     $cohorts = array(0 => array('errors' => array(), 'warnings' => array(), 'data' => array()));
     // Read and parse the CSV file using csv library.
     $content = $file->get_content();
     if (!$content) {
         $cohorts[0]['errors'][] = new lang_string('csvemptyfile', 'error');
         return $cohorts;
     }
     $uploadid = csv_import_reader::get_new_iid('uploadcohort');
     $cir = new csv_import_reader($uploadid, 'uploadcohort');
     $readcount = $cir->load_csv_content($content, $encoding, $delimiter);
     unset($content);
     if (!$readcount) {
         $cohorts[0]['errors'][] = get_string('csvloaderror', 'error', $cir->get_error());
         return $cohorts;
     }
     $columns = $cir->get_columns();
     // Check that columns include 'name' and warn about extra columns.
     $allowedcolumns = array('contextid', 'name', 'idnumber', 'description', 'descriptionformat', 'visible');
     $additionalcolumns = array('context', 'category', 'category_id', 'category_idnumber', 'category_path');
     $displaycolumns = array();
     $extracolumns = array();
     $columnsmapping = array();
     foreach ($columns as $i => $columnname) {
         $columnnamelower = preg_replace('/ /', '', core_text::strtolower($columnname));
         $columnsmapping[$i] = null;
         if (in_array($columnnamelower, $allowedcolumns)) {
             $displaycolumns[$columnnamelower] = $columnname;
             $columnsmapping[$i] = $columnnamelower;
         } else {
             if (in_array($columnnamelower, $additionalcolumns)) {
                 $columnsmapping[$i] = $columnnamelower;
             } else {
                 $extracolumns[] = $columnname;
             }
         }
     }
     if (!in_array('name', $columnsmapping)) {
         $cohorts[0]['errors'][] = new lang_string('namecolumnmissing', 'cohort');
         return $cohorts;
     }
     if ($extracolumns) {
         $cohorts[0]['warnings'][] = new lang_string('csvextracolumns', 'cohort', s(join(', ', $extracolumns)));
     }
     if (!isset($displaycolumns['contextid'])) {
         $displaycolumns['contextid'] = 'contextid';
     }
     $cohorts[0]['data'] = $displaycolumns;
     // Parse data rows.
     $cir->init();
     $rownum = 0;
     $idnumbers = array();
     $haserrors = false;
     $haswarnings = false;
     while ($row = $cir->next()) {
         $rownum++;
         $cohorts[$rownum] = array('errors' => array(), 'warnings' => array(), 'data' => array());
         $hash = array();
         foreach ($row as $i => $value) {
             if ($columnsmapping[$i]) {
                 $hash[$columnsmapping[$i]] = $value;
             }
         }
         $this->clean_cohort_data($hash);
         $warnings = $this->resolve_context($hash, $defaultcontext);
         $cohorts[$rownum]['warnings'] = array_merge($cohorts[$rownum]['warnings'], $warnings);
         if (!empty($hash['idnumber'])) {
             if (isset($idnumbers[$hash['idnumber']]) || $DB->record_exists('cohort', array('idnumber' => $hash['idnumber']))) {
                 $cohorts[$rownum]['errors'][] = new lang_string('duplicateidnumber', 'cohort');
             }
             $idnumbers[$hash['idnumber']] = true;
         }
         if (empty($hash['name'])) {
             $cohorts[$rownum]['errors'][] = new lang_string('namefieldempty', 'cohort');
         }
         $cohorts[$rownum]['data'] = array_intersect_key($hash, $cohorts[0]['data']);
         $haserrors = $haserrors || !empty($cohorts[$rownum]['errors']);
         $haswarnings = $haswarnings || !empty($cohorts[$rownum]['warnings']);
     }
     if ($haserrors) {
         $cohorts[0]['errors'][] = new lang_string('csvcontainserrors', 'cohort');
     }
     if ($haswarnings) {
         $cohorts[0]['warnings'][] = new lang_string('csvcontainswarnings', 'cohort');
     }
     return $cohorts;
 }

$strcoursecategorynotaddederror = get_string('coursecategorynotaddederror', 'tool_uploadcoursecategory');
$strcoursecategorydeleted = get_string('coursecategorydeleted', 'tool_uploadcoursecategory');
$strcoursecategorynotdeletederror = get_string('coursecategorynotdeletederror', 'tool_uploadcoursecategory');
$strcoursecategorynotdeletedmissing = get_string('coursecategorynotdeletedmissing', 'tool_uploadcoursecategory');
$strcoursecategorynotdeletedoff = get_string('coursecategorynotdeletedoff', 'tool_uploadcoursecategory');
$errorstr = get_string('error');
$returnurl = new moodle_url('/admin/tool/uploadcoursecategory/index.php');
$bulknurl = new moodle_url('/admin/tool/uploadcoursecategory/index.php');
$today = time();
$today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);
// array of all valid fields for validation
$STD_FIELDS = array('name', 'description', 'idnumber', 'theme', 'visible', 'deleted', 'oldname');
if (empty($iid)) {
    $mform1 = new admin_uploadcoursecategory_form1();
    if ($formdata = $mform1->get_data()) {
        $iid = csv_import_reader::get_new_iid('uploadcoursecategory');
        $cir = new csv_import_reader($iid, 'uploadcoursecategory');
        $content = $mform1->get_file_content('coursefile');
        $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
        unset($content);
        if ($readcount === false) {
            print_error('csvloaderror', '', $returnurl);
        } else {
            if ($readcount == 0) {
                print_error('csvemptyfile', 'error', $returnurl);
            }
        }
        // test if columns ok
        $filecolumns = cc_validate_coursecategory_upload_columns($cir, $STD_FIELDS, $returnurl);
        // continue to form2
    } else {

$PAGE->set_url('/local/learningplan/upload.php');
$PAGE->set_pagelayout('admin');
$PAGE->set_heading($SITE->fullname);
$strheading = get_string('pluginname', 'local_learningplan');
$PAGE->set_title($strheading);
$PAGE->navbar->add(get_string('pluginname', 'local_learningplan'), new moodle_url('/local/learningplan/index.php'));
$PAGE->navbar->add(get_string('uploadlearningplans', 'local_learningplan'));
global $USER;
/* ---array of all valid fields for validation--- */
$STD_FIELDS = array('fullname', 'parentid', 'type', 'description');
$PRF_FIELDS = array();
/* ---if variable $iid equal to zero,it allows enter into the form--- */
if (empty($iid)) {
    $mform1 = new admin_learningplan_form1();
    if ($formdata = $mform1->get_data()) {
        $iid = csv_import_reader::get_new_iid('uploadlearningplan');
        $cir = new csv_import_reader($iid, 'uploadlearningplan');
        /* ---this class fromcsvlib.php(includes csv methods and classes)--- */
        $content = $mform1->get_file_content('learningplanfile');
        $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
        unset($content);
        if ($readcount === false) {
            print_error('csvloaderror', '', $returnurl);
        } else if ($readcount == 0) {
            print_error('csvemptyfile', 'error', $returnurl);
        }
        /* ---test if columns ok(to validate the csv file content)--- */
        $filecolumns = uu_validate_learningplan_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
        /* ---continue to form2--- */
    } else {
        echo $OUTPUT->header();

require_once 'locallib.php';
require_login();
admin_externalpage_setup('keymanager_import');
require_capability('local/rcommon:importcredentials', context_system::instance());
@set_time_limit(3600);
// 1 hour should be enough
@raise_memory_limit('256M');
$iid = optional_param('iid', '', PARAM_INT);
$continue = optional_param('continue', false, PARAM_BOOL);
$fields = array('required' => array('isbn', 'credential'), 'optional' => array('username', 'userid'), 'ignored' => array('pack', 'packid'));
$errorstr = get_string('error');
$returnurl = new moodle_url('/local/rcommon/import.php');
if (empty($iid)) {
    $mform = new local_rcommon_import_credentials_form();
    if ($formdata = $mform->get_data()) {
        $iid = csv_import_reader::get_new_iid('import_marsupial');
        $cir = new csv_import_reader($iid, 'import_marsupial');
        $content = $mform->get_file_content('import_marsupial');
        $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
        $csvloaderror = $cir->get_error();
        unset($content);
        if (!is_null($csvloaderror)) {
            print_error('csvloaderror', '', $returnurl, $csvloaderror);
        }
        $filecolumns = credentials::validate_columns($cir, $fields, $returnurl);
    } else {
        echo $OUTPUT->header();
        echo $OUTPUT->heading_with_help(get_string('keymanager_import_title', 'local_rcommon'), 'importcsv', 'local_rcommon');
        $mform->display();
        echo $OUTPUT->footer();
        die;