CHIEFSOFT\ameye
844 lines
33 KiB
PHP
844 lines
33 KiB
PHP
<?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;
|
|
|
|
/**
|
|
* Class manager
|
|
* @package tool_brickfield
|
|
* @copyright 2021 Brickfield Education Labs https://www.brickfield.ie
|
|
* @license https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class manager {
|
|
|
|
/**
|
|
* Defines the waiting for analysis status.
|
|
*/
|
|
const STATUS_WAITING = 0;
|
|
|
|
/**
|
|
* Defined the analysis in progress status.
|
|
*/
|
|
const STATUS_INPROGRESS = -1;
|
|
|
|
/**
|
|
* Defines the analysis has completed status.
|
|
*/
|
|
const STATUS_CHECKED = 1;
|
|
|
|
/**
|
|
* Defines summary error value.
|
|
*/
|
|
const SUMMARY_ERROR = 0;
|
|
|
|
/**
|
|
* Defines summary failed value.
|
|
*/
|
|
const SUMMARY_FAILED = 1;
|
|
|
|
/**
|
|
* Defines summary percent value.
|
|
*/
|
|
const SUMMARY_PERCENT = 2;
|
|
|
|
/**
|
|
* Default bulk record limit.
|
|
*/
|
|
const BULKRECORDLIMIT = 1000;
|
|
|
|
/**
|
|
* Name of this plugin.
|
|
*/
|
|
const PLUGINNAME = 'tool_brickfield';
|
|
|
|
/**
|
|
* Areas table name.
|
|
*/
|
|
const DB_AREAS = self::PLUGINNAME . '_areas';
|
|
|
|
/**
|
|
* Cacheacts table name.
|
|
*/
|
|
const DB_CACHEACTS = self::PLUGINNAME . '_cache_acts';
|
|
|
|
/**
|
|
* Cachecheck table name.
|
|
*/
|
|
const DB_CACHECHECK = self::PLUGINNAME . '_cache_check';
|
|
|
|
/**
|
|
* Checks table name.
|
|
*/
|
|
const DB_CHECKS = self::PLUGINNAME . '_checks';
|
|
|
|
/**
|
|
* Content table name.
|
|
*/
|
|
const DB_CONTENT = self::PLUGINNAME . '_content';
|
|
|
|
/**
|
|
* Errors table name.
|
|
*/
|
|
const DB_ERRORS = self::PLUGINNAME . '_errors';
|
|
|
|
/**
|
|
* Process table name.
|
|
*/
|
|
const DB_PROCESS = self::PLUGINNAME . '_process';
|
|
|
|
/**
|
|
* Results table name.
|
|
*/
|
|
const DB_RESULTS = self::PLUGINNAME . '_results';
|
|
|
|
/**
|
|
* Schedule table name.
|
|
*/
|
|
const DB_SCHEDULE = self::PLUGINNAME . '_schedule';
|
|
|
|
/**
|
|
* Summary table name.
|
|
*/
|
|
const DB_SUMMARY = self::PLUGINNAME . '_summary';
|
|
|
|
/** @var string The URL to find help at. */
|
|
private static $helpurl = 'https://www.brickfield.ie/moodle-help-311';
|
|
|
|
|
|
/** @var array Statically stores the database checks records. */
|
|
static protected $checks;
|
|
|
|
/**
|
|
* Returns the URL used for registration.
|
|
*
|
|
* @return \moodle_url
|
|
*/
|
|
public static function registration_url(): \moodle_url {
|
|
return accessibility::get_plugin_url('registration.php');
|
|
}
|
|
|
|
/**
|
|
* Returns an appropriate message about the current registration state.
|
|
*
|
|
* @return string
|
|
* @throws \coding_exception
|
|
* @throws \dml_exception
|
|
* @throws \moodle_exception
|
|
*/
|
|
public static function registration_message(): string {
|
|
$firstline = get_string('notregistered', self::PLUGINNAME);
|
|
if (has_capability('moodle/site:config', \context_system::instance())) {
|
|
$secondline = \html_writer::link(self::registration_url(), get_string('registernow', self::PLUGINNAME));
|
|
} else {
|
|
$secondline = get_string('contactadmin', self::PLUGINNAME);
|
|
}
|
|
return $firstline . '<br />' . $secondline;
|
|
}
|
|
|
|
/**
|
|
* Get the help page URL.
|
|
* @return string
|
|
* @throws dml_exception
|
|
*/
|
|
public static function get_helpurl(): string {
|
|
return self::$helpurl;
|
|
}
|
|
|
|
/**
|
|
* Return an array of system checks available, and store them statically.
|
|
*
|
|
* @return array
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function get_checks(): array {
|
|
global $DB;
|
|
if (self::$checks === null) {
|
|
self::$checks = $DB->get_records(self::DB_CHECKS, [] , 'id');
|
|
}
|
|
return self::$checks;
|
|
}
|
|
|
|
/**
|
|
* Find all available areas.
|
|
*
|
|
* @return area_base[]
|
|
* @throws \ReflectionException
|
|
*/
|
|
public static function get_all_areas(): array {
|
|
return array_filter(
|
|
array_map(
|
|
function($classname) {
|
|
$reflectionclass = new \ReflectionClass($classname);
|
|
if ($reflectionclass->isAbstract()) {
|
|
return false;
|
|
}
|
|
$instance = new $classname();
|
|
|
|
if ($instance->is_available()) {
|
|
return $instance;
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
array_keys(\core_component::get_component_classes_in_namespace('tool_brickfield', 'local\areas'))
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Calculate contenthash of a given content string
|
|
*
|
|
* @param string|null $content
|
|
* @return string
|
|
*/
|
|
public static function get_contenthash(?string $content = null): string {
|
|
return sha1($content ?? '');
|
|
}
|
|
|
|
/**
|
|
* Does the current area content need to be scheduled for check?
|
|
*
|
|
* It does not need to be scheduled if:
|
|
* - it is the current content
|
|
* OR
|
|
* - there is already schedule
|
|
*
|
|
* @param int $areaid
|
|
* @param string $contenthash
|
|
* @return bool
|
|
* @throws \dml_exception
|
|
*/
|
|
protected static function content_needs_scheduling(int $areaid, string $contenthash): bool {
|
|
global $DB;
|
|
return ! $DB->get_field_sql('SELECT 1 FROM {' . self::DB_CONTENT . '} '.
|
|
'WHERE areaid = ?
|
|
AND (status = 0 OR (iscurrent = 1 AND contenthash = ?))',
|
|
[$areaid, $contenthash], IGNORE_MULTIPLE);
|
|
}
|
|
|
|
/**
|
|
* Schedule an area for analysis if there has been changes.
|
|
*
|
|
* @param \stdClass $arearecord record with the fields from the {tool_brickfield_areas} table
|
|
* as returned by area_base::find_relevant_areas().
|
|
* It also contains the 'content' property with the current area content
|
|
* @throws \dml_exception
|
|
*/
|
|
protected static function schedule_area_if_necessary(\stdClass $arearecord) {
|
|
global $DB;
|
|
|
|
$contenthash = static::get_contenthash($arearecord->content);
|
|
$searchparams = array_diff_key((array)$arearecord, ['content' => 1, 'reftable' => 1, 'refid' => 1]);
|
|
if ($dbrecord = $DB->get_record(self::DB_AREAS, $searchparams)) {
|
|
if ( ! static::content_needs_scheduling($dbrecord->id, $contenthash)) {
|
|
// This is already the latest content record or there is already scheduled record, nothing to do.
|
|
return;
|
|
}
|
|
} else {
|
|
$dbrecord = (object)array_diff_key((array)$arearecord, ['content' => 1]);
|
|
$dbrecord->id = $DB->insert_record(self::DB_AREAS, $dbrecord);
|
|
}
|
|
// Schedule the area for the check. Note that we do not record the contenthash, we will calculate it again
|
|
// during the actual check.
|
|
$DB->insert_record(self::DB_CONTENT,
|
|
(object)['areaid' => $dbrecord->id, 'contenthash' => '', 'timecreated' => time(),
|
|
'status' => self::STATUS_WAITING]);
|
|
}
|
|
|
|
/**
|
|
* Asks all area providers if they have any areas that might have changed as a result of an event and schedules them
|
|
*
|
|
* @param \core\event\base $event
|
|
* @throws \ReflectionException
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function find_new_or_updated_areas(\core\event\base $event) {
|
|
foreach (static::get_all_areas() as $area) {
|
|
if ($records = $area->find_relevant_areas($event)) {
|
|
foreach ($records as $record) {
|
|
static::schedule_area_if_necessary($record);
|
|
}
|
|
$records->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the current content of the area.
|
|
*
|
|
* @param \stdClass $arearecord record from the tool_brickfield_areas table
|
|
* @return array|null array where the first element is the value of the field and the second element
|
|
* is the 'format' for this field if it is present. If the record was not found null is returned.
|
|
* @throws \ddl_exception
|
|
* @throws \ddl_table_missing_exception
|
|
* @throws \dml_exception
|
|
*/
|
|
protected static function get_area_content(\stdClass $arearecord): array {
|
|
global $DB;
|
|
if ($arearecord->type == area_base::TYPE_FIELD) {
|
|
$tablename = $arearecord->tablename;
|
|
$fieldname = $arearecord->fieldorarea;
|
|
$itemid = $arearecord->itemid;
|
|
|
|
if (!$DB->get_manager()->table_exists($tablename)) {
|
|
return [];
|
|
}
|
|
if (!$DB->get_manager()->field_exists($tablename, $fieldname)) {
|
|
return [];
|
|
}
|
|
$fields = $fieldname;
|
|
if ($DB->get_manager()->field_exists($tablename, $fieldname . 'format')) {
|
|
$fields .= ',' . $fieldname . 'format';
|
|
}
|
|
if ($record = $DB->get_record($tablename, ['id' => $itemid], $fields)) {
|
|
return array_values((array)$record);
|
|
}
|
|
}
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Asks all area providers if they have any areas that might have changed per courseid and schedules them.
|
|
*
|
|
* @param int $courseid
|
|
* @throws \ReflectionException
|
|
* @throws \coding_exception
|
|
* @throws \ddl_exception
|
|
* @throws \ddl_table_missing_exception
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function find_new_or_updated_areas_per_course(int $courseid) {
|
|
$totalcount = 0;
|
|
foreach (static::get_all_areas() as $area) {
|
|
if ($records = $area->find_course_areas($courseid)) {
|
|
foreach ($records as $record) {
|
|
$totalcount++;
|
|
static::schedule_area_if_necessary($record);
|
|
}
|
|
$records->close();
|
|
}
|
|
// For a site course request, also process the site level areas.
|
|
if (($courseid == SITEID) && ($records = $area->find_system_areas())) {
|
|
foreach ($records as $record) {
|
|
$totalcount++;
|
|
// Currently, the courseid in the area table is null if there is a category id.
|
|
if (!empty($record->categoryid)) {
|
|
$record->courseid = null;
|
|
}
|
|
static::schedule_area_if_necessary($record);
|
|
}
|
|
$records->close();
|
|
}
|
|
}
|
|
// Need to run for total count of areas.
|
|
static::check_scheduled_areas($totalcount);
|
|
}
|
|
|
|
/**
|
|
* Finds all areas that are waiting to be checked, performs checks. Returns true if there were records processed, false if not.
|
|
* To be called from scheduled task
|
|
*
|
|
* @param int $batch
|
|
* @return bool
|
|
* @throws \coding_exception
|
|
* @throws \ddl_exception
|
|
* @throws \ddl_table_missing_exception
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function check_scheduled_areas(int $batch = 0): bool {
|
|
global $DB;
|
|
|
|
$processingtime = 0;
|
|
$resultstime = 0;
|
|
|
|
$config = get_config(self::PLUGINNAME);
|
|
if ($batch == 0) {
|
|
$batch = $config->batch;
|
|
}
|
|
// Creating insert array for courseid cache reruns.
|
|
$recordsfound = false;
|
|
$batchinserts = [];
|
|
echo("Batch amount is ".$batch.", starttime ".time()."\n");
|
|
$rs = $DB->get_recordset_sql('SELECT a.*, ch.id AS contentid
|
|
FROM {' . self::DB_AREAS. '} a
|
|
JOIN {' . self::DB_CONTENT . '} ch ON ch.areaid = a.id
|
|
WHERE ch.status = ?
|
|
ORDER BY a.id, ch.timecreated, ch.id',
|
|
[self::STATUS_WAITING], 0, $batch);
|
|
|
|
foreach ($rs as $arearecord) {
|
|
$recordsfound = true;
|
|
$DB->set_field(self::DB_CONTENT, 'status', self::STATUS_INPROGRESS, ['id' => $arearecord->contentid]);
|
|
$content = static::get_area_content($arearecord);
|
|
if ($content[0] == null) {
|
|
$content[0] = '';
|
|
}
|
|
accessibility::run_check($content[0], $arearecord->contentid, $processingtime, $resultstime);
|
|
|
|
// Set all content 'iscurrent' fields for this areaid to 0.
|
|
$DB->set_field(self::DB_CONTENT, 'iscurrent', 0, ['areaid' => $arearecord->id]);
|
|
// Update this content record to be the current record.
|
|
$DB->update_record(self::DB_CONTENT,
|
|
(object)['id' => $arearecord->contentid, 'status' => self::STATUS_CHECKED, 'timechecked' => time(),
|
|
'contenthash' => static::get_contenthash($content[0]), 'iscurrent' => 1]);
|
|
|
|
// If full caching has been run, then queue, if not in queue already.
|
|
if (($arearecord->courseid != null) && static::is_okay_to_cache() &&
|
|
!isset($batchinserts[$arearecord->courseid])) {
|
|
$batchinserts[$arearecord->courseid] = ['courseid' => $arearecord->courseid, 'item' => 'cache'];
|
|
}
|
|
}
|
|
|
|
if (count($batchinserts) > 0) {
|
|
$DB->insert_records(self::DB_PROCESS, $batchinserts);
|
|
}
|
|
|
|
mtrace('Total time in htmlchecker: ' . $processingtime . ' secs.');
|
|
mtrace('Total time in results: ' . $resultstime . ' secs.');
|
|
return $recordsfound;
|
|
}
|
|
|
|
/**
|
|
* Return true if analysis hasn't been disabled.
|
|
* @return bool
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function is_okay_to_cache(): bool {
|
|
return (analysis::type_is_byrequest());
|
|
}
|
|
|
|
/**
|
|
* Finds all areas that are waiting to be deleted, performs deletions.
|
|
*
|
|
* @param int $batch limit, can be called from runcli.php
|
|
* To be called from scheduled task
|
|
* @throws \coding_exception
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function check_scheduled_deletions(int $batch = 0) {
|
|
global $DB;
|
|
|
|
$config = get_config(self::PLUGINNAME);
|
|
if ($batch == 0) {
|
|
$batch = $config->batch;
|
|
}
|
|
|
|
// Creating insert array for courseid cache reruns.
|
|
$batchinserts = [];
|
|
|
|
$rs = $DB->get_recordset(self::DB_PROCESS, ['contextid' => -1, 'timecompleted' => 0], '', '*', 0, $batch);
|
|
|
|
foreach ($rs as $record) {
|
|
|
|
if ($record->item == "core_course") {
|
|
$tidyparams = ['courseid' => $record->courseid];
|
|
static::delete_summary_data($record->courseid); // Delete cache too.
|
|
} else if ($record->item == "course_categories") {
|
|
$tidyparams = ['component' => 'core_course', 'categoryid' => $record->innercontextid];
|
|
} else if ($record->item == "course_sections") {
|
|
// Locate course sections, using innercontextid, contextid set to -1 for delete.
|
|
$tidyparams = ['courseid' => $record->courseid, 'component' => 'core_course',
|
|
'tablename' => $record->item, 'itemid' => $record->innercontextid];
|
|
} else if ($record->item == "lesson_pages") {
|
|
// Locate lesson pages, using innercontextid, contextid set to -1 for delete.
|
|
$tidyparams = ['courseid' => $record->courseid, 'component' => 'mod_lesson',
|
|
'tablename' => $record->item, 'itemid' => $record->innercontextid];
|
|
} else if ($record->item == "book_chapters") {
|
|
// Locate book chapters, using innercontextid, contextid set to -1 for delete.
|
|
$tidyparams = ['courseid' => $record->courseid, 'component' => 'mod_book',
|
|
'tablename' => $record->item, 'itemid' => $record->innercontextid];
|
|
} else if ($record->item == "question") {
|
|
// Locate question areas, using innercontextid, contextid set to -1 for delete.
|
|
$tidyparams = [
|
|
'courseid' => $record->courseid, 'component' => 'core_question',
|
|
'tablename' => $record->item, 'itemid' => $record->innercontextid
|
|
];
|
|
} else {
|
|
// Locate specific module instance, using innercontextid, contextid set to -1 for delete.
|
|
$tidyparams = ['courseid' => $record->courseid, 'component' => $record->item,
|
|
'itemid' => $record->innercontextid];
|
|
}
|
|
|
|
$areas = $DB->get_records(self::DB_AREAS, $tidyparams);
|
|
foreach ($areas as $area) {
|
|
static::delete_area_tree($area);
|
|
}
|
|
|
|
$DB->delete_records(self::DB_PROCESS, ['id' => $record->id]);
|
|
|
|
// If full caching has been run, then queue, if not in queue already.
|
|
if ($record->courseid != null && static::is_okay_to_cache() && !isset($batchinserts[$record->courseid])) {
|
|
$batchinserts[$record->courseid] = ['courseid' => $record->courseid, 'item' => 'cache'];
|
|
}
|
|
}
|
|
$rs->close();
|
|
|
|
if (count($batchinserts) > 0) {
|
|
$DB->insert_records(self::DB_PROCESS, $batchinserts);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks all queued course updates, and finds all relevant areas.
|
|
*
|
|
* @param int $batch limit
|
|
* To be called from scheduled task
|
|
* @throws \ReflectionException
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function check_course_updates(int $batch = 0) {
|
|
global $DB;
|
|
|
|
if ($batch == 0) {
|
|
$config = get_config(self::PLUGINNAME);
|
|
$batch = $config->batch;
|
|
}
|
|
|
|
$recs = $DB->get_records(self::DB_PROCESS, ['item' => 'coursererun'], '', 'DISTINCT courseid', 0, $batch);
|
|
|
|
foreach ($recs as $record) {
|
|
static::find_new_or_updated_areas_per_course($record->courseid);
|
|
$DB->delete_records(self::DB_PROCESS, ['courseid' => $record->courseid, 'item' => 'coursererun']);
|
|
static::store_result_summary($record->courseid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Finds all records for a given content area and performs deletions.
|
|
*
|
|
* To be called from scheduled task
|
|
* @param \stdClass $area
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function delete_area_tree(\stdClass $area) {
|
|
global $DB;
|
|
|
|
$contents = $DB->get_records(self::DB_CONTENT, ['areaid' => $area->id]);
|
|
foreach ($contents as $content) {
|
|
$results = $DB->get_records(self::DB_RESULTS, ['contentid' => $content->id]);
|
|
foreach ($results as $result) {
|
|
$DB->delete_records(self::DB_ERRORS, ['resultid' => $result->id]);
|
|
}
|
|
$DB->delete_records(self::DB_RESULTS, ['contentid' => $content->id]);
|
|
}
|
|
|
|
// Also, delete all child areas, if existing.
|
|
$childparams = ['type' => $area->type, 'reftable' => $area->tablename,
|
|
'refid' => $area->itemid];
|
|
$childareas = $DB->get_records(self::DB_AREAS, $childparams);
|
|
foreach ($childareas as $childarea) {
|
|
static::delete_area_tree($childarea);
|
|
}
|
|
|
|
$DB->delete_records(self::DB_CONTENT, ['areaid' => $area->id]);
|
|
$DB->delete_records(self::DB_AREAS, ['id' => $area->id]);
|
|
}
|
|
|
|
/**
|
|
* Finds all records which are no longer current and performs deletions.
|
|
*
|
|
* To be called from scheduled task.
|
|
*/
|
|
public static function delete_historical_data() {
|
|
global $DB;
|
|
|
|
$config = get_config(self::PLUGINNAME);
|
|
|
|
if ($config->deletehistoricaldata) {
|
|
$contents = $DB->get_records(self::DB_CONTENT, ['iscurrent' => 0, 'status' => self::STATUS_CHECKED]);
|
|
foreach ($contents as $content) {
|
|
$results = $DB->get_records(self::DB_RESULTS, ['contentid' => $content->id]);
|
|
foreach ($results as $result) {
|
|
$DB->delete_records(self::DB_ERRORS, ['resultid' => $result->id]);
|
|
}
|
|
$DB->delete_records(self::DB_RESULTS, ['contentid' => $content->id]);
|
|
$DB->delete_records(self::DB_CONTENT, ['id' => $content->id]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Finds all summary cache records for a given courseid and performs deletions.
|
|
* To be called from scheduled task.
|
|
*
|
|
* @param int $courseid
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function delete_summary_data(int $courseid) {
|
|
global $DB;
|
|
|
|
if ($courseid == null) {
|
|
mtrace('Attempting to run delete_summary_data with no courseid, returning');
|
|
return;
|
|
}
|
|
|
|
$DB->delete_records(self::DB_SUMMARY, ['courseid' => $courseid]);
|
|
$DB->delete_records(self::DB_CACHECHECK, ['courseid' => $courseid]);
|
|
$DB->delete_records(self::DB_CACHEACTS, ['courseid' => $courseid]);
|
|
}
|
|
|
|
/**
|
|
* Finds all results required to display accessibility report and stores them in the database.
|
|
*
|
|
* To be called from scheduled task.
|
|
* @param int|null $courseid
|
|
* @throws \coding_exception
|
|
* @throws \dml_exception
|
|
*/
|
|
public static function store_result_summary(int $courseid = null) {
|
|
global $DB;
|
|
|
|
if (static::is_okay_to_cache() && ($courseid == null)) {
|
|
mtrace('Attempting to run update cache with no courseid, returning');
|
|
return;
|
|
}
|
|
|
|
$extrasql = !$courseid ? "" : "AND courseid = ?";
|
|
$coursesqlval = !$courseid ? [] : [$courseid];
|
|
|
|
// Count of failed activities and count of errors by check.
|
|
$errorsql = "SELECT areas.courseid, chx.checkgroup,
|
|
COUNT(DISTINCT (".$DB->sql_concat('areas.contextid', 'areas.component').")) AS failed,
|
|
SUM(res.errorcount) AS errors
|
|
FROM {" . self::DB_AREAS . "} areas
|
|
INNER JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = areas.id
|
|
INNER JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
|
|
INNER JOIN {" . self::DB_CHECKS . "} chx ON chx.id = res.checkid
|
|
WHERE res.errorcount > ? AND ch.iscurrent = ? ". $extrasql ." GROUP BY courseid, chx.checkgroup";
|
|
|
|
$recordserrored = $DB->get_recordset_sql($errorsql, array_merge([0, 1], $coursesqlval));
|
|
|
|
// Count of failed activities by course.
|
|
$failsql = "SELECT areas.courseid,
|
|
COUNT(DISTINCT (".$DB->sql_concat('areas.contextid', 'areas.component').")) AS failed,
|
|
SUM(res.errorcount) AS errors
|
|
FROM {" . self::DB_AREAS . "} areas
|
|
INNER JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = areas.id
|
|
INNER JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
|
|
WHERE res.errorcount > ? AND ch.iscurrent = ? ". $extrasql ." GROUP BY courseid";
|
|
|
|
$recordsfailed = $DB->get_recordset_sql($failsql, array_merge([0, 1], $coursesqlval));
|
|
|
|
$extrasql = !$courseid ? "" : "WHERE courseid = ?";
|
|
// Count of activities per course.
|
|
$countsql = "SELECT courseid, COUNT(DISTINCT (".$DB->sql_concat('areas.contextid', 'areas.component').")) AS activities
|
|
FROM {" . self::DB_AREAS . "} areas ". $extrasql ." GROUP BY areas.courseid";
|
|
|
|
$recordscount = $DB->get_records_sql($countsql, $coursesqlval);
|
|
|
|
$final = [];
|
|
$values = [];
|
|
|
|
foreach ($recordscount as $countrecord) {
|
|
$final[$countrecord->courseid] = array_pad(array(), 8,
|
|
[self::SUMMARY_ERROR => 0, self::SUMMARY_FAILED => 0, self::SUMMARY_PERCENT => 100]
|
|
) + [
|
|
"activitiespassed" => $countrecord->activities,
|
|
"activitiesfailed" => 0,
|
|
"activities" => $countrecord->activities
|
|
];
|
|
}
|
|
|
|
foreach ($recordsfailed as $failedrecord) {
|
|
$final[$failedrecord->courseid]["activitiespassed"] -= $failedrecord->failed;
|
|
$final[$failedrecord->courseid]["activitiesfailed"] += $failedrecord->failed;
|
|
}
|
|
|
|
foreach ($recordserrored as $errorrecord) {
|
|
$final[$errorrecord->courseid][$errorrecord->checkgroup][self::SUMMARY_ERROR] = $errorrecord->errors;
|
|
$final[$errorrecord->courseid][$errorrecord->checkgroup][self::SUMMARY_FAILED] = $errorrecord->failed;
|
|
$final[$errorrecord->courseid][$errorrecord->checkgroup][self::SUMMARY_PERCENT] = round(100 * (1 -
|
|
($final[$errorrecord->courseid][$errorrecord->checkgroup][self::SUMMARY_FAILED]
|
|
/ $final[$errorrecord->courseid]["activities"])));
|
|
}
|
|
|
|
foreach ($recordscount as $course) {
|
|
if (!$course->courseid) {
|
|
continue;
|
|
}
|
|
$element = [
|
|
'courseid' => $course->courseid,
|
|
'status' => self::STATUS_CHECKED,
|
|
'activities' => $final[$course->courseid]["activities"],
|
|
'activitiespassed' => $final[$course->courseid]["activitiespassed"],
|
|
'activitiesfailed' => $final[$course->courseid]["activitiesfailed"],
|
|
'errorschecktype1' => $final[$course->courseid][area_base::CHECKGROUP_FORM][self::SUMMARY_ERROR],
|
|
'errorschecktype2' => $final[$course->courseid][area_base::CHECKGROUP_IMAGE][self::SUMMARY_ERROR],
|
|
'errorschecktype3' => $final[$course->courseid][area_base::CHECKGROUP_LAYOUT][self::SUMMARY_ERROR],
|
|
'errorschecktype4' => $final[$course->courseid][area_base::CHECKGROUP_LINK][self::SUMMARY_ERROR],
|
|
'errorschecktype5' => $final[$course->courseid][area_base::CHECKGROUP_MEDIA][self::SUMMARY_ERROR],
|
|
'errorschecktype6' => $final[$course->courseid][area_base::CHECKGROUP_TABLE][self::SUMMARY_ERROR],
|
|
'errorschecktype7' => $final[$course->courseid][area_base::CHECKGROUP_TEXT][self::SUMMARY_ERROR],
|
|
'failedchecktype1' => $final[$course->courseid][area_base::CHECKGROUP_FORM][self::SUMMARY_FAILED],
|
|
'failedchecktype2' => $final[$course->courseid][area_base::CHECKGROUP_IMAGE][self::SUMMARY_FAILED],
|
|
'failedchecktype3' => $final[$course->courseid][area_base::CHECKGROUP_LAYOUT][self::SUMMARY_FAILED],
|
|
'failedchecktype4' => $final[$course->courseid][area_base::CHECKGROUP_LINK][self::SUMMARY_FAILED],
|
|
'failedchecktype5' => $final[$course->courseid][area_base::CHECKGROUP_MEDIA][self::SUMMARY_FAILED],
|
|
'failedchecktype6' => $final[$course->courseid][area_base::CHECKGROUP_TABLE][self::SUMMARY_FAILED],
|
|
'failedchecktype7' => $final[$course->courseid][area_base::CHECKGROUP_TEXT][self::SUMMARY_FAILED],
|
|
'percentchecktype1' => $final[$course->courseid][area_base::CHECKGROUP_FORM][self::SUMMARY_PERCENT],
|
|
'percentchecktype2' => $final[$course->courseid][area_base::CHECKGROUP_IMAGE][self::SUMMARY_PERCENT],
|
|
'percentchecktype3' => $final[$course->courseid][area_base::CHECKGROUP_LAYOUT][self::SUMMARY_PERCENT],
|
|
'percentchecktype4' => $final[$course->courseid][area_base::CHECKGROUP_LINK][self::SUMMARY_PERCENT],
|
|
'percentchecktype5' => $final[$course->courseid][area_base::CHECKGROUP_MEDIA][self::SUMMARY_PERCENT],
|
|
'percentchecktype6' => $final[$course->courseid][area_base::CHECKGROUP_TABLE][self::SUMMARY_PERCENT],
|
|
'percentchecktype7' => $final[$course->courseid][area_base::CHECKGROUP_TEXT][self::SUMMARY_PERCENT]
|
|
];
|
|
$resultid = $DB->get_field(self::DB_SUMMARY, 'id', ['courseid' => $course->courseid]);
|
|
if ($resultid) {
|
|
$element['id'] = $resultid;
|
|
$DB->update_record(self::DB_SUMMARY, (object)$element);
|
|
continue;
|
|
}
|
|
array_push($values, $element);
|
|
}
|
|
|
|
$DB->insert_records(self::DB_SUMMARY, $values);
|
|
|
|
$extrasql = !$courseid ? "WHERE courseid != ?" : "WHERE courseid = ?";
|
|
$coursesqlval = !$courseid ? [0] : [$courseid];
|
|
// Count of failed errors per check.
|
|
$checkssql = "SELECT area.courseid, ".self::STATUS_CHECKED." AS status, res.checkid,
|
|
COUNT(res.errorcount) as checkcount, SUM(res.errorcount) AS errorcount
|
|
FROM {" . self::DB_AREAS . "} area
|
|
INNER JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = area.id AND ch.iscurrent = 1
|
|
INNER JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
|
|
".$extrasql." GROUP BY area.courseid, res.checkid";
|
|
|
|
$checksresult = $DB->get_recordset_sql($checkssql, $coursesqlval);
|
|
|
|
$checkvalues = [];
|
|
foreach ($checksresult as $check) {
|
|
if ($result = $DB->get_record(self::DB_CACHECHECK, ['courseid' => $check->courseid, 'checkid' => $check->checkid])) {
|
|
$check->id = $result->id;
|
|
$DB->update_record(self::DB_CACHECHECK, $check);
|
|
} else {
|
|
array_push($checkvalues, (array)$check);
|
|
}
|
|
}
|
|
$DB->insert_records(self::DB_CACHECHECK, $checkvalues);
|
|
|
|
// Count of failed or passed rate per activity.
|
|
$activitysql = "SELECT courseid, ".self::STATUS_CHECKED." AS status, area.component,
|
|
COUNT(DISTINCT area.contextid) AS totalactivities, 0 AS failedactivities,
|
|
COUNT(DISTINCT area.contextid) AS passedactivities, 0 AS errorcount
|
|
FROM {" . self::DB_AREAS . "} area
|
|
".$extrasql."
|
|
GROUP BY area.courseid, area.component";
|
|
|
|
$activityresults = $DB->get_recordset_sql($activitysql, $coursesqlval);
|
|
|
|
$activityvalues = [];
|
|
|
|
// Count of failed errors per courseid per activity.
|
|
$activityfailedsql = "SELECT area.courseid, area.component, area.contextid, SUM(res.errorcount) AS errorcount
|
|
FROM {" . self::DB_AREAS . "} area
|
|
INNER JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = area.id AND ch.iscurrent = 1
|
|
INNER JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
|
|
".$extrasql." AND res.errorcount != 0
|
|
GROUP BY area.courseid, area.component, area.contextid";
|
|
|
|
$activityfailedresults = $DB->get_recordset_sql($activityfailedsql, $coursesqlval);
|
|
|
|
foreach ($activityresults as $activity) {
|
|
$tmpkey = $activity->courseid.$activity->component;
|
|
$activityvalues[$tmpkey] = $activity;
|
|
}
|
|
|
|
foreach ($activityfailedresults as $failed) {
|
|
$tmpkey = $failed->courseid.$failed->component;
|
|
$activityvalues[$tmpkey]->failedactivities ++;
|
|
$activityvalues[$tmpkey]->passedactivities --;
|
|
$activityvalues[$tmpkey]->errorcount += $failed->errorcount;
|
|
}
|
|
|
|
$activityvaluespush = [];
|
|
foreach ($activityvalues as $value) {
|
|
if ($result = $DB->get_record(self::DB_CACHEACTS, ['courseid' => $value->courseid, 'component' => $value->component])) {
|
|
$value->id = $result->id;
|
|
$DB->update_record(self::DB_CACHEACTS, $value);
|
|
} else {
|
|
array_push($activityvaluespush, (array)$value);
|
|
}
|
|
}
|
|
|
|
$DB->insert_records(self::DB_CACHEACTS, $activityvaluespush);
|
|
|
|
$recordserrored->close();
|
|
$recordsfailed->close();
|
|
$checksresult->close();
|
|
$activityresults->close();
|
|
$activityfailedresults->close();
|
|
}
|
|
|
|
/**
|
|
* Get course module summary information for a course.
|
|
*
|
|
* @param int $courseid
|
|
* @return \stdClass[]
|
|
*/
|
|
public static function get_cm_summary_for_course(int $courseid): array {
|
|
global $DB;
|
|
|
|
$sql = "
|
|
SELECT
|
|
area.cmid,
|
|
sum(errorcount) as numerrors,
|
|
count(errorcount) as numchecks
|
|
FROM {" . self::DB_AREAS . "} area
|
|
JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = area.id AND ch.iscurrent = 1
|
|
JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
|
|
WHERE area.courseid = :courseid AND component != :component
|
|
GROUP BY cmid";
|
|
|
|
$params = [
|
|
'courseid' => $courseid,
|
|
'component' => 'core_course',
|
|
];
|
|
|
|
return $DB->get_records_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Get section summary information for a course.
|
|
*
|
|
* @param int $courseid
|
|
* @return stdClass[]
|
|
*/
|
|
public static function get_section_summary_for_course(int $courseid): array {
|
|
global $DB;
|
|
|
|
$sql = "
|
|
SELECT
|
|
sec.section,
|
|
sum(errorcount) AS numerrors,
|
|
count(errorcount) as numchecks
|
|
FROM {" . self::DB_AREAS . "} area
|
|
JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = area.id AND ch.iscurrent = 1
|
|
JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
|
|
JOIN {course_sections} sec ON area.itemid = sec.id
|
|
WHERE area.tablename = :tablename AND area.courseid = :courseid
|
|
GROUP BY sec.section";
|
|
|
|
$params = [
|
|
'courseid' => $courseid,
|
|
'tablename' => 'course_sections'
|
|
];
|
|
|
|
return $DB->get_records_sql($sql, $params);
|
|
}
|
|
}
|