Exemple #1
0
 /**
  * Reset the current process.
  *
  * @return void.
  */
 public function reset()
 {
     $this->processstarted = false;
     $this->linenb = 0;
     $this->cir->init();
     $this->errors = array();
 }
 /**
  * Reset the current process.
  *
  * @return void.
  */
 protected function reset()
 {
     $this->processstarted = false;
     $this->linenum = 0;
     $this->cir->init();
     $this->errors = array();
 }
 /**
  * Initialise the import reader and locate the column indexes.
  *
  * @return bool false is a failed import
  */
 public function init()
 {
     if ($this->csvreader == null) {
         $this->csvreader = new csv_import_reader($this->importid, 'assignfeedback_offline');
     }
     $this->csvreader->init();
     $columns = $this->csvreader->get_columns();
     $strgrade = get_string('grade');
     $strid = get_string('recordid', 'assign');
     $strmodified = get_string('lastmodifiedgrade', 'assign');
     foreach ($this->assignment->get_feedback_plugins() as $plugin) {
         if ($plugin->is_enabled() && $plugin->is_visible()) {
             foreach ($plugin->get_editor_fields() as $field => $description) {
                 $this->feedbackcolumnindexes[$description] = array('plugin' => $plugin, 'field' => $field, 'description' => $description);
             }
         }
     }
     if ($columns) {
         foreach ($columns as $index => $column) {
             if (isset($this->feedbackcolumnindexes[$column])) {
                 $this->feedbackcolumnindexes[$column]['index'] = $index;
             }
             if ($column == $strgrade) {
                 $this->gradeindex = $index;
             }
             if ($column == $strid) {
                 $this->idindex = $index;
             }
             if ($column == $strmodified) {
                 $this->modifiedindex = $index;
             }
         }
     }
     if ($this->idindex < 0 || $this->gradeindex < 0 || $this->modifiedindex < 0) {
         return false;
     }
     $groupmode = groups_get_activity_groupmode($this->assignment->get_course_module());
     // All users.
     $groupid = 0;
     $groupname = '';
     if ($groupmode) {
         $groupid = groups_get_activity_group($this->assignment->get_course_module(), true);
         $groupname = groups_get_group_name($groupid) . '-';
     }
     $this->validusers = $this->assignment->list_participants($groupid, false);
     return true;
 }
 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);
     }
 }
Exemple #5
0
    public function test_csv_functions() {
        $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);
    }
Exemple #6
0
 /**
  * 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;
 }
Exemple #8
0
 } else {
     if (!($fieldnames = $cir->get_columns())) {
         print_error('cannotreadtmpfile', 'error');
     }
     // check the fieldnames are valid
     $fields = $DB->get_records('data_fields', array('dataid' => $data->id), '', 'name, id, type');
     $errorfield = '';
     foreach ($fieldnames as $name) {
         if (!isset($fields[$name])) {
             $errorfield .= "'{$name}' ";
         }
     }
     if (!empty($errorfield)) {
         print_error('fieldnotmatched', 'data', "{$CFG->wwwroot}/mod/data/edit.php?d={$data->id}", $errorfield);
     }
     $cir->init();
     $recordsadded = 0;
     while ($record = $cir->next()) {
         if ($recordid = data_add_record($data, 0)) {
             // add instance to data_record
             $fields = $DB->get_records('data_fields', array('dataid' => $data->id), '', 'name, id, type');
             // Insert new data_content fields with NULL contents:
             foreach ($fields as $field) {
                 $content = new stdClass();
                 $content->recordid = $recordid;
                 $content->fieldid = $field->id;
                 $DB->insert_record('data_content', $content);
             }
             // Fill data_content with the values imported from the CSV file:
             foreach ($record as $key => $value) {
                 $name = $fieldnames[$key];
/**
 * process the mass enrolment
 * @param csv_import_reader $cir  an import reader created by caller
 * @param Object $course  a course record from table mdl_course
 * @param Object $context  course context instance
 * @param Object $data    data from a moodleform 
 * @return string  log of operations 
 */
function bulk_costcenter_enroll($cir,   $data) {
    global $CFG,$DB,$USER;
    require_once ($CFG->dirroot . '/group/lib.php');

    $result = '';
    
    $roleid = $data->roleassign;
    $useridfield = $data->firstcolumn;

    $enrollablecount = 0;
    $createdgroupscount = 0;
    $createdgroupingscount = 0;
    $createdgroups = '';
    $createdgroupings = '';
    
    $plugin = enrol_get_plugin('manual');
    // init csv import helper
    $cir->init();
    while ($fields = $cir->next()) {
        $a = new StdClass();
        if (empty ($fields))
            continue;
        
        // 1rst column = id Moodle (idnumber,username or email)    
        // get rid on eventual double quotes unfortunately not done by Moodle CSV importer 
            //$fields[0]= str_replace('"', '', trim($fields[0]));
            //$fields[1]= str_replace('"', '', trim($fields[1]));
        if (!$costcenter = $DB->get_record_sql('select * from {local_costcenter} where shortname="'.$fields[1].'"')) {
            $result .= '<div class="alert alert-error">'.get_string('im:costcenter_unknown', 'local_users', $fields[0] ). '</div>';
            continue;
        }
        if (!$user = $DB->get_record_sql('select * from {user} where '.$useridfield.' = "'.$fields[0].'"')) {
            $result .= '<div class="alert alert-error">'.get_string('im:user_unknown', 'local_users', $fields[1] ). '</div>';
            continue;
        }

        if(!is_siteadmin() && !$DB->record_exists_sql("select id from {local_costcenter_permissions} where costcenterid=$costcenter->id AND userid=$USER->id")){
            $costcentername = $DB->get_field('local_costcenter','fullname',array('id'=>$costcenter->id));
            $cs_object = new stdClass();
            $cs_object->csname = $costcentername;
            $cs_object->user   = fullname($user);
            $result .= '<div class="alert alert-error">'.get_string('im:user_notcostcenter', 'local_userdata',$cs_object ). '</div>';
            continue; 
        }
        //already enroled ?
        if ($DB->record_exists_sql('select * from {local_userdata} where userid='.$user->id.' and costcenterid>0')) {
            $result .= '<div class="alert alert-error">'.get_string('im:already_in', 'local_users', fullname($user)). '</div>';
        } else {
        $userdata = new stdClass();
        $userdata->userid = $user->id;
        $userdata->costcenterid = $costcenter->id;
        $userdata->supervisorid = 0;
        $userdata->reportingmanagerid = 0;
        $userdata->usermodified = $USER->id;
        $userdata->timecreated = time();
        $userdata->timemodified = time();
        $DB->insert_record('local_userdata',$userdata);     
                $result .= '<div class="alert alert-success">'.get_string('im:assigned_ok', 'local_userdata', fullname($user)).'</div>';
            $enrollablecount++;
        }
    }
    $result .= '<br />';

    //$result .= get_string('im:stats_i', 'local_userdata', $enrollablecount) . "";
 
    return $result;
}
Exemple #10
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();
 }
Exemple #11
0
/**
 * process the mass enrolment
 * @param csv_import_reader $cir  an import reader created by caller
 * @param Object $course  a course record from table mdl_course
 * @param Object $context  course context instance
 * @param Object $data    data from a moodleform 
 * @return string  log of operations 
 */
function mass_enroll($cir, $course, $context, $data) {
    global $CFG,$DB;
    require_once ($CFG->dirroot . '/group/lib.php');

    $result = '';
    
    $courseid=$course->id;
    $roleid = $data->roleassign;
    $useridfield = $data->firstcolumn;

    $enrollablecount = 0;
    $createdgroupscount = 0;
    $createdgroupingscount = 0;
    $createdgroups = '';
    $createdgroupings = '';


    $plugin = enrol_get_plugin('manual');
    //Moodle 2.x enrolment and role assignment are different
    // make sure couse DO have a manual enrolment plugin instance in that course
    //that we are going to use (only one instance is allowed @see enrol/manual/lib.php get_new_instance)
    // thus call to get_record is safe 
    $instance = $DB->get_record('enrol', array('courseid' => $course->id, 'enrol' => 'manual'));
    if (empty($instance)) {
        // Only add an enrol instance to the course if non-existent
        $enrolid = $plugin->add_instance($course);
        $instance = $DB->get_record('enrol', array('id' => $enrolid));
    }
    
   
    // init csv import helper
    $cir->init();
    while ($fields = $cir->next()) {
        $a = new StdClass();

        if (empty ($fields))
            continue;

        // print_r($fields);
        // $enrollablecount++;
        // continue;
        
        // 1rst column = id Moodle (idnumber,username or email)    
        // get rid on eventual double quotes unfortunately not done by Moodle CSV importer 
            $fields[0]= str_replace('"', '', trim($fields[0]));
        
        if (!$user = $DB->get_record('user', array($useridfield => $fields[0]))) {
            $result .= '<div class="alert alert-error">'.get_string('im:user_unknown', 'local_mass_enroll', $fields[0] ). '</div>';
            continue;
        }
        if(!$DB->record_exists_sql("select id from {local_userdata} where costcenterid=$course->costcenter AND userid=$user->id")){
            $costcentername = $DB->get_field('local_costcenter','fullname',array('id'=>$course->costcenter));
            $cs_object = new stdClass();
            $cs_object->csname = $costcentername;
            $cs_object->user   = fullname($user);
            $result .= '<div class="alert alert-error">'.get_string('im:user_notcostcenter', 'local_mass_enroll',$cs_object ). '</div>';
            continue; 
        }
        //already enroled ?
        if (user_has_role_assignment($user->id, $roleid, $context->id)) {
            $result .= '<div class="alert alert-error">'.get_string('im:already_in', 'local_mass_enroll', fullname($user)). '</div>';

        } else {
            //TODO take care of timestart/timeend in course settings
            // done in rev 1.1
            $timestart = time();
            // remove time part from the timestamp and keep only the date part
            $timestart = make_timestamp(date('Y', $timestart), date('m', $timestart), date('d', $timestart), 0, 0, 0);
            if ($instance->enrolperiod) {
                $timeend = $timestart + $instance->enrolperiod;
            } else {
                $timeend = 0;
            }
            // not anymore so easy in Moodle 2.x
            // if (!role_assign($roleid, $user->id, null, $context->id, $timestart, $timeend, 0, 'flatfile')) {
            //    $result .= get_string('im:error_in', 'local_mass_enroll', fullname($user)) . "";
            //    continue;
            //}
            //
            // Enrol the user with this plugin instance (unfortunately return void, no more status )
            $plugin->enrol_user($instance, $user->id,$roleid,$timestart,$timeend);
            $result .= '<div class="alert alert-success">'.get_string('im:enrolled_ok', 'local_mass_enroll', fullname($user)).'</div>';
            $enrollablecount++;
        }

        $group = str_replace('"','',trim($fields[1]));
        // 2nd column ?
        if (empty ($group)) {
            $result .= "";
            continue; // no group for this one
        }

        // create group if needed
        if (!($gid = mass_enroll_group_exists($group, $courseid))) {
            if ($data->creategroups) {
                if (!($gid = mass_enroll_add_group($group, $courseid))) {
                    $a->group = $group;
                    $a->courseid = $courseid;
                    $result .= '<div class="alert alert-error">'.get_string('im:error_addg', 'local_mass_enroll', $a) . '</div>';
                    continue;
                }
                $createdgroupscount++;
                $createdgroups .= " $group";
            } else {
                $result .= '<div class="alert alert-error">'.get_string('im:error_g_unknown', 'local_mass_enroll', $group) . '</div>';
                continue;
            }
        }

        // if groupings are enabled on the site (should be ?)
        // if ($CFG->enablegroupings) { // not anymore in Moodle 2.x
        if (!($gpid = mass_enroll_grouping_exists($group, $courseid))) {
            if ($data->creategroupings) {
                if (!($gpid = mass_enroll_add_grouping($group, $courseid))) {
                    $a->group = $group;
                    $a->courseid = $courseid;
                    $result .= '<div class="alert alert-error">'.get_string('im:error_add_grp', 'local_mass_enroll', $a) . '</div>';
                    continue;
                }
                $createdgroupingscount++;
                $createdgroupings .= " $group";
            } else {
                // don't complains,
                // just do the enrolment to group
            }
        }
        // if grouping existed or has just been created
        if ($gpid && !(mass_enroll_group_in_grouping($gid, $gpid))) {
            if (!(mass_enroll_add_group_grouping($gid, $gpid))) {
                $a->group = $group;
                $result .= '<div class="alert alert-error">'.get_string('im:error_add_g_grp', 'local_mass_enroll', $a) . '</div>';
                continue;
            }
        }
        //}

        // finally add to group if needed
        if (!groups_is_member($gid, $user->id)) {
            $ok = groups_add_member($gid, $user->id);
            if ($ok) {
                $result .= '<div class="alert alert-success">'.get_string('im:and_added_g', 'local_mass_enroll', $group) . '</div>';
            } else {
                $result .= '<div class="alert alert-error">'.get_string('im:error_adding_u_g', 'local_mass_enroll', $group) . '</div>';
            }
        } else {
            $result .= '<div class="alert alert-notice">'.get_string('im:already_in_g', 'local_mass_enroll', $group) . '</div>';
        }

    }
    $result .= '<br />';
    //recap final
    $result .= get_string('im:stats_i', 'local_mass_enroll', $enrollablecount) . "";
    $a->nb = $createdgroupscount;
    if(!isset($createdgroups) || empty($createdgroups)||$createdgroups='')
    $a->what = '-';
    else
    $a->what = $createdgroups;
    $result .= get_string('im:stats_g', 'local_mass_enroll', $a) . "";
    $a->nb = $createdgroupingscount;
    if(!isset($createdgroupings) || empty($createdgroupings)||$createdgroupings='')
    $a->what = '-';
    else
    $a->what = $createdgroupings;
    $result .= get_string('im:stats_grp', 'local_mass_enroll', $a) . "";

    return $result;
}
/**
 * process the mass enrolment
 * @param csv_import_reader $cir  an import reader created by caller
 * @param Object $course  a course record from table mdl_course
 * @param Object $context  course context instance
 * @param Object $data    data from a moodleform 
 * @return string  log of operations 
 */
function mass_unenroll($cir, $course, $context, $data)
{
    global $CFG, $DB;
    $result = '';
    $courseid = $course->id;
    $useridfield = $data->firstcolumn;
    $unenrollablecount = 0;
    $plugin = enrol_get_plugin('manual');
    //Moodle 2.x enrolment and role assignment are different
    // make sure couse DO have a manual enrolment plugin instance in that course
    //that we are going to use (only one instance is allowed @see enrol/manual/lib.php get_new_instance)
    // thus call to get_record is safe
    $instance = $DB->get_record('enrol', array('courseid' => $course->id, 'enrol' => 'manual'));
    if (empty($instance)) {
        // Only add an enrol instance to the course if non-existent
        $enrolid = $plugin->add_instance($course);
        $instance = $DB->get_record('enrol', array('id' => $enrolid));
    }
    // init csv import helper
    $cir->init();
    while ($fields = $cir->next()) {
        $a = new StdClass();
        if (empty($fields)) {
            continue;
        }
        // 1rst column = id Moodle (idnumber,username or email)
        // get rid on eventual double quotes unfortunately not done by Moodle CSV importer
        $fields[0] = str_replace('"', '', trim($fields[0]));
        if (!($user = $DB->get_record('user', array($useridfield => $fields[0])))) {
            $result .= get_string('im:user_unknown', 'local_mass_enroll', $fields[0]) . "\n";
            continue;
        }
        //already enroled ?
        if (!($ue = $DB->get_record('user_enrolments', array('enrolid' => $instance->id, 'userid' => $user->id)))) {
            // weird, user not enrolled
            $result .= get_string('im:not_in', 'local_mass_enroll', fullname($user)) . "\n";
        } else {
            // Enrol the user with this plugin instance (unfortunately return void, no more status )
            $plugin->unenrol_user($instance, $user->id);
            $result .= get_string('im:unenrolled_ok', 'local_mass_enroll', fullname($user)) . "\n";
            $unenrollablecount++;
        }
    }
    //recap final
    $result .= get_string('im:stats_ui', 'local_mass_enroll', $unenrollablecount) . "\n";
    return $result;
}
 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);
 }
Exemple #14
0
 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
                 }
             }
             echo "\tGrade for '{$gradeitem->get_name()}', type {$gradeitem->gradetype} will be set to '{$value}'\n";
             $newgrade->finalgrade = $value;
             $newgrade->userid = $user->id;
             $newgrade->importer = $USER->id;
             $newgrades[] = $newgrade;
         }
     }
     if ($options['test']) {
         echo "Test mode - exiting without performing import.\n";
     }
     //we will use safer method of importing useing temporary table
     $importcode = get_new_importcode();
     foreach ($newgrades as $newgrade) {
         $newgrade->importcode = $importcode;
         $DB->insert_record('grade_import_values', $newgrade);
     }
     grade_import_commit($course->id, $importcode);
 }
Exemple #15
0
 /**
  * @param array  $options associative delimiter,enclosure,encoding,updateexisting,settings
  */
 public function process_csv($data, $csvcontent, $options = null)
 {
     global $CFG, $DB;
     require_once "{$CFG->libdir}/csvlib.class.php";
     @set_time_limit(0);
     raise_memory_limit(MEMORY_EXTRA);
     $iid = \csv_import_reader::get_new_iid('moddataform');
     $cir = new \csv_import_reader($iid, 'moddataform');
     $delimiter = !empty($options['delimiter']) ? $options['delimiter'] : $this->_delimiter;
     $enclosure = !empty($options['enclosure']) ? $options['enclosure'] : $this->_enclosure;
     $encoding = !empty($options['encoding']) ? $options['encoding'] : $this->_encoding;
     $fieldsettings = !empty($options['settings']) ? $options['settings'] : array();
     $readcount = $cir->load_csv_content($csvcontent, $encoding, $delimiter);
     if (empty($readcount)) {
         $data->errors[] = $cir->get_error();
         return $data;
     }
     // Csv column headers.
     if (!($fieldnames = $cir->get_columns())) {
         $data->errors[] = $cir->get_error();
         return $data;
     }
     // Are we updating existing entries?
     $existingkeys = array();
     $keyname = null;
     if ($updateexisting = !empty($options['updateexisting'])) {
         if (isset($fieldnames['entryid'])) {
             $keyname = 'entryid';
         } else {
             $keyname = reset($fieldnames);
             if ($field = $this->df->field_manager->get_field_by_name($keyname)) {
                 $params = array('fieldid' => $field->id);
                 $existingkeys = $DB->get_records_menu('dataform_contents', $params, '', 'entryid,content');
             }
         }
     }
     // Are we adding the imported entries to every participant?
     $addperparticipant = (!empty($options['addperparticipant']) and $users = $this->df->grade_manager->get_gradebook_users());
     $i = 0;
     $cir->init();
     while ($csvrecord = $cir->next()) {
         $csvrecord = array_combine($fieldnames, $csvrecord);
         // Add the entry for every participant.
         if ($addperparticipant) {
             foreach ($users as $userid => $unused) {
                 // Set the entry id.
                 $i++;
                 $entryid = -$i;
                 $data->eids[$entryid] = $entryid;
                 $data->{"entry_{$entryid}_userid"} = $userid;
                 // Iterate the fields and collate their entry content.
                 foreach ($fieldsettings as $fieldid => $importsettings) {
                     $field = $this->df->field_manager->get_field_by_id($fieldid);
                     $data = $field->prepare_import_content($data, $importsettings, $csvrecord, $entryid);
                 }
             }
             continue;
         }
         // Get the entry id.
         $entryid = 0;
         if ($updateexisting and $keyname) {
             if ($keyname == 'entryid') {
                 if (!empty($csvrecord['entryid'])) {
                     $entryid = $csvrecord['entryid'];
                 }
             } else {
                 if ($existingkeys and !empty($csvrecord[$keyname])) {
                     $entryid = array_search($csvrecord[$keyname], $existingkeys);
                 }
             }
         }
         if (!$entryid) {
             $i++;
             $entryid = -$i;
         }
         $data->eids[$entryid] = $entryid;
         // Iterate the fields and collate their entry content.
         foreach ($fieldsettings as $fieldid => $importsettings) {
             $field = $this->df->field_manager->get_field_by_id($fieldid);
             $data = $field->prepare_import_content($data, $importsettings, $csvrecord, $entryid);
         }
     }
     $cir->cleanup(true);
     $cir->close();
     return $data;
 }
 /**
  * Inserts data from a csv file into the data module table specified.
  *
  * @param string $file comma seperated value file
  * @param string $tablename name of the table for the data to be inserted into.
  */
 function insert_data_from_csv($file, $tablename) {
     global $DB;
     $iid = csv_import_reader::get_new_iid('moddata');
     $csvdata = new csv_import_reader($iid, 'moddata');
     $fielddata = $csvdata->load_csv_content($file, 'utf8', 'comma');
     $columns = $csvdata->get_columns();
     $columncount = count($columns);
     $csvdata->init();
     $fieldinfo = array();
     for ($j = 0; $j < $fielddata; $j++) {
         $thing = $csvdata->next();
         $fieldinfo[$j] = new stdClass();
         for ($i = 0; $i < $columncount; $i++) {
             $fieldinfo[$j]->$columns[$i] = $thing[$i];
         }
         $DB->insert_record($tablename, $fieldinfo[$j], false);
     }
 }
 /**
  * enrol and add user to groups in course
  * @param object $course
  * @param csv_import_reader $reader
  * @param int $roleid
  */
 public function process_uploaded_groups($course, $reader, $roleid)
 {
     global $DB, $PAGE;
     $usercol = null;
     // Index of username column.
     $groupcol = null;
     // Index of group column.
     // Find the index of the needed columns.
     $i = 0;
     foreach ($reader->get_columns() as $col) {
         $col = strtoupper(trim($col));
         switch ($col) {
             case 'USERNAME':
                 $usercol = $i;
                 break;
             case 'GROUP':
                 $groupcol = $i;
                 break;
         }
         $i++;
     }
     // Get the manual enrolment plugin.
     $enrolinstances = enrol_get_instances($course->id, true);
     $manualinstance = null;
     foreach ($enrolinstances as $instance) {
         if ($instance->enrol == 'manual') {
             $manualinstance = $instance;
             break;
         }
     }
     $manualenroler = enrol_get_plugin('manual');
     // Get the list of enrolled users for the course.
     $manager = new course_enrolment_manager($PAGE, $course);
     $totalusers = $manager->get_total_users();
     /*
      * Since the number of fields being retrieved are limited (email, id, lastaccess, and lastseen),
      * I feel comfortable retrieving the entire enrolled userbase for this course.
      */
     $users = $manager->get_users('firstname', 'ASC', 0, $totalusers);
     $groups = $manager->get_all_groups();
     $groupids = array();
     foreach ($groups as $group) {
         $groupids[$group->name] = $group->id;
     }
     // Prep the returned array.
     $output = array('group_created' => array(), 'user_enrolled' => array(), 'member_added' => array(), 'error' => array('user_not_found' => array(), 'group_failed' => array(), 'enrol_failed' => array(), 'member_failed' => array(), 'user_not_added' => array()));
     // Loop through the records.
     $reader->init();
     while ($line = $reader->next()) {
         $username = trim($line[$usercol]);
         $groupname = trim($line[$groupcol]);
         // Check if the user exists.
         $user = $DB->get_record('user', array('username' => $username));
         if ($user === false) {
             $output['error']['user_not_found'][] = $username;
             continue;
         }
         // Enroll the user as needed.
         if (!isset($users[$user->id])) {
             try {
                 $manualenroler->enrol_user($manualinstance, $user->id, $roleid);
                 $output['user_enrolled'][] = $username;
             } catch (Exception $e) {
                 $output['error']['enroll_failed'][] = $username;
             }
         }
         // Create the group as needed.
         if (!isset($groupids[$groupname])) {
             if ($groupname != '') {
                 $data = new stdClass();
                 $data->courseid = $course->id;
                 $data->name = $groupname;
                 $newgroupid = groups_create_group($data);
             } else {
                 $newgroupid = false;
             }
             if ($newgroupid === false) {
                 if ($groupname != '') {
                     $output['error']['group_failed'][] = $groupname;
                 }
             } else {
                 $groupids[$groupname] = $newgroupid;
                 $output['group_created'][] = $groupname;
             }
         }
         // Add the user to the group.
         if ($groupname != '') {
             if (groups_add_member($groupids[$groupname], $user->id)) {
                 if (!isset($output['member_added'][$groupname])) {
                     $output['member_added'][$groupname] = array();
                 }
                 $output['member_added'][$groupname][] = $username;
             } else {
                 if (!isset($output['error']['member_failed'][$groupname])) {
                     $output['error']['member_failed'][$groupname] = array();
                 }
                 $output['error']['member_failed'][$groupname][] = $username;
             }
         } else {
             // No group name was provided for this user.
             $output['error']['user_not_added'][] = $username;
         }
     }
     return $output;
 }
Exemple #18
0
 /**
  * @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;
 }
 /**
  * Imports the log views defined in the csv file, iterating each row. This is made under the transaction initiated in
  * import_data function.
  *
  * @param object $logsfile Course csv file.
  * @param object $formdata Submitted form data, needed to load the csv.
  * @param int $courseid Generated course id in this transaction.
  * @param \block_mycourse_recommendations\database_helper $db Database handler object, passed as argument to instance it
  * again.
  */
 public static function import_logs($logsfile, $formdata, $courseid, $db)
 {
     $iid = \csv_import_reader::get_new_iid('logsfile');
     $csvreader = new \csv_import_reader($iid, 'logsfile');
     $csvreader->load_csv_content($logsfile, $formdata->encoding, $formdata->delimiter_name);
     $csvreader->init();
     $fields = $csvreader->get_columns();
     while ($fields) {
         $userid = $fields[0];
         $resourcename = $fields[1];
         $resourcetype = $fields[2];
         $resourceid = $fields[3];
         $views = $fields[4];
         $timecreated = $fields[5];
         $db->insert_historic_logs($userid, $courseid, $resourcename, $resourcetype, $resourceid, $views, $timecreated);
         self::$lastinsertedlogs++;
         $fields = $csvreader->next();
     }
     $csvreader->close();
 }
/**
 * process the mass unenrolment
 *
 * @param csv_import_reader $cir  an import reader created by caller
 * @param stdClass $course  a course record from table mdl_course
 * @param stdClass $context  course context instance
 * @param stdClass $data    data from a moodleform
 * @return string  log of operations
 */
function mass_unenroll($cir, $course, $context, $data)
{
    global $DB;
    $result = '';
    $useridfield = $data->firstcolumn;
    $unenrollablecount = 0;
    $plugin = enrol_get_plugin('manual');
    // Moodle 2.x enrolment and role assignment are different.
    // Assure course has manual enrolment plugin instance we are going to use.
    // Only one instance is allowed; see enrol/manual/lib.php get_new_instance().
    $instance = $DB->get_record('enrol', array('courseid' => $course->id, 'enrol' => 'manual'));
    if (empty($instance)) {
        // Only add an enrol instance to the course if non-existent.
        $enrolid = $plugin->add_instance($course);
        $instance = $DB->get_record('enrol', array('id' => $enrolid));
    }
    // Init csv import helper.
    $cir->init();
    while ($fields = $cir->next()) {
        $a = new stdClass();
        if (empty($fields)) {
            continue;
        }
        // First column = id Moodle (idnumber,username or email).
        // Get rid on eventual double quotes unfortunately not done by Moodle CSV importer.
        $fields[0] = str_replace('"', '', trim($fields[0]));
        if (!($user = $DB->get_record('user', array($useridfield => $fields[0])))) {
            $result .= get_string('im:user_unknown', 'local_mass_enroll', $fields[0]) . "\n";
            continue;
        }
        // Already enroled?
        if (!($ue = $DB->get_record('user_enrolments', array('enrolid' => $instance->id, 'userid' => $user->id)))) {
            // Weird, user not enrolled.
            $result .= get_string('im:not_in', 'local_mass_enroll', fullname($user)) . "\n";
        } else {
            // Enrol the user with this plugin instance (unfortunately return void, no more status).
            $plugin->unenrol_user($instance, $user->id);
            $result .= get_string('im:unenrolled_ok', 'local_mass_enroll', fullname($user)) . "\n";
            $unenrollablecount++;
        }
    }
    // Recap final.
    $result .= get_string('im:stats_ui', 'local_mass_enroll', $unenrollablecount) . "\n";
    // Trigger event.
    $event = \local_mass_enroll\event\mass_unenrolment_created::create(array('objectid' => $course->id, 'courseid' => $course->id, 'context' => context_course::instance($course->id), 'other' => array('info' => get_string('mass_unenroll', 'local_mass_enroll'))));
    $event->trigger();
    return $result;
}
 // 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]);
         }
         $current++;
     }
     if (isset($_REQUEST["submitbutton"]) && $_REQUEST["submitbutton"] === get_string("confirm")) {
         foreach ($data as $comment) {
             $predefinedcomment = new stdClass();
             $predefinedcomment->emarkingid = $emarking->id;
             $predefinedcomment->text = $comment[0];
             $predefinedcomment->markerid = $USER->id;
             $predefinedcomment->id = $DB->insert_record("emarking_predefined_comment", $predefinedcomment);
         }
Exemple #22
0
            echo $OUTPUT->footer();
            die;
        }
    }
}
// Data has already been submitted so we can use the $iid to retrieve it.
$mform2 = new import_mapping_form(null, array('iid' => $iid));
if ($mform2->is_cancelled()) {
    redirect($url);
} else {
    if ($formdata = $mform2->get_data()) {
        $csvimport = new csv_import_reader($iid, 'rooms');
        $header = $csvimport->get_columns();
        @set_time_limit(0);
        raise_memory_limit(MEMORY_EXTRA);
        $csvimport->init();
        $info = array();
        while ($line = $csvimport->next()) {
            if (count($line) <= 1) {
                // there is no data on this line, move on
                continue;
            }
            $data = new stdClass();
            $data->fecha_reserva = $line[0];
            $data->modulo = $line[1];
            $data->confirmado = $line[2];
            $data->activa = $line[3];
            $data->alumno_id = $line[4];
            $data->salas_id = $line[5];
            $data->comentario_alumno = $line[6];
            $data->comentario_admin = $line[7];
/**
 * process the mass enrolment
 * @param csv_import_reader $cir  an import reader created by caller
 * @param Object $course  a course record from table mdl_course
 * @param Object $context  course context instance
 * @param Object $data    data from a moodleform 
 * @return string  log of operations 
 */
function bulk_enroll($cir,   $data) {
    global $CFG,$DB,$USER;
    require_once ($CFG->dirroot . '/group/lib.php');

    $result = '';
    
    $roleid = $data->roleassign;
    $useridfield = $data->firstcolumn;

    $enrollablecount = 0;
    $createdgroupscount = 0;
    $createdgroupingscount = 0;
    $createdgroups = '';
    $createdgroupings = '';
    
    $plugin = enrol_get_plugin('manual');
    
    // init csv import helper
    $cir->init();
    while ($fields = $cir->next()) {
        $a = new StdClass();
        if (empty ($fields))
            continue;
        
        // 1rst column = id Moodle (idnumber,username or email)    
        // get rid on eventual double quotes unfortunately not done by Moodle CSV importer 
            $fields[0]= str_replace('"', '', trim($fields[0]));
           $fields[1]= str_replace('"', '', trim($fields[1]));
        if (!$lplan = $DB->get_record('learning_learningplan', array('shortname' => $fields[0]))) {
            $result .= '<div class="alert alert-error">'.get_string('im:learningplan_unknown', 'block_learning_plan', $fields[1] ). '</div>';
            continue;
        }
        
        if (!$user = $DB->get_record('user', array($useridfield => $fields[1]))) {
            $result .= '<div class="alert alert-error">'.get_string('im:user_unknown', 'block_learning_plan', $fields[1] ). '</div>';
            continue;
        }
        if(!$DB->record_exists_sql("select id from {local_userdata} where costcenterid=$lplan->costcenter AND userid=$user->id")){
          echo  $costcentername = $DB->get_field('local_costcenter','fullname',array('id'=>$lplan->costcenter));
            $cs_object = new stdClass();
            $cs_object->csname = $costcentername;
            $cs_object->user   = fullname($user);
            $result .= '<div class="alert alert-error">'.get_string('im:user_notcostcenter', 'local_mass_enroll',$cs_object ). '</div>';
            continue; 
        }
        //already enroled ?
        if ($DB->record_exists('learning_user_learningplan',array('u_id'=>$user->id, 'lp_id'=>$lplan->id))) {
            $result .= '<div class="alert alert-error">'.get_string('im:already_in', 'local_mass_enroll', fullname($user)). '</div>';

        } else {
                $record = new stdClass();
                $record2 = new stdClass();
                $record->lp_id = $lplan->id;
                $record->assignee_id = $USER->id;
                    $record->u_id = $user->id;
                    $training = learningplan_training($lplan->id);
					if(!empty($training)){
                    foreach ($training as $train) {
                        $studentroleid = $DB->get_field('role', 'id', array('shortname' => 'student'), MUST_EXIST);
                        $manualenrol = enrol_get_plugin('manual');
                        $enrol = $DB->get_record('enrol', array('courseid'=>$train->t_id, 'enrol'=>'manual'));
                        $manualenrol->enrol_user($enrol, $user->id,$studentroleid,$lplan->startdate,$lplan->enddate);
                        $record2->lpt_id = $train->id;
                        $record2->u_id = $user->id;
						$record2->timemodified = time();
                        // Insert in learning_user_trainingplan
                        $DB->insert_record('learning_user_trainingplan', $record2);
                    }
					}
                    $record->timemodified = time();
                    // Insert in learning_user_learningplan
                    if(!$DB->record_exists('learning_user_learningplan',array('lp_id'=>$lplan->id,'u_id'=>$user->id)))
                    $DB->insert_record('learning_user_learningplan', $record);
                $result .= '<div class="alert alert-success">'.get_string('im:enrolled_ok', 'local_mass_enroll', fullname($user)).'</div>';
            $enrollablecount++;
        }
    }
    $result .= '<br />';

    $result .= get_string('im:stats_i', 'local_mass_enroll', $enrollablecount) . "";
 
    return $result;
}