228 lines
8.0 KiB
PHP
228 lines
8.0 KiB
PHP
<?php
|
|
namespace local_treestudyplan;
|
|
|
|
require_once($CFG->libdir.'/externallib.php');
|
|
|
|
class period {
|
|
const TABLE = "local_treestudyplan_period";
|
|
private static $CACHE = [];
|
|
private static $PAGECACHE = [];
|
|
|
|
|
|
private $r; // Holds database record
|
|
private $id;
|
|
private $page;
|
|
|
|
public function aggregator(){
|
|
return $this->studyplan->aggregator();
|
|
}
|
|
|
|
// Cache constructors to avoid multiple creation events in one session.
|
|
public static function findById($id): self {
|
|
if(!array_key_exists($id,self::$CACHE)){
|
|
self::$CACHE[$id] = new self($id);
|
|
}
|
|
return self::$CACHE[$id];
|
|
}
|
|
|
|
/**
|
|
* Find a period by page and period number [1..$page->periods()]
|
|
*/
|
|
public static function find(studyplanpage $page,$periodnr): self{
|
|
global $DB;
|
|
if($periodnr < 1){
|
|
// Clamp period index
|
|
$periodnr = 1;
|
|
}
|
|
try{
|
|
$id = $DB->get_field(self::TABLE,"id",["page_id"=>$page->id(), "period" => $periodnr],MUST_EXIST);
|
|
$period = self::findById($id);
|
|
} catch(\dml_missing_record_exception $x){
|
|
// Period does not exist - create one ...
|
|
// Make a best guess estimate of the start and end date, based on surrounding periods,
|
|
// or specified duration of the page and the sequence of the periods
|
|
$pcount = $page->periods();
|
|
$ystart = $page->startdate()->getTimestamp();
|
|
$yend = $page->enddate()->getTimestamp();
|
|
|
|
// Estimate the period's timing to make a reasonable first guess
|
|
$ydelta = $yend - $ystart;
|
|
$ptime = $ydelta / $pcount;
|
|
|
|
try{
|
|
// Check if we have a previous period to glance the end date of as a reference
|
|
$startdate = $DB->get_field(self::TABLE,"enddate",["page_id"=>$page->id(), "period" => $periodnr-1],MUST_EXIST);
|
|
$pstart = strtotime($startdate)+(24*60*60); // Add one day
|
|
} catch(\dml_missing_record_exception $x2){
|
|
// If not, do a fair guess
|
|
$pstart = $ystart + (($periodnr-1)*$ptime);
|
|
}
|
|
try{
|
|
// Check if we have a next period to glance the start date of as a reference
|
|
$enddate = $DB->get_field(self::TABLE,"startdate",["page_id"=>$page->id(), "period" => $periodnr+1],MUST_EXIST);
|
|
$pstart = strtotime($enddate)-(24*60*60); // subtract one day
|
|
} catch(\dml_missing_record_exception $x2){
|
|
// If not, do a fair guess
|
|
$pend = $pstart + $ptime;
|
|
}
|
|
|
|
// And create the period
|
|
$period = self::add([
|
|
'page_id' => $page->id(),
|
|
'period' => $periodnr,
|
|
'fullname' => \get_string("period_default_fullname","local_treestudyplan",$periodnr),
|
|
'shortname' => \get_string("period_default_shortname","local_treestudyplan",$periodnr),
|
|
'startdate' => date("Y-m-d",$pstart),
|
|
'enddate' => date("Y-m-d",$pend),
|
|
]);
|
|
}
|
|
return $period;
|
|
}
|
|
|
|
// Cache constructors to avoid multiple creation events in one session.
|
|
public static function findForPage(studyplanpage $page): array {
|
|
if(!array_key_exists($page->id(),self::$PAGECACHE)){
|
|
$periods = [];
|
|
// find and add the periods to an array with the period sequence as a key
|
|
for($i=1; $i <= $page->periods(); $i++){
|
|
$period = self::find($page,$i);
|
|
$periods[$i] = $period;
|
|
}
|
|
self::$PAGECACHE[$page->id()] = $periods;
|
|
}
|
|
return self::$PAGECACHE[$page->id()];
|
|
}
|
|
|
|
private function __construct($id) {
|
|
global $DB;
|
|
$this->id = $id;
|
|
$this->r = $DB->get_record(self::TABLE,['id' => $id]);
|
|
$this->page = studyplanpage::findById($this->r->page_id);
|
|
}
|
|
|
|
public function id(){
|
|
return $this->id;
|
|
}
|
|
|
|
public function studyplan() : studyplan {
|
|
return $this->page->studyplan();
|
|
}
|
|
|
|
public function page(){
|
|
return $this->page;
|
|
}
|
|
|
|
public function shortname(){
|
|
return $this->r->shortname;
|
|
}
|
|
|
|
public function fullname(){
|
|
return $this->r->fullname;
|
|
}
|
|
|
|
public function period(){
|
|
return $this->r->period;
|
|
}
|
|
|
|
public function startdate(){
|
|
return new \DateTime($this->r->startdate);
|
|
}
|
|
|
|
public function enddate(){
|
|
if($this->r->enddate && strlen($this->r->enddate) > 0){
|
|
return new \DateTime($this->r->enddate);
|
|
}
|
|
else{
|
|
// return a date 100 years into the future
|
|
return (new \DateTime($this->r->startdate))->add(new \DateInterval("P100Y"));
|
|
}
|
|
}
|
|
|
|
public static function structure($value=VALUE_REQUIRED){
|
|
return new \external_single_structure([
|
|
"id" => new \external_value(PARAM_INT, 'id of period'),
|
|
"fullname" => new \external_value(PARAM_TEXT, 'Full name of period'),
|
|
"shortname"=> new \external_value(PARAM_TEXT, 'Short name of period'),
|
|
"period" => new \external_value(PARAM_INT, 'period sequence'),
|
|
"startdate" => new \external_value(PARAM_TEXT, 'start date of period'),
|
|
"enddate" => new \external_value(PARAM_TEXT, 'end date of period'),
|
|
],'Period info',$value);
|
|
}
|
|
|
|
public function model(){
|
|
return [
|
|
'id' => $this->r->id,
|
|
'fullname' => $this->r->fullname,
|
|
'shortname' => $this->r->shortname,
|
|
'period' => $this->r->period,
|
|
'startdate' => $this->r->startdate,
|
|
'enddate' => $this->r->enddate,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Do not use directly to add periods, unless performing import
|
|
* The static find() and findForPage() functions create the period if needed
|
|
*/
|
|
public static function add($fields){
|
|
global $DB;
|
|
|
|
if(!isset($fields['page_id'])){
|
|
throw new \InvalidArgumentException("parameter 'page_id' missing");
|
|
}
|
|
if(!isset($fields['period'])){
|
|
throw new \InvalidArgumentException("parameter 'period' missing");
|
|
}
|
|
|
|
if($DB->record_exists(self::TABLE,["page_id"=>$fields["page_id"], "period"=>$fields["period"]])){
|
|
throw new \InvalidArgumentException("record already exists for specified page and period");
|
|
}
|
|
|
|
$addable = ['page_id','fullname','shortname','period','startdate','enddate'];
|
|
$info = [ ];
|
|
foreach($addable as $f){
|
|
if(array_key_exists($f,$fields)){
|
|
$info[$f] = $fields[$f];
|
|
}
|
|
}
|
|
$id = $DB->insert_record(self::TABLE, $info);
|
|
unset(self::$PAGECACHE[$fields['page_id']]); // invalidate the cache for this page
|
|
return self::findById($id); // make sure the new page is immediately cached
|
|
}
|
|
|
|
public function edit($fields){
|
|
global $DB;
|
|
$editable = ['fullname','shortname','startdate','enddate'];
|
|
$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);
|
|
unset(self::$PAGECACHE[$this->r->page_id]); // invalidate the cache for this page
|
|
return $this;
|
|
}
|
|
|
|
public function delete(){
|
|
global $DB;
|
|
$DB->delete_records(self::TABLE, ['id' => $this->id]);
|
|
unset(self::$PAGECACHE[$this->r->page_id]); // invalidate the cache for this page
|
|
return success::success();
|
|
}
|
|
|
|
public static function page_structure($value=VALUE_REQUIRED){
|
|
return new \external_multiple_structure(self::structure(),"The periods in the page",$value);
|
|
}
|
|
|
|
public static function page_model(studyplanpage $page){
|
|
$model = [];
|
|
foreach(self::findForPage($page) as $p){
|
|
$model[] = $p->model();
|
|
}
|
|
return $model;
|
|
}
|
|
|
|
} |