CHIEFSOFT\ameye
516 lines
16 KiB
PHP
516 lines
16 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/>.
|
|
|
|
/**
|
|
* H5P activity attempt object
|
|
*
|
|
* @package mod_h5pactivity
|
|
* @since Moodle 3.9
|
|
* @copyright 2020 Ferran Recio <ferran@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
namespace mod_h5pactivity\local;
|
|
|
|
use core_xapi\handler;
|
|
use stdClass;
|
|
use core_xapi\local\statement;
|
|
|
|
/**
|
|
* Class attempt for H5P activity
|
|
*
|
|
* @package mod_h5pactivity
|
|
* @since Moodle 3.9
|
|
* @copyright 2020 Ferran Recio <ferran@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class attempt {
|
|
|
|
/** @var stdClass the h5pactivity_attempts record. */
|
|
private $record;
|
|
|
|
/** @var boolean if the DB statement has been updated. */
|
|
private $scoreupdated = false;
|
|
|
|
/**
|
|
* Create a new attempt object.
|
|
*
|
|
* @param stdClass $record the h5pactivity_attempts record
|
|
*/
|
|
public function __construct(stdClass $record) {
|
|
$this->record = $record;
|
|
}
|
|
|
|
/**
|
|
* Create a new user attempt in a specific H5P activity.
|
|
*
|
|
* @param stdClass $user a user record
|
|
* @param stdClass $cm a course_module record
|
|
* @return attempt|null a new attempt object or null if fail
|
|
*/
|
|
public static function new_attempt(stdClass $user, stdClass $cm): ?attempt {
|
|
global $DB;
|
|
$record = new stdClass();
|
|
$record->h5pactivityid = $cm->instance;
|
|
$record->userid = $user->id;
|
|
$record->timecreated = time();
|
|
$record->timemodified = $record->timecreated;
|
|
$record->rawscore = 0;
|
|
$record->maxscore = 0;
|
|
$record->duration = 0;
|
|
$record->completion = null;
|
|
$record->success = null;
|
|
|
|
// Get last attempt number.
|
|
$conditions = ['h5pactivityid' => $cm->instance, 'userid' => $user->id];
|
|
$countattempts = $DB->count_records('h5pactivity_attempts', $conditions);
|
|
$record->attempt = $countattempts + 1;
|
|
|
|
$record->id = $DB->insert_record('h5pactivity_attempts', $record);
|
|
if (!$record->id) {
|
|
return null;
|
|
}
|
|
// Remove any xAPI State associated to this attempt.
|
|
$context = \context_module::instance($cm->id);
|
|
$xapihandler = handler::create('mod_h5pactivity');
|
|
$xapihandler->wipe_states($context->id, $user->id);
|
|
|
|
return new attempt($record);
|
|
}
|
|
|
|
/**
|
|
* Get the last user attempt in a specific H5P activity.
|
|
*
|
|
* If no previous attempt exists, it generates a new one.
|
|
*
|
|
* @param stdClass $user a user record
|
|
* @param stdClass $cm a course_module record
|
|
* @return attempt|null a new attempt object or null if some problem accured
|
|
*/
|
|
public static function last_attempt(stdClass $user, stdClass $cm): ?attempt {
|
|
global $DB;
|
|
$conditions = ['h5pactivityid' => $cm->instance, 'userid' => $user->id];
|
|
$records = $DB->get_records('h5pactivity_attempts', $conditions, 'attempt DESC', '*', 0, 1);
|
|
if (empty($records)) {
|
|
return self::new_attempt($user, $cm);
|
|
}
|
|
return new attempt(array_shift($records));
|
|
}
|
|
|
|
/**
|
|
* Wipe all attempt data for specific course_module and an optional user.
|
|
*
|
|
* @param stdClass $cm a course_module record
|
|
* @param stdClass $user a user record
|
|
*/
|
|
public static function delete_all_attempts(stdClass $cm, stdClass $user = null): void {
|
|
global $DB;
|
|
|
|
$where = 'a.h5pactivityid = :h5pactivityid';
|
|
$conditions = ['h5pactivityid' => $cm->instance];
|
|
if (!empty($user)) {
|
|
$where .= ' AND a.userid = :userid';
|
|
$conditions['userid'] = $user->id;
|
|
}
|
|
|
|
$DB->delete_records_select('h5pactivity_attempts_results', "attemptid IN (
|
|
SELECT a.id
|
|
FROM {h5pactivity_attempts} a
|
|
WHERE $where)", $conditions);
|
|
|
|
$DB->delete_records('h5pactivity_attempts', $conditions);
|
|
}
|
|
|
|
/**
|
|
* Delete a specific attempt.
|
|
*
|
|
* @param attempt $attempt the attempt object to delete
|
|
*/
|
|
public static function delete_attempt(attempt $attempt): void {
|
|
global $DB;
|
|
$attempt->delete_results();
|
|
$DB->delete_records('h5pactivity_attempts', ['id' => $attempt->get_id()]);
|
|
}
|
|
|
|
/**
|
|
* Save a new result statement into the attempt.
|
|
*
|
|
* It also updates the rawscore and maxscore if necessary.
|
|
*
|
|
* @param statement $statement the xAPI statement object
|
|
* @param string $subcontent = '' optional subcontent identifier
|
|
* @return bool if it can save the statement into db
|
|
*/
|
|
public function save_statement(statement $statement, string $subcontent = ''): bool {
|
|
global $DB;
|
|
|
|
// Check statement data.
|
|
$xapiobject = $statement->get_object();
|
|
if (empty($xapiobject)) {
|
|
return false;
|
|
}
|
|
$xapiresult = $statement->get_result();
|
|
$xapidefinition = $xapiobject->get_definition();
|
|
if (empty($xapidefinition) || empty($xapiresult)) {
|
|
return false;
|
|
}
|
|
|
|
$xapicontext = $statement->get_context();
|
|
if ($xapicontext) {
|
|
$context = $xapicontext->get_data();
|
|
} else {
|
|
$context = new stdClass();
|
|
}
|
|
$definition = $xapidefinition->get_data();
|
|
$result = $xapiresult->get_data();
|
|
$duration = $xapiresult->get_duration();
|
|
|
|
// Insert attempt_results record.
|
|
$record = new stdClass();
|
|
$record->attemptid = $this->record->id;
|
|
$record->subcontent = $subcontent;
|
|
$record->timecreated = time();
|
|
$record->interactiontype = $definition->interactionType ?? 'other';
|
|
$record->description = $this->get_description_from_definition($definition);
|
|
$record->correctpattern = $this->get_correctpattern_from_definition($definition);
|
|
$record->response = $result->response ?? '';
|
|
$record->additionals = $this->get_additionals($definition, $context);
|
|
$record->rawscore = 0;
|
|
$record->maxscore = 0;
|
|
if (isset($result->score)) {
|
|
$record->rawscore = $result->score->raw ?? 0;
|
|
$record->maxscore = $result->score->max ?? 0;
|
|
}
|
|
$record->duration = $duration;
|
|
if (isset($result->completion)) {
|
|
$record->completion = ($result->completion) ? 1 : 0;
|
|
}
|
|
if (isset($result->success)) {
|
|
$record->success = ($result->success) ? 1 : 0;
|
|
}
|
|
if (!$DB->insert_record('h5pactivity_attempts_results', $record)) {
|
|
return false;
|
|
}
|
|
|
|
// If no subcontent provided, results are propagated to the attempt itself.
|
|
if (empty($subcontent)) {
|
|
$this->set_duration($record->duration);
|
|
$this->set_completion($record->completion ?? null);
|
|
$this->set_success($record->success ?? null);
|
|
// If Maxscore is not empty means that the rawscore is valid (even if it's 0)
|
|
// and scaled score can be calculated.
|
|
if ($record->maxscore) {
|
|
$this->set_score($record->rawscore, $record->maxscore);
|
|
}
|
|
}
|
|
// Refresh current attempt.
|
|
return $this->save();
|
|
}
|
|
|
|
/**
|
|
* Update the current attempt record into DB.
|
|
*
|
|
* @return bool true if update is succesful
|
|
*/
|
|
public function save(): bool {
|
|
global $DB;
|
|
$this->record->timemodified = time();
|
|
// Calculate scaled score.
|
|
if ($this->scoreupdated) {
|
|
if (empty($this->record->maxscore)) {
|
|
$this->record->scaled = 0;
|
|
} else {
|
|
$this->record->scaled = $this->record->rawscore / $this->record->maxscore;
|
|
}
|
|
}
|
|
return $DB->update_record('h5pactivity_attempts', $this->record);
|
|
}
|
|
|
|
/**
|
|
* Set the attempt score.
|
|
*
|
|
* @param int|null $rawscore the attempt rawscore
|
|
* @param int|null $maxscore the attempt maxscore
|
|
*/
|
|
public function set_score(?int $rawscore, ?int $maxscore): void {
|
|
$this->record->rawscore = $rawscore;
|
|
$this->record->maxscore = $maxscore;
|
|
$this->scoreupdated = true;
|
|
}
|
|
|
|
/**
|
|
* Set the attempt duration.
|
|
*
|
|
* @param int|null $duration the attempt duration
|
|
*/
|
|
public function set_duration(?int $duration): void {
|
|
$this->record->duration = $duration;
|
|
}
|
|
|
|
/**
|
|
* Set the attempt completion.
|
|
*
|
|
* @param int|null $completion the attempt completion
|
|
*/
|
|
public function set_completion(?int $completion): void {
|
|
$this->record->completion = $completion;
|
|
}
|
|
|
|
/**
|
|
* Set the attempt success.
|
|
*
|
|
* @param int|null $success the attempt success
|
|
*/
|
|
public function set_success(?int $success): void {
|
|
$this->record->success = $success;
|
|
}
|
|
|
|
/**
|
|
* Delete the current attempt results from the DB.
|
|
*/
|
|
public function delete_results(): void {
|
|
global $DB;
|
|
$conditions = ['attemptid' => $this->record->id];
|
|
$DB->delete_records('h5pactivity_attempts_results', $conditions);
|
|
}
|
|
|
|
/**
|
|
* Return de number of results stored in this attempt.
|
|
*
|
|
* @return int the number of results stored in this attempt.
|
|
*/
|
|
public function count_results(): int {
|
|
global $DB;
|
|
$conditions = ['attemptid' => $this->record->id];
|
|
return $DB->count_records('h5pactivity_attempts_results', $conditions);
|
|
}
|
|
|
|
/**
|
|
* Return all results stored in this attempt.
|
|
*
|
|
* @return stdClass[] results records.
|
|
*/
|
|
public function get_results(): array {
|
|
global $DB;
|
|
$conditions = ['attemptid' => $this->record->id];
|
|
return $DB->get_records('h5pactivity_attempts_results', $conditions, 'id ASC');
|
|
}
|
|
|
|
/**
|
|
* Get additional data for some interaction types.
|
|
*
|
|
* @param stdClass $definition the statement object definition data
|
|
* @param stdClass $context the statement optional context
|
|
* @return string JSON encoded additional information
|
|
*/
|
|
private function get_additionals(stdClass $definition, stdClass $context): string {
|
|
$additionals = [];
|
|
$interactiontype = $definition->interactionType ?? 'other';
|
|
switch ($interactiontype) {
|
|
case 'choice':
|
|
case 'sequencing':
|
|
$additionals['choices'] = $definition->choices ?? [];
|
|
break;
|
|
|
|
case 'matching':
|
|
$additionals['source'] = $definition->source ?? [];
|
|
$additionals['target'] = $definition->target ?? [];
|
|
break;
|
|
|
|
case 'likert':
|
|
$additionals['scale'] = $definition->scale ?? [];
|
|
break;
|
|
|
|
case 'performance':
|
|
$additionals['steps'] = $definition->steps ?? [];
|
|
break;
|
|
}
|
|
|
|
$additionals['extensions'] = $definition->extensions ?? new stdClass();
|
|
|
|
// Add context extensions.
|
|
$additionals['contextExtensions'] = $context->extensions ?? new stdClass();
|
|
|
|
if (empty($additionals)) {
|
|
return '';
|
|
}
|
|
return json_encode($additionals);
|
|
}
|
|
|
|
/**
|
|
* Extract the result description from statement object definition.
|
|
*
|
|
* In principle, H5P package can send a multilang description but the reality
|
|
* is that most activities only send the "en_US" description if any and the
|
|
* activity does not have any control over it.
|
|
*
|
|
* @param stdClass $definition the statement object definition
|
|
* @return string The available description if any
|
|
*/
|
|
private function get_description_from_definition(stdClass $definition): string {
|
|
if (!isset($definition->description)) {
|
|
return '';
|
|
}
|
|
$translations = (array) $definition->description;
|
|
if (empty($translations)) {
|
|
return '';
|
|
}
|
|
// By default, H5P packages only send "en-US" descriptions.
|
|
return $translations['en-US'] ?? array_shift($translations);
|
|
}
|
|
|
|
/**
|
|
* Extract the correct pattern from statement object definition.
|
|
*
|
|
* The correct pattern depends on the type of content and the plugin
|
|
* has no control over it so we just store it in case that the statement
|
|
* data have it.
|
|
*
|
|
* @param stdClass $definition the statement object definition
|
|
* @return string The correct pattern if any
|
|
*/
|
|
private function get_correctpattern_from_definition(stdClass $definition): string {
|
|
if (!isset($definition->correctResponsesPattern)) {
|
|
return '';
|
|
}
|
|
// Only arrays are allowed.
|
|
if (is_array($definition->correctResponsesPattern)) {
|
|
return json_encode($definition->correctResponsesPattern);
|
|
}
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Return the attempt number.
|
|
*
|
|
* @return int the attempt number
|
|
*/
|
|
public function get_attempt(): int {
|
|
return $this->record->attempt;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt ID.
|
|
*
|
|
* @return int the attempt id
|
|
*/
|
|
public function get_id(): int {
|
|
return $this->record->id;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt user ID.
|
|
*
|
|
* @return int the attempt userid
|
|
*/
|
|
public function get_userid(): int {
|
|
return $this->record->userid;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt H5P timecreated.
|
|
*
|
|
* @return int the attempt timecreated
|
|
*/
|
|
public function get_timecreated(): int {
|
|
return $this->record->timecreated;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt H5P timemodified.
|
|
*
|
|
* @return int the attempt timemodified
|
|
*/
|
|
public function get_timemodified(): int {
|
|
return $this->record->timemodified;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt H5P activity ID.
|
|
*
|
|
* @return int the attempt userid
|
|
*/
|
|
public function get_h5pactivityid(): int {
|
|
return $this->record->h5pactivityid;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt maxscore.
|
|
*
|
|
* @return int the maxscore value
|
|
*/
|
|
public function get_maxscore(): int {
|
|
return $this->record->maxscore;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt rawscore.
|
|
*
|
|
* @return int the rawscore value
|
|
*/
|
|
public function get_rawscore(): int {
|
|
return $this->record->rawscore;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt duration.
|
|
*
|
|
* @return int|null the duration value
|
|
*/
|
|
public function get_duration(): ?int {
|
|
return $this->record->duration;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt completion.
|
|
*
|
|
* @return int|null the completion value
|
|
*/
|
|
public function get_completion(): ?int {
|
|
return $this->record->completion;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt success.
|
|
*
|
|
* @return int|null the success value
|
|
*/
|
|
public function get_success(): ?int {
|
|
return $this->record->success;
|
|
}
|
|
|
|
/**
|
|
* Return the attempt scaled.
|
|
*
|
|
* @return int|null the scaled value
|
|
*/
|
|
public function get_scaled(): ?int {
|
|
return is_null($this->record->scaled) ? $this->record->scaled : (int)$this->record->scaled;
|
|
}
|
|
|
|
/**
|
|
* Return if the attempt has been modified.
|
|
*
|
|
* Note: adding a result only add track information unless the statement does
|
|
* not specify subcontent. In this case this will update also the statement.
|
|
*
|
|
* @return bool if the attempt score have been modified
|
|
*/
|
|
public function get_scoreupdated(): bool {
|
|
return $this->scoreupdated;
|
|
}
|
|
}
|