mirror of
https://github.com/moodle/moodle.git
synced 2025-02-15 13:24:56 +01:00
2783 lines
110 KiB
PHP
2783 lines
110 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/>.
|
|
|
|
/**
|
|
* Library of internal classes and functions for module workshop
|
|
*
|
|
* All the workshop specific functions, needed to implement the module
|
|
* logic, should go to here. Instead of having bunch of function named
|
|
* workshop_something() taking the workshop instance as the first
|
|
* parameter, we use a class workshop that provides all methods.
|
|
*
|
|
* @package mod
|
|
* @subpackage workshop
|
|
* @copyright 2009 David Mudrak <david.mudrak@gmail.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
require_once(dirname(__FILE__).'/lib.php'); // we extend this library here
|
|
require_once($CFG->libdir . '/gradelib.php'); // we use some rounding and comparing routines here
|
|
require_once($CFG->libdir . '/filelib.php');
|
|
|
|
/**
|
|
* Full-featured workshop API
|
|
*
|
|
* This wraps the workshop database record with a set of methods that are called
|
|
* from the module itself. The class should be initialized right after you get
|
|
* $workshop, $cm and $course records at the begining of the script.
|
|
*/
|
|
class workshop {
|
|
|
|
/** return statuses of {@link add_allocation} to be passed to a workshop renderer method */
|
|
const ALLOCATION_EXISTS = -9999;
|
|
const ALLOCATION_ERROR = -9998;
|
|
|
|
/** the internal code of the workshop phases as are stored in the database */
|
|
const PHASE_SETUP = 10;
|
|
const PHASE_SUBMISSION = 20;
|
|
const PHASE_ASSESSMENT = 30;
|
|
const PHASE_EVALUATION = 40;
|
|
const PHASE_CLOSED = 50;
|
|
|
|
/** the internal code of the examples modes as are stored in the database */
|
|
const EXAMPLES_VOLUNTARY = 0;
|
|
const EXAMPLES_BEFORE_SUBMISSION = 1;
|
|
const EXAMPLES_BEFORE_ASSESSMENT = 2;
|
|
|
|
/** @var stdclass course module record */
|
|
public $cm;
|
|
|
|
/** @var stdclass course record */
|
|
public $course;
|
|
|
|
/** @var stdclass context object */
|
|
public $context;
|
|
|
|
/** @var int workshop instance identifier */
|
|
public $id;
|
|
|
|
/** @var string workshop activity name */
|
|
public $name;
|
|
|
|
/** @var string introduction or description of the activity */
|
|
public $intro;
|
|
|
|
/** @var int format of the {@link $intro} */
|
|
public $introformat;
|
|
|
|
/** @var string instructions for the submission phase */
|
|
public $instructauthors;
|
|
|
|
/** @var int format of the {@link $instructauthors} */
|
|
public $instructauthorsformat;
|
|
|
|
/** @var string instructions for the assessment phase */
|
|
public $instructreviewers;
|
|
|
|
/** @var int format of the {@link $instructreviewers} */
|
|
public $instructreviewersformat;
|
|
|
|
/** @var int timestamp of when the module was modified */
|
|
public $timemodified;
|
|
|
|
/** @var int current phase of workshop, for example {@link workshop::PHASE_SETUP} */
|
|
public $phase;
|
|
|
|
/** @var bool optional feature: students practise evaluating on example submissions from teacher */
|
|
public $useexamples;
|
|
|
|
/** @var bool optional feature: students perform peer assessment of others' work */
|
|
public $usepeerassessment;
|
|
|
|
/** @var bool optional feature: students perform self assessment of their own work */
|
|
public $useselfassessment;
|
|
|
|
/** @var float number (10, 5) unsigned, the maximum grade for submission */
|
|
public $grade;
|
|
|
|
/** @var float number (10, 5) unsigned, the maximum grade for assessment */
|
|
public $gradinggrade;
|
|
|
|
/** @var string type of the current grading strategy used in this workshop, for example 'accumulative' */
|
|
public $strategy;
|
|
|
|
/** @var string the name of the evaluation plugin to use for grading grades calculation */
|
|
public $evaluation;
|
|
|
|
/** @var int number of digits that should be shown after the decimal point when displaying grades */
|
|
public $gradedecimals;
|
|
|
|
/** @var int number of allowed submission attachments and the files embedded into submission */
|
|
public $nattachments;
|
|
|
|
/** @var bool allow submitting the work after the deadline */
|
|
public $latesubmissions;
|
|
|
|
/** @var int maximum size of the one attached file in bytes */
|
|
public $maxbytes;
|
|
|
|
/** @var int mode of example submissions support, for example {@link workshop::EXAMPLES_VOLUNTARY} */
|
|
public $examplesmode;
|
|
|
|
/** @var int if greater than 0 then the submission is not allowed before this timestamp */
|
|
public $submissionstart;
|
|
|
|
/** @var int if greater than 0 then the submission is not allowed after this timestamp */
|
|
public $submissionend;
|
|
|
|
/** @var int if greater than 0 then the peer assessment is not allowed before this timestamp */
|
|
public $assessmentstart;
|
|
|
|
/** @var int if greater than 0 then the peer assessment is not allowed after this timestamp */
|
|
public $assessmentend;
|
|
|
|
/**
|
|
* @var workshop_strategy grading strategy instance
|
|
* Do not use directly, get the instance using {@link workshop::grading_strategy_instance()}
|
|
*/
|
|
protected $strategyinstance = null;
|
|
|
|
/**
|
|
* @var workshop_evaluation grading evaluation instance
|
|
* Do not use directly, get the instance using {@link workshop::grading_evaluation_instance()}
|
|
*/
|
|
protected $evaluationinstance = null;
|
|
|
|
/**
|
|
* Initializes the workshop API instance using the data from DB
|
|
*
|
|
* Makes deep copy of all passed records properties. Replaces integer $course attribute
|
|
* with a full database record (course should not be stored in instances table anyway).
|
|
*
|
|
* @param stdClass $dbrecord Workshop instance data from {workshop} table
|
|
* @param stdClass $cm Course module record as returned by {@link get_coursemodule_from_id()}
|
|
* @param stdClass $course Course record from {course} table
|
|
* @param stdClass $context The context of the workshop instance
|
|
*/
|
|
public function __construct(stdclass $dbrecord, stdclass $cm, stdclass $course, stdclass $context=null) {
|
|
foreach ($dbrecord as $field => $value) {
|
|
if (property_exists('workshop', $field)) {
|
|
$this->{$field} = $value;
|
|
}
|
|
}
|
|
$this->cm = $cm;
|
|
$this->course = $course;
|
|
if (is_null($context)) {
|
|
$this->context = get_context_instance(CONTEXT_MODULE, $this->cm->id);
|
|
} else {
|
|
$this->context = $context;
|
|
}
|
|
$this->evaluation = 'best'; // todo make this configurable although we have no alternatives yet
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Static methods //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Return list of available allocation methods
|
|
*
|
|
* @return array Array ['string' => 'string'] of localized allocation method names
|
|
*/
|
|
public static function installed_allocators() {
|
|
$installed = get_plugin_list('workshopallocation');
|
|
$forms = array();
|
|
foreach ($installed as $allocation => $allocationpath) {
|
|
if (file_exists($allocationpath . '/lib.php')) {
|
|
$forms[$allocation] = get_string('pluginname', 'workshopallocation_' . $allocation);
|
|
}
|
|
}
|
|
// usability - make sure that manual allocation appears the first
|
|
if (isset($forms['manual'])) {
|
|
$m = array('manual' => $forms['manual']);
|
|
unset($forms['manual']);
|
|
$forms = array_merge($m, $forms);
|
|
}
|
|
return $forms;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of options for the editors that are used for submitting and assessing instructions
|
|
*
|
|
* @param stdClass $context
|
|
* @return array
|
|
*/
|
|
public static function instruction_editors_options(stdclass $context) {
|
|
return array('subdirs' => 1, 'maxbytes' => 0, 'maxfiles' => EDITOR_UNLIMITED_FILES,
|
|
'changeformat' => 1, 'context' => $context, 'noclean' => 1, 'trusttext' => 0);
|
|
}
|
|
|
|
/**
|
|
* Given the percent and the total, returns the number
|
|
*
|
|
* @param float $percent from 0 to 100
|
|
* @param float $total the 100% value
|
|
* @return float
|
|
*/
|
|
public static function percent_to_value($percent, $total) {
|
|
if ($percent < 0 or $percent > 100) {
|
|
throw new coding_exception('The percent can not be less than 0 or higher than 100');
|
|
}
|
|
|
|
return $total * $percent / 100;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of numeric values that can be used as maximum grades
|
|
*
|
|
* @return array Array of integers
|
|
*/
|
|
public static function available_maxgrades_list() {
|
|
$grades = array();
|
|
for ($i=100; $i>=0; $i--) {
|
|
$grades[$i] = $i;
|
|
}
|
|
return $grades;
|
|
}
|
|
|
|
/**
|
|
* Returns the localized list of supported examples modes
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function available_example_modes_list() {
|
|
$options = array();
|
|
$options[self::EXAMPLES_VOLUNTARY] = get_string('examplesvoluntary', 'workshop');
|
|
$options[self::EXAMPLES_BEFORE_SUBMISSION] = get_string('examplesbeforesubmission', 'workshop');
|
|
$options[self::EXAMPLES_BEFORE_ASSESSMENT] = get_string('examplesbeforeassessment', 'workshop');
|
|
return $options;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of available grading strategy methods
|
|
*
|
|
* @return array ['string' => 'string']
|
|
*/
|
|
public static function available_strategies_list() {
|
|
$installed = get_plugin_list('workshopform');
|
|
$forms = array();
|
|
foreach ($installed as $strategy => $strategypath) {
|
|
if (file_exists($strategypath . '/lib.php')) {
|
|
$forms[$strategy] = get_string('pluginname', 'workshopform_' . $strategy);
|
|
}
|
|
}
|
|
return $forms;
|
|
}
|
|
|
|
/**
|
|
* Return an array of possible values of assessment dimension weight
|
|
*
|
|
* @return array of integers 0, 1, 2, ..., 16
|
|
*/
|
|
public static function available_dimension_weights_list() {
|
|
$weights = array();
|
|
for ($i=16; $i>=0; $i--) {
|
|
$weights[$i] = $i;
|
|
}
|
|
return $weights;
|
|
}
|
|
|
|
/**
|
|
* Return an array of possible values of assessment weight
|
|
*
|
|
* Note there is no real reason why the maximum value here is 16. It used to be 10 in
|
|
* workshop 1.x and I just decided to use the same number as in the maximum weight of
|
|
* a single assessment dimension.
|
|
* The value looks reasonable, though. Teachers who would want to assign themselves
|
|
* higher weight probably do not want peer assessment really...
|
|
*
|
|
* @return array of integers 0, 1, 2, ..., 16
|
|
*/
|
|
public static function available_assessment_weights_list() {
|
|
$weights = array();
|
|
for ($i=16; $i>=0; $i--) {
|
|
$weights[$i] = $i;
|
|
}
|
|
return $weights;
|
|
}
|
|
|
|
/**
|
|
* Helper function returning the greatest common divisor
|
|
*
|
|
* @param int $a
|
|
* @param int $b
|
|
* @return int
|
|
*/
|
|
public static function gcd($a, $b) {
|
|
return ($b == 0) ? ($a):(self::gcd($b, $a % $b));
|
|
}
|
|
|
|
/**
|
|
* Helper function returning the least common multiple
|
|
*
|
|
* @param int $a
|
|
* @param int $b
|
|
* @return int
|
|
*/
|
|
public static function lcm($a, $b) {
|
|
return ($a / self::gcd($a,$b)) * $b;
|
|
}
|
|
|
|
/**
|
|
* Returns an object suitable for strings containing dates/times
|
|
*
|
|
* The returned object contains properties date, datefullshort, datetime, ... containing the given
|
|
* timestamp formatted using strftimedate, strftimedatefullshort, strftimedatetime, ... from the
|
|
* current lang's langconfig.php
|
|
* This allows translators and administrators customize the date/time format.
|
|
*
|
|
* @param int $timestamp the timestamp in UTC
|
|
* @return stdclass
|
|
*/
|
|
public static function timestamp_formats($timestamp) {
|
|
$formats = array('date', 'datefullshort', 'dateshort', 'datetime',
|
|
'datetimeshort', 'daydate', 'daydatetime', 'dayshort', 'daytime',
|
|
'monthyear', 'recent', 'recentfull', 'time');
|
|
$a = new stdclass();
|
|
foreach ($formats as $format) {
|
|
$a->{$format} = userdate($timestamp, get_string('strftime'.$format, 'langconfig'));
|
|
}
|
|
$day = userdate($timestamp, '%Y%m%d', 99, false);
|
|
$today = userdate(time(), '%Y%m%d', 99, false);
|
|
$tomorrow = userdate(time() + DAYSECS, '%Y%m%d', 99, false);
|
|
$yesterday = userdate(time() - DAYSECS, '%Y%m%d', 99, false);
|
|
$distance = (int)round(abs(time() - $timestamp) / DAYSECS);
|
|
if ($day == $today) {
|
|
$a->distanceday = get_string('daystoday', 'workshop');
|
|
} elseif ($day == $yesterday) {
|
|
$a->distanceday = get_string('daysyesterday', 'workshop');
|
|
} elseif ($day < $today) {
|
|
$a->distanceday = get_string('daysago', 'workshop', $distance);
|
|
} elseif ($day == $tomorrow) {
|
|
$a->distanceday = get_string('daystomorrow', 'workshop');
|
|
} elseif ($day > $today) {
|
|
$a->distanceday = get_string('daysleft', 'workshop', $distance);
|
|
}
|
|
return $a;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Workshop API //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Fetches all users with the capability mod/workshop:submit in the current context
|
|
*
|
|
* The returned objects contain id, lastname and firstname properties and are ordered by lastname,firstname
|
|
*
|
|
* @todo handle with limits and groups
|
|
* @param bool $musthavesubmission If true, return only users who have already submitted. All possible authors otherwise.
|
|
* @return array array[userid] => stdclass{->id ->lastname ->firstname}
|
|
*/
|
|
public function get_potential_authors($musthavesubmission=true) {
|
|
$users = get_users_by_capability($this->context, 'mod/workshop:submit',
|
|
'u.id,u.lastname,u.firstname', 'u.lastname,u.firstname,u.id', '', '', '', '', false, false, true);
|
|
if ($musthavesubmission) {
|
|
$users = array_intersect_key($users, $this->users_with_submission(array_keys($users)));
|
|
}
|
|
return $users;
|
|
}
|
|
|
|
/**
|
|
* Fetches all users with the capability mod/workshop:peerassess in the current context
|
|
*
|
|
* The returned objects contain id, lastname and firstname properties and are ordered by lastname,firstname
|
|
*
|
|
* @todo handle with limits and groups
|
|
* @param bool $musthavesubmission If true, return only users who have already submitted. All possible users otherwise.
|
|
* @return array array[userid] => stdclass{->id ->lastname ->firstname}
|
|
*/
|
|
public function get_potential_reviewers($musthavesubmission=false) {
|
|
$users = get_users_by_capability($this->context, 'mod/workshop:peerassess',
|
|
'u.id, u.lastname, u.firstname', 'u.lastname,u.firstname,u.id', '', '', '', '', false, false, true);
|
|
if ($musthavesubmission) {
|
|
// users without their own submission can not be reviewers
|
|
$users = array_intersect_key($users, $this->users_with_submission(array_keys($users)));
|
|
}
|
|
return $users;
|
|
}
|
|
|
|
/**
|
|
* Groups the given users by the group membership
|
|
*
|
|
* This takes the module grouping settings into account. If "Available for group members only"
|
|
* is set, returns only groups withing the course module grouping. Always returns group [0] with
|
|
* all the given users.
|
|
*
|
|
* @param array $users array[userid] => stdclass{->id ->lastname ->firstname}
|
|
* @return array array[groupid][userid] => stdclass{->id ->lastname ->firstname}
|
|
*/
|
|
public function get_grouped($users) {
|
|
global $DB;
|
|
global $CFG;
|
|
|
|
$grouped = array(); // grouped users to be returned
|
|
if (empty($users)) {
|
|
return $grouped;
|
|
}
|
|
if (!empty($CFG->enablegroupmembersonly) and $this->cm->groupmembersonly) {
|
|
// Available for group members only - the workshop is available only
|
|
// to users assigned to groups within the selected grouping, or to
|
|
// any group if no grouping is selected.
|
|
$groupingid = $this->cm->groupingid;
|
|
// All users that are members of at least one group will be
|
|
// added into a virtual group id 0
|
|
$grouped[0] = array();
|
|
} else {
|
|
$groupingid = 0;
|
|
// there is no need to be member of a group so $grouped[0] will contain
|
|
// all users
|
|
$grouped[0] = $users;
|
|
}
|
|
$gmemberships = groups_get_all_groups($this->cm->course, array_keys($users), $groupingid,
|
|
'gm.id,gm.groupid,gm.userid');
|
|
foreach ($gmemberships as $gmembership) {
|
|
if (!isset($grouped[$gmembership->groupid])) {
|
|
$grouped[$gmembership->groupid] = array();
|
|
}
|
|
$grouped[$gmembership->groupid][$gmembership->userid] = $users[$gmembership->userid];
|
|
$grouped[0][$gmembership->userid] = $users[$gmembership->userid];
|
|
}
|
|
return $grouped;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of all allocations (i.e. assigned assessments) in the workshop
|
|
*
|
|
* Assessments of example submissions are ignored
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_allocations() {
|
|
global $DB;
|
|
|
|
$sql = 'SELECT a.id, a.submissionid, a.reviewerid, s.authorid
|
|
FROM {workshop_assessments} a
|
|
INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
|
|
WHERE s.example = 0 AND s.workshopid = :workshopid';
|
|
$params = array('workshopid' => $this->id);
|
|
|
|
return $DB->get_records_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Returns submissions from this workshop
|
|
*
|
|
* Fetches data from {workshop_submissions} and adds some useful information from other
|
|
* tables. Does not return textual fields to prevent possible memory lack issues.
|
|
*
|
|
* @param mixed $authorid int|array|'all' If set to [array of] integer, return submission[s] of the given user[s] only
|
|
* @return array of records or an empty array
|
|
*/
|
|
public function get_submissions($authorid='all') {
|
|
global $DB;
|
|
|
|
$sql = 'SELECT s.id, s.workshopid, s.example, s.authorid, s.timecreated, s.timemodified,
|
|
s.title, s.grade, s.gradeover, s.gradeoverby, s.published,
|
|
u.lastname AS authorlastname, u.firstname AS authorfirstname,
|
|
u.picture AS authorpicture, u.imagealt AS authorimagealt, u.email AS authoremail,
|
|
t.lastname AS overlastname, t.firstname AS overfirstname,
|
|
t.picture AS overpicture, t.imagealt AS overimagealt, t.email AS overemail
|
|
FROM {workshop_submissions} s
|
|
INNER JOIN {user} u ON (s.authorid = u.id)
|
|
LEFT JOIN {user} t ON (s.gradeoverby = t.id)
|
|
WHERE s.example = 0 AND s.workshopid = :workshopid';
|
|
$params = array('workshopid' => $this->id);
|
|
|
|
if ('all' === $authorid) {
|
|
// no additional conditions
|
|
} elseif (!empty($authorid)) {
|
|
list($usql, $uparams) = $DB->get_in_or_equal($authorid, SQL_PARAMS_NAMED);
|
|
$sql .= " AND authorid $usql";
|
|
$params = array_merge($params, $uparams);
|
|
} else {
|
|
// $authorid is empty
|
|
return array();
|
|
}
|
|
$sql .= ' ORDER BY u.lastname, u.firstname';
|
|
|
|
return $DB->get_records_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Returns a submission record with the author's data
|
|
*
|
|
* @param int $id submission id
|
|
* @return stdclass
|
|
*/
|
|
public function get_submission_by_id($id) {
|
|
global $DB;
|
|
|
|
// we intentionally check the workshopid here, too, so the workshop can't touch submissions
|
|
// from other instances
|
|
$sql = 'SELECT s.*,
|
|
u.lastname AS authorlastname, u.firstname AS authorfirstname, u.id AS authorid,
|
|
u.picture AS authorpicture, u.imagealt AS authorimagealt, u.email AS authoremail
|
|
FROM {workshop_submissions} s
|
|
INNER JOIN {user} u ON (s.authorid = u.id)
|
|
WHERE s.example = 0 AND s.workshopid = :workshopid AND s.id = :id';
|
|
$params = array('workshopid' => $this->id, 'id' => $id);
|
|
return $DB->get_record_sql($sql, $params, MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Returns a submission submitted by the given author
|
|
*
|
|
* @param int $id author id
|
|
* @return stdclass|false
|
|
*/
|
|
public function get_submission_by_author($authorid) {
|
|
global $DB;
|
|
|
|
if (empty($authorid)) {
|
|
return false;
|
|
}
|
|
$sql = 'SELECT s.*,
|
|
u.lastname AS authorlastname, u.firstname AS authorfirstname, u.id AS authorid,
|
|
u.picture AS authorpicture, u.imagealt AS authorimagealt, u.email AS authoremail
|
|
FROM {workshop_submissions} s
|
|
INNER JOIN {user} u ON (s.authorid = u.id)
|
|
WHERE s.example = 0 AND s.workshopid = :workshopid AND s.authorid = :authorid';
|
|
$params = array('workshopid' => $this->id, 'authorid' => $authorid);
|
|
return $DB->get_record_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Returns published submissions with their authors data
|
|
*
|
|
* @return array of stdclass
|
|
*/
|
|
public function get_published_submissions($orderby='finalgrade DESC') {
|
|
global $DB;
|
|
|
|
$sql = "SELECT s.id, s.authorid, s.timecreated, s.timemodified,
|
|
s.title, s.grade, s.gradeover, COALESCE(s.gradeover,s.grade) AS finalgrade,
|
|
u.lastname AS authorlastname, u.firstname AS authorfirstname, u.id AS authorid,
|
|
u.picture AS authorpicture, u.imagealt AS authorimagealt, u.email AS authoremail
|
|
FROM {workshop_submissions} s
|
|
INNER JOIN {user} u ON (s.authorid = u.id)
|
|
WHERE s.example = 0 AND s.workshopid = :workshopid AND s.published = 1
|
|
ORDER BY $orderby";
|
|
$params = array('workshopid' => $this->id);
|
|
return $DB->get_records_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Returns full record of the given example submission
|
|
*
|
|
* @param int $id example submission od
|
|
* @return object
|
|
*/
|
|
public function get_example_by_id($id) {
|
|
global $DB;
|
|
return $DB->get_record('workshop_submissions',
|
|
array('id' => $id, 'workshopid' => $this->id, 'example' => 1), '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Returns the list of example submissions in this workshop with reference assessments attached
|
|
*
|
|
* @return array of objects or an empty array
|
|
* @see workshop::prepare_example_summary()
|
|
*/
|
|
public function get_examples_for_manager() {
|
|
global $DB;
|
|
|
|
$sql = 'SELECT s.id, s.title,
|
|
a.id AS assessmentid, a.grade, a.gradinggrade
|
|
FROM {workshop_submissions} s
|
|
LEFT JOIN {workshop_assessments} a ON (a.submissionid = s.id AND a.weight = 1)
|
|
WHERE s.example = 1 AND s.workshopid = :workshopid
|
|
ORDER BY s.title';
|
|
return $DB->get_records_sql($sql, array('workshopid' => $this->id));
|
|
}
|
|
|
|
/**
|
|
* Returns the list of all example submissions in this workshop with the information of assessments done by the given user
|
|
*
|
|
* @param int $reviewerid user id
|
|
* @return array of objects, indexed by example submission id
|
|
* @see workshop::prepare_example_summary()
|
|
*/
|
|
public function get_examples_for_reviewer($reviewerid) {
|
|
global $DB;
|
|
|
|
if (empty($reviewerid)) {
|
|
return false;
|
|
}
|
|
$sql = 'SELECT s.id, s.title,
|
|
a.id AS assessmentid, a.grade, a.gradinggrade
|
|
FROM {workshop_submissions} s
|
|
LEFT JOIN {workshop_assessments} a ON (a.submissionid = s.id AND a.reviewerid = :reviewerid AND a.weight = 0)
|
|
WHERE s.example = 1 AND s.workshopid = :workshopid
|
|
ORDER BY s.title';
|
|
return $DB->get_records_sql($sql, array('workshopid' => $this->id, 'reviewerid' => $reviewerid));
|
|
}
|
|
|
|
/**
|
|
* Prepares renderable submission component
|
|
*
|
|
* @param stdClass $record required by {@see workshop_submission}
|
|
* @param bool $showauthor show the author-related information
|
|
* @return workshop_submission
|
|
*/
|
|
public function prepare_submission(stdClass $record, $showauthor = false) {
|
|
|
|
$submission = new workshop_submission($record, $showauthor);
|
|
$submission->url = $this->submission_url($record->id);
|
|
|
|
return $submission;
|
|
}
|
|
|
|
/**
|
|
* Prepares renderable submission summary component
|
|
*
|
|
* @param stdClass $record required by {@see workshop_submission_summary}
|
|
* @param bool $showauthor show the author-related information
|
|
* @return workshop_submission_summary
|
|
*/
|
|
public function prepare_submission_summary(stdClass $record, $showauthor = false) {
|
|
|
|
$summary = new workshop_submission_summary($record, $showauthor);
|
|
$summary->url = $this->submission_url($record->id);
|
|
|
|
return $summary;
|
|
}
|
|
|
|
/**
|
|
* Prepares renderable example submission component
|
|
*
|
|
* @param stdClass $record required by {@see workshop_example_submission}
|
|
* @return workshop_example_submission
|
|
*/
|
|
public function prepare_example_submission(stdClass $record) {
|
|
|
|
$example = new workshop_example_submission($record);
|
|
|
|
return $example;
|
|
}
|
|
|
|
/**
|
|
* Prepares renderable example submission summary component
|
|
*
|
|
* If the example is editable, the caller must set the 'editable' flag explicitly.
|
|
*
|
|
* @param stdClass $example as returned by {@link workshop::get_examples_for_manager()} or {@link workshop::get_examples_for_reviewer()}
|
|
* @return workshop_example_submission_summary to be rendered
|
|
*/
|
|
public function prepare_example_summary(stdClass $example) {
|
|
|
|
$summary = new workshop_example_submission_summary($example);
|
|
|
|
if (is_null($example->grade)) {
|
|
$summary->status = 'notgraded';
|
|
$summary->assesslabel = get_string('assess', 'workshop');
|
|
} else {
|
|
$summary->status = 'graded';
|
|
$summary->assesslabel = get_string('reassess', 'workshop');
|
|
}
|
|
|
|
$summary->gradeinfo = new stdclass();
|
|
$summary->gradeinfo->received = $this->real_grade($example->grade);
|
|
$summary->gradeinfo->max = $this->real_grade(100);
|
|
|
|
$summary->url = new moodle_url($this->exsubmission_url($example->id));
|
|
$summary->editurl = new moodle_url($this->exsubmission_url($example->id), array('edit' => 'on'));
|
|
$summary->assessurl = new moodle_url($this->exsubmission_url($example->id), array('assess' => 'on', 'sesskey' => sesskey()));
|
|
|
|
return $summary;
|
|
}
|
|
|
|
/**
|
|
* Removes the submission and all relevant data
|
|
*
|
|
* @param stdClass $submission record to delete
|
|
* @return void
|
|
*/
|
|
public function delete_submission(stdclass $submission) {
|
|
global $DB;
|
|
$assessments = $DB->get_records('workshop_assessments', array('submissionid' => $submission->id), '', 'id');
|
|
$this->delete_assessment(array_keys($assessments));
|
|
$DB->delete_records('workshop_submissions', array('id' => $submission->id));
|
|
}
|
|
|
|
/**
|
|
* Returns the list of all assessments in the workshop with some data added
|
|
*
|
|
* Fetches data from {workshop_assessments} and adds some useful information from other
|
|
* tables. The returned object does not contain textual fields (i.e. comments) to prevent memory
|
|
* lack issues.
|
|
*
|
|
* @return array [assessmentid] => assessment stdclass
|
|
*/
|
|
public function get_all_assessments() {
|
|
global $DB;
|
|
|
|
$sql = 'SELECT a.id, a.submissionid, a.reviewerid, a.timecreated, a.timemodified,
|
|
a.grade, a.gradinggrade, a.gradinggradeover, a.gradinggradeoverby,
|
|
reviewer.id AS reviewerid,reviewer.firstname AS reviewerfirstname,reviewer.lastname as reviewerlastname,
|
|
s.title,
|
|
author.id AS authorid, author.firstname AS authorfirstname,author.lastname AS authorlastname
|
|
FROM {workshop_assessments} a
|
|
INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
|
|
INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
|
|
INNER JOIN {user} author ON (s.authorid = author.id)
|
|
WHERE s.workshopid = :workshopid AND s.example = 0
|
|
ORDER BY reviewer.lastname, reviewer.firstname';
|
|
$params = array('workshopid' => $this->id);
|
|
|
|
return $DB->get_records_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Get the complete information about the given assessment
|
|
*
|
|
* @param int $id Assessment ID
|
|
* @return stdclass
|
|
*/
|
|
public function get_assessment_by_id($id) {
|
|
global $DB;
|
|
|
|
$sql = 'SELECT a.*,
|
|
reviewer.id AS reviewerid,reviewer.firstname AS reviewerfirstname,reviewer.lastname as reviewerlastname,
|
|
s.title,
|
|
author.id AS authorid, author.firstname AS authorfirstname,author.lastname as authorlastname
|
|
FROM {workshop_assessments} a
|
|
INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
|
|
INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
|
|
INNER JOIN {user} author ON (s.authorid = author.id)
|
|
WHERE a.id = :id AND s.workshopid = :workshopid';
|
|
$params = array('id' => $id, 'workshopid' => $this->id);
|
|
|
|
return $DB->get_record_sql($sql, $params, MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Get the complete information about the user's assessment of the given submission
|
|
*
|
|
* @param int $sid submission ID
|
|
* @param int $uid user ID of the reviewer
|
|
* @return false|stdclass false if not found, stdclass otherwise
|
|
*/
|
|
public function get_assessment_of_submission_by_user($submissionid, $reviewerid) {
|
|
global $DB;
|
|
|
|
$sql = 'SELECT a.*,
|
|
reviewer.id AS reviewerid,reviewer.firstname AS reviewerfirstname,reviewer.lastname as reviewerlastname,
|
|
s.title,
|
|
author.id AS authorid, author.firstname AS authorfirstname,author.lastname as authorlastname
|
|
FROM {workshop_assessments} a
|
|
INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
|
|
INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
|
|
INNER JOIN {user} author ON (s.authorid = author.id)
|
|
WHERE s.id = :sid AND reviewer.id = :rid AND s.workshopid = :workshopid';
|
|
$params = array('sid' => $submissionid, 'rid' => $reviewerid, 'workshopid' => $this->id);
|
|
|
|
return $DB->get_record_sql($sql, $params, IGNORE_MISSING);
|
|
}
|
|
|
|
/**
|
|
* Get the complete information about all assessments of the given submission
|
|
*
|
|
* @param int $submissionid
|
|
* @return array
|
|
*/
|
|
public function get_assessments_of_submission($submissionid) {
|
|
global $DB;
|
|
|
|
$sql = 'SELECT a.*,
|
|
reviewer.id AS reviewerid,reviewer.firstname AS reviewerfirstname,reviewer.lastname AS reviewerlastname
|
|
FROM {workshop_assessments} a
|
|
INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
|
|
INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
|
|
WHERE s.example = 0 AND s.id = :submissionid AND s.workshopid = :workshopid';
|
|
$params = array('submissionid' => $submissionid, 'workshopid' => $this->id);
|
|
|
|
return $DB->get_records_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Get the complete information about all assessments allocated to the given reviewer
|
|
*
|
|
* @param int $reviewerid
|
|
* @return array
|
|
*/
|
|
public function get_assessments_by_reviewer($reviewerid) {
|
|
global $DB;
|
|
|
|
$sql = 'SELECT a.*,
|
|
reviewer.id AS reviewerid,reviewer.firstname AS reviewerfirstname,reviewer.lastname AS reviewerlastname,
|
|
s.id AS submissionid, s.title AS submissiontitle, s.timecreated AS submissioncreated,
|
|
s.timemodified AS submissionmodified,
|
|
author.id AS authorid, author.firstname AS authorfirstname,author.lastname AS authorlastname,
|
|
author.picture AS authorpicture, author.imagealt AS authorimagealt, author.email AS authoremail
|
|
FROM {workshop_assessments} a
|
|
INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
|
|
INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
|
|
INNER JOIN {user} author ON (s.authorid = author.id)
|
|
WHERE s.example = 0 AND reviewer.id = :reviewerid AND s.workshopid = :workshopid';
|
|
$params = array('reviewerid' => $reviewerid, 'workshopid' => $this->id);
|
|
|
|
return $DB->get_records_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Allocate a submission to a user for review
|
|
*
|
|
* @param stdClass $submission Submission object with at least id property
|
|
* @param int $reviewerid User ID
|
|
* @param int $weight of the new assessment, from 0 to 16
|
|
* @param bool $bulk repeated inserts into DB expected
|
|
* @return int ID of the new assessment or an error code
|
|
*/
|
|
public function add_allocation(stdclass $submission, $reviewerid, $weight=1, $bulk=false) {
|
|
global $DB;
|
|
|
|
if ($DB->record_exists('workshop_assessments', array('submissionid' => $submission->id, 'reviewerid' => $reviewerid))) {
|
|
return self::ALLOCATION_EXISTS;
|
|
}
|
|
|
|
$weight = (int)$weight;
|
|
if ($weight < 0) {
|
|
$weight = 0;
|
|
}
|
|
if ($weight > 16) {
|
|
$weight = 16;
|
|
}
|
|
|
|
$now = time();
|
|
$assessment = new stdclass();
|
|
$assessment->submissionid = $submission->id;
|
|
$assessment->reviewerid = $reviewerid;
|
|
$assessment->timecreated = $now; // do not set timemodified here
|
|
$assessment->weight = $weight;
|
|
$assessment->generalcommentformat = editors_get_preferred_format();
|
|
$assessment->feedbackreviewerformat = editors_get_preferred_format();
|
|
|
|
return $DB->insert_record('workshop_assessments', $assessment, true, $bulk);
|
|
}
|
|
|
|
/**
|
|
* Delete assessment record or records
|
|
*
|
|
* @param mixed $id int|array assessment id or array of assessments ids
|
|
* @return bool false if $id not a valid parameter, true otherwise
|
|
*/
|
|
public function delete_assessment($id) {
|
|
global $DB;
|
|
|
|
// todo remove all given grades from workshop_grades;
|
|
|
|
if (is_array($id)) {
|
|
return $DB->delete_records_list('workshop_assessments', 'id', $id);
|
|
} else {
|
|
return $DB->delete_records('workshop_assessments', array('id' => $id));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns instance of grading strategy class
|
|
*
|
|
* @return stdclass Instance of a grading strategy
|
|
*/
|
|
public function grading_strategy_instance() {
|
|
global $CFG; // because we require other libs here
|
|
|
|
if (is_null($this->strategyinstance)) {
|
|
$strategylib = dirname(__FILE__) . '/form/' . $this->strategy . '/lib.php';
|
|
if (is_readable($strategylib)) {
|
|
require_once($strategylib);
|
|
} else {
|
|
throw new coding_exception('the grading forms subplugin must contain library ' . $strategylib);
|
|
}
|
|
$classname = 'workshop_' . $this->strategy . '_strategy';
|
|
$this->strategyinstance = new $classname($this);
|
|
if (!in_array('workshop_strategy', class_implements($this->strategyinstance))) {
|
|
throw new coding_exception($classname . ' does not implement workshop_strategy interface');
|
|
}
|
|
}
|
|
return $this->strategyinstance;
|
|
}
|
|
|
|
/**
|
|
* Returns instance of grading evaluation class
|
|
*
|
|
* @return stdclass Instance of a grading evaluation
|
|
*/
|
|
public function grading_evaluation_instance() {
|
|
global $CFG; // because we require other libs here
|
|
|
|
if (is_null($this->evaluationinstance)) {
|
|
$evaluationlib = dirname(__FILE__) . '/eval/' . $this->evaluation . '/lib.php';
|
|
if (is_readable($evaluationlib)) {
|
|
require_once($evaluationlib);
|
|
} else {
|
|
throw new coding_exception('the grading evaluation subplugin must contain library ' . $evaluationlib);
|
|
}
|
|
$classname = 'workshop_' . $this->evaluation . '_evaluation';
|
|
$this->evaluationinstance = new $classname($this);
|
|
if (!in_array('workshop_evaluation', class_implements($this->evaluationinstance))) {
|
|
throw new coding_exception($classname . ' does not implement workshop_evaluation interface');
|
|
}
|
|
}
|
|
return $this->evaluationinstance;
|
|
}
|
|
|
|
/**
|
|
* Returns instance of submissions allocator
|
|
*
|
|
* @param string $method The name of the allocation method, must be PARAM_ALPHA
|
|
* @return stdclass Instance of submissions allocator
|
|
*/
|
|
public function allocator_instance($method) {
|
|
global $CFG; // because we require other libs here
|
|
|
|
$allocationlib = dirname(__FILE__) . '/allocation/' . $method . '/lib.php';
|
|
if (is_readable($allocationlib)) {
|
|
require_once($allocationlib);
|
|
} else {
|
|
throw new coding_exception('Unable to find the allocation library ' . $allocationlib);
|
|
}
|
|
$classname = 'workshop_' . $method . '_allocator';
|
|
return new $classname($this);
|
|
}
|
|
|
|
/**
|
|
* @return moodle_url of this workshop's view page
|
|
*/
|
|
public function view_url() {
|
|
global $CFG;
|
|
return new moodle_url('/mod/workshop/view.php', array('id' => $this->cm->id));
|
|
}
|
|
|
|
/**
|
|
* @return moodle_url of the page for editing this workshop's grading form
|
|
*/
|
|
public function editform_url() {
|
|
global $CFG;
|
|
return new moodle_url('/mod/workshop/editform.php', array('cmid' => $this->cm->id));
|
|
}
|
|
|
|
/**
|
|
* @return moodle_url of the page for previewing this workshop's grading form
|
|
*/
|
|
public function previewform_url() {
|
|
global $CFG;
|
|
return new moodle_url('/mod/workshop/editformpreview.php', array('cmid' => $this->cm->id));
|
|
}
|
|
|
|
/**
|
|
* @param int $assessmentid The ID of assessment record
|
|
* @return moodle_url of the assessment page
|
|
*/
|
|
public function assess_url($assessmentid) {
|
|
global $CFG;
|
|
$assessmentid = clean_param($assessmentid, PARAM_INT);
|
|
return new moodle_url('/mod/workshop/assessment.php', array('asid' => $assessmentid));
|
|
}
|
|
|
|
/**
|
|
* @param int $assessmentid The ID of assessment record
|
|
* @return moodle_url of the example assessment page
|
|
*/
|
|
public function exassess_url($assessmentid) {
|
|
global $CFG;
|
|
$assessmentid = clean_param($assessmentid, PARAM_INT);
|
|
return new moodle_url('/mod/workshop/exassessment.php', array('asid' => $assessmentid));
|
|
}
|
|
|
|
/**
|
|
* @return moodle_url of the page to view a submission, defaults to the own one
|
|
*/
|
|
public function submission_url($id=null) {
|
|
global $CFG;
|
|
return new moodle_url('/mod/workshop/submission.php', array('cmid' => $this->cm->id, 'id' => $id));
|
|
}
|
|
|
|
/**
|
|
* @param int $id example submission id
|
|
* @return moodle_url of the page to view an example submission
|
|
*/
|
|
public function exsubmission_url($id) {
|
|
global $CFG;
|
|
return new moodle_url('/mod/workshop/exsubmission.php', array('cmid' => $this->cm->id, 'id' => $id));
|
|
}
|
|
|
|
/**
|
|
* @param int $sid submission id
|
|
* @param array $aid of int assessment ids
|
|
* @return moodle_url of the page to compare assessments of the given submission
|
|
*/
|
|
public function compare_url($sid, array $aids) {
|
|
global $CFG;
|
|
|
|
$url = new moodle_url('/mod/workshop/compare.php', array('cmid' => $this->cm->id, 'sid' => $sid));
|
|
$i = 0;
|
|
foreach ($aids as $aid) {
|
|
$url->param("aid{$i}", $aid);
|
|
$i++;
|
|
}
|
|
return $url;
|
|
}
|
|
|
|
/**
|
|
* @param int $sid submission id
|
|
* @param int $aid assessment id
|
|
* @return moodle_url of the page to compare the reference assessments of the given example submission
|
|
*/
|
|
public function excompare_url($sid, $aid) {
|
|
global $CFG;
|
|
return new moodle_url('/mod/workshop/excompare.php', array('cmid' => $this->cm->id, 'sid' => $sid, 'aid' => $aid));
|
|
}
|
|
|
|
/**
|
|
* @return moodle_url of the mod_edit form
|
|
*/
|
|
public function updatemod_url() {
|
|
global $CFG;
|
|
return new moodle_url('/course/modedit.php', array('update' => $this->cm->id, 'return' => 1));
|
|
}
|
|
|
|
/**
|
|
* @param string $method allocation method
|
|
* @return moodle_url to the allocation page
|
|
*/
|
|
public function allocation_url($method=null) {
|
|
global $CFG;
|
|
$params = array('cmid' => $this->cm->id);
|
|
if (!empty($method)) {
|
|
$params['method'] = $method;
|
|
}
|
|
return new moodle_url('/mod/workshop/allocation.php', $params);
|
|
}
|
|
|
|
/**
|
|
* @param int $phasecode The internal phase code
|
|
* @return moodle_url of the script to change the current phase to $phasecode
|
|
*/
|
|
public function switchphase_url($phasecode) {
|
|
global $CFG;
|
|
$phasecode = clean_param($phasecode, PARAM_INT);
|
|
return new moodle_url('/mod/workshop/switchphase.php', array('cmid' => $this->cm->id, 'phase' => $phasecode));
|
|
}
|
|
|
|
/**
|
|
* @return moodle_url to the aggregation page
|
|
*/
|
|
public function aggregate_url() {
|
|
global $CFG;
|
|
return new moodle_url('/mod/workshop/aggregate.php', array('cmid' => $this->cm->id));
|
|
}
|
|
|
|
/**
|
|
* @return moodle_url of this workshop's toolbox page
|
|
*/
|
|
public function toolbox_url($tool) {
|
|
global $CFG;
|
|
return new moodle_url('/mod/workshop/toolbox.php', array('id' => $this->cm->id, 'tool' => $tool));
|
|
}
|
|
|
|
/**
|
|
* Workshop wrapper around {@see add_to_log()}
|
|
*
|
|
* @param string $action to be logged
|
|
* @param moodle_url $url absolute url as returned by {@see workshop::submission_url()} and friends
|
|
* @param mixed $info additional info, usually id in a table
|
|
*/
|
|
public function log($action, moodle_url $url = null, $info = null) {
|
|
|
|
if (is_null($url)) {
|
|
$url = $this->view_url();
|
|
}
|
|
|
|
if (is_null($info)) {
|
|
$info = $this->id;
|
|
}
|
|
|
|
$logurl = $this->log_convert_url($url);
|
|
add_to_log($this->course->id, 'workshop', $action, $logurl, $info, $this->cm->id);
|
|
}
|
|
|
|
/**
|
|
* Are users allowed to create their submissions?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function creating_submission_allowed() {
|
|
$now = time();
|
|
|
|
if ($this->latesubmissions) {
|
|
if ($this->phase != self::PHASE_SUBMISSION and $this->phase != self::PHASE_ASSESSMENT) {
|
|
// late submissions are allowed in the submission and assessment phase only
|
|
return false;
|
|
}
|
|
if (!empty($this->submissionstart) and $this->submissionstart > $now) {
|
|
// late submissions are not allowed before the submission start
|
|
return false;
|
|
}
|
|
return true;
|
|
|
|
} else {
|
|
if ($this->phase != self::PHASE_SUBMISSION) {
|
|
// submissions are allowed during the submission phase only
|
|
return false;
|
|
}
|
|
if (!empty($this->submissionstart) and $this->submissionstart > $now) {
|
|
// if enabled, submitting is not allowed before the date/time defined in the mod_form
|
|
return false;
|
|
}
|
|
if (!empty($this->submissionend) and $now > $this->submissionend ) {
|
|
// if enabled, submitting is not allowed after the date/time defined in the mod_form unless late submission is allowed
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Are users allowed to modify their existing submission?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function modifying_submission_allowed() {
|
|
$now = time();
|
|
|
|
if ($this->phase != self::PHASE_SUBMISSION) {
|
|
// submissions can be edited during the submission phase only
|
|
return false;
|
|
}
|
|
if (!empty($this->submissionstart) and $this->submissionstart > $now) {
|
|
// if enabled, submitting is not allowed before the date/time defined in the mod_form
|
|
return false;
|
|
}
|
|
if (!empty($this->submissionend) and $now > $this->submissionend) {
|
|
// if enabled, submitting is not allowed after the date/time defined in the mod_form unless late submission is allowed
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Are reviewers allowed to create/edit their assessments?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function assessing_allowed() {
|
|
if ($this->phase != self::PHASE_ASSESSMENT) {
|
|
// assessing is not allowed but in the assessment phase
|
|
return false;
|
|
}
|
|
$now = time();
|
|
if (!empty($this->assessmentstart) and $this->assessmentstart > $now) {
|
|
// if enabled, assessing is not allowed before the date/time defined in the mod_form
|
|
return false;
|
|
}
|
|
if (!empty($this->assessmentend) and $now > $this->assessmentend ) {
|
|
// if enabled, assessing is not allowed after the date/time defined in the mod_form
|
|
return false;
|
|
}
|
|
// here we go, assessing is allowed
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Are reviewers allowed to create/edit their assessments of the example submissions?
|
|
*
|
|
* Returns null if example submissions are not enabled in this workshop. Otherwise returns
|
|
* true or false. Note this does not check other conditions like the number of already
|
|
* assessed examples, examples mode etc.
|
|
*
|
|
* @return null|bool
|
|
*/
|
|
public function assessing_examples_allowed() {
|
|
if (empty($this->useexamples)) {
|
|
return null;
|
|
}
|
|
if (self::EXAMPLES_VOLUNTARY == $this->examplesmode) {
|
|
return true;
|
|
}
|
|
if (self::EXAMPLES_BEFORE_SUBMISSION == $this->examplesmode and self::PHASE_SUBMISSION == $this->phase) {
|
|
return true;
|
|
}
|
|
if (self::EXAMPLES_BEFORE_ASSESSMENT == $this->examplesmode and self::PHASE_ASSESSMENT == $this->phase) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Are the peer-reviews available to the authors?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function assessments_available() {
|
|
return $this->phase == self::PHASE_CLOSED;
|
|
}
|
|
|
|
/**
|
|
* Switch to a new workshop phase
|
|
*
|
|
* Modifies the underlying database record. You should terminate the script shortly after calling this.
|
|
*
|
|
* @param int $newphase new phase code
|
|
* @return bool true if success, false otherwise
|
|
*/
|
|
public function switch_phase($newphase) {
|
|
global $DB;
|
|
|
|
$known = $this->available_phases_list();
|
|
if (!isset($known[$newphase])) {
|
|
return false;
|
|
}
|
|
|
|
if (self::PHASE_CLOSED == $newphase) {
|
|
// push the grades into the gradebook
|
|
$workshop = new stdclass();
|
|
foreach ($this as $property => $value) {
|
|
$workshop->{$property} = $value;
|
|
}
|
|
$workshop->course = $this->course->id;
|
|
$workshop->cmidnumber = $this->cm->id;
|
|
$workshop->modname = 'workshop';
|
|
workshop_update_grades($workshop);
|
|
}
|
|
|
|
$DB->set_field('workshop', 'phase', $newphase, array('id' => $this->id));
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Saves a raw grade for submission as calculated from the assessment form fields
|
|
*
|
|
* @param array $assessmentid assessment record id, must exists
|
|
* @param mixed $grade raw percentual grade from 0.00000 to 100.00000
|
|
* @return false|float the saved grade
|
|
*/
|
|
public function set_peer_grade($assessmentid, $grade) {
|
|
global $DB;
|
|
|
|
if (is_null($grade)) {
|
|
return false;
|
|
}
|
|
$data = new stdclass();
|
|
$data->id = $assessmentid;
|
|
$data->grade = $grade;
|
|
$data->timemodified = time();
|
|
$DB->update_record('workshop_assessments', $data);
|
|
return $grade;
|
|
}
|
|
|
|
/**
|
|
* Prepares data object with all workshop grades to be rendered
|
|
*
|
|
* @param int $userid the user we are preparing the report for
|
|
* @param mixed $groups single group or array of groups - only show users who are in one of these group(s). Defaults to all
|
|
* @param int $page the current page (for the pagination)
|
|
* @param int $perpage participants per page (for the pagination)
|
|
* @param string $sortby lastname|firstname|submissiontitle|submissiongrade|gradinggrade
|
|
* @param string $sorthow ASC|DESC
|
|
* @return stdclass data for the renderer
|
|
*/
|
|
public function prepare_grading_report_data($userid, $groups, $page, $perpage, $sortby, $sorthow) {
|
|
global $DB;
|
|
|
|
$canviewall = has_capability('mod/workshop:viewallassessments', $this->context, $userid);
|
|
$isparticipant = has_any_capability(array('mod/workshop:submit', 'mod/workshop:peerassess'), $this->context, $userid);
|
|
|
|
if (!$canviewall and !$isparticipant) {
|
|
// who the hell is this?
|
|
return array();
|
|
}
|
|
|
|
if (!in_array($sortby, array('lastname','firstname','submissiontitle','submissiongrade','gradinggrade'))) {
|
|
$sortby = 'lastname';
|
|
}
|
|
|
|
if (!($sorthow === 'ASC' or $sorthow === 'DESC')) {
|
|
$sorthow = 'ASC';
|
|
}
|
|
|
|
// get the list of user ids to be displayed
|
|
if ($canviewall) {
|
|
// fetch the list of ids of all workshop participants - this may get really long so fetch just id
|
|
$participants = get_users_by_capability($this->context, array('mod/workshop:submit', 'mod/workshop:peerassess'),
|
|
'u.id', '', '', '', $groups, '', false, false, true);
|
|
} else {
|
|
// this is an ordinary workshop participant (aka student) - display the report just for him/her
|
|
$participants = array($userid => (object)array('id' => $userid));
|
|
}
|
|
|
|
// we will need to know the number of all records later for the pagination purposes
|
|
$numofparticipants = count($participants);
|
|
|
|
if ($numofparticipants > 0) {
|
|
// load all fields which can be used for sorting and paginate the records
|
|
list($participantids, $params) = $DB->get_in_or_equal(array_keys($participants), SQL_PARAMS_NAMED);
|
|
$params['workshopid1'] = $this->id;
|
|
$params['workshopid2'] = $this->id;
|
|
$sqlsort = $sortby . ' ' . $sorthow . ',u.lastname,u.firstname,u.id';
|
|
$sql = "SELECT u.id AS userid,u.firstname,u.lastname,u.picture,u.imagealt,u.email,
|
|
s.title AS submissiontitle, s.grade AS submissiongrade, ag.gradinggrade
|
|
FROM {user} u
|
|
LEFT JOIN {workshop_submissions} s ON (s.authorid = u.id AND s.workshopid = :workshopid1 AND s.example = 0)
|
|
LEFT JOIN {workshop_aggregations} ag ON (ag.userid = u.id AND ag.workshopid = :workshopid2)
|
|
WHERE u.id $participantids
|
|
ORDER BY $sqlsort";
|
|
$participants = $DB->get_records_sql($sql, $params, $page * $perpage, $perpage);
|
|
} else {
|
|
$participants = array();
|
|
}
|
|
|
|
// this will hold the information needed to display user names and pictures
|
|
$userinfo = array();
|
|
|
|
// get the user details for all participants to display
|
|
foreach ($participants as $participant) {
|
|
if (!isset($userinfo[$participant->userid])) {
|
|
$userinfo[$participant->userid] = new stdclass();
|
|
$userinfo[$participant->userid]->id = $participant->userid;
|
|
$userinfo[$participant->userid]->firstname = $participant->firstname;
|
|
$userinfo[$participant->userid]->lastname = $participant->lastname;
|
|
$userinfo[$participant->userid]->picture = $participant->picture;
|
|
$userinfo[$participant->userid]->imagealt = $participant->imagealt;
|
|
$userinfo[$participant->userid]->email = $participant->email;
|
|
}
|
|
}
|
|
|
|
// load the submissions details
|
|
$submissions = $this->get_submissions(array_keys($participants));
|
|
|
|
// get the user details for all moderators (teachers) that have overridden a submission grade
|
|
foreach ($submissions as $submission) {
|
|
if (!isset($userinfo[$submission->gradeoverby])) {
|
|
$userinfo[$submission->gradeoverby] = new stdclass();
|
|
$userinfo[$submission->gradeoverby]->id = $submission->gradeoverby;
|
|
$userinfo[$submission->gradeoverby]->firstname = $submission->overfirstname;
|
|
$userinfo[$submission->gradeoverby]->lastname = $submission->overlastname;
|
|
$userinfo[$submission->gradeoverby]->picture = $submission->overpicture;
|
|
$userinfo[$submission->gradeoverby]->imagealt = $submission->overimagealt;
|
|
$userinfo[$submission->gradeoverby]->email = $submission->overemail;
|
|
}
|
|
}
|
|
|
|
// get the user details for all reviewers of the displayed participants
|
|
$reviewers = array();
|
|
if ($submissions) {
|
|
list($submissionids, $params) = $DB->get_in_or_equal(array_keys($submissions), SQL_PARAMS_NAMED);
|
|
$sql = "SELECT a.id AS assessmentid, a.submissionid, a.grade, a.gradinggrade, a.gradinggradeover, a.weight,
|
|
r.id AS reviewerid, r.lastname, r.firstname, r.picture, r.imagealt, r.email,
|
|
s.id AS submissionid, s.authorid
|
|
FROM {workshop_assessments} a
|
|
JOIN {user} r ON (a.reviewerid = r.id)
|
|
JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
|
|
WHERE a.submissionid $submissionids
|
|
ORDER BY a.weight DESC, r.lastname, r.firstname";
|
|
$reviewers = $DB->get_records_sql($sql, $params);
|
|
foreach ($reviewers as $reviewer) {
|
|
if (!isset($userinfo[$reviewer->reviewerid])) {
|
|
$userinfo[$reviewer->reviewerid] = new stdclass();
|
|
$userinfo[$reviewer->reviewerid]->id = $reviewer->reviewerid;
|
|
$userinfo[$reviewer->reviewerid]->firstname = $reviewer->firstname;
|
|
$userinfo[$reviewer->reviewerid]->lastname = $reviewer->lastname;
|
|
$userinfo[$reviewer->reviewerid]->picture = $reviewer->picture;
|
|
$userinfo[$reviewer->reviewerid]->imagealt = $reviewer->imagealt;
|
|
$userinfo[$reviewer->reviewerid]->email = $reviewer->email;
|
|
}
|
|
}
|
|
}
|
|
|
|
// get the user details for all reviewees of the displayed participants
|
|
$reviewees = array();
|
|
if ($participants) {
|
|
list($participantids, $params) = $DB->get_in_or_equal(array_keys($participants), SQL_PARAMS_NAMED);
|
|
$params['workshopid'] = $this->id;
|
|
$sql = "SELECT a.id AS assessmentid, a.submissionid, a.grade, a.gradinggrade, a.gradinggradeover, a.reviewerid, a.weight,
|
|
s.id AS submissionid,
|
|
e.id AS authorid, e.lastname, e.firstname, e.picture, e.imagealt, e.email
|
|
FROM {user} u
|
|
JOIN {workshop_assessments} a ON (a.reviewerid = u.id)
|
|
JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
|
|
JOIN {user} e ON (s.authorid = e.id)
|
|
WHERE u.id $participantids AND s.workshopid = :workshopid
|
|
ORDER BY a.weight DESC, e.lastname, e.firstname";
|
|
$reviewees = $DB->get_records_sql($sql, $params);
|
|
foreach ($reviewees as $reviewee) {
|
|
if (!isset($userinfo[$reviewee->authorid])) {
|
|
$userinfo[$reviewee->authorid] = new stdclass();
|
|
$userinfo[$reviewee->authorid]->id = $reviewee->authorid;
|
|
$userinfo[$reviewee->authorid]->firstname = $reviewee->firstname;
|
|
$userinfo[$reviewee->authorid]->lastname = $reviewee->lastname;
|
|
$userinfo[$reviewee->authorid]->picture = $reviewee->picture;
|
|
$userinfo[$reviewee->authorid]->imagealt = $reviewee->imagealt;
|
|
$userinfo[$reviewee->authorid]->email = $reviewee->email;
|
|
}
|
|
}
|
|
}
|
|
|
|
// finally populate the object to be rendered
|
|
$grades = $participants;
|
|
|
|
foreach ($participants as $participant) {
|
|
// set up default (null) values
|
|
$grades[$participant->userid]->submissionid = null;
|
|
$grades[$participant->userid]->submissiontitle = null;
|
|
$grades[$participant->userid]->submissiongrade = null;
|
|
$grades[$participant->userid]->submissiongradeover = null;
|
|
$grades[$participant->userid]->submissiongradeoverby = null;
|
|
$grades[$participant->userid]->submissionpublished = null;
|
|
$grades[$participant->userid]->reviewedby = array();
|
|
$grades[$participant->userid]->reviewerof = array();
|
|
}
|
|
unset($participants);
|
|
unset($participant);
|
|
|
|
foreach ($submissions as $submission) {
|
|
$grades[$submission->authorid]->submissionid = $submission->id;
|
|
$grades[$submission->authorid]->submissiontitle = $submission->title;
|
|
$grades[$submission->authorid]->submissiongrade = $this->real_grade($submission->grade);
|
|
$grades[$submission->authorid]->submissiongradeover = $this->real_grade($submission->gradeover);
|
|
$grades[$submission->authorid]->submissiongradeoverby = $submission->gradeoverby;
|
|
$grades[$submission->authorid]->submissionpublished = $submission->published;
|
|
}
|
|
unset($submissions);
|
|
unset($submission);
|
|
|
|
foreach($reviewers as $reviewer) {
|
|
$info = new stdclass();
|
|
$info->userid = $reviewer->reviewerid;
|
|
$info->assessmentid = $reviewer->assessmentid;
|
|
$info->submissionid = $reviewer->submissionid;
|
|
$info->grade = $this->real_grade($reviewer->grade);
|
|
$info->gradinggrade = $this->real_grading_grade($reviewer->gradinggrade);
|
|
$info->gradinggradeover = $this->real_grading_grade($reviewer->gradinggradeover);
|
|
$info->weight = $reviewer->weight;
|
|
$grades[$reviewer->authorid]->reviewedby[$reviewer->reviewerid] = $info;
|
|
}
|
|
unset($reviewers);
|
|
unset($reviewer);
|
|
|
|
foreach($reviewees as $reviewee) {
|
|
$info = new stdclass();
|
|
$info->userid = $reviewee->authorid;
|
|
$info->assessmentid = $reviewee->assessmentid;
|
|
$info->submissionid = $reviewee->submissionid;
|
|
$info->grade = $this->real_grade($reviewee->grade);
|
|
$info->gradinggrade = $this->real_grading_grade($reviewee->gradinggrade);
|
|
$info->gradinggradeover = $this->real_grading_grade($reviewee->gradinggradeover);
|
|
$info->weight = $reviewee->weight;
|
|
$grades[$reviewee->reviewerid]->reviewerof[$reviewee->authorid] = $info;
|
|
}
|
|
unset($reviewees);
|
|
unset($reviewee);
|
|
|
|
foreach ($grades as $grade) {
|
|
$grade->gradinggrade = $this->real_grading_grade($grade->gradinggrade);
|
|
}
|
|
|
|
$data = new stdclass();
|
|
$data->grades = $grades;
|
|
$data->userinfo = $userinfo;
|
|
$data->totalcount = $numofparticipants;
|
|
$data->maxgrade = $this->real_grade(100);
|
|
$data->maxgradinggrade = $this->real_grading_grade(100);
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Calculates the real value of a grade
|
|
*
|
|
* @param float $value percentual value from 0 to 100
|
|
* @param float $max the maximal grade
|
|
* @return string
|
|
*/
|
|
public function real_grade_value($value, $max) {
|
|
$localized = true;
|
|
if (is_null($value) or $value === '') {
|
|
return null;
|
|
} elseif ($max == 0) {
|
|
return 0;
|
|
} else {
|
|
return format_float($max * $value / 100, $this->gradedecimals, $localized);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculates the raw (percentual) value from a real grade
|
|
*
|
|
* This is used in cases when a user wants to give a grade such as 12 of 20 and we need to save
|
|
* this value in a raw percentual form into DB
|
|
* @param float $value given grade
|
|
* @param float $max the maximal grade
|
|
* @return float suitable to be stored as numeric(10,5)
|
|
*/
|
|
public function raw_grade_value($value, $max) {
|
|
if (is_null($value) or $value === '') {
|
|
return null;
|
|
}
|
|
if ($max == 0 or $value < 0) {
|
|
return 0;
|
|
}
|
|
$p = $value / $max * 100;
|
|
if ($p > 100) {
|
|
return $max;
|
|
}
|
|
return grade_floatval($p);
|
|
}
|
|
|
|
/**
|
|
* Calculates the real value of grade for submission
|
|
*
|
|
* @param float $value percentual value from 0 to 100
|
|
* @return string
|
|
*/
|
|
public function real_grade($value) {
|
|
return $this->real_grade_value($value, $this->grade);
|
|
}
|
|
|
|
/**
|
|
* Calculates the real value of grade for assessment
|
|
*
|
|
* @param float $value percentual value from 0 to 100
|
|
* @return string
|
|
*/
|
|
public function real_grading_grade($value) {
|
|
return $this->real_grade_value($value, $this->gradinggrade);
|
|
}
|
|
|
|
/**
|
|
* Sets the given grades and received grading grades to null
|
|
*
|
|
* This does not clear the information about how the peers filled the assessment forms, but
|
|
* clears the calculated grades in workshop_assessments. Therefore reviewers have to re-assess
|
|
* the allocated submissions.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function clear_assessments() {
|
|
global $DB;
|
|
|
|
$submissions = $this->get_submissions();
|
|
if (empty($submissions)) {
|
|
// no money, no love
|
|
return;
|
|
}
|
|
$submissions = array_keys($submissions);
|
|
list($sql, $params) = $DB->get_in_or_equal($submissions, SQL_PARAMS_NAMED);
|
|
$sql = "submissionid $sql";
|
|
$DB->set_field_select('workshop_assessments', 'grade', null, $sql, $params);
|
|
$DB->set_field_select('workshop_assessments', 'gradinggrade', null, $sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Sets the grades for submission to null
|
|
*
|
|
* @param null|int|array $restrict If null, update all authors, otherwise update just grades for the given author(s)
|
|
* @return void
|
|
*/
|
|
public function clear_submission_grades($restrict=null) {
|
|
global $DB;
|
|
|
|
$sql = "workshopid = :workshopid AND example = 0";
|
|
$params = array('workshopid' => $this->id);
|
|
|
|
if (is_null($restrict)) {
|
|
// update all users - no more conditions
|
|
} elseif (!empty($restrict)) {
|
|
list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
|
|
$sql .= " AND authorid $usql";
|
|
$params = array_merge($params, $uparams);
|
|
} else {
|
|
throw new coding_exception('Empty value is not a valid parameter here');
|
|
}
|
|
|
|
$DB->set_field_select('workshop_submissions', 'grade', null, $sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Calculates grades for submission for the given participant(s) and updates it in the database
|
|
*
|
|
* @param null|int|array $restrict If null, update all authors, otherwise update just grades for the given author(s)
|
|
* @return void
|
|
*/
|
|
public function aggregate_submission_grades($restrict=null) {
|
|
global $DB;
|
|
|
|
// fetch a recordset with all assessments to process
|
|
$sql = 'SELECT s.id AS submissionid, s.grade AS submissiongrade,
|
|
a.weight, a.grade
|
|
FROM {workshop_submissions} s
|
|
LEFT JOIN {workshop_assessments} a ON (a.submissionid = s.id)
|
|
WHERE s.example=0 AND s.workshopid=:workshopid'; // to be cont.
|
|
$params = array('workshopid' => $this->id);
|
|
|
|
if (is_null($restrict)) {
|
|
// update all users - no more conditions
|
|
} elseif (!empty($restrict)) {
|
|
list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
|
|
$sql .= " AND s.authorid $usql";
|
|
$params = array_merge($params, $uparams);
|
|
} else {
|
|
throw new coding_exception('Empty value is not a valid parameter here');
|
|
}
|
|
|
|
$sql .= ' ORDER BY s.id'; // this is important for bulk processing
|
|
|
|
$rs = $DB->get_recordset_sql($sql, $params);
|
|
$batch = array(); // will contain a set of all assessments of a single submission
|
|
$previous = null; // a previous record in the recordset
|
|
|
|
foreach ($rs as $current) {
|
|
if (is_null($previous)) {
|
|
// we are processing the very first record in the recordset
|
|
$previous = $current;
|
|
}
|
|
if ($current->submissionid == $previous->submissionid) {
|
|
// we are still processing the current submission
|
|
$batch[] = $current;
|
|
} else {
|
|
// process all the assessments of a sigle submission
|
|
$this->aggregate_submission_grades_process($batch);
|
|
// and then start to process another submission
|
|
$batch = array($current);
|
|
$previous = $current;
|
|
}
|
|
}
|
|
// do not forget to process the last batch!
|
|
$this->aggregate_submission_grades_process($batch);
|
|
$rs->close();
|
|
}
|
|
|
|
/**
|
|
* Sets the aggregated grades for assessment to null
|
|
*
|
|
* @param null|int|array $restrict If null, update all reviewers, otherwise update just grades for the given reviewer(s)
|
|
* @return void
|
|
*/
|
|
public function clear_grading_grades($restrict=null) {
|
|
global $DB;
|
|
|
|
$sql = "workshopid = :workshopid";
|
|
$params = array('workshopid' => $this->id);
|
|
|
|
if (is_null($restrict)) {
|
|
// update all users - no more conditions
|
|
} elseif (!empty($restrict)) {
|
|
list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
|
|
$sql .= " AND userid $usql";
|
|
$params = array_merge($params, $uparams);
|
|
} else {
|
|
throw new coding_exception('Empty value is not a valid parameter here');
|
|
}
|
|
|
|
$DB->set_field_select('workshop_aggregations', 'gradinggrade', null, $sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Calculates grades for assessment for the given participant(s)
|
|
*
|
|
* Grade for assessment is calculated as a simple mean of all grading grades calculated by the grading evaluator.
|
|
* The assessment weight is not taken into account here.
|
|
*
|
|
* @param null|int|array $restrict If null, update all reviewers, otherwise update just grades for the given reviewer(s)
|
|
* @return void
|
|
*/
|
|
public function aggregate_grading_grades($restrict=null) {
|
|
global $DB;
|
|
|
|
// fetch a recordset with all assessments to process
|
|
$sql = 'SELECT a.reviewerid, a.gradinggrade, a.gradinggradeover,
|
|
ag.id AS aggregationid, ag.gradinggrade AS aggregatedgrade
|
|
FROM {workshop_assessments} a
|
|
INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
|
|
LEFT JOIN {workshop_aggregations} ag ON (ag.userid = a.reviewerid AND ag.workshopid = s.workshopid)
|
|
WHERE s.example=0 AND s.workshopid=:workshopid'; // to be cont.
|
|
$params = array('workshopid' => $this->id);
|
|
|
|
if (is_null($restrict)) {
|
|
// update all users - no more conditions
|
|
} elseif (!empty($restrict)) {
|
|
list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
|
|
$sql .= " AND a.reviewerid $usql";
|
|
$params = array_merge($params, $uparams);
|
|
} else {
|
|
throw new coding_exception('Empty value is not a valid parameter here');
|
|
}
|
|
|
|
$sql .= ' ORDER BY a.reviewerid'; // this is important for bulk processing
|
|
|
|
$rs = $DB->get_recordset_sql($sql, $params);
|
|
$batch = array(); // will contain a set of all assessments of a single submission
|
|
$previous = null; // a previous record in the recordset
|
|
|
|
foreach ($rs as $current) {
|
|
if (is_null($previous)) {
|
|
// we are processing the very first record in the recordset
|
|
$previous = $current;
|
|
}
|
|
if ($current->reviewerid == $previous->reviewerid) {
|
|
// we are still processing the current reviewer
|
|
$batch[] = $current;
|
|
} else {
|
|
// process all the assessments of a sigle submission
|
|
$this->aggregate_grading_grades_process($batch);
|
|
// and then start to process another reviewer
|
|
$batch = array($current);
|
|
$previous = $current;
|
|
}
|
|
}
|
|
// do not forget to process the last batch!
|
|
$this->aggregate_grading_grades_process($batch);
|
|
$rs->close();
|
|
}
|
|
|
|
/**
|
|
* Returns the mform the teachers use to put a feedback for the reviewer
|
|
*
|
|
* @param moodle_url $actionurl
|
|
* @param stdClass $assessment
|
|
* @param array $options editable, editableweight, overridablegradinggrade
|
|
* @return workshop_feedbackreviewer_form
|
|
*/
|
|
public function get_feedbackreviewer_form(moodle_url $actionurl, stdclass $assessment, $options=array()) {
|
|
global $CFG;
|
|
require_once(dirname(__FILE__) . '/feedbackreviewer_form.php');
|
|
|
|
$current = new stdclass();
|
|
$current->asid = $assessment->id;
|
|
$current->weight = $assessment->weight;
|
|
$current->gradinggrade = $this->real_grading_grade($assessment->gradinggrade);
|
|
$current->gradinggradeover = $this->real_grading_grade($assessment->gradinggradeover);
|
|
$current->feedbackreviewer = $assessment->feedbackreviewer;
|
|
$current->feedbackreviewerformat = $assessment->feedbackreviewerformat;
|
|
if (is_null($current->gradinggrade)) {
|
|
$current->gradinggrade = get_string('nullgrade', 'workshop');
|
|
}
|
|
if (!isset($options['editable'])) {
|
|
$editable = true; // by default
|
|
} else {
|
|
$editable = (bool)$options['editable'];
|
|
}
|
|
|
|
// prepare wysiwyg editor
|
|
$current = file_prepare_standard_editor($current, 'feedbackreviewer', array());
|
|
|
|
return new workshop_feedbackreviewer_form($actionurl,
|
|
array('workshop' => $this, 'current' => $current, 'editoropts' => array(), 'options' => $options),
|
|
'post', '', null, $editable);
|
|
}
|
|
|
|
/**
|
|
* Returns the mform the teachers use to put a feedback for the author on their submission
|
|
*
|
|
* @param moodle_url $actionurl
|
|
* @param stdClass $submission
|
|
* @param array $options editable
|
|
* @return workshop_feedbackauthor_form
|
|
*/
|
|
public function get_feedbackauthor_form(moodle_url $actionurl, stdclass $submission, $options=array()) {
|
|
global $CFG;
|
|
require_once(dirname(__FILE__) . '/feedbackauthor_form.php');
|
|
|
|
$current = new stdclass();
|
|
$current->submissionid = $submission->id;
|
|
$current->published = $submission->published;
|
|
$current->grade = $this->real_grade($submission->grade);
|
|
$current->gradeover = $this->real_grade($submission->gradeover);
|
|
$current->feedbackauthor = $submission->feedbackauthor;
|
|
$current->feedbackauthorformat = $submission->feedbackauthorformat;
|
|
if (is_null($current->grade)) {
|
|
$current->grade = get_string('nullgrade', 'workshop');
|
|
}
|
|
if (!isset($options['editable'])) {
|
|
$editable = true; // by default
|
|
} else {
|
|
$editable = (bool)$options['editable'];
|
|
}
|
|
|
|
// prepare wysiwyg editor
|
|
$current = file_prepare_standard_editor($current, 'feedbackauthor', array());
|
|
|
|
return new workshop_feedbackauthor_form($actionurl,
|
|
array('workshop' => $this, 'current' => $current, 'editoropts' => array(), 'options' => $options),
|
|
'post', '', null, $editable);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Internal methods (implementation details) //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Given an array of all assessments of a single submission, calculates the final grade for this submission
|
|
*
|
|
* This calculates the weighted mean of the passed assessment grades. If, however, the submission grade
|
|
* was overridden by a teacher, the gradeover value is returned and the rest of grades are ignored.
|
|
*
|
|
* @param array $assessments of stdclass(->submissionid ->submissiongrade ->gradeover ->weight ->grade)
|
|
* @return void
|
|
*/
|
|
protected function aggregate_submission_grades_process(array $assessments) {
|
|
global $DB;
|
|
|
|
$submissionid = null; // the id of the submission being processed
|
|
$current = null; // the grade currently saved in database
|
|
$finalgrade = null; // the new grade to be calculated
|
|
$sumgrades = 0;
|
|
$sumweights = 0;
|
|
|
|
foreach ($assessments as $assessment) {
|
|
if (is_null($submissionid)) {
|
|
// the id is the same in all records, fetch it during the first loop cycle
|
|
$submissionid = $assessment->submissionid;
|
|
}
|
|
if (is_null($current)) {
|
|
// the currently saved grade is the same in all records, fetch it during the first loop cycle
|
|
$current = $assessment->submissiongrade;
|
|
}
|
|
if (is_null($assessment->grade)) {
|
|
// this was not assessed yet
|
|
continue;
|
|
}
|
|
if ($assessment->weight == 0) {
|
|
// this does not influence the calculation
|
|
continue;
|
|
}
|
|
$sumgrades += $assessment->grade * $assessment->weight;
|
|
$sumweights += $assessment->weight;
|
|
}
|
|
if ($sumweights > 0 and is_null($finalgrade)) {
|
|
$finalgrade = grade_floatval($sumgrades / $sumweights);
|
|
}
|
|
// check if the new final grade differs from the one stored in the database
|
|
if (grade_floats_different($finalgrade, $current)) {
|
|
// we need to save new calculation into the database
|
|
$record = new stdclass();
|
|
$record->id = $submissionid;
|
|
$record->grade = $finalgrade;
|
|
$record->timegraded = time();
|
|
$DB->update_record('workshop_submissions', $record);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given an array of all assessments done by a single reviewer, calculates the final grading grade
|
|
*
|
|
* This calculates the simple mean of the passed grading grades. If, however, the grading grade
|
|
* was overridden by a teacher, the gradinggradeover value is returned and the rest of grades are ignored.
|
|
*
|
|
* @param array $assessments of stdclass(->reviewerid ->gradinggrade ->gradinggradeover ->aggregationid ->aggregatedgrade)
|
|
* @return void
|
|
*/
|
|
protected function aggregate_grading_grades_process(array $assessments) {
|
|
global $DB;
|
|
|
|
$reviewerid = null; // the id of the reviewer being processed
|
|
$current = null; // the gradinggrade currently saved in database
|
|
$finalgrade = null; // the new grade to be calculated
|
|
$agid = null; // aggregation id
|
|
$sumgrades = 0;
|
|
$count = 0;
|
|
|
|
foreach ($assessments as $assessment) {
|
|
if (is_null($reviewerid)) {
|
|
// the id is the same in all records, fetch it during the first loop cycle
|
|
$reviewerid = $assessment->reviewerid;
|
|
}
|
|
if (is_null($agid)) {
|
|
// the id is the same in all records, fetch it during the first loop cycle
|
|
$agid = $assessment->aggregationid;
|
|
}
|
|
if (is_null($current)) {
|
|
// the currently saved grade is the same in all records, fetch it during the first loop cycle
|
|
$current = $assessment->aggregatedgrade;
|
|
}
|
|
if (!is_null($assessment->gradinggradeover)) {
|
|
// the grading grade for this assessment is overridden by a teacher
|
|
$sumgrades += $assessment->gradinggradeover;
|
|
$count++;
|
|
} else {
|
|
if (!is_null($assessment->gradinggrade)) {
|
|
$sumgrades += $assessment->gradinggrade;
|
|
$count++;
|
|
}
|
|
}
|
|
}
|
|
if ($count > 0) {
|
|
$finalgrade = grade_floatval($sumgrades / $count);
|
|
}
|
|
// check if the new final grade differs from the one stored in the database
|
|
if (grade_floats_different($finalgrade, $current)) {
|
|
// we need to save new calculation into the database
|
|
if (is_null($agid)) {
|
|
// no aggregation record yet
|
|
$record = new stdclass();
|
|
$record->workshopid = $this->id;
|
|
$record->userid = $reviewerid;
|
|
$record->gradinggrade = $finalgrade;
|
|
$record->timegraded = time();
|
|
$DB->insert_record('workshop_aggregations', $record);
|
|
} else {
|
|
$record = new stdclass();
|
|
$record->id = $agid;
|
|
$record->gradinggrade = $finalgrade;
|
|
$record->timegraded = time();
|
|
$DB->update_record('workshop_aggregations', $record);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given a list of user ids, returns the filtered one containing just ids of users with own submission
|
|
*
|
|
* Example submissions are ignored.
|
|
*
|
|
* @param array $userids
|
|
* @return array
|
|
*/
|
|
protected function users_with_submission(array $userids) {
|
|
global $DB;
|
|
|
|
if (empty($userids)) {
|
|
return array();
|
|
}
|
|
$userswithsubmission = array();
|
|
list($usql, $uparams) = $DB->get_in_or_equal($userids, SQL_PARAMS_NAMED);
|
|
$sql = "SELECT id,authorid
|
|
FROM {workshop_submissions}
|
|
WHERE example = 0 AND workshopid = :workshopid AND authorid $usql";
|
|
$params = array('workshopid' => $this->id);
|
|
$params = array_merge($params, $uparams);
|
|
$submissions = $DB->get_records_sql($sql, $params);
|
|
foreach ($submissions as $submission) {
|
|
$userswithsubmission[$submission->authorid] = true;
|
|
}
|
|
|
|
return $userswithsubmission;
|
|
}
|
|
|
|
/**
|
|
* @return array of available workshop phases
|
|
*/
|
|
protected function available_phases_list() {
|
|
return array(
|
|
self::PHASE_SETUP => true,
|
|
self::PHASE_SUBMISSION => true,
|
|
self::PHASE_ASSESSMENT => true,
|
|
self::PHASE_EVALUATION => true,
|
|
self::PHASE_CLOSED => true,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Converts absolute URL to relative URL needed by {@see add_to_log()}
|
|
*
|
|
* @param moodle_url $url absolute URL
|
|
* @return string
|
|
*/
|
|
protected function log_convert_url(moodle_url $fullurl) {
|
|
static $baseurl;
|
|
|
|
if (!isset($baseurl)) {
|
|
$baseurl = new moodle_url('/mod/workshop/');
|
|
$baseurl = $baseurl->out();
|
|
}
|
|
|
|
return substr($fullurl->out(), strlen($baseurl));
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Renderable components
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Represents the user planner tool
|
|
*
|
|
* Planner contains list of phases. Each phase contains list of tasks. Task is a simple object with
|
|
* title, link and completed (true/false/null logic).
|
|
*/
|
|
class workshop_user_plan implements renderable {
|
|
|
|
/** @var int id of the user this plan is for */
|
|
public $userid;
|
|
/** @var workshop */
|
|
public $workshop;
|
|
/** @var array of (stdclass)tasks */
|
|
public $phases = array();
|
|
/** @var null|array of example submissions to be assessed by the planner owner */
|
|
protected $examples = null;
|
|
|
|
/**
|
|
* Prepare an individual workshop plan for the given user.
|
|
*
|
|
* @param workshop $workshop instance
|
|
* @param int $userid whom the plan is prepared for
|
|
*/
|
|
public function __construct(workshop $workshop, $userid) {
|
|
global $DB;
|
|
|
|
$this->workshop = $workshop;
|
|
$this->userid = $userid;
|
|
|
|
//---------------------------------------------------------
|
|
// * SETUP | submission | assessment | evaluation | closed
|
|
//---------------------------------------------------------
|
|
$phase = new stdclass();
|
|
$phase->title = get_string('phasesetup', 'workshop');
|
|
$phase->tasks = array();
|
|
if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('taskintro', 'workshop');
|
|
$task->link = $workshop->updatemod_url();
|
|
$task->completed = !(trim($workshop->intro) == '');
|
|
$phase->tasks['intro'] = $task;
|
|
}
|
|
if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('taskinstructauthors', 'workshop');
|
|
$task->link = $workshop->updatemod_url();
|
|
$task->completed = !(trim($workshop->instructauthors) == '');
|
|
$phase->tasks['instructauthors'] = $task;
|
|
}
|
|
if (has_capability('mod/workshop:editdimensions', $workshop->context, $userid)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('editassessmentform', 'workshop');
|
|
$task->link = $workshop->editform_url();
|
|
if ($workshop->grading_strategy_instance()->form_ready()) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase > workshop::PHASE_SETUP) {
|
|
$task->completed = false;
|
|
}
|
|
$phase->tasks['editform'] = $task;
|
|
}
|
|
if ($workshop->useexamples and has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('prepareexamples', 'workshop');
|
|
if ($DB->count_records('workshop_submissions', array('example' => 1, 'workshopid' => $workshop->id)) > 0) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase > workshop::PHASE_SETUP) {
|
|
$task->completed = false;
|
|
}
|
|
$phase->tasks['prepareexamples'] = $task;
|
|
}
|
|
if (empty($phase->tasks) and $workshop->phase == workshop::PHASE_SETUP) {
|
|
// if we are in the setup phase and there is no task (typical for students), let us
|
|
// display some explanation what is going on
|
|
$task = new stdclass();
|
|
$task->title = get_string('undersetup', 'workshop');
|
|
$task->completed = 'info';
|
|
$phase->tasks['setupinfo'] = $task;
|
|
}
|
|
$this->phases[workshop::PHASE_SETUP] = $phase;
|
|
|
|
//---------------------------------------------------------
|
|
// setup | * SUBMISSION | assessment | evaluation | closed
|
|
//---------------------------------------------------------
|
|
$phase = new stdclass();
|
|
$phase->title = get_string('phasesubmission', 'workshop');
|
|
$phase->tasks = array();
|
|
if (($workshop->usepeerassessment or $workshop->useselfassessment)
|
|
and has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('taskinstructreviewers', 'workshop');
|
|
$task->link = $workshop->updatemod_url();
|
|
if (trim($workshop->instructreviewers)) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
|
|
$task->completed = false;
|
|
}
|
|
$phase->tasks['instructreviewers'] = $task;
|
|
}
|
|
if ($workshop->useexamples and $workshop->examplesmode == workshop::EXAMPLES_BEFORE_SUBMISSION
|
|
and has_capability('mod/workshop:submit', $workshop->context, $userid, false)
|
|
and !has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('exampleassesstask', 'workshop');
|
|
$examples = $this->get_examples();
|
|
$a = new stdclass();
|
|
$a->expected = count($examples);
|
|
$a->assessed = 0;
|
|
foreach ($examples as $exampleid => $example) {
|
|
if (!is_null($example->grade)) {
|
|
$a->assessed++;
|
|
}
|
|
}
|
|
$task->details = get_string('exampleassesstaskdetails', 'workshop', $a);
|
|
if ($a->assessed == $a->expected) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
|
|
$task->completed = false;
|
|
}
|
|
$phase->tasks['examples'] = $task;
|
|
}
|
|
if (has_capability('mod/workshop:submit', $workshop->context, $userid, false)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('tasksubmit', 'workshop');
|
|
$task->link = $workshop->submission_url();
|
|
if ($DB->record_exists('workshop_submissions', array('workshopid'=>$workshop->id, 'example'=>0, 'authorid'=>$userid))) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
|
|
$task->completed = false;
|
|
} else {
|
|
$task->completed = null; // still has a chance to submit
|
|
}
|
|
$phase->tasks['submit'] = $task;
|
|
}
|
|
if (has_capability('mod/workshop:allocate', $workshop->context, $userid)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('allocate', 'workshop');
|
|
$task->link = $workshop->allocation_url();
|
|
$numofauthors = count(get_users_by_capability($workshop->context, 'mod/workshop:submit', 'u.id', '', '', '',
|
|
'', '', false, true));
|
|
$numofsubmissions = $DB->count_records('workshop_submissions', array('workshopid'=>$workshop->id, 'example'=>0));
|
|
$sql = 'SELECT COUNT(s.id) AS nonallocated
|
|
FROM {workshop_submissions} s
|
|
LEFT JOIN {workshop_assessments} a ON (a.submissionid=s.id)
|
|
WHERE s.workshopid = :workshopid AND s.example=0 AND a.submissionid IS NULL';
|
|
$params['workshopid'] = $workshop->id;
|
|
$numnonallocated = $DB->count_records_sql($sql, $params);
|
|
if ($numofsubmissions == 0) {
|
|
$task->completed = null;
|
|
} elseif ($numnonallocated == 0) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase > workshop::PHASE_SUBMISSION) {
|
|
$task->completed = false;
|
|
} else {
|
|
$task->completed = null; // still has a chance to allocate
|
|
}
|
|
$a = new stdclass();
|
|
$a->expected = $numofauthors;
|
|
$a->submitted = $numofsubmissions;
|
|
$a->allocate = $numnonallocated;
|
|
$task->details = get_string('allocatedetails', 'workshop', $a);
|
|
unset($a);
|
|
$phase->tasks['allocate'] = $task;
|
|
|
|
if ($numofsubmissions < $numofauthors and $workshop->phase >= workshop::PHASE_SUBMISSION) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('someuserswosubmission', 'workshop');
|
|
$task->completed = 'info';
|
|
$phase->tasks['allocateinfo'] = $task;
|
|
}
|
|
}
|
|
if ($workshop->submissionstart) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('submissionstartdatetime', 'workshop', workshop::timestamp_formats($workshop->submissionstart));
|
|
$task->completed = 'info';
|
|
$phase->tasks['submissionstartdatetime'] = $task;
|
|
}
|
|
if ($workshop->submissionend) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('submissionenddatetime', 'workshop', workshop::timestamp_formats($workshop->submissionend));
|
|
$task->completed = 'info';
|
|
$phase->tasks['submissionenddatetime'] = $task;
|
|
}
|
|
if (($workshop->submissionstart < time()) and $workshop->latesubmissions) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('latesubmissionsallowed', 'workshop');
|
|
$task->completed = 'info';
|
|
$phase->tasks['latesubmissionsallowed'] = $task;
|
|
}
|
|
$this->phases[workshop::PHASE_SUBMISSION] = $phase;
|
|
|
|
//---------------------------------------------------------
|
|
// setup | submission | * ASSESSMENT | evaluation | closed
|
|
//---------------------------------------------------------
|
|
$phase = new stdclass();
|
|
$phase->title = get_string('phaseassessment', 'workshop');
|
|
$phase->tasks = array();
|
|
$phase->isreviewer = has_capability('mod/workshop:peerassess', $workshop->context, $userid);
|
|
if ($workshop->useexamples and $workshop->examplesmode == workshop::EXAMPLES_BEFORE_ASSESSMENT
|
|
and $phase->isreviewer and !has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('exampleassesstask', 'workshop');
|
|
$examples = $workshop->get_examples_for_reviewer($userid);
|
|
$a = new stdclass();
|
|
$a->expected = count($examples);
|
|
$a->assessed = 0;
|
|
foreach ($examples as $exampleid => $example) {
|
|
if (!is_null($example->grade)) {
|
|
$a->assessed++;
|
|
}
|
|
}
|
|
$task->details = get_string('exampleassesstaskdetails', 'workshop', $a);
|
|
if ($a->assessed == $a->expected) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
|
|
$task->completed = false;
|
|
}
|
|
$phase->tasks['examples'] = $task;
|
|
}
|
|
if (empty($phase->tasks['examples']) or !empty($phase->tasks['examples']->completed)) {
|
|
$phase->assessments = $workshop->get_assessments_by_reviewer($userid);
|
|
$numofpeers = 0; // number of allocated peer-assessments
|
|
$numofpeerstodo = 0; // number of peer-assessments to do
|
|
$numofself = 0; // number of allocated self-assessments - should be 0 or 1
|
|
$numofselftodo = 0; // number of self-assessments to do - should be 0 or 1
|
|
foreach ($phase->assessments as $a) {
|
|
if ($a->authorid == $userid) {
|
|
$numofself++;
|
|
if (is_null($a->grade)) {
|
|
$numofselftodo++;
|
|
}
|
|
} else {
|
|
$numofpeers++;
|
|
if (is_null($a->grade)) {
|
|
$numofpeerstodo++;
|
|
}
|
|
}
|
|
}
|
|
unset($a);
|
|
if ($workshop->usepeerassessment and $numofpeers) {
|
|
$task = new stdclass();
|
|
if ($numofpeerstodo == 0) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
|
|
$task->completed = false;
|
|
}
|
|
$a = new stdclass();
|
|
$a->total = $numofpeers;
|
|
$a->todo = $numofpeerstodo;
|
|
$task->title = get_string('taskassesspeers', 'workshop');
|
|
$task->details = get_string('taskassesspeersdetails', 'workshop', $a);
|
|
unset($a);
|
|
$phase->tasks['assesspeers'] = $task;
|
|
}
|
|
if ($workshop->useselfassessment and $numofself) {
|
|
$task = new stdclass();
|
|
if ($numofselftodo == 0) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
|
|
$task->completed = false;
|
|
}
|
|
$task->title = get_string('taskassessself', 'workshop');
|
|
$phase->tasks['assessself'] = $task;
|
|
}
|
|
}
|
|
if ($workshop->assessmentstart) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('assessmentstartdatetime', 'workshop', workshop::timestamp_formats($workshop->assessmentstart));
|
|
$task->completed = 'info';
|
|
$phase->tasks['assessmentstartdatetime'] = $task;
|
|
}
|
|
if ($workshop->assessmentend) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('assessmentenddatetime', 'workshop', workshop::timestamp_formats($workshop->assessmentend));
|
|
$task->completed = 'info';
|
|
$phase->tasks['assessmentenddatetime'] = $task;
|
|
}
|
|
$this->phases[workshop::PHASE_ASSESSMENT] = $phase;
|
|
|
|
//---------------------------------------------------------
|
|
// setup | submission | assessment | * EVALUATION | closed
|
|
//---------------------------------------------------------
|
|
$phase = new stdclass();
|
|
$phase->title = get_string('phaseevaluation', 'workshop');
|
|
$phase->tasks = array();
|
|
if (has_capability('mod/workshop:overridegrades', $workshop->context)) {
|
|
$expected = count($workshop->get_potential_authors(false));
|
|
$calculated = $DB->count_records_select('workshop_submissions',
|
|
'workshopid = ? AND (grade IS NOT NULL OR gradeover IS NOT NULL)', array($workshop->id));
|
|
$task = new stdclass();
|
|
$task->title = get_string('calculatesubmissiongrades', 'workshop');
|
|
$a = new stdclass();
|
|
$a->expected = $expected;
|
|
$a->calculated = $calculated;
|
|
$task->details = get_string('calculatesubmissiongradesdetails', 'workshop', $a);
|
|
if ($calculated >= $expected) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase > workshop::PHASE_EVALUATION) {
|
|
$task->completed = false;
|
|
}
|
|
$phase->tasks['calculatesubmissiongrade'] = $task;
|
|
|
|
$expected = count($workshop->get_potential_reviewers(false));
|
|
$calculated = $DB->count_records_select('workshop_aggregations',
|
|
'workshopid = ? AND gradinggrade IS NOT NULL', array($workshop->id));
|
|
$task = new stdclass();
|
|
$task->title = get_string('calculategradinggrades', 'workshop');
|
|
$a = new stdclass();
|
|
$a->expected = $expected;
|
|
$a->calculated = $calculated;
|
|
$task->details = get_string('calculategradinggradesdetails', 'workshop', $a);
|
|
if ($calculated >= $expected) {
|
|
$task->completed = true;
|
|
} elseif ($workshop->phase > workshop::PHASE_EVALUATION) {
|
|
$task->completed = false;
|
|
}
|
|
$phase->tasks['calculategradinggrade'] = $task;
|
|
|
|
} elseif ($workshop->phase == workshop::PHASE_EVALUATION) {
|
|
$task = new stdclass();
|
|
$task->title = get_string('evaluategradeswait', 'workshop');
|
|
$task->completed = 'info';
|
|
$phase->tasks['evaluateinfo'] = $task;
|
|
}
|
|
$this->phases[workshop::PHASE_EVALUATION] = $phase;
|
|
|
|
//---------------------------------------------------------
|
|
// setup | submission | assessment | evaluation | * CLOSED
|
|
//---------------------------------------------------------
|
|
$phase = new stdclass();
|
|
$phase->title = get_string('phaseclosed', 'workshop');
|
|
$phase->tasks = array();
|
|
$this->phases[workshop::PHASE_CLOSED] = $phase;
|
|
|
|
// Polish data, set default values if not done explicitly
|
|
foreach ($this->phases as $phasecode => $phase) {
|
|
$phase->title = isset($phase->title) ? $phase->title : '';
|
|
$phase->tasks = isset($phase->tasks) ? $phase->tasks : array();
|
|
if ($phasecode == $workshop->phase) {
|
|
$phase->active = true;
|
|
} else {
|
|
$phase->active = false;
|
|
}
|
|
if (!isset($phase->actions)) {
|
|
$phase->actions = array();
|
|
}
|
|
|
|
foreach ($phase->tasks as $taskcode => $task) {
|
|
$task->title = isset($task->title) ? $task->title : '';
|
|
$task->link = isset($task->link) ? $task->link : null;
|
|
$task->details = isset($task->details) ? $task->details : '';
|
|
$task->completed = isset($task->completed) ? $task->completed : null;
|
|
}
|
|
}
|
|
|
|
// Add phase switching actions
|
|
if (has_capability('mod/workshop:switchphase', $workshop->context, $userid)) {
|
|
foreach ($this->phases as $phasecode => $phase) {
|
|
if (! $phase->active) {
|
|
$action = new stdclass();
|
|
$action->type = 'switchphase';
|
|
$action->url = $workshop->switchphase_url($phasecode);
|
|
$phase->actions[] = $action;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns example submissions to be assessed by the owner of the planner
|
|
*
|
|
* This is here to cache the DB query because the same list is needed later in view.php
|
|
*
|
|
* @see workshop::get_examples_for_reviewer() for the format of returned value
|
|
* @return array
|
|
*/
|
|
public function get_examples() {
|
|
if (is_null($this->examples)) {
|
|
$this->examples = $this->workshop->get_examples_for_reviewer($this->userid);
|
|
}
|
|
return $this->examples;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Common base class for submissions and example submissions rendering
|
|
*
|
|
* Subclasses of this class convert raw submission record from
|
|
* workshop_submissions table (as returned by {@see workshop::get_submission_by_id()}
|
|
* for example) into renderable objects.
|
|
*/
|
|
abstract class workshop_submission_base {
|
|
|
|
/** @var bool is the submission anonymous (i.e. contains author information) */
|
|
protected $anonymous;
|
|
|
|
/* @var array of columns from workshop_submissions that are assigned as properties */
|
|
protected $fields = array();
|
|
|
|
/**
|
|
* Copies the properties of the given database record into properties of $this instance
|
|
*
|
|
* @param stdClass $submission full record
|
|
* @param bool $showauthor show the author-related information
|
|
* @param array $options additional properties
|
|
*/
|
|
public function __construct(stdClass $submission, $showauthor = false) {
|
|
|
|
foreach ($this->fields as $field) {
|
|
if (!property_exists($submission, $field)) {
|
|
throw new coding_exception('Submission record must provide public property ' . $field);
|
|
}
|
|
if (!property_exists($this, $field)) {
|
|
throw new coding_exception('Renderable component must accept public property ' . $field);
|
|
}
|
|
$this->{$field} = $submission->{$field};
|
|
}
|
|
|
|
if ($showauthor) {
|
|
$this->anonymous = false;
|
|
} else {
|
|
$this->anonymize();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unsets all author-related properties so that the renderer does not have access to them
|
|
*
|
|
* Usually this is called by the contructor but can be called explicitely, too.
|
|
*/
|
|
public function anonymize() {
|
|
foreach (array('authorid', 'authorfirstname', 'authorlastname',
|
|
'authorpicture', 'authorimagealt', 'authoremail') as $field) {
|
|
unset($this->{$field});
|
|
}
|
|
$this->anonymous = true;
|
|
}
|
|
|
|
/**
|
|
* Does the submission object contain author-related information?
|
|
*
|
|
* @return null|boolean
|
|
*/
|
|
public function is_anonymous() {
|
|
return $this->anonymous;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renderable object containing a basic set of information needed to display the submission summary
|
|
*
|
|
* @see workshop_renderer::render_workshop_submission_summary
|
|
*/
|
|
class workshop_submission_summary extends workshop_submission_base implements renderable {
|
|
|
|
/** @var int */
|
|
public $id;
|
|
/** @var string */
|
|
public $title;
|
|
/** @var string graded|notgraded */
|
|
public $status;
|
|
/** @var int */
|
|
public $timecreated;
|
|
/** @var int */
|
|
public $timemodified;
|
|
/** @var int */
|
|
public $authorid;
|
|
/** @var string */
|
|
public $authorfirstname;
|
|
/** @var string */
|
|
public $authorlastname;
|
|
/** @var int */
|
|
public $authorpicture;
|
|
/** @var string */
|
|
public $authorimagealt;
|
|
/** @var string */
|
|
public $authoremail;
|
|
/** @var moodle_url to display submission */
|
|
public $url;
|
|
|
|
/**
|
|
* @var array of columns from workshop_submissions that are assigned as properties
|
|
* of instances of this class
|
|
*/
|
|
protected $fields = array(
|
|
'id', 'title', 'timecreated', 'timemodified',
|
|
'authorid', 'authorfirstname', 'authorlastname', 'authorpicture',
|
|
'authorimagealt', 'authoremail');
|
|
}
|
|
|
|
/**
|
|
* Renderable object containing all the information needed to display the submission
|
|
*
|
|
* @see workshop_renderer::render_workshop_submission()
|
|
*/
|
|
class workshop_submission extends workshop_submission_summary implements renderable {
|
|
|
|
/** @var string */
|
|
public $content;
|
|
/** @var int */
|
|
public $contentformat;
|
|
/** @var bool */
|
|
public $contenttrust;
|
|
/** @var array */
|
|
public $attachment;
|
|
|
|
/**
|
|
* @var array of columns from workshop_submissions that are assigned as properties
|
|
* of instances of this class
|
|
*/
|
|
protected $fields = array(
|
|
'id', 'title', 'timecreated', 'timemodified', 'content', 'contentformat', 'contenttrust',
|
|
'attachment', 'authorid', 'authorfirstname', 'authorlastname', 'authorpicture',
|
|
'authorimagealt', 'authoremail');
|
|
}
|
|
|
|
/**
|
|
* Renderable object containing a basic set of information needed to display the example submission summary
|
|
*
|
|
* @see workshop::prepare_example_summary()
|
|
* @see workshop_renderer::render_workshop_example_submission_summary()
|
|
*/
|
|
class workshop_example_submission_summary extends workshop_submission_base implements renderable {
|
|
|
|
/** @var int */
|
|
public $id;
|
|
/** @var string */
|
|
public $title;
|
|
/** @var string graded|notgraded */
|
|
public $status;
|
|
/** @var stdClass */
|
|
public $gradeinfo;
|
|
/** @var moodle_url */
|
|
public $url;
|
|
/** @var moodle_url */
|
|
public $editurl;
|
|
/** @var string */
|
|
public $assesslabel;
|
|
/** @var moodle_url */
|
|
public $assessurl;
|
|
/** @var bool must be set explicitly by the caller */
|
|
public $editable = false;
|
|
|
|
/**
|
|
* @var array of columns from workshop_submissions that are assigned as properties
|
|
* of instances of this class
|
|
*/
|
|
protected $fields = array('id', 'title');
|
|
|
|
/**
|
|
* Example submissions are always anonymous
|
|
*
|
|
* @return true
|
|
*/
|
|
public function is_anonymous() {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renderable object containing all the information needed to display the example submission
|
|
*
|
|
* @see workshop_renderer::render_workshop_example_submission()
|
|
*/
|
|
class workshop_example_submission extends workshop_example_submission_summary implements renderable {
|
|
|
|
/** @var string */
|
|
public $content;
|
|
/** @var int */
|
|
public $contentformat;
|
|
/** @var bool */
|
|
public $contenttrust;
|
|
/** @var array */
|
|
public $attachment;
|
|
|
|
/**
|
|
* @var array of columns from workshop_submissions that are assigned as properties
|
|
* of instances of this class
|
|
*/
|
|
protected $fields = array('id', 'title', 'content', 'contentformat', 'contenttrust', 'attachment');
|
|
}
|
|
|
|
/**
|
|
* Renderable message to be displayed to the user
|
|
*
|
|
* Message can contain an optional action link with a label that is supposed to be rendered
|
|
* as a button or a link.
|
|
*
|
|
* @see workshop::renderer::render_workshop_message()
|
|
*/
|
|
class workshop_message implements renderable {
|
|
|
|
const TYPE_INFO = 10;
|
|
const TYPE_OK = 20;
|
|
const TYPE_ERROR = 30;
|
|
|
|
/** @var string */
|
|
protected $text = '';
|
|
/** @var int */
|
|
protected $type = self::TYPE_INFO;
|
|
/** @var moodle_url */
|
|
protected $actionurl = null;
|
|
/** @var string */
|
|
protected $actionlabel = '';
|
|
|
|
/**
|
|
* @param string $text short text to be displayed
|
|
* @param string $type optional message type info|ok|error
|
|
*/
|
|
public function __construct($text = null, $type = self::TYPE_INFO) {
|
|
$this->set_text($text);
|
|
$this->set_type($type);
|
|
}
|
|
|
|
/**
|
|
* Sets the message text
|
|
*
|
|
* @param string $text short text to be displayed
|
|
*/
|
|
public function set_text($text) {
|
|
$this->text = $text;
|
|
}
|
|
|
|
/**
|
|
* Sets the message type
|
|
*
|
|
* @param int $type
|
|
*/
|
|
public function set_type($type = self::TYPE_INFO) {
|
|
if (in_array($type, array(self::TYPE_OK, self::TYPE_ERROR, self::TYPE_INFO))) {
|
|
$this->type = $type;
|
|
} else {
|
|
throw new coding_exception('Unknown message type.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the optional message action
|
|
*
|
|
* @param moodle_url $url to follow on action
|
|
* @param string $label action label
|
|
*/
|
|
public function set_action(moodle_url $url, $label) {
|
|
$this->actionurl = $url;
|
|
$this->actionlabel = $label;
|
|
}
|
|
|
|
/**
|
|
* Returns message text with HTML tags quoted
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_message() {
|
|
return s($this->text);
|
|
}
|
|
|
|
/**
|
|
* Returns message type
|
|
*
|
|
* @return int
|
|
*/
|
|
public function get_type() {
|
|
return $this->type;
|
|
}
|
|
|
|
/**
|
|
* Returns action URL
|
|
*
|
|
* @return moodle_url|null
|
|
*/
|
|
public function get_action_url() {
|
|
return $this->actionurl;
|
|
}
|
|
|
|
/**
|
|
* Returns action label
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_action_label() {
|
|
return $this->actionlabel;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renderable output of submissions allocation process
|
|
*/
|
|
class workshop_allocation_init_result implements renderable {
|
|
|
|
/** @var workshop_message */
|
|
protected $message;
|
|
/** @var array of steps */
|
|
protected $info = array();
|
|
/** @var moodle_url */
|
|
protected $continue;
|
|
|
|
/**
|
|
* Supplied argument can be either integer status code or an array of string messages. Messages
|
|
* in a array can have optional prefix or prefixes, using '::' as delimiter. Prefixes determine
|
|
* the type of the message and may influence its visualisation.
|
|
*
|
|
* @param mixed $result int|array returned by {@see workshop_allocator::init()}
|
|
* @param moodle_url to continue
|
|
*/
|
|
public function __construct($result, moodle_url $continue) {
|
|
|
|
if ($result === workshop::ALLOCATION_ERROR) {
|
|
$this->message = new workshop_message(get_string('allocationerror', 'workshop'), workshop_message::TYPE_ERROR);
|
|
} else {
|
|
$this->message = new workshop_message(get_string('allocationdone', 'workshop'), workshop_message::TYPE_OK);
|
|
if (is_array($result)) {
|
|
$this->info = $result;
|
|
}
|
|
}
|
|
|
|
$this->continue = $continue;
|
|
}
|
|
|
|
/**
|
|
* @return workshop_message instance to render
|
|
*/
|
|
public function get_message() {
|
|
return $this->message;
|
|
}
|
|
|
|
/**
|
|
* @return array of strings with allocation process details
|
|
*/
|
|
public function get_info() {
|
|
return $this->info;
|
|
}
|
|
|
|
/**
|
|
* @return moodle_url where the user shoudl continue
|
|
*/
|
|
public function get_continue_url() {
|
|
return $this->continue;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renderable component containing all the data needed to display the grading report
|
|
*/
|
|
class workshop_grading_report implements renderable {
|
|
|
|
/** @var stdClass returned by {@see workshop::prepare_grading_report_data()} */
|
|
protected $data;
|
|
/** @var stdClass rendering options */
|
|
protected $options;
|
|
|
|
/**
|
|
* Grades in $data must be already rounded to the set number of decimals or must be null
|
|
* (in which later case, the [mod_workshop,nullgrade] string shall be displayed)
|
|
*
|
|
* @param stdClass $data prepared by {@link workshop::prepare_grading_report_data()}
|
|
* @param stdClass $options display options (showauthornames, showreviewernames, sortby, sorthow, showsubmissiongrade, showgradinggrade)
|
|
*/
|
|
public function __construct(stdClass $data, stdClass $options) {
|
|
$this->data = $data;
|
|
$this->options = $options;
|
|
}
|
|
|
|
/**
|
|
* @return stdClass grading report data
|
|
*/
|
|
public function get_data() {
|
|
return $this->data;
|
|
}
|
|
|
|
/**
|
|
* @return stdClass rendering options
|
|
*/
|
|
public function get_options() {
|
|
return $this->options;
|
|
}
|
|
}
|