moodle_local_treestudyplan/classes/studyplan.php
2024-05-10 15:22:52 +02:00

1184 lines
42 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;
use DateInterval;
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";
/** @var string */
const TABLE_COACH = "local_treestudyplan_coach";
/**
* 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;
}
/**
* True if studyplan is suspended
* @return string
*/
public function suspended() {
return boolval($this->r->suspended);
}
/**
* Determine earliest start date of a page
* @return \DateTime|null
*/
public function startdate() {
$date = null;
foreach($this->pages() as $p) {
if (!isset($date) || $p->startdate() < $date) {
$date = $p->startdate();
}
}
return $date;
}
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),
"suspended" => new \external_value(PARAM_BOOL, 'if studyplan is suspended',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,
'suspended' => boolval($this->r->suspended),
];
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),
"suspended" => new \external_value(PARAM_BOOL, 'if studyplan is suspended',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' => [],
'suspended' => boolval($this->r->suspended),
];
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,$bare);
$plan->page_cache = [$page];
}
return $plan;
}
/**
* Edit study line properties
* @param array $fields Changed properties for study line ['name', 'shortname', 'description', 'idnumber',
* 'context_id', 'aggregation', 'aggregation_config', 'suspended']
*/
public function edit($fields) : self {
global $DB;
$editable = [
'name',
'shortname',
'description',
'descriptionformat',
'idnumber',
'context_id',
'aggregation',
'aggregation_config',
'suspended',
'template'
];
$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. ANY 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 template studyplans in a given context or the system context
* @param int $contextid Optional contextid to search in. ANY context used if left empty
* @return studyplan[]
*/
public static function find_template($contextid = -1) : array {
global $DB, $USER;
$list = [];
$templatewhere = "template = 1";
if ($contextid <= 0) {
$ids = $DB->get_fieldset_select(self::TABLE, "id", $templatewhere);
} 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} AND {$templatewhere}", ["contextid" => $contextid]);
}
foreach ($ids as $id) {
$list[] = self::find_by_id($id);
}
return $list;
}
/**
* Count all template studyplans in a given context or the system context
* @param int $contextid Optional contextid to search in. ANY context used if left empty
* @return int
*/
public static function count_template($contextid = -1) : int {
global $DB, $USER;
$list = [];
$templatewhere = "template = 1";
if ($contextid <= 0) {
return $DB->count_records_select(self::TABLE, $templatewhere);
} else {
if ($contextid == 1) {
$contextid = 1;
$where = "context_id <= :contextid OR context_id IS NULL";
} else {
$where = "context_id = :contextid";
}
return $DB->count_records_select(self::TABLE, "{$where} AND {$templatewhere}", ["contextid" => $contextid]);
}
}
/**
* 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;
}
}
/** Check if this studyplan is linked to a particular user
* @param bool|stdClass|null $user The userid or user record of the user Leave empty to check current user.
*/
public function is_coach($user=null) {
global $DB, $USER
;
if ( ! (premium::enabled() && \get_config("local_treestudyplan","enablecoach")) ) {
// If coach role is not available, return false immediately.
return false;
}
if($user == null) {
$user = $USER;
$userid = $USER->id;
} else if (is_numeric($user)) {
$userid = intval($user);
} else {
$userid = $user->id;
}
$r = $DB->get_record(self::TABLE_COACH,["studyplan_id" => $this->id, "user_id"=> $userid]);
if ($r && has_capability(associationservice::CAP_COACH,$this->context(),$userid)) {
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,$ori->context()->id);
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, $contextid, $idnumber=null, $newstartdate = null) : self {
// First duplicate the studyplan structure.
$newplan = self::add([
'name' => $name,
'shortname' => $shortname,
'idnumber' => ($idnumber?$idnumber:$this->r->idnumber),
'context_id' => $contextid,
'description' => $this->r->description,
'descriptionformat' => $this->r->descriptionformat,
'aggregation' => $this->r->aggregation,
'aggregation_config' => $this->r->aggregation_config
],true);
// Copy any files related to this studyplan.
$areas = ["icon","studyplan"];
$fs = \get_file_storage();
foreach ($areas as $area) {
$files = $fs->get_area_files(
\context_system::instance()->id,
"local_treestudyplan",
$area,
$this->id()
);
foreach ($files as $file) {
$path = $file->get_filepath();
$filename = $file->get_filename();
if ($filename != ".") {
// Prepare new file info for the target file.
$fileinfo = [
'contextid' => \context_system::instance()->id, // System context.
'component' => 'local_treestudyplan', // Your component name.
'filearea' => $area, // Area name.
'itemid' => $newplan->id(), // Study plan id.
'filepath' => $path, // Original file path.
'filename' => $filename, // Original file name.
];
// Copy existing file into new file.
$fs->create_file_from_storedfile($fileinfo, $file);
debug::write("Copied {$area}::{$path}{$filename} from {$this->id} to {$newplan->id()}");
}
}
}
// Next, copy the studylines.
$timeless = \get_config("local_treestudyplan","timelessperiods");
if (!$timeless && $newstartdate) {
$newstart = new \DateTime(date("Y-m-d",$newstartdate));
$oldstart = $this->startdate();
$timeoffset = $oldstart->diff($newstart);
} else {
$timeoffset = new \DateInterval("P0D");
}
foreach ($this->pages() as $page) {
$newchild = $page->duplicate($newplan,$timeoffset);
}
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;
}
}