moodle_local_treestudyplan/classes/studyline.php
2023-08-27 22:20:17 +02:00

434 lines
15 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/>.
/**
*
* @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');
class studyline {
public const SLOTSET_COMPETENCY = 'competencies';
public const SLOTSET_FILTER = 'filters';
public const COMPETENCY_TYPES = [
studyitem::COMPETENCY,
studyitem::COURSE,
];
public const FILTER_TYPES = [
studyitem::JUNCTION,
studyitem::BADGE,
studyitem::FINISH,
studyitem::START,
];
public const FILTER0_TYPES = [
studyitem::START,
];
public const TABLE = "local_treestudyplan_line";
private static $studylinecache = [];
/**
* Holds database record
* @var stdClass
*/
private $r; // Holds database record.
/** @var int */
private $id;
/** @var studyplanpage */
private $page;
/** @var studyplan*/
private $studyplan;
/**
* Return the context the studyplan is associated to
* @return \context
*/
public function context(): \context {
return $this->studyplan->context();
}
public function studyplan() : studyplan {
return $this->studyplan;
}
public function page() : studyplanpage {
return $this->page;
}
public static function find_by_id($id): self {
if (!array_key_exists($id, self::$studylinecache)) {
self::$studylinecache[$id] = new self($id);
}
return self::$studylinecache[$id];
}
private function __construct($id) {
global $DB;
$this->id = $id;
$this->r = $DB->get_record(self::TABLE, ['id' => $id]);
$this->page = studyplanpage::find_by_id($this->r->page_id);
$this->studyplan = $this->page->studyplan();
}
/**
* Return database identifier
* @return int
*/
public function id() {
return $this->id;
}
/**
* Return full name
* @return string
*/
public function name() {
return $this->r->name;
}
public function shortname() {
return $this->r->shortname;
}
/**
* Webservice structure for editor info
* @param int $value Webservice requirement constant
* @return \external_single_structure Webservice output structure
*/
public static function editor_structure($value = VALUE_REQUIRED) {
return new \external_single_structure([
"id" => new \external_value(PARAM_INT, 'id of studyline'),
"name" => new \external_value(PARAM_TEXT, 'shortname of studyline'),
"shortname" => new \external_value(PARAM_TEXT, 'idnumber of studyline'),
"color" => new \external_value(PARAM_TEXT, 'description of studyline'),
"sequence" => new \external_value(PARAM_INT, 'order of studyline'),
"slots" => new \external_multiple_structure(
new \external_single_structure([
self::SLOTSET_COMPETENCY => new \external_multiple_structure(
studyitem::editor_structure(), 'competency items', VALUE_OPTIONAL),
self::SLOTSET_FILTER => new \external_multiple_structure(
studyitem::editor_structure(), 'filter items'),
])
)
]);
}
/**
* Webservice model for editor info
* @return array Webservice data model
*/
public function editor_model() {
return $this->generate_model("editor");
}
protected function generate_model($mode) {
// Mode parameter is used to geep this function for both editor model and export model.
// (Export model results in fewer parameters on children, but is otherwise basically the same as this function).
global $DB;
$model = [
'id' => $this->r->id,
'name' => $this->r->name,
'shortname' => $this->r->shortname,
'color' => $this->r->color,
'sequence' => $this->r->sequence,
'slots' => [],
];
if ($mode == "export") {
// Id and sequence are not used in export model.
unset($model["id"]);
unset($model["sequence"]);
}
// TODO: Make this a little nicer.
// Get the number of slots.
// As a safety data integrity measure, if there are any items in a higher slot than currently allowed, .
// Make sure there are enought slots to account for them.
// Alternatively, we could ensure that on reduction of slots, the items that no longer have a slot will be removed.
$maxslot = $DB->get_field_select(studyitem::TABLE, "MAX(slot)", "line_id = :lineid", ['lineid' => $this->id]);
$numslots = max($this->page->periods(), $maxslot + 1);
// Create the required amount of slots.
for ($i = 0; $i < $numslots + 1; $i++) {
if ($mode == "export") {
// Export mode does not separate between filter or competency type, since that is determined automatically.
$slots = [];
} else {
if ($i > 0) {
$slots = [self::SLOTSET_COMPETENCY => [], self::SLOTSET_FILTER => []];
} else {
$slots = [self::SLOTSET_FILTER => []];
}
}
$model['slots'][$i] = $slots;
}
$children = studyitem::find_studyline_children($this);
foreach ($children as $c) {
if ($mode == "export") {
$model['slots'][$c->slot()][] = $c->export_model();
} else {
$slotset = null;
if ($c->slot() > 0) {
if (in_array($c->type(), self::COMPETENCY_TYPES)) {
$slotset = self::SLOTSET_COMPETENCY;
} else if (in_array($c->type(), self::FILTER_TYPES)) {
$slotset = self::SLOTSET_FILTER;
}
} else if (in_array($c->type(), self::FILTER0_TYPES)) {
$slotset = self::SLOTSET_FILTER;
}
if (isset($slotset)) {
$model['slots'][$c->slot()][$slotset][] = $c->editor_model();
}
}
}
return $model;
}
public static function add($fields) {
global $DB;
if (!isset($fields['page_id'])) {
throw new \InvalidArgumentException("parameter 'page_id' missing");
}
$pageid = $fields['page_id'];
$sqmax = $DB->get_field_select(self::TABLE, "MAX(sequence)", "page_id = :page_id", ['page_id' => $pageid]);
$addable = ['page_id', 'name', 'shortname', 'color'];
$info = ['sequence' => $sqmax + 1];
foreach ($addable as $f) {
if (array_key_exists($f, $fields)) {
$info[$f] = $fields[$f];
}
}
$id = $DB->insert_record(self::TABLE, $info);
return self::find_by_id($id);
}
public function edit($fields) {
global $DB;
$editable = ['name', 'shortname', 'color'];
$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);
return $this;
}
public function delete($force = false) {
global $DB;
if ($force) {
$children = studyitem::find_studyline_children($this);
foreach ($children as $c) {
$c->delete($force);
}
}
// Check if this item has study items in it.
if ($DB->count_records(studyitem::TABLE, ['line_id' => $this->id]) > 0) {
return success::fail('cannot delete studyline with items');
} else {
$DB->delete_records(self::TABLE, ['id' => $this->id]);
return success::success();
}
}
public static function reorder($resequence) {
global $DB;
foreach ($resequence as $sq) {
$DB->update_record(self::TABLE, [
'id' => $sq['id'],
'sequence' => $sq['sequence'],
]);
}
return success::success();
}
public static function find_page_children(studyplanpage $page) {
global $DB;
$list = [];
$ids = $DB->get_fieldset_select(self::TABLE, "id", "page_id = :page_id ORDER BY sequence",
['page_id' => $page->id()]);
foreach ($ids as $id) {
$list[] = self::find_by_id($id);
}
return $list;
}
/**
* Webservice structure for userinfo
* @param int $value Webservice requirement constant
* @return \external_single_structure Webservice output structure
*/
public static function user_structure($value = VALUE_REQUIRED) {
return new \external_single_structure([
"id" => new \external_value(PARAM_INT, 'id of studyline'),
"name" => new \external_value(PARAM_TEXT, 'shortname of studyline'),
"shortname" => new \external_value(PARAM_TEXT, 'idnumber of studyline'),
"color" => new \external_value(PARAM_TEXT, 'description of studyline'),
"sequence" => new \external_value(PARAM_INT, 'order of studyline'),
"slots" => new \external_multiple_structure(
new \external_single_structure([
self::SLOTSET_COMPETENCY => new \external_multiple_structure(
studyitem::user_structure(), 'competency items', VALUE_OPTIONAL),
self::SLOTSET_FILTER => new \external_multiple_structure(
studyitem::user_structure(), 'filter items'),
])
)
], 'Studyline with user info', $value);
}
/**
* 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) {
// TODO: Integrate this function into generate_model() for ease of maintenance.
global $DB;
$model = [
'id' => $this->r->id,
'name' => $this->r->name,
'shortname' => $this->r->shortname,
'color' => $this->r->color,
'sequence' => $this->r->sequence,
'slots' => [],
];
// Get the number of slots.
// As a safety data integrity measure, if there are any items in a higher slot than currently allowed, .
// Make sure there are enought slots to account for them.
// Alternatively, we could ensure that on reduction of slots, the items that no longer have a slot will be removed.
$maxslot = $DB->get_field_select(studyitem::TABLE, "MAX(slot)", "line_id = :lineid", ['lineid' => $this->id]);
$numslots = max($this->page->periods(), $maxslot + 1);
// Create the required amount of slots.
for ($i = 0; $i < $numslots + 1; $i++) {
if ($i > 0) {
$slots = [self::SLOTSET_COMPETENCY => [], self::SLOTSET_FILTER => []];
} else {
$slots = [self::SLOTSET_FILTER => []];
}
$model['slots'][$i] = $slots;
}
$children = studyitem::find_studyline_children($this);
foreach ($children as $c) {
if ($c->valid()) {
$slotset = null;
if ($c->slot() > 0) {
if (in_array($c->type(), self::COMPETENCY_TYPES)) {
$slotset = self::SLOTSET_COMPETENCY;
} else if (in_array($c->type(), self::FILTER_TYPES)) {
$slotset = self::SLOTSET_FILTER;
}
} else if (in_array($c->type(), self::FILTER0_TYPES)) {
$slotset = self::SLOTSET_FILTER;
}
if (isset($slotset)) {
$model['slots'][$c->slot()][$slotset][] = $c->user_model($userid);
}
}
}
return $model;
}
public function duplicate($newstudyplan, &$translation) {
global $DB;
// Clone the database fields.
$fields = clone $this->r;
// Set new studyplan id.
unset($fields->id);
$fields->studyplan_id = $newstudyplan->id();
// Create new record with the new data.
$id = $DB->insert_record(self::TABLE, (array)$fields);
$new = self::find_by_id($id);
// Next copy all the study items for this studyline.
// And record the original and copy id's in the $translation array.
// So the calling function can connect the new studyitems as required.
$children = studyitem::find_studyline_children($this);
$translation = [];
foreach ($children as $c) {
$newchild = $c->duplicate($new);
$translation[$c->id()] = $newchild->id();
}
return $new;
}
/**
* Export essential information for export
* @return array information model
*/
public function export_model() {
return $this->generate_model("export");
}
public function import_studyitems($model, &$itemtranslation, &$connections) {
global $DB;
foreach ($model as $slot => $slotmodel) {
$courselayer = 0;
$filterlayer = 0;
foreach ($slotmodel as $itemmodel) {
if ($itemmodel["type"] == "course") {
$itemmodel["layer"] = $courselayer;
$courselayer++;
} else {
$itemmodel["layer"] = $filterlayer;
$filterlayer++;
}
$itemmodel["slot"] = $slot;
$itemmodel["line_id"] = $this->id();
$item = studyitem::import_item($itemmodel);
if (!empty($item)) {
$itemtranslation[$itemmodel["id"]] = $item->id();
if (count($itemmodel["connections"]) > 0) {
if (! isset($connections[$item->id()]) || ! is_array($connections[$item->id()])) {
$connections[$item->id()] = [];
}
foreach ($itemmodel["connections"] as $toid) {
$connections[$item->id()][] = $toid;
}
}
}
}
}
}
}