1024 lines
37 KiB
PHP
1024 lines
37 KiB
PHP
<?php
|
|
// This file is part of the Studyplan plugin for Moodle
|
|
//
|
|
// 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 <https://www.gnu.org/licenses/>.
|
|
/**
|
|
* Model class for study plan
|
|
* @package local_treestudyplan
|
|
* @copyright 2023 P.M. Kuipers
|
|
* @license https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
namespace local_treestudyplan;
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
require_once($CFG->libdir.'/externallib.php');
|
|
require_once($CFG->libdir.'/filelib.php');
|
|
/**
|
|
* Model class for study plan
|
|
*/
|
|
class studyplan {
|
|
|
|
/** @var string */
|
|
const TABLE = "local_treestudyplan";
|
|
|
|
/**
|
|
* Cache retrieved studyitems in this session
|
|
* @var array */
|
|
private static $cache = [];
|
|
|
|
/**
|
|
* Cache retrieved pages for the studyplan in this session
|
|
* @var array */
|
|
private static $pagecache = [];
|
|
|
|
/**
|
|
* Holds database record
|
|
* @var stdClass
|
|
*/
|
|
private $r;
|
|
/** @var int */
|
|
private $id;
|
|
/** @var aggregator */
|
|
private $aggregator;
|
|
|
|
/**
|
|
* Hold context object once retrieved.
|
|
* @var \context
|
|
*/
|
|
private $context = null;
|
|
/**
|
|
* Cache lookup of linked users (saves queries).
|
|
* @var int[]
|
|
*/
|
|
private $linkeduserids = null;
|
|
|
|
/**
|
|
* Return configured aggregator for this studyplan
|
|
*/
|
|
public function aggregator() : aggregator {
|
|
return $this->aggregator;
|
|
}
|
|
|
|
/**
|
|
* Find record in database and return management object
|
|
* Cache objects to avoid multiple creation events in one session.
|
|
* @param int $id Id of database record
|
|
*/
|
|
public static function find_by_id($id): self {
|
|
if (!array_key_exists($id, self::$cache)) {
|
|
self::$cache[$id] = new self($id);
|
|
}
|
|
return self::$cache[$id];
|
|
}
|
|
|
|
/**
|
|
* Construct new instance from DB record
|
|
* @param int $id Id of database record
|
|
*/
|
|
private function __construct($id) {
|
|
global $DB;
|
|
$this->id = $id;
|
|
$this->r = $DB->get_record(self::TABLE, ['id' => $id],"*",MUST_EXIST);
|
|
|
|
$this->aggregator = aggregator::create_or_default($this->r->aggregation, $this->r->aggregation_config);
|
|
}
|
|
|
|
/**
|
|
* Return database identifier
|
|
* @return int
|
|
*/
|
|
public function id() {
|
|
return $this->id;
|
|
}
|
|
|
|
/**
|
|
* Return short name
|
|
* @return string
|
|
*/
|
|
public function shortname() {
|
|
return $this->r->shortname;
|
|
}
|
|
|
|
/**
|
|
* Return full name
|
|
* @return string
|
|
*/
|
|
public function name() {
|
|
return $this->r->name;
|
|
}
|
|
|
|
private function icon() {
|
|
global $CFG;
|
|
$fs = \get_file_storage();
|
|
// Returns an array of `stored_file` instances.
|
|
$files = $fs->get_area_files(\context_system::instance()->id, 'local_treestudyplan', 'icon', $this->id);
|
|
|
|
if (count($files) > 0 ){
|
|
$file = array_shift($files);
|
|
if ($file->get_filename() == ".") {
|
|
// Get next file if the first is the directory itself.
|
|
$file = array_shift($files);
|
|
}
|
|
|
|
$url = \moodle_url::make_pluginfile_url(
|
|
$file->get_contextid(),
|
|
$file->get_component(),
|
|
$file->get_filearea(),
|
|
$file->get_itemid(),
|
|
$file->get_filepath(),
|
|
$file->get_filename(),
|
|
false // Do not force download of the file.
|
|
);
|
|
} else {
|
|
// Try the configured default in settings.
|
|
$defaulticon = get_config('local_treestudyplan', 'defaulticon');
|
|
if (empty($defaulticon)) {
|
|
// Fall back to the standard (ugly) default image.
|
|
$url = new \moodle_url($CFG->wwwroot . "/local/treestudyplan/pix/default_icon.png");
|
|
} else {
|
|
$url = \moodle_url::make_pluginfile_url(\context_system::instance()->id, 'local_treestudyplan', 'defaulticon', 0, "/",
|
|
$defaulticon);
|
|
}
|
|
|
|
}
|
|
return $url->out();
|
|
}
|
|
|
|
/**
|
|
* Return description with all file references resolved
|
|
*/
|
|
public function description() {
|
|
$text = \file_rewrite_pluginfile_urls(
|
|
// The content of the text stored in the database.
|
|
$this->r->description,
|
|
// The pluginfile URL which will serve the request.
|
|
'pluginfile.php',
|
|
|
|
// The combination of contextid / component / filearea / itemid
|
|
// form the virtual bucket that file are stored in.
|
|
\context_system::instance()->id, // System instance is always used for this
|
|
'local_treestudyplan',
|
|
'studyplan',
|
|
$this->id
|
|
);
|
|
return $text;
|
|
}
|
|
/**
|
|
* Return the studyplan pages associated with this plan
|
|
* @param bool $refresh Set to true to force a refresh of the pages
|
|
* @return studyplanpage[]
|
|
*/
|
|
public function pages($refresh=false) : array {
|
|
if ( ((bool)$refresh) || empty($this->pagecache)) {
|
|
$this->pagecache = studyplanpage::find_studyplan_children($this);
|
|
}
|
|
return $this->pagecache;
|
|
}
|
|
|
|
/**
|
|
* Return the context the studyplan is associated to
|
|
* @return \context
|
|
*/
|
|
public function context(): \context {
|
|
global $DB;
|
|
if (!isset($this->context)) {
|
|
try {
|
|
$this->context = contextinfo::context_by_id($this->r->context_id);
|
|
} catch (\dml_missing_record_exception $x) {
|
|
/* The associated context cannot be found.
|
|
Probably the category was removed, but the studyplan was not.
|
|
Revert the studyplan back to the system context to avoid lost studyplans.
|
|
Note that the daily cleanup task calls this function to make sure
|
|
studyplans without a valid context are not lost.
|
|
*/
|
|
$this->context = \context_system::instance();
|
|
$this->r->context_id = $this->context->id;
|
|
$DB->update_record(self::TABLE, $this->r);
|
|
}
|
|
}
|
|
return $this->context;
|
|
}
|
|
|
|
/**
|
|
* Webservice structure for basic info
|
|
* @param int $value Webservice requirement constant
|
|
*/
|
|
public static function simple_structure($value = VALUE_REQUIRED) : \external_description {
|
|
return new \external_single_structure([
|
|
"id" => new \external_value(PARAM_INT, 'id of studyplan'),
|
|
"userid" => new \external_value(PARAM_INT, 'id of user the plan is shown for',VALUE_OPTIONAL),
|
|
"name" => new \external_value(PARAM_TEXT, 'name of studyplan'),
|
|
"shortname" => new \external_value(PARAM_TEXT, 'shortname of studyplan'),
|
|
"idnumber" => new \external_value(PARAM_TEXT, 'idnumber of curriculum'),
|
|
"context_id" => new \external_value(PARAM_INT, 'context_id of studyplan'),
|
|
"description" => new \external_value(PARAM_RAW, 'description of studyplan'),
|
|
"descriptionformat" => new \external_value(PARAM_INT, 'description format'),
|
|
"icon" => new \external_value(PARAM_RAW,'icon for this plan'),
|
|
"aggregation" => new \external_value(PARAM_TEXT, 'selected aggregator'),
|
|
"aggregation_config" => new \external_value(PARAM_TEXT, 'config string for aggregator'),
|
|
"aggregation_info" => aggregator::basic_structure(),
|
|
"pages" => new \external_multiple_structure(studyplanpage::simple_structure(), 'pages'),
|
|
"progress" => new \external_value(PARAM_FLOAT,"fraction of completed modules",VALUE_OPTIONAL),
|
|
"amteaching" => new \external_value(PARAM_BOOL,"Current user is teaching one or more courses in this studyplan",VALUE_OPTIONAL),
|
|
], 'Basic studyplan info', $value);
|
|
}
|
|
|
|
/**
|
|
* Webservice model for basic info
|
|
* @return array Webservice data model
|
|
*/
|
|
public function simple_model($userid=null) {
|
|
global $USER;
|
|
$pages = [];
|
|
foreach ($this->pages() as $p) {
|
|
$pages[] = $p->simple_model();
|
|
}
|
|
|
|
$model = [
|
|
'id' => $this->r->id,
|
|
'name' => $this->r->name,
|
|
'shortname' => $this->r->shortname,
|
|
'idnumber' => $this->r->idnumber,
|
|
'context_id' => $this->context()->id,
|
|
'description' => $this->description(),
|
|
'descriptionformat' => $this->r->descriptionformat,
|
|
'icon' => $this->icon(),
|
|
'aggregation' => $this->r->aggregation,
|
|
'aggregation_config' => $this->aggregator->config_string(),
|
|
'aggregation_info' => $this->aggregator->basic_model(),
|
|
'pages' => $pages,
|
|
];
|
|
if(isset($userid)) {
|
|
$model["userid"] = $userid;
|
|
$model["progress"] = $this->scanuserprogress($userid);
|
|
$model['amteaching'] = teachingfinder::is_teaching_studyplan($this,$userid);
|
|
}
|
|
return $model;
|
|
}
|
|
|
|
/**
|
|
* Webservice structure for editor info
|
|
* @param int $value Webservice requirement constant
|
|
*/
|
|
public static function editor_structure($value = VALUE_REQUIRED) : \external_description {
|
|
return new \external_single_structure([
|
|
"id" => new \external_value(PARAM_INT, 'id of studyplan'),
|
|
"name" => new \external_value(PARAM_TEXT, 'name of studyplan'),
|
|
"shortname" => new \external_value(PARAM_TEXT, 'shortname of studyplan'),
|
|
"idnumber" => new \external_value(PARAM_TEXT, 'idnumber of curriculum'),
|
|
"description" => new \external_value(PARAM_RAW, 'description of studyplan'),
|
|
"descriptionformat" => new \external_value(PARAM_INT, 'description format'),
|
|
"icon" => new \external_value(PARAM_RAW,'icon for this plan'),
|
|
"context_id" => new \external_value(PARAM_INT, 'context_id of studyplan'),
|
|
"aggregation" => new \external_value(PARAM_TEXT, 'selected aggregator'),
|
|
"aggregation_config" => new \external_value(PARAM_TEXT, 'config string for aggregator'),
|
|
"aggregation_info" => aggregator::basic_structure(),
|
|
"pages" => new \external_multiple_structure(studyplanpage::editor_structure()),
|
|
"advanced" => new \external_single_structure([
|
|
"force_scales" => new \external_single_structure([
|
|
"scales" => new \external_multiple_structure(new \external_single_structure([
|
|
"id" => new \external_value(PARAM_INT, 'id of scale'),
|
|
"name" => new \external_value(PARAM_TEXT, 'name of scale'),
|
|
])),
|
|
], "Scale forcing on stuff", VALUE_OPTIONAL),
|
|
], "Advanced features available", VALUE_OPTIONAL),
|
|
], 'Studyplan full structure', $value);
|
|
}
|
|
|
|
/**
|
|
* Webservice model for editor info
|
|
* @return array Webservice data model
|
|
*/
|
|
public function editor_model() {
|
|
global $DB;
|
|
|
|
$model = [
|
|
'id' => $this->r->id,
|
|
'name' => $this->r->name,
|
|
'shortname' => $this->r->shortname,
|
|
'idnumber' => $this->r->idnumber,
|
|
'description' => $this->description(),
|
|
'descriptionformat' => $this->r->descriptionformat,
|
|
'icon' => $this->icon(),
|
|
'context_id' => $this->context()->id,
|
|
"aggregation" => $this->r->aggregation,
|
|
"aggregation_config" => $this->aggregator->config_string(),
|
|
'aggregation_info' => $this->aggregator->basic_model(),
|
|
'pages' => [],
|
|
];
|
|
|
|
foreach ($this->pages() as $p) {
|
|
$model['pages'][] = $p->editor_model();
|
|
}
|
|
|
|
if (has_capability('local/treestudyplan:forcescales', \context_system::instance())) {
|
|
|
|
if (!array_key_exists('advanced', $model)) {
|
|
// Create advanced node if it does not exist.
|
|
$model['advanced'] = [];
|
|
}
|
|
|
|
// Get a list of available scales.
|
|
$scales = array_map( function($scale) {
|
|
return [ "id" => $scale->id, "name" => $scale->name, ];
|
|
}, \grade_scale::fetch_all(['courseid' => 0]) );
|
|
|
|
$model['advanced']['force_scales'] = [
|
|
'scales' => $scales,
|
|
];
|
|
}
|
|
|
|
return $model;
|
|
}
|
|
|
|
/**
|
|
* Add a new studyplan
|
|
* @param array $fields Properties for study line ['name', 'shortname', 'description', 'idnumber', 'context_id', 'aggregation',
|
|
* 'aggregation_config', 'periods', 'startdate', 'enddate'];
|
|
* @param bool $bare If true, do not create a first page with copy of studyplan names
|
|
*/
|
|
public static function add($fields, $bare = false) : self {
|
|
global $CFG, $DB;
|
|
|
|
$addable = ['name', 'shortname', 'description', 'descriptionformat', 'idnumber', 'context_id', 'aggregation', 'aggregation_config'];
|
|
$info = ['enddate' => null ];
|
|
foreach ($addable as $f) {
|
|
if (array_key_exists($f, $fields)) {
|
|
$info[$f] = $fields[$f];
|
|
}
|
|
}
|
|
$id = $DB->insert_record(self::TABLE, $info);
|
|
$plan = self::find_by_id($id); // Make sure the new studyplan is immediately cached.
|
|
|
|
// Add a single page and initialize it with placeholder data
|
|
// This makes it easier to create a new study plan
|
|
// On import, adding an empty page messes things up , so we have an option to skip this....
|
|
if (!$bare) {
|
|
|
|
$pageaddable = ['name', 'shortname', 'description', 'descriptionformat', 'periods', 'startdate', 'enddate'];
|
|
$pageinfo = ['studyplan_id' => $id];
|
|
foreach ($pageaddable as $f) {
|
|
if (array_key_exists($f, $fields)) {
|
|
if ($f == "name") {
|
|
$pageinfo["fullname"] = $fields[$f];
|
|
} else {
|
|
$pageinfo[$f] = $fields[$f];
|
|
}
|
|
}
|
|
}
|
|
|
|
$page = studyplanpage::add($pageinfo);
|
|
$plan->page_cache = [$page];
|
|
}
|
|
// End temporary skräpp code.
|
|
|
|
return $plan;
|
|
}
|
|
|
|
/**
|
|
* Edit study line properties
|
|
* @param array $fields Changed roperties for study line ['name', 'shortname', 'description', 'idnumber',
|
|
* 'context_id', 'aggregation', 'aggregation_config']
|
|
*/
|
|
public function edit($fields) : self {
|
|
global $DB;
|
|
$editable = ['name', 'shortname', 'description', 'descriptionformat', 'idnumber', 'context_id', 'aggregation', 'aggregation_config'];
|
|
$info = ['id' => $this->id, ];
|
|
foreach ($editable as $f) {
|
|
if (array_key_exists($f, $fields)) {
|
|
$info[$f] = $fields[$f];
|
|
}
|
|
}
|
|
$DB->update_record(self::TABLE, $info);
|
|
// Reload record after edit.
|
|
$this->r = $DB->get_record(self::TABLE, ['id' => $this->id], "*", MUST_EXIST);
|
|
|
|
// Reload the context...
|
|
$this->context = null;
|
|
$this->context();
|
|
// Reload aggregator.
|
|
$this->aggregator = aggregator::create_or_default($this->r->aggregation, $this->r->aggregation_config);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Delete studyline
|
|
* @param bool $force Force deletion even if study line contains items
|
|
*/
|
|
public function delete($force = false) : success {
|
|
global $DB;
|
|
|
|
if ($force) {
|
|
$children = studyplanpage::find_studyplan_children($this);
|
|
foreach ($children as $c) {
|
|
$c->delete($force);
|
|
}
|
|
}
|
|
|
|
if ($DB->count_records('local_treestudyplan_page', ['studyplan_id' => $this->id]) > 0) {
|
|
return success::fail('cannot delete studyplan that still has pages');
|
|
} else {
|
|
$DB->delete_records('local_treestudyplan', ['id' => $this->id]);
|
|
return success::success();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find all studyplans in a given context or the system context
|
|
* @param int $contextid Optional contextid to search in. System context used if left empty
|
|
* @return studyplan[]
|
|
*/
|
|
public static function find_all($contextid = -1) : array {
|
|
global $DB, $USER;
|
|
$list = [];
|
|
|
|
if ($contextid <= 0) {
|
|
$ids = $DB->get_fieldset_select(self::TABLE, "id", "");
|
|
} else {
|
|
if ($contextid == 1) {
|
|
$contextid = 1;
|
|
$where = "context_id <= :contextid OR context_id IS NULL";
|
|
} else {
|
|
$where = "context_id = :contextid";
|
|
}
|
|
$ids = $DB->get_fieldset_select(self::TABLE, "id", $where, ["contextid" => $contextid]);
|
|
}
|
|
|
|
foreach ($ids as $id) {
|
|
$list[] = self::find_by_id($id);
|
|
}
|
|
return $list;
|
|
}
|
|
|
|
/**
|
|
* Find all studyplans in a given context or the system context with a specific short name
|
|
* (Used in generating random grades for development)
|
|
* @param string $shortname Shortname to match
|
|
* @param int $contextid Optional contextid to search in. System context used if left empty
|
|
* @return studyplan[]
|
|
*/
|
|
public static function find_by_shortname($shortname, $contextid = 0): array {
|
|
global $DB;
|
|
$list = [];
|
|
|
|
$where = "shortname = :shortname AND context_id = :contextid";
|
|
if ($contextid == 0) {
|
|
$where .= "OR context_id IS NULL";
|
|
}
|
|
$ids = $DB->get_fieldset_select(self::TABLE, "id", $where, ["shortname" => $shortname, "contextid" => $contextid]);
|
|
foreach ($ids as $id) {
|
|
$list[] = self::find_by_id($id);
|
|
}
|
|
return $list;
|
|
}
|
|
|
|
/**
|
|
* Find all studyplans for a given user
|
|
* @param int $userid Id of the user to search for
|
|
* @return studyplan[]
|
|
*/
|
|
public static function find_for_user($userid) : array {
|
|
global $DB;
|
|
|
|
$sql = "SELECT s.id FROM {local_treestudyplan} s
|
|
INNER JOIN {local_treestudyplan_cohort} j ON j.studyplan_id = s.id
|
|
INNER JOIN {cohort_members} cm ON j.cohort_id = cm.cohortid
|
|
WHERE cm.userid = :userid";
|
|
$cohortplanids = $DB->get_fieldset_sql($sql, ['userid' => $userid]);
|
|
|
|
$sql = "SELECT s.id FROM {local_treestudyplan} s
|
|
INNER JOIN {local_treestudyplan_user} j ON j.studyplan_id = s.id
|
|
WHERE j.user_id = :userid";
|
|
$userplanids = $DB->get_fieldset_sql($sql, ['userid' => $userid]);
|
|
|
|
$plans = [];
|
|
foreach ($cohortplanids as $id) {
|
|
$plans[$id] = self::find_by_id($id);
|
|
}
|
|
foreach ($userplanids as $id) {
|
|
if (!array_key_exists($id, $plans)) {
|
|
$plans[$id] = self::find_by_id($id);
|
|
}
|
|
}
|
|
|
|
return $plans;
|
|
|
|
}
|
|
|
|
/**
|
|
* Check if a given user has associated studyplans
|
|
* @param int $userid Id of the user to search for
|
|
*/
|
|
public static function exist_for_user($userid) : bool {
|
|
global $DB;
|
|
$count = 0;
|
|
$sql = "SELECT COUNT(s.id) FROM {local_treestudyplan} s
|
|
INNER JOIN {local_treestudyplan_cohort} j ON j.studyplan_id = s.id
|
|
INNER JOIN {cohort_members} cm ON j.cohort_id = cm.cohortid
|
|
WHERE cm.userid = :userid";
|
|
$count += $DB->count_records_sql($sql, ['userid' => $userid]);
|
|
|
|
$sql = "SELECT COUNT(s.id) FROM {local_treestudyplan} s
|
|
INNER JOIN {local_treestudyplan_user} j ON j.studyplan_id = s.id
|
|
WHERE j.user_id = :userid";
|
|
$count += $DB->count_records_sql($sql, ['userid' => $userid]);
|
|
|
|
return ($count > 0);
|
|
}
|
|
|
|
/**
|
|
* Retrieve the users linked to this studyplan.
|
|
* @return stdClass[] User objects
|
|
*/
|
|
public function find_linked_users() : array {
|
|
global $DB;
|
|
|
|
$users = [];
|
|
|
|
$uids = $this->find_linked_userids();
|
|
|
|
foreach ($uids as $uid) {
|
|
$users[] = $DB->get_record("user", ["id" => $uid]);
|
|
}
|
|
|
|
return $users;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the user id's of the users linked to this studyplan.
|
|
* @return array of int (User Id)
|
|
*/
|
|
public function find_linked_userids(): array {
|
|
global $DB;
|
|
|
|
if ($this->linkeduserids === null) {
|
|
$uids = [];
|
|
// First get directly linked userids.
|
|
$sql = "SELECT j.user_id FROM {local_treestudyplan_user} j
|
|
WHERE j.studyplan_id = :planid";
|
|
$ulist = $DB->get_fieldset_sql($sql, ['planid' => $this->id]);
|
|
|
|
$uids = array_merge($uids, $ulist);
|
|
foreach ($ulist as $uid) {
|
|
$users[] = $DB->get_record("user", ["id" => $uid]);
|
|
}
|
|
|
|
// Next het users linked though cohort.
|
|
$sql = "SELECT cm.userid FROM {local_treestudyplan_cohort} j
|
|
INNER JOIN {cohort_members} cm ON j.cohort_id = cm.cohortid
|
|
WHERE j.studyplan_id = :planid";
|
|
$ulist = $DB->get_fieldset_sql($sql, ['planid' => $this->id]);
|
|
|
|
$uids = array_merge($uids, $ulist);
|
|
|
|
$this->linkeduserids = array_unique($uids);
|
|
}
|
|
return $this->linkeduserids;
|
|
}
|
|
|
|
/** Check if this studyplan is linked to a particular user
|
|
* @param bool|stdClass $user The userid or user record of the user
|
|
*/
|
|
public function has_linked_user($user) {
|
|
if (is_int($user)) {
|
|
$userid = $user;
|
|
} else {
|
|
$userid = $user->id;
|
|
}
|
|
$uids = $this->find_linked_userids();
|
|
if (in_array($userid, $uids)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Webservice structure for userinfo
|
|
* @param int $value Webservice requirement constant
|
|
*/
|
|
public static function user_structure($value = VALUE_REQUIRED) : \external_description {
|
|
return new \external_single_structure([
|
|
"id" => new \external_value(PARAM_INT, 'id of studyplan'),
|
|
"userid" => new \external_value(PARAM_INT, 'id of user the plan is shown for'),
|
|
"name" => new \external_value(PARAM_TEXT, 'name of studyplan'),
|
|
"shortname" => new \external_value(PARAM_TEXT, 'shortname of studyplan'),
|
|
"description" => new \external_value(PARAM_RAW, 'description of studyplan'),
|
|
"descriptionformat" => new \external_value(PARAM_INT, 'description format'),
|
|
"icon" => new \external_value(PARAM_RAW,'icon for this plan'),
|
|
"progress" => new \external_value(PARAM_FLOAT,"fraction of completed modules"),
|
|
"idnumber" => new \external_value(PARAM_TEXT, 'idnumber of curriculum'),
|
|
"pages" => new \external_multiple_structure(studyplanpage::user_structure()),
|
|
"aggregation_info" => aggregator::basic_structure(),
|
|
], 'Studyplan with user info', $value);
|
|
|
|
}
|
|
|
|
/**
|
|
* Scan user progress (completed modules) over all pages for a specific user
|
|
* @param int $userid ID of user to check for
|
|
* @return float Fraction of completion
|
|
*/
|
|
private function scanuserprogress($userid) {
|
|
$progress = 0;
|
|
$pages = $this->pages();
|
|
foreach ($pages as $p) {
|
|
$prg = $p->scanuserprogress($userid);
|
|
$progress += $prg;
|
|
}
|
|
// Now average it out over the amount of pages
|
|
if (count($pages) > 0 ) {
|
|
return $progress / count($pages);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Webservice model for user info
|
|
* @param int $userid ID of user to check specific info for
|
|
* @return array Webservice data model
|
|
*/
|
|
public function user_model($userid) {
|
|
$progress = $this->scanuserprogress($userid);
|
|
if (is_nan($progress)) {
|
|
$progress = 0;
|
|
}
|
|
$model = [
|
|
'id' => $this->r->id,
|
|
'userid' => $userid,
|
|
'name' => $this->r->name,
|
|
'shortname' => $this->r->shortname,
|
|
'description' => $this->description(),
|
|
'descriptionformat' => $this->r->descriptionformat,
|
|
'icon' => $this->icon(),
|
|
'idnumber' => $this->r->idnumber,
|
|
'progress' => $progress,
|
|
'pages' => [],
|
|
'aggregation_info' => $this->aggregator->basic_model(),
|
|
];
|
|
|
|
foreach ($this->pages() as $p) {
|
|
$model['pages'][] = $p->user_model($userid);
|
|
}
|
|
return $model;
|
|
}
|
|
|
|
/**
|
|
* Duplicate a studyplan by id
|
|
* Function used by webservices and returns webservices model
|
|
* @param int $planid Id if studyplan
|
|
* @param string $name New fullname of studyplan
|
|
* @param string $shortname New shortname of studyplan
|
|
* @return array Simple webservices model of plan
|
|
*/
|
|
public static function duplicate_plan($planid, $name, $shortname) : array {
|
|
$ori = self::find_by_id($planid);
|
|
$new = $ori->duplicate($name, $shortname);
|
|
return $new->simple_model();
|
|
}
|
|
|
|
/**
|
|
* Duplicate this studyplan
|
|
* @param string $name New fullname of studyplan
|
|
* @param string $shortname New shortname of studyplan
|
|
*/
|
|
public function duplicate($name, $shortname) : self {
|
|
// First duplicate the studyplan structure.
|
|
$newplan = self::add([
|
|
'name' => $name,
|
|
'shortname' => $shortname,
|
|
'description' => $this->r->description,
|
|
'descriptionformat' => $this->r->descriptionformat,
|
|
'aggregation' => $this->r->aggregation,
|
|
'aggregation_config' => $this->r->aggregation_config
|
|
]);
|
|
|
|
//TODO: Copy any files related to this userid....
|
|
|
|
// Next, copy the studylines.
|
|
|
|
foreach ($this->pages() as $p) {
|
|
$newchild = $p->duplicate($newplan);
|
|
}
|
|
|
|
return $newplan;
|
|
}
|
|
|
|
/**
|
|
* Description of export structure for webservices
|
|
*/
|
|
public static function export_structure() : \external_description {
|
|
return new \external_single_structure([
|
|
"format" => new \external_value(PARAM_TEXT, 'format of studyplan export'),
|
|
"content" => new \external_value(PARAM_RAW, 'exported studyplan content'),
|
|
], 'Exported studyplan');
|
|
}
|
|
|
|
/**
|
|
* Export this page into a json model
|
|
* @return array
|
|
*/
|
|
public function export_plan() {
|
|
$model = $this->export_model();
|
|
$json = json_encode([
|
|
"type" => "studyplan",
|
|
"version" => 2.0,
|
|
"studyplan" => $model
|
|
], \JSON_PRETTY_PRINT);
|
|
return [ "format" => "application/json", "content" => $json];
|
|
}
|
|
|
|
/**
|
|
* Export essential information for export
|
|
* @return array information model
|
|
*/
|
|
public function export_model() {
|
|
$exportfiles = $this->export_files('studyplan');
|
|
$iconfiles = $this->export_files('icon');
|
|
$model = [
|
|
'name' => $this->r->name,
|
|
'shortname' => $this->r->shortname,
|
|
'description' => $this->r->description,
|
|
'descriptionformat' => $this->r->descriptionformat,
|
|
"aggregation" => $this->r->aggregation,
|
|
"aggregation_config" => json_decode($this->aggregator->config_string()),
|
|
'aggregation_info' => $this->aggregator->basic_model(),
|
|
'pages' => $this->export_pages_model(),
|
|
'files' => $exportfiles,
|
|
'iconfiles' => $iconfiles,
|
|
];
|
|
return $model;
|
|
}
|
|
|
|
|
|
/**
|
|
* Export files from file storage
|
|
* @param string $area Name of the file area to export
|
|
* @return array information model
|
|
*/
|
|
public function export_files($area) {
|
|
$exportfiles = [];
|
|
$fs = get_file_storage();
|
|
$files = $fs->get_area_files(
|
|
\context_system::instance()->id,
|
|
'local_treestudyplan',
|
|
$area,
|
|
$this->id);
|
|
foreach ($files as $file) {
|
|
if ($file->get_filename() != ".") {
|
|
$contents = $file->get_content();
|
|
$exportfiles[] = [
|
|
"name" => $file->get_filename(),
|
|
"path" => $file->get_filepath(),
|
|
"content" => convert_uuencode($contents),
|
|
];
|
|
}
|
|
}
|
|
return $exportfiles;
|
|
}
|
|
|
|
/**
|
|
* Import previously exported files into the file storage
|
|
* @param string $area Name of the file area to import
|
|
* @param mixed $importfiles List of files to import from string in the format exported in export_model()
|
|
*
|
|
*/
|
|
public function import_files($importfiles,$area) {
|
|
$fs = get_file_storage();
|
|
foreach($importfiles as $file) {
|
|
if ($file['name'] != ".") {
|
|
$fileinfo = [
|
|
'contextid' =>\context_system::instance()->id, // ID of the system context.
|
|
'component' => 'local_treestudyplan', // Your component name.
|
|
'filearea' => $area, // Usually = table name.
|
|
'itemid' => $this->id, // ID of the studyplanpage.
|
|
'filepath' => $file["path"], // Path of the file.
|
|
'filename' => $file["name"], // Name of the file..
|
|
];
|
|
|
|
$fs->create_file_from_string($fileinfo, convert_uudecode($file["content"]));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Export all pages
|
|
* @return array information model
|
|
*/
|
|
public function export_pages_model() {
|
|
$pages = [];
|
|
foreach ($this->pages() as $p) {
|
|
$pages[] = $p->export_model();
|
|
}
|
|
return $pages;
|
|
}
|
|
|
|
/**
|
|
* Import studyplan from file contents
|
|
* @param string $content String
|
|
* @param string $format Format description
|
|
* @param int $contextid The context to import into
|
|
*/
|
|
public static function import_studyplan($content, $format = "application/json", $contextid = 1) {
|
|
if ($format != "application/json") {
|
|
return false;
|
|
}
|
|
|
|
$content = json_decode($content, true);
|
|
if ($content["type"] == "studyplan" && $content["version"] >= 2.0) {
|
|
|
|
$planmodel = $content["studyplan"];
|
|
// Make sure the aggregation_config is re-encoded as json text.
|
|
$planmodel["aggregation_config"] = json_encode( $planmodel["aggregation_config"]);
|
|
|
|
// And make sure the context_id is set to the provided context for import.
|
|
$planmodel["context_id"] = $contextid;
|
|
|
|
// Create a new plan, based on the given parameters - this is the import studyplan part.
|
|
$plan = self::add( $planmodel, true);
|
|
|
|
// Import the files
|
|
if (isset( $planmodel['files']) && is_array( $planmodel['files'])) {
|
|
$plan->import_files( $planmodel['files'],"studyplan");
|
|
}
|
|
// Import the icon
|
|
if (isset( $planmodel['iconfiles']) && is_array( $planmodel['iconfiles'])) {
|
|
$plan->import_files( $planmodel['iconfiles'],"icon");
|
|
}
|
|
|
|
// Now import each page.
|
|
return $plan->import_pages_model($planmodel["pages"]);
|
|
|
|
} else {
|
|
debugging("Invalid format and type: {$content['type']} version {$content['version']}");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import studyplan pages from file contents
|
|
* @param string $content String
|
|
* @param string $format Format description
|
|
*/
|
|
public function import_pages($content, $format = "application/json") {
|
|
if ($format != "application/json") {
|
|
return false;
|
|
}
|
|
$content = json_decode($content, true);
|
|
if ($content["version"] >= 2.0) {
|
|
if ($content["type"] == "studyplanpage") {
|
|
// Import single page from a studyplanpage (wrapped in array of one page).
|
|
return $this->import_pages_model([$content["page"]]);
|
|
} else if ($content["type"] == "studyplan") {
|
|
// Import all pages from the studyplan.
|
|
return $this->import_pages_model($content["studyplan"]["pages"]);
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Import pages from decoded array model
|
|
* @param array $model Decoded array
|
|
*/
|
|
protected function import_pages_model($model) : bool {
|
|
$this->pages(); // Make sure the page cache is initialized, since we will be adding to it.
|
|
foreach ($model as $p) {
|
|
$p["studyplan_id"] = $this->id();
|
|
$page = studyplanpage::add($p);
|
|
$this->page_cache[] = $page;
|
|
$page->import_periods_model($p["perioddesc"]);
|
|
$page->import_studylines_model($p["studylines"]);
|
|
if ($p['files']) {
|
|
$page->import_files($p["files"],'studyplanpage');
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Mark the studyplan as changed regarding courses and associated cohorts
|
|
*/
|
|
public function mark_csync_changed() {
|
|
global $DB;
|
|
$DB->update_record(self::TABLE, ['id' => $this->id, "csync_flag" => 1]);
|
|
// Manually set it in the cache, if something unexpected happened, an exception has already been thrown anyway.
|
|
$this->r->csync_flag = 1;
|
|
}
|
|
|
|
/**
|
|
* Clear the studyplan as changed regarding courses and associated cohorts
|
|
*/
|
|
public function clear_csync_changed() {
|
|
global $DB;
|
|
$DB->update_record(self::TABLE, ['id' => $this->id, "csync_flag" => 0]);
|
|
// Manually set it in the cache, if something unexpected happened, an exception has already been thrown anyway.
|
|
$this->r->csync_flag = 0;
|
|
}
|
|
|
|
/**
|
|
* Check if the studyplan as changed regarding courses and associated cohorts
|
|
*/
|
|
public function has_csync_changed() : bool {
|
|
return ($this->r->csync_flag > 0) ? true : false;
|
|
}
|
|
|
|
/**
|
|
* See if the specified course id is linked in this studyplan
|
|
* @param int $courseid Id of course to check
|
|
*/
|
|
public function course_linked($courseid) : bool {
|
|
global $DB;
|
|
|
|
$sql = "SELECT COUNT(i.id)
|
|
FROM {local_treestudyplan}
|
|
INNER JOIN {local_treestudyplan_line} l ON p.id = l.studyplan_id
|
|
{local_treestudyplan_item} i ON l.id = i.line_id
|
|
WHERE p.id = :planid
|
|
AND i.course_id = :courseid";
|
|
$count = $DB->get_field_sql($sql, ["courseid" => $courseid, "planid" => $this->id]);
|
|
|
|
return ($count > 0) ? true : false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get all study lines linked to this plan (quickly)
|
|
* Used for cohort enrolment cascading
|
|
* @return studyline[]
|
|
*/
|
|
public function get_all_studylines() : array {
|
|
global $DB;
|
|
|
|
$sql = "SELECT l.id
|
|
FROM {local_treestudyplan} p
|
|
INNER JOIN {local_treestudyplan_page} pg ON p.id = pg.studyplan_id
|
|
INNER JOIN {local_treestudyplan_line} l ON pg.id = l.page_id
|
|
WHERE p.id = :studyplan_id";
|
|
$fields = $DB->get_fieldset_sql($sql, ["studyplan_id" => $this->id]);
|
|
|
|
$list = [];
|
|
foreach($fields as $id) {
|
|
$list[] = studyline::find_by_id($id);
|
|
}
|
|
return $list;
|
|
}
|
|
|
|
/**
|
|
* List the cohort id's associated with this studyplan
|
|
*/
|
|
public function get_linked_cohort_ids() {
|
|
global $CFG, $DB;
|
|
|
|
$sql = "SELECT DISTINCT j.cohort_id FROM {local_treestudyplan_cohort} j
|
|
WHERE j.studyplan_id = :studyplan_id";
|
|
$fields = $DB->get_fieldset_sql($sql, ['studyplan_id' => $this->id]);
|
|
return $fields;
|
|
}
|
|
|
|
/**
|
|
* List the user id's explicitly associated with this studyplan
|
|
* @return int[]
|
|
*/
|
|
public function get_linked_user_ids() : array {
|
|
global $CFG, $DB;
|
|
|
|
$sql = "SELECT DISTINCT j.user_id FROM {local_treestudyplan_user} j
|
|
WHERE j.studyplan_id = :studyplan_id";
|
|
$fields = $DB->get_fieldset_sql($sql, ['studyplan_id' => $this->id]);
|
|
return $fields;
|
|
}
|
|
/**
|
|
* See if the specified badge is linked in this studyplan
|
|
* @param int $badgeid Badge id
|
|
*/
|
|
public function badge_linked($badgeid) : bool {
|
|
global $DB;
|
|
|
|
$sql = "SELECT COUNT(i.id)
|
|
FROM {local_treestudyplan}
|
|
INNER JOIN {local_treestudyplan_line} l ON p.id = l.studyplan_id
|
|
INNER JOIN {local_treestudyplan_item} i ON l.id = i.line_id
|
|
WHERE p.id = :planid
|
|
AND i.badge_id = :badgeid";
|
|
$count = $DB->get_field_sql($sql, ["badgeid" => $badgeid, "planid" => $this->id]);
|
|
|
|
return ($count > 0) ? true : false;
|
|
}
|
|
}
|