You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
638 lines
23 KiB
638 lines
23 KiB
<?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/>.
|
|
|
|
/**
|
|
* Processor.
|
|
*
|
|
* @package tool_lpmigrate
|
|
* @copyright 2016 Frédéric Massart - FMCorz.net
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
namespace tool_lpmigrate;
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
use coding_exception;
|
|
use moodle_exception;
|
|
use core_competency\api;
|
|
use core_competency\competency;
|
|
use core_competency\course_competency;
|
|
use core_competency\course_module_competency;
|
|
|
|
/**
|
|
* Processor class.
|
|
*
|
|
* @package tool_lpmigrate
|
|
* @copyright 2016 Frédéric Massart - FMCorz.net
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class framework_processor {
|
|
|
|
/** @var array Indexed as courseid => competencyids */
|
|
protected $coursescompetencies = array();
|
|
/** @var array Indexed as courseid => competencyid => ruleoutcome*/
|
|
protected $coursescompetenciesoutcomes = array();
|
|
/** @var array Indexed as courseid => cmid => competencyids */
|
|
protected $modulecompetencies = array();
|
|
/** @var array Indexed as courseid => cmid => competencyid => ruleoutcome*/
|
|
protected $modulecompetenciesoutcomes = array();
|
|
/** @var array The IDs of the objects of origin. */
|
|
protected $fromids = array();
|
|
/** @var array The mapping originId => destinationId. */
|
|
protected $mappings = array();
|
|
|
|
/** @var array Courses found. */
|
|
protected $coursesfound = array();
|
|
/** @var array Course modules found. */
|
|
protected $cmsfound = array();
|
|
/** @var integer Number of migrations expected in courses. */
|
|
protected $coursecompetencyexpectedmigrations = 0;
|
|
/** @var integer Count of migrations in the course level. */
|
|
protected $coursecompetencymigrations = 0;
|
|
/** @var integer Count of removals in the course level. */
|
|
protected $coursecompetencyremovals = 0;
|
|
/** @var integer Number of migrations expected in CMs. */
|
|
protected $modulecompetencyexpectedmigrations = 0;
|
|
/** @var integer Count of migrations in CMs. */
|
|
protected $modulecompetencymigrations = 0;
|
|
/** @var integer Count of removals in CMs. */
|
|
protected $modulecompetencyremovals = 0;
|
|
/** @var array IDs of objects missing a mapping in origin, originId => true. */
|
|
protected $missingmappings = array();
|
|
/** @var array List of errors. */
|
|
protected $errors = array();
|
|
/** @var array List of warnings. */
|
|
protected $warnings = array();
|
|
|
|
/** @var array List of course IDs that can be migrated. */
|
|
protected $allowedcourses = array();
|
|
/** @var int Minimum start date of courses that can be migrated. */
|
|
protected $coursestartdatefrom = 0;
|
|
/** @var array List of course IDs that cannot be migrated. */
|
|
protected $disallowedcourses = array();
|
|
/** @var bool Whether to remove the original competency when its destination was already there. */
|
|
protected $removeoriginalwhenalreadypresent = false;
|
|
/** @var bool Whether to remove the competency from course, or cm, when a mapping is not found. */
|
|
protected $removewhenmappingismissing = false;
|
|
|
|
/** @var boolean Has this processor run? */
|
|
protected $proceeded = false;
|
|
/** @var framework_mapper The mapper. */
|
|
protected $mapper;
|
|
/** @var \core\progress\base The progress. */
|
|
protected $progress;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param framework_mapper $mapper The mapper.
|
|
* @param \core\progress\base $progress The progress object.
|
|
*/
|
|
public function __construct(framework_mapper $mapper, \core\progress\base $progress = null) {
|
|
$this->mapper = $mapper;
|
|
|
|
if ($progress == null) {
|
|
$progress = new \core\progress\none();
|
|
}
|
|
$this->progress = $progress;
|
|
}
|
|
|
|
/**
|
|
* Process the mapping.
|
|
* @return void
|
|
*/
|
|
protected function process_mapping() {
|
|
$this->mappings = $this->mapper->get_mappings();
|
|
$this->fromids = $this->mapper->get_all_from();
|
|
}
|
|
|
|
/**
|
|
* Identifies what courses and their competencies to work with.
|
|
* @return void
|
|
*/
|
|
protected function find_coursescompetencies() {
|
|
global $DB;
|
|
$this->progress->start_progress(get_string('findingcoursecompetencies', 'tool_lpmigrate'), 3);
|
|
$this->progress->increment_progress();
|
|
|
|
$joins = array();
|
|
$conditions = array();
|
|
$params = array();
|
|
|
|
// Limit to mapped objects.
|
|
list($insql, $inparams) = $DB->get_in_or_equal($this->fromids, SQL_PARAMS_NAMED);
|
|
$conditions[] = "c.id $insql";
|
|
$params += $inparams;
|
|
|
|
// Restriction on course IDs.
|
|
if (!empty($this->allowedcourses)) {
|
|
list($insql, $inparams) = $DB->get_in_or_equal($this->allowedcourses, SQL_PARAMS_NAMED);
|
|
$conditions[] = "cc.courseid $insql";
|
|
$params += $inparams;
|
|
}
|
|
if (!empty($this->disallowedcourses)) {
|
|
list($insql, $inparams) = $DB->get_in_or_equal($this->disallowedcourses, SQL_PARAMS_NAMED, 'param', false);
|
|
$conditions[] = "cc.courseid $insql";
|
|
$params += $inparams;
|
|
}
|
|
|
|
// Restriction on start date.
|
|
if (!empty($this->coursestartdatefrom)) {
|
|
$joins[] = "JOIN {course} co
|
|
ON co.id = cc.courseid";
|
|
$conditions[] = "co.startdate >= :startdate";
|
|
$params += array('startdate' => $this->coursestartdatefrom);
|
|
}
|
|
|
|
// Find the courses.
|
|
$ccs = array();
|
|
$ccsoutcomes = array();
|
|
$joins = implode(' ', $joins);
|
|
$conditions = implode(' AND ', $conditions);
|
|
$sql = "SELECT cc.id, cc.courseid, cc.competencyid, cc.ruleoutcome
|
|
FROM {" . course_competency::TABLE . "} cc
|
|
JOIN {" . competency::TABLE . "} c
|
|
ON c.id = cc.competencyid
|
|
$joins
|
|
WHERE $conditions
|
|
ORDER BY cc.sortorder, cc.id";
|
|
|
|
$records = $DB->get_recordset_sql($sql, $params);
|
|
$this->progress->increment_progress();
|
|
|
|
foreach ($records as $record) {
|
|
if (!isset($ccs[$record->courseid])) {
|
|
$ccs[$record->courseid] = array();
|
|
$ccsoutcomes[$record->courseid] = array();
|
|
}
|
|
$ccs[$record->courseid][] = $record->competencyid;
|
|
$ccsoutcomes[$record->courseid][$record->competencyid] = $record->ruleoutcome;
|
|
}
|
|
$records->close();
|
|
|
|
$this->coursescompetencies = $ccs;
|
|
$this->coursescompetenciesoutcomes = $ccsoutcomes;
|
|
$this->coursesfound = $ccs;
|
|
|
|
$this->progress->increment_progress();
|
|
$this->progress->end_progress();
|
|
}
|
|
|
|
/**
|
|
* Identifies what course modules and their competencies to work with.
|
|
* @return void
|
|
*/
|
|
protected function find_modulecompetencies() {
|
|
global $DB;
|
|
if (empty($this->coursescompetencies)) {
|
|
return;
|
|
}
|
|
|
|
$this->progress->start_progress(get_string('findingmodulecompetencies', 'tool_lpmigrate'), 3);
|
|
$this->progress->increment_progress();
|
|
|
|
// Limit to mapped objects.
|
|
list($inidsql, $inidparams) = $DB->get_in_or_equal($this->fromids, SQL_PARAMS_NAMED);
|
|
|
|
// Limit to known courses.
|
|
list($incoursesql, $incourseparams) = $DB->get_in_or_equal(array_keys($this->coursescompetencies), SQL_PARAMS_NAMED);
|
|
$sql = "SELECT mc.id, cm.course AS courseid, mc.cmid, mc.competencyid, mc.ruleoutcome
|
|
FROM {" . course_module_competency::TABLE . "} mc
|
|
JOIN {course_modules} cm
|
|
ON cm.id = mc.cmid
|
|
AND cm.course $incoursesql
|
|
JOIN {" . competency::TABLE . "} c
|
|
ON c.id = mc.competencyid
|
|
WHERE c.id $inidsql
|
|
ORDER BY mc.sortorder, mc.id";
|
|
$params = $inidparams + $incourseparams;
|
|
|
|
$records = $DB->get_recordset_sql($sql, $params);
|
|
$this->progress->increment_progress();
|
|
$cmsfound = array();
|
|
|
|
$cmcs = array();
|
|
$cmcsoutcomes = array();
|
|
foreach ($records as $record) {
|
|
if (!isset($cmcs[$record->courseid])) {
|
|
$cmcs[$record->courseid] = array();
|
|
$cmcsoutcomes[$record->courseid] = array();
|
|
}
|
|
if (!isset($cmcs[$record->courseid][$record->cmid])) {
|
|
$cmcs[$record->courseid][$record->cmid] = array();
|
|
$cmcsoutcomes[$record->courseid][$record->cmid] = array();
|
|
}
|
|
$cmcs[$record->courseid][$record->cmid][] = $record->competencyid;
|
|
$cmcsoutcomes[$record->courseid][$record->cmid][$record->competencyid] = $record->ruleoutcome;
|
|
$cmsfound[$record->cmid] = true;
|
|
}
|
|
$records->close();
|
|
|
|
$this->modulecompetencies = $cmcs;
|
|
$this->modulecompetenciesoutcomes = $cmcsoutcomes;
|
|
$this->cmsfound = $cmsfound;
|
|
|
|
$this->progress->increment_progress();
|
|
$this->progress->end_progress();
|
|
}
|
|
|
|
/**
|
|
* Return a list of CMs found.
|
|
* @return int
|
|
*/
|
|
public function get_cms_found() {
|
|
return $this->cmsfound;
|
|
}
|
|
|
|
/**
|
|
* Return the number of CMs found.
|
|
* @return int
|
|
*/
|
|
public function get_cms_found_count() {
|
|
return count($this->cmsfound);
|
|
}
|
|
|
|
/**
|
|
* Return a list of courses found.
|
|
* @return int
|
|
*/
|
|
public function get_courses_found() {
|
|
return $this->coursesfound;
|
|
}
|
|
|
|
/**
|
|
* Return the number of courses found.
|
|
* @return int
|
|
*/
|
|
public function get_courses_found_count() {
|
|
return count($this->coursesfound);
|
|
}
|
|
|
|
/**
|
|
* Get the number of course migrations.
|
|
* @return int
|
|
*/
|
|
public function get_course_competency_migrations() {
|
|
return $this->coursecompetencymigrations;
|
|
}
|
|
|
|
/**
|
|
* Get the number of removals.
|
|
* @return int
|
|
*/
|
|
public function get_course_competency_removals() {
|
|
return $this->coursecompetencyremovals;
|
|
}
|
|
|
|
/**
|
|
* Get the number of expected course migrations.
|
|
* @return int
|
|
*/
|
|
public function get_expected_course_competency_migrations() {
|
|
return $this->coursecompetencyexpectedmigrations;
|
|
}
|
|
|
|
/**
|
|
* Get the number of expected course module migrations.
|
|
* @return int
|
|
*/
|
|
public function get_expected_module_competency_migrations() {
|
|
return $this->modulecompetencyexpectedmigrations;
|
|
}
|
|
|
|
/**
|
|
* Get the number of course module migrations.
|
|
* @return int
|
|
*/
|
|
public function get_module_competency_migrations() {
|
|
return $this->modulecompetencymigrations;
|
|
}
|
|
|
|
/**
|
|
* Get the number of removals.
|
|
* @return int
|
|
*/
|
|
public function get_module_competency_removals() {
|
|
return $this->modulecompetencyremovals;
|
|
}
|
|
|
|
/**
|
|
* Return a list of errors.
|
|
* @return array
|
|
*/
|
|
public function get_errors() {
|
|
return $this->errors;
|
|
}
|
|
|
|
/**
|
|
* Get the missing mappings.
|
|
* @return array Where keys are origin IDs.
|
|
*/
|
|
public function get_missing_mappings() {
|
|
if (!$this->has_run()) {
|
|
throw new coding_exception('The processor has not run yet.');
|
|
}
|
|
return $this->missingmappings;
|
|
}
|
|
|
|
/**
|
|
* Return a list of warnings.
|
|
* @return array
|
|
*/
|
|
public function get_warnings() {
|
|
return $this->warnings;
|
|
}
|
|
|
|
/**
|
|
* Whether the processor has run.
|
|
* @return boolean
|
|
*/
|
|
public function has_run() {
|
|
return $this->proceeded;
|
|
}
|
|
|
|
/**
|
|
* Log an error.
|
|
* @param int $courseid The course ID.
|
|
* @param int $competencyid The competency ID.
|
|
* @param int $cmid The CM ID.
|
|
* @param string $message The error message.
|
|
* @return void
|
|
*/
|
|
protected function log_error($courseid, $competencyid, $cmid, $message) {
|
|
$this->errors[] = array(
|
|
'courseid' => $courseid,
|
|
'competencyid' => $competencyid,
|
|
'cmid' => $cmid,
|
|
'message' => $message
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Log a warning.
|
|
* @param int $courseid The course ID.
|
|
* @param int $competencyid The competency ID.
|
|
* @param int $cmid The CM ID.
|
|
* @param string $message The warning message.
|
|
* @return void
|
|
*/
|
|
protected function log_warning($courseid, $competencyid, $cmid, $message) {
|
|
$this->warnings[] = array(
|
|
'courseid' => $courseid,
|
|
'competencyid' => $competencyid,
|
|
'cmid' => $cmid,
|
|
'message' => $message
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Execute the whole task.
|
|
* @return void
|
|
*/
|
|
public function proceed() {
|
|
if ($this->has_run()) {
|
|
throw new coding_exception('The processor has already run.');
|
|
} else if (!$this->mapper->has_mappings()) {
|
|
throw new coding_exception('Mapping was not set.');
|
|
}
|
|
|
|
$this->proceeded = true;
|
|
$this->process_mapping();
|
|
$this->find_coursescompetencies();
|
|
$this->find_modulecompetencies();
|
|
$this->process_courses();
|
|
}
|
|
|
|
/**
|
|
* Process each course individually.
|
|
* @return void
|
|
*/
|
|
protected function process_courses() {
|
|
global $DB;
|
|
$this->progress->start_progress(get_string('migratingcourses', 'tool_lpmigrate'), count($this->coursescompetencies));
|
|
|
|
// Process each course.
|
|
foreach ($this->coursescompetencies as $courseid => $competencyids) {
|
|
$this->progress->increment_progress();
|
|
|
|
$competenciestoremovefromcourse = array();
|
|
$skipcompetencies = array();
|
|
|
|
// First, add all the new competencies to the course.
|
|
foreach ($competencyids as $key => $competencyid) {
|
|
$this->coursecompetencyexpectedmigrations++;
|
|
$mapto = isset($this->mappings[$competencyid]) ? $this->mappings[$competencyid] : false;
|
|
|
|
// Skip the competencies that are not mapped.
|
|
if ($mapto === false) {
|
|
$this->missingmappings[$competencyid] = true;
|
|
|
|
if ($this->removewhenmappingismissing) {
|
|
$competenciestoremovefromcourse[$competencyid] = true;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
$transaction = $DB->start_delegated_transaction();
|
|
try {
|
|
// Add the new competency to the course.
|
|
if (api::add_competency_to_course($courseid, $mapto)) {
|
|
|
|
// Find the added course competency.
|
|
$cc = course_competency::get_record(array('courseid' => $courseid, 'competencyid' => $mapto));
|
|
|
|
// Set the rule.
|
|
api::set_course_competency_ruleoutcome($cc, $this->coursescompetenciesoutcomes[$courseid][$competencyid]);
|
|
|
|
// Adapt the sortorder.
|
|
api::reorder_course_competency($courseid, $mapto, $competencyid);
|
|
|
|
$competenciestoremovefromcourse[$competencyid] = true;
|
|
$this->coursecompetencymigrations++;
|
|
|
|
} else {
|
|
// The competency was already in the course...
|
|
if ($this->removeoriginalwhenalreadypresent) {
|
|
$competenciestoremovefromcourse[$competencyid] = true;
|
|
} else {
|
|
$this->log_warning($courseid, $competencyid, null,
|
|
get_string('warningdestinationcoursecompetencyalreadyexists', 'tool_lpmigrate'));
|
|
}
|
|
}
|
|
|
|
} catch (moodle_exception $e) {
|
|
// There was a major problem with this competency, we will ignore it entirely for the course.
|
|
$skipcompetencies[$competencyid] = true;
|
|
|
|
$this->log_error($courseid, $competencyid, null,
|
|
get_string('errorwhilemigratingcoursecompetencywithexception', 'tool_lpmigrate', $e->getMessage()));
|
|
|
|
try {
|
|
$transaction->rollback($e);
|
|
} catch (moodle_exception $e) {
|
|
// Catch the re-thrown exception.
|
|
}
|
|
|
|
continue;
|
|
}
|
|
$transaction->allow_commit();
|
|
}
|
|
|
|
// Then, convert the module competencies.
|
|
if (!empty($this->modulecompetencies[$courseid])) {
|
|
foreach ($this->modulecompetencies[$courseid] as $cmid => $competencyids) {
|
|
foreach ($competencyids as $competencyid) {
|
|
$this->modulecompetencyexpectedmigrations++;
|
|
|
|
// This mapped competency was not added to the course.
|
|
if (!empty($skipcompetencies[$competencyid])) {
|
|
continue;
|
|
}
|
|
|
|
$remove = true;
|
|
$mapto = isset($this->mappings[$competencyid]) ? $this->mappings[$competencyid] : false;
|
|
|
|
// We don't have mapping.
|
|
if ($mapto === false) {
|
|
if (!$this->removewhenmappingismissing) {
|
|
$remove = false;
|
|
}
|
|
|
|
} else {
|
|
// We have a mapping.
|
|
$transaction = $DB->start_delegated_transaction();
|
|
try {
|
|
// The competency was added successfully.
|
|
if (api::add_competency_to_course_module($cmid, $mapto)) {
|
|
|
|
// Find the added module competency.
|
|
$mc = course_module_competency::get_record(array('cmid' => $cmid, 'competencyid' => $mapto));
|
|
|
|
// Set the competency rule.
|
|
api::set_course_module_competency_ruleoutcome($mc,
|
|
$this->modulecompetenciesoutcomes[$courseid][$cmid][$competencyid]);
|
|
|
|
// Adapt the sortorder.
|
|
api::reorder_course_module_competency($cmid, $mapto, $competencyid);
|
|
|
|
$this->modulecompetencymigrations++;
|
|
|
|
} else {
|
|
// The competency was already in the module.
|
|
if (!$this->removeoriginalwhenalreadypresent) {
|
|
$remove = false;
|
|
$competencieswithissues[$competencyid] = true;
|
|
$this->log_warning($courseid, $competencyid, $cmid,
|
|
get_string('warningdestinationmodulecompetencyalreadyexists', 'tool_lpmigrate'));
|
|
}
|
|
}
|
|
|
|
} catch (moodle_exception $e) {
|
|
// There was a major problem with this competency in this module.
|
|
$competencieswithissues[$competencyid] = true;
|
|
$message = get_string('errorwhilemigratingmodulecompetencywithexception', 'tool_lpmigrate',
|
|
$e->getMessage());
|
|
$this->log_error($courseid, $competencyid, $cmid, $message);
|
|
|
|
try {
|
|
$transaction->rollback($e);
|
|
} catch (moodle_exception $e) {
|
|
// Catch the re-thrown exception.
|
|
}
|
|
|
|
continue;
|
|
}
|
|
$transaction->allow_commit();
|
|
}
|
|
|
|
try {
|
|
// Go away competency!
|
|
if ($remove && api::remove_competency_from_course_module($cmid, $competencyid)) {
|
|
$this->modulecompetencyremovals++;
|
|
}
|
|
} catch (moodle_exception $e) {
|
|
$competencieswithissues[$competencyid] = true;
|
|
$this->log_warning($courseid, $competencyid, $cmid,
|
|
get_string('warningcouldnotremovemodulecompetency', 'tool_lpmigrate'));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finally, we remove the course competencies, but only for the 100% successful ones.
|
|
foreach ($competenciestoremovefromcourse as $competencyid => $unused) {
|
|
|
|
// Skip competencies with issues.
|
|
if (isset($competencieswithissues[$competencyid])) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
// Process the course competency.
|
|
api::remove_competency_from_course($courseid, $competencyid);
|
|
$this->coursecompetencyremovals++;
|
|
} catch (moodle_exception $e) {
|
|
$this->log_warning($courseid, $competencyid, null,
|
|
get_string('warningcouldnotremovecoursecompetency', 'tool_lpmigrate'));
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->progress->end_progress();
|
|
}
|
|
|
|
/**
|
|
* Set the IDs of the courses that are allowed.
|
|
* @param array $courseids
|
|
*/
|
|
public function set_allowedcourses(array $courseids) {
|
|
$this->allowedcourses = $courseids;
|
|
}
|
|
|
|
/**
|
|
* Set the minimum start date for courses to be migrated.
|
|
* @param int $value Timestamp, or 0.
|
|
*/
|
|
public function set_course_start_date_from($value) {
|
|
$this->coursestartdatefrom = intval($value);
|
|
}
|
|
|
|
/**
|
|
* Set the IDs of the courses that are not allowed.
|
|
* @param array $courseids
|
|
*/
|
|
public function set_disallowedcourses(array $courseids) {
|
|
$this->disallowedcourses = $courseids;
|
|
}
|
|
|
|
/**
|
|
* Set whether we should remove original competencies when the destination competency was already there.
|
|
* @param bool $value
|
|
*/
|
|
public function set_remove_original_when_destination_already_present($value) {
|
|
$this->removeoriginalwhenalreadypresent = $value;
|
|
}
|
|
|
|
/**
|
|
* Set whether we should remove unmapped competencies.
|
|
* @param bool $value
|
|
*/
|
|
public function set_remove_when_mapping_is_missing($value) {
|
|
$this->removewhenmappingismissing = $value;
|
|
}
|
|
|
|
}
|
|
|