<?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/>.
namespace tool_brickfield;
/**
* Scheduler class.
*
* @package tool_brickfield
* @author Mike Churchward <mike@brickfieldlabs.ie>
* @copyright 2020 Brickfield Education Labs https://www.brickfield.ie
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL
*/
class scheduler {
/**
* Analysis has not been requested.
*/
const STATUS_NOT_REQUESTED = 0;
/**
* Analysis has been requested but not submitted.
*/
const STATUS_REQUESTED = 1;
/**
* Analysis has been submitted.
*/
const STATUS_SUBMITTED = 2;
/**
* The data table used by the scheduler.
*/
const DATA_TABLE = 'tool_brickfield_schedule';
/** @var int $instanceid The specific instance id of the context e.g. courseid. */
public $instanceid;
/** @var int $contextlevel The context level of the instance id e.g. CONTEXT_COURSE / 50. */
public $contextlevel;
/**
* Scheduler constructor.
* @param int $instanceid
* @param int $contextlevel
*/
public function __construct(int $instanceid = 0, int $contextlevel = CONTEXT_COURSE) {
$this->instanceid = $instanceid;
$this->contextlevel = $contextlevel;
}
/**
* Request this schedule object to be analyzed. Create the schedule if not present.
* @return bool
*/
public function request_analysis(): bool {
global $DB;
if (!$this->create_schedule()) {
return false;
}
if ($DB->set_field(self::DATA_TABLE, 'status', self::STATUS_REQUESTED, $this->standard_search_params())) {
if ($this->contextlevel == CONTEXT_COURSE) {
$context = \context_course::instance($this->instanceid);
} else {
$context = \context_system::instance();
}
$event = \tool_brickfield\event\analysis_requested::create([
'context' => $context,
'other' => ['course' => $this->instanceid],
]);
$event->trigger();
return true;
} else {
return false;
}
}
/**
* Mark this schedule object as analyzed.
* @return bool
* @throws \dml_exception
*/
public function mark_analyzed(): bool {
global $DB;
if (!$this->create_schedule()) {
return false;
}
$DB->set_field(self::DATA_TABLE, 'status', self::STATUS_SUBMITTED, $this->standard_search_params());
$DB->set_field(self::DATA_TABLE, 'timeanalyzed', time(), $this->standard_search_params());
return true;
}
/**
* Request this schedule object be added. Return true if already added, or the status of the insert operation.
* @return bool
*/
public function create_schedule(): bool {
global $DB;
if (!$this->is_in_schedule()) {
$datarecord = $this->get_datarecord();
return $DB->insert_record(self::DATA_TABLE, $datarecord, false);
}
return true;
}
/**
* Request this schedule object be deleted.
* @return bool
*/
public function delete_schedule(): bool {
global $DB;
if ($this->is_in_schedule()) {
return $DB->delete_records(self::DATA_TABLE, $this->standard_search_params());
}
return true;
}
/**
* Return true if this schedule object is in the schedule.
* @return bool
*/
public function is_in_schedule(): bool {
global $DB;
return $DB->record_exists(self::DATA_TABLE, $this->standard_search_params());
}
/**
* Return true if this schedule object has been requested to be analyzed.
* @return bool
*/
public function is_scheduled(): bool {
global $DB;
return $DB->record_exists(self::DATA_TABLE, $this->standard_search_params() + ['status' => self::STATUS_REQUESTED]);
}
/**
* Return true if this schedule object has been submitted.
* @return bool
*/
public function is_submitted(): bool {
global $DB;
return $DB->record_exists(self::DATA_TABLE, $this->standard_search_params() + ['status' => self::STATUS_SUBMITTED]);
}
/**
* Return true if this schedule object has been analyzed.
* @return bool
*/
public function is_analyzed(): bool {
global $DB;
// Future... If not a course analysis request, just return the schedule table status.
if ($this->contextlevel != CONTEXT_COURSE) {
return $this->is_submitted();
}
// A course is considered analyzed if it has been submitted and there is summary cache data for it.
$sql = 'SELECT * ' .
'FROM {' . self::DATA_TABLE . '} sch ' .
'INNER JOIN {' . manager::DB_SUMMARY . '} sum ON sch.instanceid = sum.courseid ' .
'WHERE (sch.contextlevel = :contextlevel) AND (sch.instanceid = :instanceid) AND (sch.status = :status)';
if (!$DB->record_exists_sql($sql, $this->standard_search_params() + ['status' => self::STATUS_SUBMITTED])) {
// It may have been created in a prior version, so check before returning false. If it was, add a record for it.
if ($DB->record_exists(manager::DB_SUMMARY, ['courseid' => $this->instanceid])) {
return $this->mark_analyzed();
} else {
return false;
}
} else {
return true;
}
}
/**
* The nornal data parameters to search for.
* @return array
*/
protected function standard_search_params(): array {
return ['contextlevel' => $this->contextlevel, 'instanceid' => $this->instanceid];
}
/**
* Get the context id for the specified context level and instance.
* @return int
* @throws \dml_exception
*/
protected function get_contextid(): int {
global $DB;
$contextid = $DB->get_field('context', 'id', $this->standard_search_params());
if ($contextid === false) {
$contextid = 0;
}
return $contextid;
}
/**
* Create and return a datarecord object for the data table.
* @param int $status
* @return \stdClass
* @throws \dml_exception
*/
public function get_datarecord(int $status = self::STATUS_NOT_REQUESTED): \stdClass {
$datarecord = new \stdClass();
$datarecord->contextlevel = $this->contextlevel;
$datarecord->instanceid = $this->instanceid;
$datarecord->contextid = $this->get_contextid();
$datarecord->status = $status;
$datarecord->timeanalyzed = 0;
$datarecord->timemodified = time();
return $datarecord;
}
/**
* Process all the course analysis requests, and mark them as analyzed. Limit the number of requests processed by time.
* @throws \ReflectionException
* @throws \dml_exception
*/
public static function process_scheduled_requests() {
global $DB;
// Run a registration check.
if (!(new registration())->validate()) {
return;
}
$runtimemax = MINSECS * 5; // Only process requests for five minutes. May want to tie this to task schedule.
$runtime = time();
$requestset = $DB->get_recordset(self::DATA_TABLE, ['status' => self::STATUS_REQUESTED], 'timemodified ASC');
foreach ($requestset as $request) {
if ($request->contextlevel == CONTEXT_COURSE) {
manager::find_new_or_updated_areas_per_course($request->instanceid);
$request->status = self::STATUS_SUBMITTED;
$request->timeanalyzed = time();
$request->timemodified = time();
$DB->update_record(self::DATA_TABLE, $request);
}
$runtime = time() - $runtime;
if ($runtime >= $runtimemax) {
break;
}
}
$requestset->close();
}
// The following are static versions of the above functions for courses that do not require creating an object first.
/**
* Load all requested context types into the schedule as requested. Write records in groups of 100.
* @param int $contextlevel
* @return bool
* @throws \coding_exception
* @throws \dml_exception
*/
public static function initialize_schedule(int $contextlevel = CONTEXT_COURSE): bool {
global $DB;
$writelimit = 100;
$recordcount = 0;
$records = [];
$scheduler = new scheduler(0, $contextlevel);
$coursesset = $DB->get_recordset('course', null, 'id', 'id, id as courseid');
foreach ($coursesset as $course) {
$recordcount++;
$scheduler->instanceid = $course->id;
$records[] = $scheduler->get_datarecord(self::STATUS_REQUESTED);
if ($recordcount >= $writelimit) {
$DB->insert_records(self::DATA_TABLE, $records);
$recordcount = 0;
$records = [];
}
}
if ($recordcount > 0) {
$DB->insert_records(self::DATA_TABLE, $records);
}
$coursesset->close();
return true;
}
/**
* Request the specified course be analyzed.
* @param int $courseid
* @return bool
*/
public static function request_course_analysis(int $courseid) {
return (new scheduler($courseid))->request_analysis();
}
/**
* Request the specified course be added.
* @param int $courseid
* @return bool
*/
public static function create_course_schedule(int $courseid) {
return (new scheduler($courseid))->create_schedule();
}
/**
* Delete the specified course from the schedule.
* @param int $courseid
* @return bool
*/
public static function delete_course_schedule(int $courseid) {
return (new scheduler($courseid))->delete_schedule();
}
/**
* Return true if the specified course is in the schedule.
* @param int $courseid
* @return bool
*/
public static function is_course_in_schedule(int $courseid) {
return (new scheduler($courseid))->is_in_schedule();
}
/**
* Return true if the specified course is scheduled.
* @param int $courseid
* @return bool
*/
public static function is_course_scheduled(int $courseid) {
return (new scheduler($courseid))->is_scheduled();
}
/**
* Return true if the specified course has been analyzed.
* @param int $courseid
* @return bool
*/
public static function is_course_analyzed(int $courseid) {
return (new scheduler($courseid))->is_analyzed();
}
}