Your IP : 192.168.165.1
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* This file contains the class to import a competency framework.
*
* @package tool_lpimportcsv
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace tool_lpimportcsv;
defined('MOODLE_INTERNAL') || die('Direct access to this script is forbidden.');
use core_competency\api;
use grade_scale;
use stdClass;
use context_system;
use csv_import_reader;
/**
* This file contains the class to import a competency framework.
*
* @package tool_lpimportcsv
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class framework_importer {
/** @var string $error The errors message from reading the xml */
protected $error = '';
/** @var array $flat The flat competencies tree */
protected $flat = array();
/** @var array $framework The framework info */
protected $framework = array();
protected $mappings = array();
protected $importid = 0;
protected $importer = null;
protected $foundheaders = array();
protected $scalecache = array();
/** @var bool $useprogressbar Control whether importing should use progress bars or not. */
protected $useprogressbar = false;
/** @var \core\progress\display_if_slow|null $progress The progress bar instance. */
protected $progress = null;
/**
* Store an error message for display later
* @param string $msg
*/
public function fail($msg) {
$this->error = $msg;
return false;
}
/**
* Get the CSV import id
* @return string The import id.
*/
public function get_importid() {
return $this->importid;
}
/**
* Get the list of headers required for import.
* @return array The headers (lang strings)
*/
public static function list_required_headers() {
return array(
get_string('parentidnumber', 'tool_lpimportcsv'),
get_string('idnumber', 'tool_lpimportcsv'),
get_string('shortname', 'tool_lpimportcsv'),
get_string('description', 'tool_lpimportcsv'),
get_string('descriptionformat', 'tool_lpimportcsv'),
get_string('scalevalues', 'tool_lpimportcsv'),
get_string('scaleconfiguration', 'tool_lpimportcsv'),
get_string('ruletype', 'tool_lpimportcsv'),
get_string('ruleoutcome', 'tool_lpimportcsv'),
get_string('ruleconfig', 'tool_lpimportcsv'),
get_string('relatedidnumbers', 'tool_lpimportcsv'),
get_string('exportid', 'tool_lpimportcsv'),
get_string('isframework', 'tool_lpimportcsv'),
get_string('taxonomy', 'tool_lpimportcsv'),
);
}
/**
* Get the list of headers found in the import.
* @return array The found headers (names from import)
*/
public function list_found_headers() {
return $this->foundheaders;
}
/**
* Read the data from the mapping form.
* @param array The mapping data.
*/
protected function read_mapping_data($data) {
if ($data) {
return array(
'parentidnumber' => $data->header0,
'idnumber' => $data->header1,
'shortname' => $data->header2,
'description' => $data->header3,
'descriptionformat' => $data->header4,
'scalevalues' => $data->header5,
'scaleconfiguration' => $data->header6,
'ruletype' => $data->header7,
'ruleoutcome' => $data->header8,
'ruleconfig' => $data->header9,
'relatedidnumbers' => $data->header10,
'exportid' => $data->header11,
'isframework' => $data->header12,
'taxonomies' => $data->header13
);
} else {
return array(
'parentidnumber' => 0,
'idnumber' => 1,
'shortname' => 2,
'description' => 3,
'descriptionformat' => 4,
'scalevalues' => 5,
'scaleconfiguration' => 6,
'ruletype' => 7,
'ruleoutcome' => 8,
'ruleconfig' => 9,
'relatedidnumbers' => 10,
'exportid' => 11,
'isframework' => 12,
'taxonomies' => 13
);
}
}
/**
* Get the a column from the imported data.
* @param array The imported raw row
* @param index The column index we want
* @return string The column data.
*/
protected function get_column_data($row, $index) {
if ($index < 0) {
return '';
}
return isset($row[$index]) ? $row[$index] : '';
}
/**
* Constructor - parses the raw text for sanity.
* @param string $text The raw csv text.
* @param string $encoding The encoding of the csv file.
* @param string delimiter The specified delimiter for the file.
* @param string importid The id of the csv import.
* @param array mappingdata The mapping data from the import form.
* @param bool $useprogressbar Whether progress bar should be displayed, to avoid html output on CLI.
*/
public function __construct($text = null, $encoding = null, $delimiter = null, $importid = 0, $mappingdata = null,
$useprogressbar = false) {
global $CFG;
// The format of our records is:
// Parent ID number, ID number, Shortname, Description, Description format, Scale values, Scale configuration,
// Rule type, Rule outcome, Rule config, Is framework, Taxonomy.
// The idnumber is concatenated with the category names.
require_once($CFG->libdir . '/csvlib.class.php');
$type = 'competency_framework';
if (!$importid) {
if ($text === null) {
return;
}
$this->importid = csv_import_reader::get_new_iid($type);
$this->importer = new csv_import_reader($this->importid, $type);
if (!$this->importer->load_csv_content($text, $encoding, $delimiter)) {
$this->fail(get_string('invalidimportfile', 'tool_lpimportcsv'));
$this->importer->cleanup();
return;
}
} else {
$this->importid = $importid;
$this->importer = new csv_import_reader($this->importid, $type);
}
if (!$this->importer->init()) {
$this->fail(get_string('invalidimportfile', 'tool_lpimportcsv'));
$this->importer->cleanup();
return;
}
$this->foundheaders = $this->importer->get_columns();
$this->useprogressbar = $useprogressbar;
$domainid = 1;
$flat = array();
$framework = null;
while ($row = $this->importer->next()) {
$mapping = $this->read_mapping_data($mappingdata);
$parentidnumber = $this->get_column_data($row, $mapping['parentidnumber']);
$idnumber = $this->get_column_data($row, $mapping['idnumber']);
$shortname = $this->get_column_data($row, $mapping['shortname']);
$description = $this->get_column_data($row, $mapping['description']);
$descriptionformat = $this->get_column_data($row, $mapping['descriptionformat']);
$scalevalues = $this->get_column_data($row, $mapping['scalevalues']);
$scaleconfiguration = $this->get_column_data($row, $mapping['scaleconfiguration']);
$ruletype = $this->get_column_data($row, $mapping['ruletype']);
$ruleoutcome = $this->get_column_data($row, $mapping['ruleoutcome']);
$ruleconfig = $this->get_column_data($row, $mapping['ruleconfig']);
$relatedidnumbers = $this->get_column_data($row, $mapping['relatedidnumbers']);
$exportid = $this->get_column_data($row, $mapping['exportid']);
$isframework = $this->get_column_data($row, $mapping['isframework']);
$taxonomies = $this->get_column_data($row, $mapping['taxonomies']);
if ($isframework) {
$framework = new stdClass();
$framework->idnumber = shorten_text(clean_param($idnumber, PARAM_TEXT), 100);
$framework->shortname = shorten_text(clean_param($shortname, PARAM_TEXT), 100);
$framework->description = clean_param($description, PARAM_RAW);
$framework->descriptionformat = clean_param($descriptionformat, PARAM_INT);
$framework->scalevalues = $scalevalues;
$framework->scaleconfiguration = $scaleconfiguration;
$framework->taxonomies = $taxonomies;
$framework->children = array();
} else {
$competency = new stdClass();
$competency->parentidnumber = clean_param($parentidnumber, PARAM_TEXT);
$competency->idnumber = shorten_text(clean_param($idnumber, PARAM_TEXT), 100);
$competency->shortname = shorten_text(clean_param($shortname, PARAM_TEXT), 100);
$competency->description = clean_param($description, PARAM_RAW);
$competency->descriptionformat = clean_param($descriptionformat, PARAM_INT);
$competency->ruletype = $ruletype;
$competency->ruleoutcome = clean_param($ruleoutcome, PARAM_INT);
$competency->ruleconfig = $ruleconfig;
$competency->relatedidnumbers = $relatedidnumbers;
$competency->exportid = $exportid;
$competency->scalevalues = $scalevalues;
$competency->scaleconfiguration = $scaleconfiguration;
$competency->children = array();
$flat[$idnumber] = $competency;
}
}
$this->flat = $flat;
$this->framework = $framework;
$this->importer->close();
if ($this->framework == null) {
$this->fail(get_string('invalidimportfile', 'tool_lpimportcsv'));
return;
} else {
// We are calling from browser, display progress bar.
if ($this->useprogressbar === true) {
$this->progress = new \core\progress\display_if_slow(get_string('processingfile', 'tool_lpimportcsv'));
} else {
// Avoid html output on CLI scripts.
$this->progress = new \core\progress\none();
}
$this->progress->start_progress('', count($this->flat));
// Build a tree from this flat list.
raise_memory_limit(MEMORY_EXTRA);
$this->add_children($this->framework, '');
$this->progress->end_progress();
}
}
/**
* Add a competency to the parent with the specified idnumber.
*
* @param competency $node (pass by reference)
* @param string $parentidnumber Add this competency to the parent with this idnumber.
*/
public function add_children(& $node, $parentidnumber) {
foreach ($this->flat as $competency) {
if ($competency->parentidnumber == $parentidnumber) {
$this->progress->increment_progress();
$node->children[] = $competency;
$this->add_children($competency, $competency->idnumber);
}
}
}
/**
* Get parse errors.
* @return array of errors from parsing the xml.
*/
public function get_error() {
return $this->error;
}
/**
* Recursive function to add a competency with all it's children.
*
* @param stdClass $record Raw data for the new competency
* @param competency $parent
* @param competency_framework $framework
*/
public function create_competency($record, $parent, $framework) {
$competency = new stdClass();
$competency->competencyframeworkid = $framework->get('id');
$competency->shortname = $record->shortname;
if (!empty($record->description)) {
$competency->description = $record->description;
$competency->descriptionformat = $record->descriptionformat;
}
if ($record->scalevalues) {
$competency->scaleid = $this->get_scale_id($record->scalevalues, $competency->shortname);
$competency->scaleconfiguration = $this->get_scale_configuration($competency->scaleid, $record->scaleconfiguration);
}
if ($parent) {
$competency->parentid = $parent->get('id');
} else {
$competency->parentid = 0;
}
$competency->idnumber = $record->idnumber;
if (!empty($competency->idnumber) && !empty($competency->shortname)) {
$comp = api::create_competency($competency);
if ($record->exportid) {
$this->mappings[$record->exportid] = $comp;
}
$record->createdcomp = $comp;
foreach ($record->children as $child) {
$this->create_competency($child, $comp, $framework);
}
return $comp;
}
return false;
}
/**
* Recreate the scale config to point to a new scaleid.
* @param int $scaleid
* @param string $config json encoded scale data.
*/
public function get_scale_configuration($scaleid, $config) {
$asarray = json_decode($config);
$asarray[0]->scaleid = $scaleid;
return json_encode($asarray);
}
/**
* Search for a global scale that matches this set of scalevalues.
* If one is not found it will be created.
* @param array $scalevalues
* @param string $competencyname (Used to create a new scale if required)
* @return int The id of the scale
*/
public function get_scale_id($scalevalues, $competencyname) {
global $CFG, $USER;
require_once($CFG->libdir . '/gradelib.php');
if (empty($this->scalecache)) {
$allscales = grade_scale::fetch_all_global();
foreach ($allscales as $scale) {
$scale->load_items();
$this->scalecache[$scale->compact_items()] = $scale;
}
}
$matchingscale = false;
if (isset($this->scalecache[$scalevalues])) {
$matchingscale = $this->scalecache[$scalevalues];
}
if (!$matchingscale) {
// Create it.
$newscale = new grade_scale();
$newscale->name = get_string('competencyscale', 'tool_lpimportcsv', $competencyname);
$newscale->courseid = 0;
$newscale->userid = $USER->id;
$newscale->scale = $scalevalues;
$newscale->description = get_string('competencyscaledescription', 'tool_lpimportcsv');
$newscale->insert();
$this->scalecache[$scalevalues] = $newscale;
return $newscale->id;
}
return $matchingscale->id;
}
/**
* Walk through the idnumbers in the relatedidnumbers col and set the relations.
* @param stdClass $record
*/
protected function set_related($record) {
$comp = $record->createdcomp;
if ($record->relatedidnumbers) {
$allidnumbers = explode(',', $record->relatedidnumbers);
foreach ($allidnumbers as $rawidnumber) {
$idnumber = str_replace('%2C', ',', $rawidnumber);
if (isset($this->flat[$idnumber])) {
$relatedcomp = $this->flat[$idnumber]->createdcomp;
api::add_related_competency($comp->get('id'), $relatedcomp->get('id'));
}
}
}
foreach ($record->children as $child) {
$this->set_related($child);
}
}
/**
* Create any completion rule attached to this competency.
* @param stdClass $record
*/
protected function set_rules($record) {
$comp = $record->createdcomp;
if ($record->ruletype) {
$class = $record->ruletype;
if (class_exists($class)) {
$oldruleconfig = $record->ruleconfig;
if ($oldruleconfig == "null") {
$oldruleconfig = null;
}
$newruleconfig = $class::migrate_config($oldruleconfig, $this->mappings);
$comp->set('ruleconfig', $newruleconfig);
$comp->set('ruletype', $class);
$comp->set('ruleoutcome', $record->ruleoutcome);
$comp->update();
}
}
foreach ($record->children as $child) {
$this->set_rules($child);
}
}
/**
* Do the job.
* @return competency_framework
*/
public function import() {
$record = clone $this->framework;
unset($record->children);
$record->scaleid = $this->get_scale_id($record->scalevalues, $record->shortname);
$record->scaleconfiguration = $this->get_scale_configuration($record->scaleid, $record->scaleconfiguration);
unset($record->scalevalues);
$record->contextid = context_system::instance()->id;
$framework = api::create_framework($record);
if ($this->useprogressbar === true) {
$this->progress = new \core\progress\display_if_slow(get_string('importingfile', 'tool_lpimportcsv'));
} else {
$this->progress = new \core\progress\none();
}
$this->progress->start_progress('', (count($this->framework->children) * 2));
raise_memory_limit(MEMORY_EXTRA);
// Now all the children.
foreach ($this->framework->children as $comp) {
$this->progress->increment_progress();
$this->create_competency($comp, null, $framework);
}
// Now create the rules.
foreach ($this->framework->children as $record) {
$this->progress->increment_progress();
$this->set_rules($record);
$this->set_related($record);
}
$this->progress->end_progress();
$this->importer->cleanup();
return $framework;
}
}