MDL-31936 workshop: Fix overall feedback content processing order
[moodle.git] / mod / workshop / locallib.php
CommitLineData
de811c0c 1<?php
53fad4b9
DM
2
3// This file is part of Moodle - http://moodle.org/
4//
de811c0c
DM
5// Moodle is free software: you can redistribute it and/or modify
6// it under the terms of the GNU General Public License as published by
7// the Free Software Foundation, either version 3 of the License, or
8// (at your option) any later version.
9//
10// Moodle is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13// GNU General Public License for more details.
53fad4b9 14//
de811c0c
DM
15// You should have received a copy of the GNU General Public License
16// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
53fad4b9 17
de811c0c 18/**
6e309973 19 * Library of internal classes and functions for module workshop
de811c0c 20 *
53fad4b9 21 * All the workshop specific functions, needed to implement the module
6e309973 22 * logic, should go to here. Instead of having bunch of function named
53fad4b9 23 * workshop_something() taking the workshop instance as the first
a39d7d87 24 * parameter, we use a class workshop that provides all methods.
53fad4b9 25 *
5cdcfcb9 26 * @package mod_workshop
65601f04
DM
27 * @copyright 2009 David Mudrak <david.mudrak@gmail.com>
28 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
de811c0c
DM
29 */
30
31defined('MOODLE_INTERNAL') || die();
32
89c1aa97
DM
33require_once(dirname(__FILE__).'/lib.php'); // we extend this library here
34require_once($CFG->libdir . '/gradelib.php'); // we use some rounding and comparing routines here
99d19c13 35require_once($CFG->libdir . '/filelib.php');
0968b1a3 36
6e309973
DM
37/**
38 * Full-featured workshop API
39 *
a39d7d87 40 * This wraps the workshop database record with a set of methods that are called
6e309973 41 * from the module itself. The class should be initialized right after you get
a39d7d87 42 * $workshop, $cm and $course records at the begining of the script.
6e309973 43 */
a39d7d87
DM
44class workshop {
45
31cea236 46 /** error status of the {@link self::add_allocation()} */
cbf87967 47 const ALLOCATION_EXISTS = -9999;
b761e6d9
DM
48
49 /** the internal code of the workshop phases as are stored in the database */
f6e8b318
DM
50 const PHASE_SETUP = 10;
51 const PHASE_SUBMISSION = 20;
52 const PHASE_ASSESSMENT = 30;
53 const PHASE_EVALUATION = 40;
54 const PHASE_CLOSED = 50;
55
56 /** the internal code of the examples modes as are stored in the database */
57 const EXAMPLES_VOLUNTARY = 0;
58 const EXAMPLES_BEFORE_SUBMISSION = 1;
59 const EXAMPLES_BEFORE_ASSESSMENT = 2;
b761e6d9 60
45ab2d9a 61 /** @var cm_info course module record */
e9ab520f 62 public $cm;
a39d7d87 63
7a789aa8 64 /** @var stdclass course record */
e9ab520f 65 public $course;
6e309973 66
7a789aa8 67 /** @var stdclass context object */
e9ab520f
DM
68 public $context;
69
70 /** @var int workshop instance identifier */
71 public $id;
72
73 /** @var string workshop activity name */
74 public $name;
75
76 /** @var string introduction or description of the activity */
77 public $intro;
78
79 /** @var int format of the {@link $intro} */
80 public $introformat;
81
82 /** @var string instructions for the submission phase */
83 public $instructauthors;
84
85 /** @var int format of the {@link $instructauthors} */
86 public $instructauthorsformat;
87
88 /** @var string instructions for the assessment phase */
89 public $instructreviewers;
90
91 /** @var int format of the {@link $instructreviewers} */
92 public $instructreviewersformat;
93
94 /** @var int timestamp of when the module was modified */
95 public $timemodified;
96
97 /** @var int current phase of workshop, for example {@link workshop::PHASE_SETUP} */
98 public $phase;
99
100 /** @var bool optional feature: students practise evaluating on example submissions from teacher */
101 public $useexamples;
102
d34ea7dc 103 /** @var bool optional feature: students perform peer assessment of others' work (deprecated, consider always enabled) */
e9ab520f
DM
104 public $usepeerassessment;
105
106 /** @var bool optional feature: students perform self assessment of their own work */
107 public $useselfassessment;
108
109 /** @var float number (10, 5) unsigned, the maximum grade for submission */
110 public $grade;
111
112 /** @var float number (10, 5) unsigned, the maximum grade for assessment */
113 public $gradinggrade;
114
115 /** @var string type of the current grading strategy used in this workshop, for example 'accumulative' */
116 public $strategy;
117
c2d2eb6e
DM
118 /** @var string the name of the evaluation plugin to use for grading grades calculation */
119 public $evaluation;
120
e9ab520f
DM
121 /** @var int number of digits that should be shown after the decimal point when displaying grades */
122 public $gradedecimals;
123
124 /** @var int number of allowed submission attachments and the files embedded into submission */
125 public $nattachments;
126
127 /** @var bool allow submitting the work after the deadline */
128 public $latesubmissions;
129
130 /** @var int maximum size of the one attached file in bytes */
131 public $maxbytes;
132
133 /** @var int mode of example submissions support, for example {@link workshop::EXAMPLES_VOLUNTARY} */
134 public $examplesmode;
135
136 /** @var int if greater than 0 then the submission is not allowed before this timestamp */
137 public $submissionstart;
138
139 /** @var int if greater than 0 then the submission is not allowed after this timestamp */
140 public $submissionend;
141
142 /** @var int if greater than 0 then the peer assessment is not allowed before this timestamp */
143 public $assessmentstart;
144
145 /** @var int if greater than 0 then the peer assessment is not allowed after this timestamp */
146 public $assessmentend;
147
3ff08057
DM
148 /** @var bool automatically switch to the assessment phase after the submissions deadline */
149 public $phaseswitchassessment;
150
4c61fcd8
DM
151 /** @var string conclusion text to be displayed at the end of the activity */
152 public $conclusion;
153
154 /** @var int format of the conclusion text */
155 public $conclusionformat;
156
c6a793d5
DM
157 /** @var int the mode of the overall feedback */
158 public $overallfeedbackmode;
159
160 /** @var int maximum number of overall feedback attachments */
161 public $overallfeedbackfiles;
162
163 /** @var int maximum size of one file attached to the overall feedback */
164 public $overallfeedbackmaxbytes;
165
b761e6d9
DM
166 /**
167 * @var workshop_strategy grading strategy instance
168 * Do not use directly, get the instance using {@link workshop::grading_strategy_instance()}
169 */
b13142da
DM
170 protected $strategyinstance = null;
171
45d24d39
DM
172 /**
173 * @var workshop_evaluation grading evaluation instance
174 * Do not use directly, get the instance using {@link workshop::grading_evaluation_instance()}
175 */
176 protected $evaluationinstance = null;
177
6e309973 178 /**
65ba104c 179 * Initializes the workshop API instance using the data from DB
a39d7d87 180 *
45ab2d9a 181 * Makes deep copy of all passed records properties.
182 *
183 * For unit testing only, $cm and $course may be set to null. This is so that
184 * you can test without having any real database objects if you like. Not all
185 * functions will work in this situation.
6e309973 186 *
5924db72 187 * @param stdClass $dbrecord Workshop instance data from {workshop} table
45ab2d9a 188 * @param stdClass|cm_info $cm Course module record
189 * @param stdClass $course Course record from {course} table
190 * @param stdClass $context The context of the workshop instance
0dc47fb9 191 */
45ab2d9a 192 public function __construct(stdclass $dbrecord, $cm, $course, stdclass $context=null) {
f05c168d 193 foreach ($dbrecord as $field => $value) {
eef46586 194 if (property_exists('workshop', $field)) {
ac239eba
DM
195 $this->{$field} = $value;
196 }
a39d7d87 197 }
45ab2d9a 198 if (is_null($cm) || is_null($course)) {
ed2ecd3e
MG
199 throw new coding_exception('Must specify $cm and $course');
200 }
201 $this->course = $course;
202 if ($cm instanceof cm_info) {
203 $this->cm = $cm;
4efd7b5d 204 } else {
ed2ecd3e
MG
205 $modinfo = get_fast_modinfo($course);
206 $this->cm = $modinfo->get_cm($cm->id);
207 }
208 if (is_null($context)) {
209 $this->context = context_module::instance($this->cm->id);
210 } else {
211 $this->context = $context;
4efd7b5d 212 }
6e309973
DM
213 }
214
aa40adbf
DM
215 ////////////////////////////////////////////////////////////////////////////////
216 // Static methods //
217 ////////////////////////////////////////////////////////////////////////////////
218
da0b1f70 219 /**
aa40adbf 220 * Return list of available allocation methods
da0b1f70 221 *
aa40adbf 222 * @return array Array ['string' => 'string'] of localized allocation method names
da0b1f70 223 */
aa40adbf 224 public static function installed_allocators() {
bd3b3bba 225 $installed = core_component::get_plugin_list('workshopallocation');
aa40adbf
DM
226 $forms = array();
227 foreach ($installed as $allocation => $allocationpath) {
228 if (file_exists($allocationpath . '/lib.php')) {
229 $forms[$allocation] = get_string('pluginname', 'workshopallocation_' . $allocation);
230 }
f05c168d 231 }
aa40adbf
DM
232 // usability - make sure that manual allocation appears the first
233 if (isset($forms['manual'])) {
234 $m = array('manual' => $forms['manual']);
235 unset($forms['manual']);
236 $forms = array_merge($m, $forms);
da0b1f70 237 }
aa40adbf
DM
238 return $forms;
239 }
da0b1f70 240
aa40adbf
DM
241 /**
242 * Returns an array of options for the editors that are used for submitting and assessing instructions
243 *
5924db72 244 * @param stdClass $context
c8ea2c45 245 * @uses EDITOR_UNLIMITED_FILES hard-coded value for the 'maxfiles' option
aa40adbf
DM
246 * @return array
247 */
7a789aa8 248 public static function instruction_editors_options(stdclass $context) {
c8ea2c45 249 return array('subdirs' => 1, 'maxbytes' => 0, 'maxfiles' => -1,
aa40adbf 250 'changeformat' => 1, 'context' => $context, 'noclean' => 1, 'trusttext' => 0);
da0b1f70
DM
251 }
252
61b737a5
DM
253 /**
254 * Given the percent and the total, returns the number
255 *
256 * @param float $percent from 0 to 100
257 * @param float $total the 100% value
258 * @return float
259 */
260 public static function percent_to_value($percent, $total) {
261 if ($percent < 0 or $percent > 100) {
262 throw new coding_exception('The percent can not be less than 0 or higher than 100');
263 }
264
265 return $total * $percent / 100;
266 }
267
f6e8b318
DM
268 /**
269 * Returns an array of numeric values that can be used as maximum grades
270 *
271 * @return array Array of integers
272 */
273 public static function available_maxgrades_list() {
274 $grades = array();
275 for ($i=100; $i>=0; $i--) {
276 $grades[$i] = $i;
277 }
278 return $grades;
279 }
280
281 /**
282 * Returns the localized list of supported examples modes
283 *
284 * @return array
285 */
286 public static function available_example_modes_list() {
287 $options = array();
288 $options[self::EXAMPLES_VOLUNTARY] = get_string('examplesvoluntary', 'workshop');
289 $options[self::EXAMPLES_BEFORE_SUBMISSION] = get_string('examplesbeforesubmission', 'workshop');
290 $options[self::EXAMPLES_BEFORE_ASSESSMENT] = get_string('examplesbeforeassessment', 'workshop');
291 return $options;
292 }
293
294 /**
295 * Returns the list of available grading strategy methods
296 *
297 * @return array ['string' => 'string']
298 */
299 public static function available_strategies_list() {
bd3b3bba 300 $installed = core_component::get_plugin_list('workshopform');
f6e8b318
DM
301 $forms = array();
302 foreach ($installed as $strategy => $strategypath) {
303 if (file_exists($strategypath . '/lib.php')) {
304 $forms[$strategy] = get_string('pluginname', 'workshopform_' . $strategy);
305 }
306 }
307 return $forms;
308 }
309
a93dc3ec
DM
310 /**
311 * Returns the list of available grading evaluation methods
312 *
313 * @return array of (string)name => (string)localized title
314 */
315 public static function available_evaluators_list() {
316 $evals = array();
d0cac8b5 317 foreach (core_component::get_plugin_list_with_file('workshopeval', 'lib.php', false) as $eval => $evalpath) {
a93dc3ec
DM
318 $evals[$eval] = get_string('pluginname', 'workshopeval_' . $eval);
319 }
320 return $evals;
321 }
322
f6e8b318
DM
323 /**
324 * Return an array of possible values of assessment dimension weight
325 *
326 * @return array of integers 0, 1, 2, ..., 16
327 */
328 public static function available_dimension_weights_list() {
329 $weights = array();
330 for ($i=16; $i>=0; $i--) {
331 $weights[$i] = $i;
332 }
333 return $weights;
334 }
335
c6b784f0
DM
336 /**
337 * Return an array of possible values of assessment weight
338 *
339 * Note there is no real reason why the maximum value here is 16. It used to be 10 in
340 * workshop 1.x and I just decided to use the same number as in the maximum weight of
341 * a single assessment dimension.
342 * The value looks reasonable, though. Teachers who would want to assign themselves
343 * higher weight probably do not want peer assessment really...
344 *
345 * @return array of integers 0, 1, 2, ..., 16
346 */
347 public static function available_assessment_weights_list() {
348 $weights = array();
349 for ($i=16; $i>=0; $i--) {
350 $weights[$i] = $i;
351 }
352 return $weights;
353 }
354
f6e8b318
DM
355 /**
356 * Helper function returning the greatest common divisor
357 *
358 * @param int $a
359 * @param int $b
360 * @return int
361 */
362 public static function gcd($a, $b) {
363 return ($b == 0) ? ($a):(self::gcd($b, $a % $b));
364 }
365
366 /**
367 * Helper function returning the least common multiple
368 *
369 * @param int $a
370 * @param int $b
371 * @return int
372 */
373 public static function lcm($a, $b) {
374 return ($a / self::gcd($a,$b)) * $b;
375 }
376
5bab64a3
DM
377 /**
378 * Returns an object suitable for strings containing dates/times
379 *
380 * The returned object contains properties date, datefullshort, datetime, ... containing the given
381 * timestamp formatted using strftimedate, strftimedatefullshort, strftimedatetime, ... from the
382 * current lang's langconfig.php
383 * This allows translators and administrators customize the date/time format.
384 *
385 * @param int $timestamp the timestamp in UTC
386 * @return stdclass
387 */
388 public static function timestamp_formats($timestamp) {
389 $formats = array('date', 'datefullshort', 'dateshort', 'datetime',
390 'datetimeshort', 'daydate', 'daydatetime', 'dayshort', 'daytime',
391 'monthyear', 'recent', 'recentfull', 'time');
392 $a = new stdclass();
393 foreach ($formats as $format) {
394 $a->{$format} = userdate($timestamp, get_string('strftime'.$format, 'langconfig'));
395 }
396 $day = userdate($timestamp, '%Y%m%d', 99, false);
397 $today = userdate(time(), '%Y%m%d', 99, false);
398 $tomorrow = userdate(time() + DAYSECS, '%Y%m%d', 99, false);
399 $yesterday = userdate(time() - DAYSECS, '%Y%m%d', 99, false);
400 $distance = (int)round(abs(time() - $timestamp) / DAYSECS);
401 if ($day == $today) {
402 $a->distanceday = get_string('daystoday', 'workshop');
403 } elseif ($day == $yesterday) {
404 $a->distanceday = get_string('daysyesterday', 'workshop');
405 } elseif ($day < $today) {
406 $a->distanceday = get_string('daysago', 'workshop', $distance);
407 } elseif ($day == $tomorrow) {
408 $a->distanceday = get_string('daystomorrow', 'workshop');
409 } elseif ($day > $today) {
410 $a->distanceday = get_string('daysleft', 'workshop', $distance);
411 }
412 return $a;
413 }
414
aa40adbf
DM
415 ////////////////////////////////////////////////////////////////////////////////
416 // Workshop API //
417 ////////////////////////////////////////////////////////////////////////////////
418
6e309973 419 /**
21f58287 420 * Fetches all enrolled users with the capability mod/workshop:submit in the current workshop
6e309973 421 *
21f58287
DM
422 * The returned objects contain properties required by user_picture and are ordered by lastname, firstname.
423 * Only users with the active enrolment are returned.
53fad4b9 424 *
21f58287
DM
425 * @param bool $musthavesubmission if true, return only users who have already submitted
426 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
427 * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set)
428 * @param int $limitnum return a subset containing this number of records (optional, required if $limitfrom is set)
429 * @return array array[userid] => stdClass
6e309973 430 */
21f58287
DM
431 public function get_potential_authors($musthavesubmission=true, $groupid=0, $limitfrom=0, $limitnum=0) {
432 global $DB;
433
434 list($sql, $params) = $this->get_users_with_capability_sql('mod/workshop:submit', $musthavesubmission, $groupid);
9691e2b1
DM
435
436 if (empty($sql)) {
437 return array();
438 }
439
c3d0157b
DM
440 list($sort, $sortparams) = users_order_by_sql('tmp');
441 $sql = "SELECT *
442 FROM ($sql) tmp
443 ORDER BY $sort";
21f58287 444
9695ff81 445 return $DB->get_records_sql($sql, array_merge($params, $sortparams), $limitfrom, $limitnum);
6e309973
DM
446 }
447
a1df59be
DM
448 /**
449 * Returns the total number of users that would be fetched by {@link self::get_potential_authors()}
450 *
451 * @param bool $musthavesubmission if true, count only users who have already submitted
452 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
453 * @return int
454 */
455 public function count_potential_authors($musthavesubmission=true, $groupid=0) {
456 global $DB;
457
458 list($sql, $params) = $this->get_users_with_capability_sql('mod/workshop:submit', $musthavesubmission, $groupid);
459
460 if (empty($sql)) {
461 return 0;
462 }
463
464 $sql = "SELECT COUNT(*)
465 FROM ($sql) tmp";
466
467 return $DB->count_records_sql($sql, $params);
468 }
469
6e309973 470 /**
21f58287 471 * Fetches all enrolled users with the capability mod/workshop:peerassess in the current workshop
6e309973 472 *
21f58287
DM
473 * The returned objects contain properties required by user_picture and are ordered by lastname, firstname.
474 * Only users with the active enrolment are returned.
53fad4b9 475 *
21f58287
DM
476 * @param bool $musthavesubmission if true, return only users who have already submitted
477 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
478 * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set)
479 * @param int $limitnum return a subset containing this number of records (optional, required if $limitfrom is set)
480 * @return array array[userid] => stdClass
6e309973 481 */
21f58287
DM
482 public function get_potential_reviewers($musthavesubmission=false, $groupid=0, $limitfrom=0, $limitnum=0) {
483 global $DB;
484
485 list($sql, $params) = $this->get_users_with_capability_sql('mod/workshop:peerassess', $musthavesubmission, $groupid);
9691e2b1
DM
486
487 if (empty($sql)) {
488 return array();
489 }
490
c3d0157b
DM
491 list($sort, $sortparams) = users_order_by_sql('tmp');
492 $sql = "SELECT *
493 FROM ($sql) tmp
494 ORDER BY $sort";
21f58287 495
9695ff81 496 return $DB->get_records_sql($sql, array_merge($params, $sortparams), $limitfrom, $limitnum);
0968b1a3
DM
497 }
498
a1df59be
DM
499 /**
500 * Returns the total number of users that would be fetched by {@link self::get_potential_reviewers()}
501 *
502 * @param bool $musthavesubmission if true, count only users who have already submitted
503 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
504 * @return int
505 */
506 public function count_potential_reviewers($musthavesubmission=false, $groupid=0) {
507 global $DB;
508
509 list($sql, $params) = $this->get_users_with_capability_sql('mod/workshop:peerassess', $musthavesubmission, $groupid);
510
511 if (empty($sql)) {
512 return 0;
513 }
514
515 $sql = "SELECT COUNT(*)
516 FROM ($sql) tmp";
517
518 return $DB->count_records_sql($sql, $params);
519 }
520
8741ebb0
DM
521 /**
522 * Fetches all enrolled users that are authors or reviewers (or both) in the current workshop
523 *
524 * The returned objects contain properties required by user_picture and are ordered by lastname, firstname.
525 * Only users with the active enrolment are returned.
526 *
527 * @see self::get_potential_authors()
528 * @see self::get_potential_reviewers()
529 * @param bool $musthavesubmission if true, return only users who have already submitted
530 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
531 * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set)
532 * @param int $limitnum return a subset containing this number of records (optional, required if $limitfrom is set)
533 * @return array array[userid] => stdClass
534 */
535 public function get_participants($musthavesubmission=false, $groupid=0, $limitfrom=0, $limitnum=0) {
536 global $DB;
537
538 list($sql, $params) = $this->get_participants_sql($musthavesubmission, $groupid);
539
540 if (empty($sql)) {
541 return array();
542 }
543
c3d0157b
DM
544 list($sort, $sortparams) = users_order_by_sql('tmp');
545 $sql = "SELECT *
546 FROM ($sql) tmp
547 ORDER BY $sort";
8741ebb0 548
9695ff81 549 return $DB->get_records_sql($sql, array_merge($params, $sortparams), $limitfrom, $limitnum);
8741ebb0
DM
550 }
551
079219bf
DM
552 /**
553 * Returns the total number of records that would be returned by {@link self::get_participants()}
554 *
555 * @param bool $musthavesubmission if true, return only users who have already submitted
556 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
557 * @return int
558 */
559 public function count_participants($musthavesubmission=false, $groupid=0) {
560 global $DB;
561
562 list($sql, $params) = $this->get_participants_sql($musthavesubmission, $groupid);
563
564 if (empty($sql)) {
565 return 0;
566 }
567
568 $sql = "SELECT COUNT(*)
569 FROM ($sql) tmp";
570
571 return $DB->count_records_sql($sql, $params);
572 }
573
8741ebb0
DM
574 /**
575 * Checks if the given user is an actively enrolled participant in the workshop
576 *
577 * @param int $userid, defaults to the current $USER
578 * @return boolean
579 */
580 public function is_participant($userid=null) {
581 global $USER, $DB;
582
583 if (is_null($userid)) {
584 $userid = $USER->id;
585 }
586
587 list($sql, $params) = $this->get_participants_sql();
588
589 if (empty($sql)) {
590 return false;
591 }
592
593 $sql = "SELECT COUNT(*)
594 FROM {user} uxx
595 JOIN ({$sql}) pxx ON uxx.id = pxx.id
596 WHERE uxx.id = :uxxid";
597 $params['uxxid'] = $userid;
598
599 if ($DB->count_records_sql($sql, $params)) {
600 return true;
601 }
602
603 return false;
604 }
605
b8ead2e6
DM
606 /**
607 * Groups the given users by the group membership
608 *
45ab2d9a 609 * This takes the module grouping settings into account. If a grouping is
610 * set, returns only groups withing the course module grouping. Always
611 * returns group [0] with all the given users.
b8ead2e6 612 *
7a789aa8
DM
613 * @param array $users array[userid] => stdclass{->id ->lastname ->firstname}
614 * @return array array[groupid][userid] => stdclass{->id ->lastname ->firstname}
53fad4b9 615 */
3d2924e9 616 public function get_grouped($users) {
53fad4b9 617 global $DB;
3d2924e9 618 global $CFG;
53fad4b9 619
b8ead2e6
DM
620 $grouped = array(); // grouped users to be returned
621 if (empty($users)) {
622 return $grouped;
a7c5b918 623 }
45ab2d9a 624 if ($this->cm->groupingid) {
625 // Group workshop set to specified grouping - only consider groups
626 // within this grouping, and leave out users who aren't members of
627 // this grouping.
53fad4b9 628 $groupingid = $this->cm->groupingid;
b8ead2e6 629 // All users that are members of at least one group will be
53fad4b9 630 // added into a virtual group id 0
b8ead2e6 631 $grouped[0] = array();
53fad4b9
DM
632 } else {
633 $groupingid = 0;
b8ead2e6
DM
634 // there is no need to be member of a group so $grouped[0] will contain
635 // all users
636 $grouped[0] = $users;
53fad4b9 637 }
b8ead2e6 638 $gmemberships = groups_get_all_groups($this->cm->course, array_keys($users), $groupingid,
53fad4b9
DM
639 'gm.id,gm.groupid,gm.userid');
640 foreach ($gmemberships as $gmembership) {
b8ead2e6
DM
641 if (!isset($grouped[$gmembership->groupid])) {
642 $grouped[$gmembership->groupid] = array();
53fad4b9 643 }
b8ead2e6
DM
644 $grouped[$gmembership->groupid][$gmembership->userid] = $users[$gmembership->userid];
645 $grouped[0][$gmembership->userid] = $users[$gmembership->userid];
53fad4b9 646 }
b8ead2e6 647 return $grouped;
53fad4b9 648 }
6e309973 649
aa40adbf 650 /**
de6aaa72 651 * Returns the list of all allocations (i.e. assigned assessments) in the workshop
aa40adbf
DM
652 *
653 * Assessments of example submissions are ignored
654 *
655 * @return array
656 */
657 public function get_allocations() {
658 global $DB;
659
00aca3c1 660 $sql = 'SELECT a.id, a.submissionid, a.reviewerid, s.authorid
aa40adbf
DM
661 FROM {workshop_assessments} a
662 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
663 WHERE s.example = 0 AND s.workshopid = :workshopid';
664 $params = array('workshopid' => $this->id);
665
666 return $DB->get_records_sql($sql, $params);
667 }
668
cd57f558
DM
669 /**
670 * Returns the total number of records that would be returned by {@link self::get_submissions()}
671 *
672 * @param mixed $authorid int|array|'all' If set to [array of] integer, return submission[s] of the given user[s] only
673 * @param int $groupid If non-zero, return only submissions by authors in the specified group
674 * @return int number of records
675 */
676 public function count_submissions($authorid='all', $groupid=0) {
677 global $DB;
678
679 $params = array('workshopid' => $this->id);
680 $sql = "SELECT COUNT(s.id)
681 FROM {workshop_submissions} s
682 JOIN {user} u ON (s.authorid = u.id)";
683 if ($groupid) {
684 $sql .= " JOIN {groups_members} gm ON (gm.userid = u.id AND gm.groupid = :groupid)";
685 $params['groupid'] = $groupid;
686 }
687 $sql .= " WHERE s.example = 0 AND s.workshopid = :workshopid";
688
689 if ('all' === $authorid) {
690 // no additional conditions
691 } elseif (!empty($authorid)) {
692 list($usql, $uparams) = $DB->get_in_or_equal($authorid, SQL_PARAMS_NAMED);
693 $sql .= " AND authorid $usql";
694 $params = array_merge($params, $uparams);
695 } else {
696 // $authorid is empty
697 return 0;
698 }
699
700 return $DB->count_records_sql($sql, $params);
701 }
702
703
6e309973
DM
704 /**
705 * Returns submissions from this workshop
706 *
3dc78e5b
DM
707 * Fetches data from {workshop_submissions} and adds some useful information from other
708 * tables. Does not return textual fields to prevent possible memory lack issues.
53fad4b9 709 *
cd57f558 710 * @see self::count_submissions()
00aca3c1 711 * @param mixed $authorid int|array|'all' If set to [array of] integer, return submission[s] of the given user[s] only
872ed859 712 * @param int $groupid If non-zero, return only submissions by authors in the specified group
cd57f558
DM
713 * @param int $limitfrom Return a subset of records, starting at this point (optional)
714 * @param int $limitnum Return a subset containing this many records in total (optional, required if $limitfrom is set)
934329e5 715 * @return array of records or an empty array
6e309973 716 */
cd57f558 717 public function get_submissions($authorid='all', $groupid=0, $limitfrom=0, $limitnum=0) {
6e309973
DM
718 global $DB;
719
0dfb4bad
DM
720 $authorfields = user_picture::fields('u', null, 'authoridx', 'author');
721 $gradeoverbyfields = user_picture::fields('t', null, 'gradeoverbyx', 'over');
872ed859 722 $params = array('workshopid' => $this->id);
0dfb4bad 723 $sql = "SELECT s.id, s.workshopid, s.example, s.authorid, s.timecreated, s.timemodified,
232175e4 724 s.title, s.grade, s.gradeover, s.gradeoverby, s.published,
0dfb4bad 725 $authorfields, $gradeoverbyfields
3d2924e9 726 FROM {workshop_submissions} s
872ed859
DM
727 JOIN {user} u ON (s.authorid = u.id)";
728 if ($groupid) {
729 $sql .= " JOIN {groups_members} gm ON (gm.userid = u.id AND gm.groupid = :groupid)";
730 $params['groupid'] = $groupid;
731 }
732 $sql .= " LEFT JOIN {user} t ON (s.gradeoverby = t.id)
0dfb4bad 733 WHERE s.example = 0 AND s.workshopid = :workshopid";
6e309973 734
00aca3c1 735 if ('all' === $authorid) {
3d2924e9 736 // no additional conditions
934329e5 737 } elseif (!empty($authorid)) {
00aca3c1
DM
738 list($usql, $uparams) = $DB->get_in_or_equal($authorid, SQL_PARAMS_NAMED);
739 $sql .= " AND authorid $usql";
6e309973 740 $params = array_merge($params, $uparams);
3d2924e9 741 } else {
934329e5
DM
742 // $authorid is empty
743 return array();
6e309973 744 }
9695ff81
TH
745 list($sort, $sortparams) = users_order_by_sql('u');
746 $sql .= " ORDER BY $sort";
6e309973 747
9695ff81 748 return $DB->get_records_sql($sql, array_merge($params, $sortparams), $limitfrom, $limitnum);
6e309973
DM
749 }
750
51508f25
DM
751 /**
752 * Returns a submission record with the author's data
753 *
754 * @param int $id submission id
7a789aa8 755 * @return stdclass
51508f25
DM
756 */
757 public function get_submission_by_id($id) {
758 global $DB;
759
29dc43e7
DM
760 // we intentionally check the workshopid here, too, so the workshop can't touch submissions
761 // from other instances
0dfb4bad
DM
762 $authorfields = user_picture::fields('u', null, 'authoridx', 'author');
763 $gradeoverbyfields = user_picture::fields('g', null, 'gradeoverbyx', 'gradeoverby');
764 $sql = "SELECT s.*, $authorfields, $gradeoverbyfields
51508f25 765 FROM {workshop_submissions} s
00aca3c1 766 INNER JOIN {user} u ON (s.authorid = u.id)
0dfb4bad
DM
767 LEFT JOIN {user} g ON (s.gradeoverby = g.id)
768 WHERE s.example = 0 AND s.workshopid = :workshopid AND s.id = :id";
51508f25
DM
769 $params = array('workshopid' => $this->id, 'id' => $id);
770 return $DB->get_record_sql($sql, $params, MUST_EXIST);
771 }
772
53fad4b9 773 /**
3dc78e5b 774 * Returns a submission submitted by the given author
53fad4b9 775 *
3dc78e5b 776 * @param int $id author id
7a789aa8 777 * @return stdclass|false
53fad4b9 778 */
00aca3c1 779 public function get_submission_by_author($authorid) {
e9b0f0ab
DM
780 global $DB;
781
00aca3c1 782 if (empty($authorid)) {
53fad4b9
DM
783 return false;
784 }
0dfb4bad
DM
785 $authorfields = user_picture::fields('u', null, 'authoridx', 'author');
786 $gradeoverbyfields = user_picture::fields('g', null, 'gradeoverbyx', 'gradeoverby');
787 $sql = "SELECT s.*, $authorfields, $gradeoverbyfields
3dc78e5b 788 FROM {workshop_submissions} s
00aca3c1 789 INNER JOIN {user} u ON (s.authorid = u.id)
0dfb4bad
DM
790 LEFT JOIN {user} g ON (s.gradeoverby = g.id)
791 WHERE s.example = 0 AND s.workshopid = :workshopid AND s.authorid = :authorid";
00aca3c1 792 $params = array('workshopid' => $this->id, 'authorid' => $authorid);
3dc78e5b 793 return $DB->get_record_sql($sql, $params);
53fad4b9 794 }
6e309973 795
00bc77ee
DM
796 /**
797 * Returns published submissions with their authors data
798 *
799 * @return array of stdclass
800 */
801 public function get_published_submissions($orderby='finalgrade DESC') {
802 global $DB;
803
0dfb4bad 804 $authorfields = user_picture::fields('u', null, 'authoridx', 'author');
00bc77ee
DM
805 $sql = "SELECT s.id, s.authorid, s.timecreated, s.timemodified,
806 s.title, s.grade, s.gradeover, COALESCE(s.gradeover,s.grade) AS finalgrade,
0dfb4bad 807 $authorfields
00bc77ee
DM
808 FROM {workshop_submissions} s
809 INNER JOIN {user} u ON (s.authorid = u.id)
810 WHERE s.example = 0 AND s.workshopid = :workshopid AND s.published = 1
811 ORDER BY $orderby";
812 $params = array('workshopid' => $this->id);
813 return $DB->get_records_sql($sql, $params);
814 }
815
81eccf0a
DM
816 /**
817 * Returns full record of the given example submission
818 *
819 * @param int $id example submission od
820 * @return object
821 */
822 public function get_example_by_id($id) {
823 global $DB;
824 return $DB->get_record('workshop_submissions',
825 array('id' => $id, 'workshopid' => $this->id, 'example' => 1), '*', MUST_EXIST);
826 }
827
cbf87967
DM
828 /**
829 * Returns the list of example submissions in this workshop with reference assessments attached
830 *
831 * @return array of objects or an empty array
832 * @see workshop::prepare_example_summary()
833 */
834 public function get_examples_for_manager() {
835 global $DB;
836
837 $sql = 'SELECT s.id, s.title,
81b22887 838 a.id AS assessmentid, a.grade, a.gradinggrade
cbf87967
DM
839 FROM {workshop_submissions} s
840 LEFT JOIN {workshop_assessments} a ON (a.submissionid = s.id AND a.weight = 1)
841 WHERE s.example = 1 AND s.workshopid = :workshopid
842 ORDER BY s.title';
843 return $DB->get_records_sql($sql, array('workshopid' => $this->id));
844 }
845
846 /**
847 * Returns the list of all example submissions in this workshop with the information of assessments done by the given user
848 *
849 * @param int $reviewerid user id
850 * @return array of objects, indexed by example submission id
851 * @see workshop::prepare_example_summary()
852 */
853 public function get_examples_for_reviewer($reviewerid) {
854 global $DB;
855
856 if (empty($reviewerid)) {
857 return false;
858 }
859 $sql = 'SELECT s.id, s.title,
81b22887 860 a.id AS assessmentid, a.grade, a.gradinggrade
cbf87967
DM
861 FROM {workshop_submissions} s
862 LEFT JOIN {workshop_assessments} a ON (a.submissionid = s.id AND a.reviewerid = :reviewerid AND a.weight = 0)
863 WHERE s.example = 1 AND s.workshopid = :workshopid
864 ORDER BY s.title';
865 return $DB->get_records_sql($sql, array('workshopid' => $this->id, 'reviewerid' => $reviewerid));
866 }
867
868 /**
81b22887
DM
869 * Prepares renderable submission component
870 *
871 * @param stdClass $record required by {@see workshop_submission}
872 * @param bool $showauthor show the author-related information
873 * @return workshop_submission
874 */
875 public function prepare_submission(stdClass $record, $showauthor = false) {
876
77d746a2 877 $submission = new workshop_submission($this, $record, $showauthor);
81b22887
DM
878 $submission->url = $this->submission_url($record->id);
879
880 return $submission;
881 }
882
883 /**
884 * Prepares renderable submission summary component
885 *
886 * @param stdClass $record required by {@see workshop_submission_summary}
887 * @param bool $showauthor show the author-related information
888 * @return workshop_submission_summary
889 */
890 public function prepare_submission_summary(stdClass $record, $showauthor = false) {
891
77d746a2 892 $summary = new workshop_submission_summary($this, $record, $showauthor);
81b22887
DM
893 $summary->url = $this->submission_url($record->id);
894
895 return $summary;
896 }
897
898 /**
899 * Prepares renderable example submission component
900 *
901 * @param stdClass $record required by {@see workshop_example_submission}
902 * @return workshop_example_submission
903 */
904 public function prepare_example_submission(stdClass $record) {
905
77d746a2 906 $example = new workshop_example_submission($this, $record);
81b22887
DM
907
908 return $example;
909 }
910
911 /**
912 * Prepares renderable example submission summary component
913 *
914 * If the example is editable, the caller must set the 'editable' flag explicitly.
cbf87967 915 *
5924db72 916 * @param stdClass $example as returned by {@link workshop::get_examples_for_manager()} or {@link workshop::get_examples_for_reviewer()}
81b22887 917 * @return workshop_example_submission_summary to be rendered
cbf87967 918 */
81b22887
DM
919 public function prepare_example_summary(stdClass $example) {
920
77d746a2 921 $summary = new workshop_example_submission_summary($this, $example);
cbf87967 922
cbf87967 923 if (is_null($example->grade)) {
81b22887
DM
924 $summary->status = 'notgraded';
925 $summary->assesslabel = get_string('assess', 'workshop');
cbf87967 926 } else {
81b22887
DM
927 $summary->status = 'graded';
928 $summary->assesslabel = get_string('reassess', 'workshop');
cbf87967
DM
929 }
930
7a789aa8 931 $summary->gradeinfo = new stdclass();
cbf87967
DM
932 $summary->gradeinfo->received = $this->real_grade($example->grade);
933 $summary->gradeinfo->max = $this->real_grade(100);
934
81b22887
DM
935 $summary->url = new moodle_url($this->exsubmission_url($example->id));
936 $summary->editurl = new moodle_url($this->exsubmission_url($example->id), array('edit' => 'on'));
937 $summary->assessurl = new moodle_url($this->exsubmission_url($example->id), array('assess' => 'on', 'sesskey' => sesskey()));
cbf87967
DM
938
939 return $summary;
940 }
941
38504a44
DM
942 /**
943 * Prepares renderable assessment component
944 *
945 * The $options array supports the following keys:
946 * showauthor - should the author user info be available for the renderer
947 * showreviewer - should the reviewer user info be available for the renderer
948 * showform - show the assessment form if it is available
e30f6ff3 949 * showweight - should the assessment weight be available for the renderer
38504a44
DM
950 *
951 * @param stdClass $record as returned by eg {@link self::get_assessment_by_id()}
952 * @param workshop_assessment_form|null $form as returned by {@link workshop_strategy::get_assessment_form()}
953 * @param array $options
954 * @return workshop_assessment
955 */
956 public function prepare_assessment(stdClass $record, $form, array $options = array()) {
957
77d746a2 958 $assessment = new workshop_assessment($this, $record, $options);
38504a44
DM
959 $assessment->url = $this->assess_url($record->id);
960 $assessment->maxgrade = $this->real_grade(100);
961
962 if (!empty($options['showform']) and !($form instanceof workshop_assessment_form)) {
963 debugging('Not a valid instance of workshop_assessment_form supplied', DEBUG_DEVELOPER);
964 }
965
966 if (!empty($options['showform']) and ($form instanceof workshop_assessment_form)) {
967 $assessment->form = $form;
968 }
969
970 if (empty($options['showweight'])) {
971 $assessment->weight = null;
972 }
973
974 if (!is_null($record->grade)) {
975 $assessment->realgrade = $this->real_grade($record->grade);
976 }
977
978 return $assessment;
979 }
980
e30f6ff3
DM
981 /**
982 * Prepares renderable example submission's assessment component
983 *
984 * The $options array supports the following keys:
985 * showauthor - should the author user info be available for the renderer
986 * showreviewer - should the reviewer user info be available for the renderer
987 * showform - show the assessment form if it is available
988 *
989 * @param stdClass $record as returned by eg {@link self::get_assessment_by_id()}
990 * @param workshop_assessment_form|null $form as returned by {@link workshop_strategy::get_assessment_form()}
991 * @param array $options
992 * @return workshop_example_assessment
993 */
994 public function prepare_example_assessment(stdClass $record, $form = null, array $options = array()) {
995
77d746a2 996 $assessment = new workshop_example_assessment($this, $record, $options);
e30f6ff3
DM
997 $assessment->url = $this->exassess_url($record->id);
998 $assessment->maxgrade = $this->real_grade(100);
999
1000 if (!empty($options['showform']) and !($form instanceof workshop_assessment_form)) {
1001 debugging('Not a valid instance of workshop_assessment_form supplied', DEBUG_DEVELOPER);
1002 }
1003
1004 if (!empty($options['showform']) and ($form instanceof workshop_assessment_form)) {
1005 $assessment->form = $form;
1006 }
1007
1008 if (!is_null($record->grade)) {
1009 $assessment->realgrade = $this->real_grade($record->grade);
1010 }
1011
1012 $assessment->weight = null;
1013
1014 return $assessment;
1015 }
1016
1017 /**
1018 * Prepares renderable example submission's reference assessment component
1019 *
1020 * The $options array supports the following keys:
1021 * showauthor - should the author user info be available for the renderer
1022 * showreviewer - should the reviewer user info be available for the renderer
1023 * showform - show the assessment form if it is available
1024 *
1025 * @param stdClass $record as returned by eg {@link self::get_assessment_by_id()}
1026 * @param workshop_assessment_form|null $form as returned by {@link workshop_strategy::get_assessment_form()}
1027 * @param array $options
1028 * @return workshop_example_reference_assessment
1029 */
1030 public function prepare_example_reference_assessment(stdClass $record, $form = null, array $options = array()) {
1031
77d746a2 1032 $assessment = new workshop_example_reference_assessment($this, $record, $options);
e30f6ff3
DM
1033 $assessment->maxgrade = $this->real_grade(100);
1034
1035 if (!empty($options['showform']) and !($form instanceof workshop_assessment_form)) {
1036 debugging('Not a valid instance of workshop_assessment_form supplied', DEBUG_DEVELOPER);
1037 }
1038
1039 if (!empty($options['showform']) and ($form instanceof workshop_assessment_form)) {
1040 $assessment->form = $form;
1041 }
1042
1043 if (!is_null($record->grade)) {
1044 $assessment->realgrade = $this->real_grade($record->grade);
1045 }
1046
1047 $assessment->weight = null;
1048
1049 return $assessment;
1050 }
1051
81eccf0a
DM
1052 /**
1053 * Removes the submission and all relevant data
1054 *
5924db72 1055 * @param stdClass $submission record to delete
81eccf0a
DM
1056 * @return void
1057 */
7a789aa8 1058 public function delete_submission(stdclass $submission) {
81eccf0a
DM
1059 global $DB;
1060 $assessments = $DB->get_records('workshop_assessments', array('submissionid' => $submission->id), '', 'id');
1061 $this->delete_assessment(array_keys($assessments));
1062 $DB->delete_records('workshop_submissions', array('id' => $submission->id));
1063 }
1064
6e309973 1065 /**
3dc78e5b 1066 * Returns the list of all assessments in the workshop with some data added
6e309973
DM
1067 *
1068 * Fetches data from {workshop_assessments} and adds some useful information from other
de6aaa72 1069 * tables. The returned object does not contain textual fields (i.e. comments) to prevent memory
3dc78e5b
DM
1070 * lack issues.
1071 *
7a789aa8 1072 * @return array [assessmentid] => assessment stdclass
6e309973 1073 */
3dc78e5b 1074 public function get_all_assessments() {
6e309973 1075 global $DB;
53fad4b9 1076
38504a44
DM
1077 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
1078 $authorfields = user_picture::fields('author', null, 'authorid', 'author');
f68648e9 1079 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
9695ff81 1080 list($sort, $params) = users_order_by_sql('reviewer');
38504a44 1081 $sql = "SELECT a.id, a.submissionid, a.reviewerid, a.timecreated, a.timemodified,
3dc78e5b 1082 a.grade, a.gradinggrade, a.gradinggradeover, a.gradinggradeoverby,
f68648e9 1083 $reviewerfields, $authorfields, $overbyfields,
38504a44 1084 s.title
3d2924e9 1085 FROM {workshop_assessments} a
00aca3c1 1086 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
3d2924e9 1087 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
00aca3c1 1088 INNER JOIN {user} author ON (s.authorid = author.id)
f68648e9 1089 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
3dc78e5b 1090 WHERE s.workshopid = :workshopid AND s.example = 0
9695ff81
TH
1091 ORDER BY $sort";
1092 $params['workshopid'] = $this->id;
3d2924e9 1093
3dc78e5b 1094 return $DB->get_records_sql($sql, $params);
53fad4b9
DM
1095 }
1096
1097 /**
3dc78e5b 1098 * Get the complete information about the given assessment
53fad4b9
DM
1099 *
1100 * @param int $id Assessment ID
5a372494 1101 * @return stdclass
53fad4b9
DM
1102 */
1103 public function get_assessment_by_id($id) {
3dc78e5b
DM
1104 global $DB;
1105
38504a44
DM
1106 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
1107 $authorfields = user_picture::fields('author', null, 'authorid', 'author');
f68648e9
DM
1108 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
1109 $sql = "SELECT a.*, s.title, $reviewerfields, $authorfields, $overbyfields
3dc78e5b 1110 FROM {workshop_assessments} a
00aca3c1 1111 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
3dc78e5b 1112 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
00aca3c1 1113 INNER JOIN {user} author ON (s.authorid = author.id)
f68648e9 1114 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
38504a44 1115 WHERE a.id = :id AND s.workshopid = :workshopid";
3dc78e5b
DM
1116 $params = array('id' => $id, 'workshopid' => $this->id);
1117
1118 return $DB->get_record_sql($sql, $params, MUST_EXIST);
53fad4b9
DM
1119 }
1120
5a372494
DM
1121 /**
1122 * Get the complete information about the user's assessment of the given submission
1123 *
1124 * @param int $sid submission ID
1125 * @param int $uid user ID of the reviewer
1126 * @return false|stdclass false if not found, stdclass otherwise
1127 */
1128 public function get_assessment_of_submission_by_user($submissionid, $reviewerid) {
1129 global $DB;
1130
38504a44
DM
1131 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
1132 $authorfields = user_picture::fields('author', null, 'authorid', 'author');
f68648e9
DM
1133 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
1134 $sql = "SELECT a.*, s.title, $reviewerfields, $authorfields, $overbyfields
5a372494
DM
1135 FROM {workshop_assessments} a
1136 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
1137 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
1138 INNER JOIN {user} author ON (s.authorid = author.id)
f68648e9 1139 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
38504a44 1140 WHERE s.id = :sid AND reviewer.id = :rid AND s.workshopid = :workshopid";
5a372494
DM
1141 $params = array('sid' => $submissionid, 'rid' => $reviewerid, 'workshopid' => $this->id);
1142
1143 return $DB->get_record_sql($sql, $params, IGNORE_MISSING);
1144 }
1145
1146 /**
1147 * Get the complete information about all assessments of the given submission
1148 *
1149 * @param int $submissionid
1150 * @return array
1151 */
1152 public function get_assessments_of_submission($submissionid) {
1153 global $DB;
1154
38504a44 1155 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
f68648e9 1156 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
9695ff81 1157 list($sort, $params) = users_order_by_sql('reviewer');
f68648e9 1158 $sql = "SELECT a.*, s.title, $reviewerfields, $overbyfields
5a372494
DM
1159 FROM {workshop_assessments} a
1160 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
1161 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
f68648e9 1162 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
38504a44 1163 WHERE s.example = 0 AND s.id = :submissionid AND s.workshopid = :workshopid
9695ff81
TH
1164 ORDER BY $sort";
1165 $params['submissionid'] = $submissionid;
1166 $params['workshopid'] = $this->id;
5a372494
DM
1167
1168 return $DB->get_records_sql($sql, $params);
1169 }
1170
53fad4b9 1171 /**
3dc78e5b 1172 * Get the complete information about all assessments allocated to the given reviewer
53fad4b9 1173 *
00aca3c1 1174 * @param int $reviewerid
3dc78e5b 1175 * @return array
53fad4b9 1176 */
00aca3c1 1177 public function get_assessments_by_reviewer($reviewerid) {
3dc78e5b
DM
1178 global $DB;
1179
38504a44
DM
1180 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
1181 $authorfields = user_picture::fields('author', null, 'authorid', 'author');
f68648e9
DM
1182 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
1183 $sql = "SELECT a.*, $reviewerfields, $authorfields, $overbyfields,
ddb59c77 1184 s.id AS submissionid, s.title AS submissiontitle, s.timecreated AS submissioncreated,
38504a44 1185 s.timemodified AS submissionmodified
3dc78e5b 1186 FROM {workshop_assessments} a
00aca3c1 1187 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
3dc78e5b 1188 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
00aca3c1 1189 INNER JOIN {user} author ON (s.authorid = author.id)
f68648e9 1190 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
38504a44 1191 WHERE s.example = 0 AND reviewer.id = :reviewerid AND s.workshopid = :workshopid";
00aca3c1 1192 $params = array('reviewerid' => $reviewerid, 'workshopid' => $this->id);
3dc78e5b
DM
1193
1194 return $DB->get_records_sql($sql, $params);
53fad4b9 1195 }
6e309973 1196
0001eea6
DM
1197 /**
1198 * Get allocated assessments not graded yet by the given reviewer
1199 *
1200 * @see self::get_assessments_by_reviewer()
1201 * @param int $reviewerid the reviewer id
1202 * @param null|int|array $exclude optional assessment id (or list of them) to be excluded
1203 * @return array
1204 */
1205 public function get_pending_assessments_by_reviewer($reviewerid, $exclude = null) {
1206
1207 $assessments = $this->get_assessments_by_reviewer($reviewerid);
1208
1209 foreach ($assessments as $id => $assessment) {
1210 if (!is_null($assessment->grade)) {
1211 unset($assessments[$id]);
1212 continue;
1213 }
1214 if (!empty($exclude)) {
1215 if (is_array($exclude) and in_array($id, $exclude)) {
1216 unset($assessments[$id]);
1217 continue;
1218 } else if ($id == $exclude) {
1219 unset($assessments[$id]);
1220 continue;
1221 }
1222 }
1223 }
1224
1225 return $assessments;
1226 }
1227
6e309973
DM
1228 /**
1229 * Allocate a submission to a user for review
53fad4b9 1230 *
5924db72 1231 * @param stdClass $submission Submission object with at least id property
6e309973 1232 * @param int $reviewerid User ID
becec954 1233 * @param int $weight of the new assessment, from 0 to 16
67ae13d9 1234 * @param bool $bulk repeated inserts into DB expected
31cea236 1235 * @return int ID of the new assessment or an error code {@link self::ALLOCATION_EXISTS} if the allocation already exists
6e309973 1236 */
67ae13d9 1237 public function add_allocation(stdclass $submission, $reviewerid, $weight=1, $bulk=false) {
6e309973
DM
1238 global $DB;
1239
00aca3c1 1240 if ($DB->record_exists('workshop_assessments', array('submissionid' => $submission->id, 'reviewerid' => $reviewerid))) {
b761e6d9 1241 return self::ALLOCATION_EXISTS;
6e309973
DM
1242 }
1243
67ae13d9
DM
1244 $weight = (int)$weight;
1245 if ($weight < 0) {
1246 $weight = 0;
1247 }
1248 if ($weight > 16) {
1249 $weight = 16;
1250 }
1251
6e309973 1252 $now = time();
7a789aa8 1253 $assessment = new stdclass();
e554671d
DM
1254 $assessment->submissionid = $submission->id;
1255 $assessment->reviewerid = $reviewerid;
7a5f4be0 1256 $assessment->timecreated = $now; // do not set timemodified here
becec954 1257 $assessment->weight = $weight;
c6a793d5 1258 $assessment->feedbackauthorformat = editors_get_preferred_format();
884482fb 1259 $assessment->feedbackreviewerformat = editors_get_preferred_format();
6e309973 1260
235b31c8 1261 return $DB->insert_record('workshop_assessments', $assessment, true, $bulk);
6e309973
DM
1262 }
1263
6e309973 1264 /**
53fad4b9 1265 * Delete assessment record or records
6e309973 1266 *
53fad4b9
DM
1267 * @param mixed $id int|array assessment id or array of assessments ids
1268 * @return bool false if $id not a valid parameter, true otherwise
6e309973
DM
1269 */
1270 public function delete_assessment($id) {
1271 global $DB;
1272
1273 // todo remove all given grades from workshop_grades;
6e309973 1274
53fad4b9 1275 if (is_array($id)) {
235b31c8 1276 return $DB->delete_records_list('workshop_assessments', 'id', $id);
3d2924e9 1277 } else {
235b31c8 1278 return $DB->delete_records('workshop_assessments', array('id' => $id));
53fad4b9 1279 }
53fad4b9 1280 }
6e309973
DM
1281
1282 /**
1283 * Returns instance of grading strategy class
53fad4b9 1284 *
7a789aa8 1285 * @return stdclass Instance of a grading strategy
6e309973
DM
1286 */
1287 public function grading_strategy_instance() {
3d2924e9
DM
1288 global $CFG; // because we require other libs here
1289
3fd2b0e1 1290 if (is_null($this->strategyinstance)) {
f05c168d 1291 $strategylib = dirname(__FILE__) . '/form/' . $this->strategy . '/lib.php';
6e309973
DM
1292 if (is_readable($strategylib)) {
1293 require_once($strategylib);
1294 } else {
f05c168d 1295 throw new coding_exception('the grading forms subplugin must contain library ' . $strategylib);
6e309973 1296 }
0dc47fb9 1297 $classname = 'workshop_' . $this->strategy . '_strategy';
3fd2b0e1
DM
1298 $this->strategyinstance = new $classname($this);
1299 if (!in_array('workshop_strategy', class_implements($this->strategyinstance))) {
b761e6d9 1300 throw new coding_exception($classname . ' does not implement workshop_strategy interface');
6e309973
DM
1301 }
1302 }
3fd2b0e1 1303 return $this->strategyinstance;
6e309973
DM
1304 }
1305
a93dc3ec
DM
1306 /**
1307 * Sets the current evaluation method to the given plugin.
1308 *
1309 * @param string $method the name of the workshopeval subplugin
1310 * @return bool true if successfully set
1311 * @throws coding_exception if attempting to set a non-installed evaluation method
1312 */
1313 public function set_grading_evaluation_method($method) {
1314 global $DB;
1315
1316 $evaluationlib = dirname(__FILE__) . '/eval/' . $method . '/lib.php';
1317
1318 if (is_readable($evaluationlib)) {
1319 $this->evaluationinstance = null;
1320 $this->evaluation = $method;
1321 $DB->set_field('workshop', 'evaluation', $method, array('id' => $this->id));
1322 return true;
1323 }
1324
1325 throw new coding_exception('Attempt to set a non-existing evaluation method.');
1326 }
1327
45d24d39
DM
1328 /**
1329 * Returns instance of grading evaluation class
1330 *
7a789aa8 1331 * @return stdclass Instance of a grading evaluation
45d24d39
DM
1332 */
1333 public function grading_evaluation_instance() {
1334 global $CFG; // because we require other libs here
1335
1336 if (is_null($this->evaluationinstance)) {
4f115176
DM
1337 if (empty($this->evaluation)) {
1338 $this->evaluation = 'best';
1339 }
45d24d39
DM
1340 $evaluationlib = dirname(__FILE__) . '/eval/' . $this->evaluation . '/lib.php';
1341 if (is_readable($evaluationlib)) {
1342 require_once($evaluationlib);
1343 } else {
4f115176
DM
1344 // Fall back in case the subplugin is not available.
1345 $this->evaluation = 'best';
1346 $evaluationlib = dirname(__FILE__) . '/eval/' . $this->evaluation . '/lib.php';
1347 if (is_readable($evaluationlib)) {
1348 require_once($evaluationlib);
1349 } else {
1350 // Fall back in case the subplugin is not available any more.
1351 throw new coding_exception('Missing default grading evaluation library ' . $evaluationlib);
1352 }
45d24d39
DM
1353 }
1354 $classname = 'workshop_' . $this->evaluation . '_evaluation';
1355 $this->evaluationinstance = new $classname($this);
4f115176
DM
1356 if (!in_array('workshop_evaluation', class_parents($this->evaluationinstance))) {
1357 throw new coding_exception($classname . ' does not extend workshop_evaluation class');
45d24d39
DM
1358 }
1359 }
1360 return $this->evaluationinstance;
1361 }
1362
66c9894d
DM
1363 /**
1364 * Returns instance of submissions allocator
53fad4b9 1365 *
130ae619 1366 * @param string $method The name of the allocation method, must be PARAM_ALPHA
7a789aa8 1367 * @return stdclass Instance of submissions allocator
66c9894d
DM
1368 */
1369 public function allocator_instance($method) {
3d2924e9
DM
1370 global $CFG; // because we require other libs here
1371
f05c168d 1372 $allocationlib = dirname(__FILE__) . '/allocation/' . $method . '/lib.php';
66c9894d
DM
1373 if (is_readable($allocationlib)) {
1374 require_once($allocationlib);
1375 } else {
f05c168d 1376 throw new coding_exception('Unable to find the allocation library ' . $allocationlib);
66c9894d
DM
1377 }
1378 $classname = 'workshop_' . $method . '_allocator';
1379 return new $classname($this);
1380 }
1381
b8ead2e6 1382 /**
454e8dd9 1383 * @return moodle_url of this workshop's view page
b8ead2e6
DM
1384 */
1385 public function view_url() {
1386 global $CFG;
a6855934 1387 return new moodle_url('/mod/workshop/view.php', array('id' => $this->cm->id));
b8ead2e6
DM
1388 }
1389
1390 /**
454e8dd9 1391 * @return moodle_url of the page for editing this workshop's grading form
b8ead2e6
DM
1392 */
1393 public function editform_url() {
1394 global $CFG;
a6855934 1395 return new moodle_url('/mod/workshop/editform.php', array('cmid' => $this->cm->id));
b8ead2e6
DM
1396 }
1397
1398 /**
454e8dd9 1399 * @return moodle_url of the page for previewing this workshop's grading form
b8ead2e6
DM
1400 */
1401 public function previewform_url() {
1402 global $CFG;
a6855934 1403 return new moodle_url('/mod/workshop/editformpreview.php', array('cmid' => $this->cm->id));
b8ead2e6
DM
1404 }
1405
1406 /**
1407 * @param int $assessmentid The ID of assessment record
454e8dd9 1408 * @return moodle_url of the assessment page
b8ead2e6 1409 */
a39d7d87 1410 public function assess_url($assessmentid) {
b8ead2e6 1411 global $CFG;
454e8dd9 1412 $assessmentid = clean_param($assessmentid, PARAM_INT);
a6855934 1413 return new moodle_url('/mod/workshop/assessment.php', array('asid' => $assessmentid));
b8ead2e6
DM
1414 }
1415
becec954
DM
1416 /**
1417 * @param int $assessmentid The ID of assessment record
1418 * @return moodle_url of the example assessment page
1419 */
1420 public function exassess_url($assessmentid) {
1421 global $CFG;
1422 $assessmentid = clean_param($assessmentid, PARAM_INT);
a6855934 1423 return new moodle_url('/mod/workshop/exassessment.php', array('asid' => $assessmentid));
becec954
DM
1424 }
1425
39861053 1426 /**
67cd00ba 1427 * @return moodle_url of the page to view a submission, defaults to the own one
39861053 1428 */
67cd00ba 1429 public function submission_url($id=null) {
39861053 1430 global $CFG;
a6855934 1431 return new moodle_url('/mod/workshop/submission.php', array('cmid' => $this->cm->id, 'id' => $id));
39861053
DM
1432 }
1433
81eccf0a
DM
1434 /**
1435 * @param int $id example submission id
1436 * @return moodle_url of the page to view an example submission
1437 */
becec954 1438 public function exsubmission_url($id) {
81eccf0a 1439 global $CFG;
a6855934 1440 return new moodle_url('/mod/workshop/exsubmission.php', array('cmid' => $this->cm->id, 'id' => $id));
81eccf0a
DM
1441 }
1442
cbf87967
DM
1443 /**
1444 * @param int $sid submission id
1445 * @param array $aid of int assessment ids
1446 * @return moodle_url of the page to compare assessments of the given submission
1447 */
1448 public function compare_url($sid, array $aids) {
1449 global $CFG;
1450
a6855934 1451 $url = new moodle_url('/mod/workshop/compare.php', array('cmid' => $this->cm->id, 'sid' => $sid));
cbf87967
DM
1452 $i = 0;
1453 foreach ($aids as $aid) {
1454 $url->param("aid{$i}", $aid);
1455 $i++;
1456 }
1457 return $url;
1458 }
1459
1460 /**
1461 * @param int $sid submission id
1462 * @param int $aid assessment id
1463 * @return moodle_url of the page to compare the reference assessments of the given example submission
1464 */
1465 public function excompare_url($sid, $aid) {
1466 global $CFG;
a6855934 1467 return new moodle_url('/mod/workshop/excompare.php', array('cmid' => $this->cm->id, 'sid' => $sid, 'aid' => $aid));
cbf87967
DM
1468 }
1469
da0b1f70 1470 /**
454e8dd9 1471 * @return moodle_url of the mod_edit form
da0b1f70
DM
1472 */
1473 public function updatemod_url() {
1474 global $CFG;
a6855934 1475 return new moodle_url('/course/modedit.php', array('update' => $this->cm->id, 'return' => 1));
da0b1f70
DM
1476 }
1477
454e8dd9 1478 /**
08af32af 1479 * @param string $method allocation method
454e8dd9
DM
1480 * @return moodle_url to the allocation page
1481 */
08af32af 1482 public function allocation_url($method=null) {
da0b1f70 1483 global $CFG;
08af32af
DM
1484 $params = array('cmid' => $this->cm->id);
1485 if (!empty($method)) {
1486 $params['method'] = $method;
1487 }
1488 return new moodle_url('/mod/workshop/allocation.php', $params);
da0b1f70
DM
1489 }
1490
454e8dd9
DM
1491 /**
1492 * @param int $phasecode The internal phase code
1493 * @return moodle_url of the script to change the current phase to $phasecode
1494 */
1495 public function switchphase_url($phasecode) {
1496 global $CFG;
1497 $phasecode = clean_param($phasecode, PARAM_INT);
a6855934 1498 return new moodle_url('/mod/workshop/switchphase.php', array('cmid' => $this->cm->id, 'phase' => $phasecode));
454e8dd9
DM
1499 }
1500
89c1aa97
DM
1501 /**
1502 * @return moodle_url to the aggregation page
1503 */
1504 public function aggregate_url() {
1505 global $CFG;
a6855934 1506 return new moodle_url('/mod/workshop/aggregate.php', array('cmid' => $this->cm->id));
89c1aa97
DM
1507 }
1508
32c78bc3
DM
1509 /**
1510 * @return moodle_url of this workshop's toolbox page
1511 */
1512 public function toolbox_url($tool) {
1513 global $CFG;
1514 return new moodle_url('/mod/workshop/toolbox.php', array('id' => $this->cm->id, 'tool' => $tool));
1515 }
1516
5450f7b6
DM
1517 /**
1518 * Workshop wrapper around {@see add_to_log()}
1a219fb6 1519 * @deprecated since 2.7 Please use the provided event classes for logging actions.
5450f7b6
DM
1520 *
1521 * @param string $action to be logged
1522 * @param moodle_url $url absolute url as returned by {@see workshop::submission_url()} and friends
1523 * @param mixed $info additional info, usually id in a table
cbf4b0e6
FM
1524 * @param bool $return true to return the arguments for add_to_log.
1525 * @return void|array array of arguments for add_to_log if $return is true
5450f7b6 1526 */
cbf4b0e6 1527 public function log($action, moodle_url $url = null, $info = null, $return = false) {
1a219fb6 1528 debugging('The log method is now deprecated, please use event classes instead', DEBUG_DEVELOPER);
5450f7b6
DM
1529
1530 if (is_null($url)) {
1531 $url = $this->view_url();
1532 }
1533
1534 if (is_null($info)) {
1535 $info = $this->id;
1536 }
1537
1538 $logurl = $this->log_convert_url($url);
cbf4b0e6
FM
1539 $args = array($this->course->id, 'workshop', $action, $logurl, $info, $this->cm->id);
1540 if ($return) {
1541 return $args;
1542 }
1543 call_user_func_array('add_to_log', $args);
5450f7b6
DM
1544 }
1545
b8ead2e6 1546 /**
9ddff589 1547 * Is the given user allowed to create their submission?
407b1e91 1548 *
9ddff589 1549 * @param int $userid
407b1e91 1550 * @return bool
b8ead2e6 1551 */
9ddff589
DM
1552 public function creating_submission_allowed($userid) {
1553
2f289d36 1554 $now = time();
9ddff589 1555 $ignoredeadlines = has_capability('mod/workshop:ignoredeadlines', $this->context, $userid);
2f289d36
DM
1556
1557 if ($this->latesubmissions) {
1558 if ($this->phase != self::PHASE_SUBMISSION and $this->phase != self::PHASE_ASSESSMENT) {
1559 // late submissions are allowed in the submission and assessment phase only
1560 return false;
1561 }
9ddff589 1562 if (!$ignoredeadlines and !empty($this->submissionstart) and $this->submissionstart > $now) {
2f289d36
DM
1563 // late submissions are not allowed before the submission start
1564 return false;
1565 }
1566 return true;
1567
1568 } else {
1569 if ($this->phase != self::PHASE_SUBMISSION) {
1570 // submissions are allowed during the submission phase only
1571 return false;
1572 }
9ddff589 1573 if (!$ignoredeadlines and !empty($this->submissionstart) and $this->submissionstart > $now) {
2f289d36
DM
1574 // if enabled, submitting is not allowed before the date/time defined in the mod_form
1575 return false;
1576 }
9ddff589 1577 if (!$ignoredeadlines and !empty($this->submissionend) and $now > $this->submissionend ) {
2f289d36
DM
1578 // if enabled, submitting is not allowed after the date/time defined in the mod_form unless late submission is allowed
1579 return false;
1580 }
1581 return true;
1582 }
1583 }
1584
1585 /**
9ddff589 1586 * Is the given user allowed to modify their existing submission?
2f289d36 1587 *
9ddff589 1588 * @param int $userid
2f289d36
DM
1589 * @return bool
1590 */
9ddff589
DM
1591 public function modifying_submission_allowed($userid) {
1592
2f289d36 1593 $now = time();
9ddff589 1594 $ignoredeadlines = has_capability('mod/workshop:ignoredeadlines', $this->context, $userid);
2f289d36 1595
74bf8a94 1596 if ($this->phase != self::PHASE_SUBMISSION) {
2f289d36 1597 // submissions can be edited during the submission phase only
74bf8a94
DM
1598 return false;
1599 }
9ddff589 1600 if (!$ignoredeadlines and !empty($this->submissionstart) and $this->submissionstart > $now) {
c1ab2b10 1601 // if enabled, re-submitting is not allowed before the date/time defined in the mod_form
74bf8a94
DM
1602 return false;
1603 }
c1ab2b10
DM
1604 if (!$ignoredeadlines and !empty($this->submissionend) and $now > $this->submissionend) {
1605 // if enabled, re-submitting is not allowed after the date/time defined in the mod_form even if late submission is allowed
74bf8a94
DM
1606 return false;
1607 }
407b1e91 1608 return true;
b8ead2e6
DM
1609 }
1610
c1e883bb 1611 /**
9ddff589 1612 * Is the given reviewer allowed to create/edit their assessments?
c1e883bb 1613 *
9ddff589 1614 * @param int $userid
c1e883bb
DM
1615 * @return bool
1616 */
9ddff589
DM
1617 public function assessing_allowed($userid) {
1618
74bf8a94 1619 if ($this->phase != self::PHASE_ASSESSMENT) {
4affa724
DM
1620 // assessing is allowed in the assessment phase only, unless the user is a teacher
1621 // providing additional assessment during the evaluation phase
1622 if ($this->phase != self::PHASE_EVALUATION or !has_capability('mod/workshop:overridegrades', $this->context, $userid)) {
1623 return false;
1624 }
74bf8a94 1625 }
9ddff589 1626
74bf8a94 1627 $now = time();
9ddff589
DM
1628 $ignoredeadlines = has_capability('mod/workshop:ignoredeadlines', $this->context, $userid);
1629
1630 if (!$ignoredeadlines and !empty($this->assessmentstart) and $this->assessmentstart > $now) {
74bf8a94
DM
1631 // if enabled, assessing is not allowed before the date/time defined in the mod_form
1632 return false;
1633 }
9ddff589 1634 if (!$ignoredeadlines and !empty($this->assessmentend) and $now > $this->assessmentend) {
74bf8a94
DM
1635 // if enabled, assessing is not allowed after the date/time defined in the mod_form
1636 return false;
1637 }
1638 // here we go, assessing is allowed
c1e883bb
DM
1639 return true;
1640 }
1641
becec954
DM
1642 /**
1643 * Are reviewers allowed to create/edit their assessments of the example submissions?
1644 *
514d8c22
DM
1645 * Returns null if example submissions are not enabled in this workshop. Otherwise returns
1646 * true or false. Note this does not check other conditions like the number of already
1647 * assessed examples, examples mode etc.
becec954 1648 *
74bf8a94 1649 * @return null|bool
becec954
DM
1650 */
1651 public function assessing_examples_allowed() {
74bf8a94
DM
1652 if (empty($this->useexamples)) {
1653 return null;
1654 }
1655 if (self::EXAMPLES_VOLUNTARY == $this->examplesmode) {
1656 return true;
1657 }
1658 if (self::EXAMPLES_BEFORE_SUBMISSION == $this->examplesmode and self::PHASE_SUBMISSION == $this->phase) {
1659 return true;
1660 }
1661 if (self::EXAMPLES_BEFORE_ASSESSMENT == $this->examplesmode and self::PHASE_ASSESSMENT == $this->phase) {
1662 return true;
1663 }
1664 return false;
becec954 1665 }
407b1e91 1666
3dc78e5b
DM
1667 /**
1668 * Are the peer-reviews available to the authors?
1669 *
3dc78e5b
DM
1670 * @return bool
1671 */
1672 public function assessments_available() {
5a372494 1673 return $this->phase == self::PHASE_CLOSED;
3dc78e5b
DM
1674 }
1675
454e8dd9
DM
1676 /**
1677 * Switch to a new workshop phase
1678 *
1679 * Modifies the underlying database record. You should terminate the script shortly after calling this.
1680 *
1681 * @param int $newphase new phase code
1682 * @return bool true if success, false otherwise
1683 */
1684 public function switch_phase($newphase) {
1685 global $DB;
1686
365c2cc2 1687 $known = $this->available_phases_list();
454e8dd9
DM
1688 if (!isset($known[$newphase])) {
1689 return false;
1690 }
f6e8b318
DM
1691
1692 if (self::PHASE_CLOSED == $newphase) {
f27b70fb 1693 // push the grades into the gradebook
7a789aa8 1694 $workshop = new stdclass();
10bc4bce
DM
1695 foreach ($this as $property => $value) {
1696 $workshop->{$property} = $value;
1697 }
1698 $workshop->course = $this->course->id;
1699 $workshop->cmidnumber = $this->cm->id;
1700 $workshop->modname = 'workshop';
1701 workshop_update_grades($workshop);
f6e8b318
DM
1702 }
1703
454e8dd9 1704 $DB->set_field('workshop', 'phase', $newphase, array('id' => $this->id));
9260bb3c 1705 $this->phase = $newphase;
1a219fb6
AG
1706 $eventdata = array(
1707 'objectid' => $this->id,
1708 'context' => $this->context,
1709 'other' => array(
1710 'workshopphase' => $this->phase
1711 )
1712 );
1713 $event = \mod_workshop\event\phase_switched::create($eventdata);
1714 $event->trigger();
454e8dd9
DM
1715 return true;
1716 }
ddb59c77
DM
1717
1718 /**
1719 * Saves a raw grade for submission as calculated from the assessment form fields
1720 *
1721 * @param array $assessmentid assessment record id, must exists
00aca3c1 1722 * @param mixed $grade raw percentual grade from 0.00000 to 100.00000
ddb59c77
DM
1723 * @return false|float the saved grade
1724 */
1725 public function set_peer_grade($assessmentid, $grade) {
1726 global $DB;
1727
1728 if (is_null($grade)) {
1729 return false;
1730 }
7a789aa8 1731 $data = new stdclass();
ddb59c77
DM
1732 $data->id = $assessmentid;
1733 $data->grade = $grade;
7a5f4be0 1734 $data->timemodified = time();
ddb59c77
DM
1735 $DB->update_record('workshop_assessments', $data);
1736 return $grade;
1737 }
6516b9e9 1738
29dc43e7
DM
1739 /**
1740 * Prepares data object with all workshop grades to be rendered
1741 *
5e71cefb 1742 * @param int $userid the user we are preparing the report for
dda42a19 1743 * @param int $groupid if non-zero, prepare the report for the given group only
29dc43e7 1744 * @param int $page the current page (for the pagination)
5e71cefb 1745 * @param int $perpage participants per page (for the pagination)
f27b70fb 1746 * @param string $sortby lastname|firstname|submissiontitle|submissiongrade|gradinggrade
5e71cefb 1747 * @param string $sorthow ASC|DESC
7a789aa8 1748 * @return stdclass data for the renderer
29dc43e7 1749 */
dda42a19 1750 public function prepare_grading_report_data($userid, $groupid, $page, $perpage, $sortby, $sorthow) {
29dc43e7
DM
1751 global $DB;
1752
d895c6aa 1753 $canviewall = has_capability('mod/workshop:viewallassessments', $this->context, $userid);
8741ebb0 1754 $isparticipant = $this->is_participant($userid);
29dc43e7
DM
1755
1756 if (!$canviewall and !$isparticipant) {
1757 // who the hell is this?
1758 return array();
1759 }
1760
f27b70fb 1761 if (!in_array($sortby, array('lastname','firstname','submissiontitle','submissiongrade','gradinggrade'))) {
5e71cefb
DM
1762 $sortby = 'lastname';
1763 }
1764
1765 if (!($sorthow === 'ASC' or $sorthow === 'DESC')) {
1766 $sorthow = 'ASC';
1767 }
1768
1769 // get the list of user ids to be displayed
29dc43e7 1770 if ($canviewall) {
dda42a19 1771 $participants = $this->get_participants(false, $groupid);
29dc43e7
DM
1772 } else {
1773 // this is an ordinary workshop participant (aka student) - display the report just for him/her
1774 $participants = array($userid => (object)array('id' => $userid));
1775 }
1776
5e71cefb 1777 // we will need to know the number of all records later for the pagination purposes
29dc43e7
DM
1778 $numofparticipants = count($participants);
1779
deea6e7a
DM
1780 if ($numofparticipants > 0) {
1781 // load all fields which can be used for sorting and paginate the records
1782 list($participantids, $params) = $DB->get_in_or_equal(array_keys($participants), SQL_PARAMS_NAMED);
1783 $params['workshopid1'] = $this->id;
1784 $params['workshopid2'] = $this->id;
20e7fd83
DM
1785 $sqlsort = array();
1786 $sqlsortfields = array($sortby => $sorthow) + array('lastname' => 'ASC', 'firstname' => 'ASC', 'u.id' => 'ASC');
1787 foreach ($sqlsortfields as $sqlsortfieldname => $sqlsortfieldhow) {
1788 $sqlsort[] = $sqlsortfieldname . ' ' . $sqlsortfieldhow;
1789 }
1790 $sqlsort = implode(',', $sqlsort);
a327f25e
AG
1791 $picturefields = user_picture::fields('u', array(), 'userid');
1792 $sql = "SELECT $picturefields, s.title AS submissiontitle, s.grade AS submissiongrade, ag.gradinggrade
deea6e7a
DM
1793 FROM {user} u
1794 LEFT JOIN {workshop_submissions} s ON (s.authorid = u.id AND s.workshopid = :workshopid1 AND s.example = 0)
1795 LEFT JOIN {workshop_aggregations} ag ON (ag.userid = u.id AND ag.workshopid = :workshopid2)
1796 WHERE u.id $participantids
1797 ORDER BY $sqlsort";
1798 $participants = $DB->get_records_sql($sql, $params, $page * $perpage, $perpage);
1799 } else {
1800 $participants = array();
1801 }
29dc43e7
DM
1802
1803 // this will hold the information needed to display user names and pictures
5e71cefb
DM
1804 $userinfo = array();
1805
1806 // get the user details for all participants to display
a327f25e 1807 $additionalnames = get_all_user_name_fields();
5e71cefb
DM
1808 foreach ($participants as $participant) {
1809 if (!isset($userinfo[$participant->userid])) {
7a789aa8 1810 $userinfo[$participant->userid] = new stdclass();
5e71cefb 1811 $userinfo[$participant->userid]->id = $participant->userid;
5e71cefb
DM
1812 $userinfo[$participant->userid]->picture = $participant->picture;
1813 $userinfo[$participant->userid]->imagealt = $participant->imagealt;
3a11c09f 1814 $userinfo[$participant->userid]->email = $participant->email;
a327f25e
AG
1815 foreach ($additionalnames as $addname) {
1816 $userinfo[$participant->userid]->$addname = $participant->$addname;
1817 }
5e71cefb
DM
1818 }
1819 }
29dc43e7 1820
5e71cefb 1821 // load the submissions details
29dc43e7 1822 $submissions = $this->get_submissions(array_keys($participants));
5e71cefb
DM
1823
1824 // get the user details for all moderators (teachers) that have overridden a submission grade
29dc43e7 1825 foreach ($submissions as $submission) {
29dc43e7 1826 if (!isset($userinfo[$submission->gradeoverby])) {
7a789aa8 1827 $userinfo[$submission->gradeoverby] = new stdclass();
29dc43e7 1828 $userinfo[$submission->gradeoverby]->id = $submission->gradeoverby;
29dc43e7
DM
1829 $userinfo[$submission->gradeoverby]->picture = $submission->overpicture;
1830 $userinfo[$submission->gradeoverby]->imagealt = $submission->overimagealt;
3a11c09f 1831 $userinfo[$submission->gradeoverby]->email = $submission->overemail;
a327f25e
AG
1832 foreach ($additionalnames as $addname) {
1833 $temp = 'over' . $addname;
1834 $userinfo[$submission->gradeoverby]->$addname = $submission->$temp;
1835 }
29dc43e7
DM
1836 }
1837 }
1838
5e71cefb 1839 // get the user details for all reviewers of the displayed participants
29dc43e7 1840 $reviewers = array();
a327f25e 1841
29dc43e7
DM
1842 if ($submissions) {
1843 list($submissionids, $params) = $DB->get_in_or_equal(array_keys($submissions), SQL_PARAMS_NAMED);
9695ff81 1844 list($sort, $sortparams) = users_order_by_sql('r');
a327f25e 1845 $picturefields = user_picture::fields('r', array(), 'reviewerid');
581878b8 1846 $sql = "SELECT a.id AS assessmentid, a.submissionid, a.grade, a.gradinggrade, a.gradinggradeover, a.weight,
a327f25e 1847 $picturefields, s.id AS submissionid, s.authorid
29dc43e7
DM
1848 FROM {workshop_assessments} a
1849 JOIN {user} r ON (a.reviewerid = r.id)
0324b6f1 1850 JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
c6b784f0 1851 WHERE a.submissionid $submissionids
9695ff81
TH
1852 ORDER BY a.weight DESC, $sort";
1853 $reviewers = $DB->get_records_sql($sql, array_merge($params, $sortparams));
29dc43e7
DM
1854 foreach ($reviewers as $reviewer) {
1855 if (!isset($userinfo[$reviewer->reviewerid])) {
7a789aa8 1856 $userinfo[$reviewer->reviewerid] = new stdclass();
29dc43e7 1857 $userinfo[$reviewer->reviewerid]->id = $reviewer->reviewerid;
29dc43e7
DM
1858 $userinfo[$reviewer->reviewerid]->picture = $reviewer->picture;
1859 $userinfo[$reviewer->reviewerid]->imagealt = $reviewer->imagealt;
3a11c09f 1860 $userinfo[$reviewer->reviewerid]->email = $reviewer->email;
a327f25e
AG
1861 foreach ($additionalnames as $addname) {
1862 $userinfo[$reviewer->reviewerid]->$addname = $reviewer->$addname;
1863 }
29dc43e7
DM
1864 }
1865 }
1866 }
1867
5e71cefb 1868 // get the user details for all reviewees of the displayed participants
934329e5
DM
1869 $reviewees = array();
1870 if ($participants) {
1871 list($participantids, $params) = $DB->get_in_or_equal(array_keys($participants), SQL_PARAMS_NAMED);
9695ff81 1872 list($sort, $sortparams) = users_order_by_sql('e');
934329e5 1873 $params['workshopid'] = $this->id;
a327f25e 1874 $picturefields = user_picture::fields('e', array(), 'authorid');
581878b8 1875 $sql = "SELECT a.id AS assessmentid, a.submissionid, a.grade, a.gradinggrade, a.gradinggradeover, a.reviewerid, a.weight,
a327f25e 1876 s.id AS submissionid, $picturefields
934329e5
DM
1877 FROM {user} u
1878 JOIN {workshop_assessments} a ON (a.reviewerid = u.id)
0324b6f1 1879 JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
934329e5 1880 JOIN {user} e ON (s.authorid = e.id)
c6b784f0 1881 WHERE u.id $participantids AND s.workshopid = :workshopid
9695ff81 1882 ORDER BY a.weight DESC, $sort";
462b4c12 1883 $reviewees = $DB->get_records_sql($sql, array_merge($params, $sortparams));
934329e5
DM
1884 foreach ($reviewees as $reviewee) {
1885 if (!isset($userinfo[$reviewee->authorid])) {
7a789aa8 1886 $userinfo[$reviewee->authorid] = new stdclass();
934329e5 1887 $userinfo[$reviewee->authorid]->id = $reviewee->authorid;
934329e5
DM
1888 $userinfo[$reviewee->authorid]->picture = $reviewee->picture;
1889 $userinfo[$reviewee->authorid]->imagealt = $reviewee->imagealt;
3a11c09f 1890 $userinfo[$reviewee->authorid]->email = $reviewee->email;
a327f25e
AG
1891 foreach ($additionalnames as $addname) {
1892 $userinfo[$reviewee->authorid]->$addname = $reviewee->$addname;
1893 }
934329e5 1894 }
29dc43e7
DM
1895 }
1896 }
1897
5e71cefb
DM
1898 // finally populate the object to be rendered
1899 $grades = $participants;
29dc43e7
DM
1900
1901 foreach ($participants as $participant) {
1902 // set up default (null) values
d183140d
DM
1903 $grades[$participant->userid]->submissionid = null;
1904 $grades[$participant->userid]->submissiontitle = null;
1905 $grades[$participant->userid]->submissiongrade = null;
1906 $grades[$participant->userid]->submissiongradeover = null;
1907 $grades[$participant->userid]->submissiongradeoverby = null;
232175e4 1908 $grades[$participant->userid]->submissionpublished = null;
5e71cefb
DM
1909 $grades[$participant->userid]->reviewedby = array();
1910 $grades[$participant->userid]->reviewerof = array();
29dc43e7
DM
1911 }
1912 unset($participants);
1913 unset($participant);
1914
1915 foreach ($submissions as $submission) {
1916 $grades[$submission->authorid]->submissionid = $submission->id;
1917 $grades[$submission->authorid]->submissiontitle = $submission->title;
b4857acb
DM
1918 $grades[$submission->authorid]->submissiongrade = $this->real_grade($submission->grade);
1919 $grades[$submission->authorid]->submissiongradeover = $this->real_grade($submission->gradeover);
29dc43e7 1920 $grades[$submission->authorid]->submissiongradeoverby = $submission->gradeoverby;
232175e4 1921 $grades[$submission->authorid]->submissionpublished = $submission->published;
29dc43e7
DM
1922 }
1923 unset($submissions);
1924 unset($submission);
1925
1926 foreach($reviewers as $reviewer) {
7a789aa8 1927 $info = new stdclass();
29dc43e7
DM
1928 $info->userid = $reviewer->reviewerid;
1929 $info->assessmentid = $reviewer->assessmentid;
1930 $info->submissionid = $reviewer->submissionid;
b4857acb
DM
1931 $info->grade = $this->real_grade($reviewer->grade);
1932 $info->gradinggrade = $this->real_grading_grade($reviewer->gradinggrade);
1933 $info->gradinggradeover = $this->real_grading_grade($reviewer->gradinggradeover);
581878b8 1934 $info->weight = $reviewer->weight;
29dc43e7
DM
1935 $grades[$reviewer->authorid]->reviewedby[$reviewer->reviewerid] = $info;
1936 }
1937 unset($reviewers);
1938 unset($reviewer);
1939
1940 foreach($reviewees as $reviewee) {
7a789aa8 1941 $info = new stdclass();
29dc43e7
DM
1942 $info->userid = $reviewee->authorid;
1943 $info->assessmentid = $reviewee->assessmentid;
1944 $info->submissionid = $reviewee->submissionid;
b4857acb
DM
1945 $info->grade = $this->real_grade($reviewee->grade);
1946 $info->gradinggrade = $this->real_grading_grade($reviewee->gradinggrade);
1947 $info->gradinggradeover = $this->real_grading_grade($reviewee->gradinggradeover);
581878b8 1948 $info->weight = $reviewee->weight;
29dc43e7
DM
1949 $grades[$reviewee->reviewerid]->reviewerof[$reviewee->authorid] = $info;
1950 }
1951 unset($reviewees);
1952 unset($reviewee);
1953
b4857acb
DM
1954 foreach ($grades as $grade) {
1955 $grade->gradinggrade = $this->real_grading_grade($grade->gradinggrade);
b4857acb
DM
1956 }
1957
7a789aa8 1958 $data = new stdclass();
29dc43e7
DM
1959 $data->grades = $grades;
1960 $data->userinfo = $userinfo;
1961 $data->totalcount = $numofparticipants;
b4857acb
DM
1962 $data->maxgrade = $this->real_grade(100);
1963 $data->maxgradinggrade = $this->real_grading_grade(100);
29dc43e7
DM
1964 return $data;
1965 }
1966
29dc43e7 1967 /**
b4857acb 1968 * Calculates the real value of a grade
29dc43e7 1969 *
b4857acb
DM
1970 * @param float $value percentual value from 0 to 100
1971 * @param float $max the maximal grade
1972 * @return string
1973 */
1974 public function real_grade_value($value, $max) {
1975 $localized = true;
557a1100 1976 if (is_null($value) or $value === '') {
b4857acb
DM
1977 return null;
1978 } elseif ($max == 0) {
1979 return 0;
1980 } else {
1981 return format_float($max * $value / 100, $this->gradedecimals, $localized);
1982 }
1983 }
1984
e554671d
DM
1985 /**
1986 * Calculates the raw (percentual) value from a real grade
1987 *
1988 * This is used in cases when a user wants to give a grade such as 12 of 20 and we need to save
1989 * this value in a raw percentual form into DB
1990 * @param float $value given grade
1991 * @param float $max the maximal grade
1992 * @return float suitable to be stored as numeric(10,5)
1993 */
1994 public function raw_grade_value($value, $max) {
557a1100 1995 if (is_null($value) or $value === '') {
e554671d
DM
1996 return null;
1997 }
1998 if ($max == 0 or $value < 0) {
1999 return 0;
2000 }
2001 $p = $value / $max * 100;
2002 if ($p > 100) {
2003 return $max;
2004 }
2005 return grade_floatval($p);
2006 }
2007
b4857acb
DM
2008 /**
2009 * Calculates the real value of grade for submission
2010 *
2011 * @param float $value percentual value from 0 to 100
2012 * @return string
2013 */
2014 public function real_grade($value) {
2015 return $this->real_grade_value($value, $this->grade);
2016 }
2017
2018 /**
2019 * Calculates the real value of grade for assessment
2020 *
2021 * @param float $value percentual value from 0 to 100
2022 * @return string
2023 */
2024 public function real_grading_grade($value) {
2025 return $this->real_grade_value($value, $this->gradinggrade);
29dc43e7
DM
2026 }
2027
e706b9c3
DM
2028 /**
2029 * Sets the given grades and received grading grades to null
2030 *
2031 * This does not clear the information about how the peers filled the assessment forms, but
2032 * clears the calculated grades in workshop_assessments. Therefore reviewers have to re-assess
2033 * the allocated submissions.
2034 *
2035 * @return void
2036 */
2037 public function clear_assessments() {
2038 global $DB;
2039
2040 $submissions = $this->get_submissions();
2041 if (empty($submissions)) {
2042 // no money, no love
2043 return;
2044 }
2045 $submissions = array_keys($submissions);
2046 list($sql, $params) = $DB->get_in_or_equal($submissions, SQL_PARAMS_NAMED);
2047 $sql = "submissionid $sql";
2048 $DB->set_field_select('workshop_assessments', 'grade', null, $sql, $params);
2049 $DB->set_field_select('workshop_assessments', 'gradinggrade', null, $sql, $params);
2050 }
2051
32c78bc3
DM
2052 /**
2053 * Sets the grades for submission to null
2054 *
2055 * @param null|int|array $restrict If null, update all authors, otherwise update just grades for the given author(s)
2056 * @return void
2057 */
2058 public function clear_submission_grades($restrict=null) {
2059 global $DB;
2060
2061 $sql = "workshopid = :workshopid AND example = 0";
2062 $params = array('workshopid' => $this->id);
2063
2064 if (is_null($restrict)) {
2065 // update all users - no more conditions
2066 } elseif (!empty($restrict)) {
2067 list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
2068 $sql .= " AND authorid $usql";
2069 $params = array_merge($params, $uparams);
2070 } else {
2071 throw new coding_exception('Empty value is not a valid parameter here');
2072 }
2073
2074 $DB->set_field_select('workshop_submissions', 'grade', null, $sql, $params);
2075 }
2076
89c1aa97 2077 /**
e9a90e69 2078 * Calculates grades for submission for the given participant(s) and updates it in the database
89c1aa97
DM
2079 *
2080 * @param null|int|array $restrict If null, update all authors, otherwise update just grades for the given author(s)
2081 * @return void
2082 */
8a1ba8ac 2083 public function aggregate_submission_grades($restrict=null) {
89c1aa97
DM
2084 global $DB;
2085
2086 // fetch a recordset with all assessments to process
1696f36c 2087 $sql = 'SELECT s.id AS submissionid, s.grade AS submissiongrade,
89c1aa97
DM
2088 a.weight, a.grade
2089 FROM {workshop_submissions} s
2090 LEFT JOIN {workshop_assessments} a ON (a.submissionid = s.id)
2091 WHERE s.example=0 AND s.workshopid=:workshopid'; // to be cont.
2092 $params = array('workshopid' => $this->id);
2093
2094 if (is_null($restrict)) {
2095 // update all users - no more conditions
2096 } elseif (!empty($restrict)) {
2097 list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
2098 $sql .= " AND s.authorid $usql";
2099 $params = array_merge($params, $uparams);
2100 } else {
2101 throw new coding_exception('Empty value is not a valid parameter here');
2102 }
2103
2104 $sql .= ' ORDER BY s.id'; // this is important for bulk processing
89c1aa97 2105
e9a90e69
DM
2106 $rs = $DB->get_recordset_sql($sql, $params);
2107 $batch = array(); // will contain a set of all assessments of a single submission
2108 $previous = null; // a previous record in the recordset
2109
89c1aa97
DM
2110 foreach ($rs as $current) {
2111 if (is_null($previous)) {
2112 // we are processing the very first record in the recordset
2113 $previous = $current;
89c1aa97 2114 }
e9a90e69 2115 if ($current->submissionid == $previous->submissionid) {
89c1aa97 2116 // we are still processing the current submission
e9a90e69
DM
2117 $batch[] = $current;
2118 } else {
2119 // process all the assessments of a sigle submission
2120 $this->aggregate_submission_grades_process($batch);
2121 // and then start to process another submission
2122 $batch = array($current);
2123 $previous = $current;
89c1aa97
DM
2124 }
2125 }
e9a90e69
DM
2126 // do not forget to process the last batch!
2127 $this->aggregate_submission_grades_process($batch);
89c1aa97
DM
2128 $rs->close();
2129 }
2130
32c78bc3
DM
2131 /**
2132 * Sets the aggregated grades for assessment to null
2133 *
2134 * @param null|int|array $restrict If null, update all reviewers, otherwise update just grades for the given reviewer(s)
2135 * @return void
2136 */
2137 public function clear_grading_grades($restrict=null) {
2138 global $DB;
2139
2140 $sql = "workshopid = :workshopid";
2141 $params = array('workshopid' => $this->id);
2142
2143 if (is_null($restrict)) {
2144 // update all users - no more conditions
2145 } elseif (!empty($restrict)) {
2146 list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
2147 $sql .= " AND userid $usql";
2148 $params = array_merge($params, $uparams);
2149 } else {
2150 throw new coding_exception('Empty value is not a valid parameter here');
2151 }
2152
2153 $DB->set_field_select('workshop_aggregations', 'gradinggrade', null, $sql, $params);
2154 }
2155
89c1aa97
DM
2156 /**
2157 * Calculates grades for assessment for the given participant(s)
2158 *
39411930
DM
2159 * Grade for assessment is calculated as a simple mean of all grading grades calculated by the grading evaluator.
2160 * The assessment weight is not taken into account here.
89c1aa97
DM
2161 *
2162 * @param null|int|array $restrict If null, update all reviewers, otherwise update just grades for the given reviewer(s)
2163 * @return void
2164 */
8a1ba8ac 2165 public function aggregate_grading_grades($restrict=null) {
89c1aa97
DM
2166 global $DB;
2167
39411930
DM
2168 // fetch a recordset with all assessments to process
2169 $sql = 'SELECT a.reviewerid, a.gradinggrade, a.gradinggradeover,
2170 ag.id AS aggregationid, ag.gradinggrade AS aggregatedgrade
2171 FROM {workshop_assessments} a
2172 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
2173 LEFT JOIN {workshop_aggregations} ag ON (ag.userid = a.reviewerid AND ag.workshopid = s.workshopid)
2174 WHERE s.example=0 AND s.workshopid=:workshopid'; // to be cont.
2175 $params = array('workshopid' => $this->id);
2176
2177 if (is_null($restrict)) {
2178 // update all users - no more conditions
2179 } elseif (!empty($restrict)) {
2180 list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
2181 $sql .= " AND a.reviewerid $usql";
2182 $params = array_merge($params, $uparams);
2183 } else {
2184 throw new coding_exception('Empty value is not a valid parameter here');
2185 }
2186
2187 $sql .= ' ORDER BY a.reviewerid'; // this is important for bulk processing
2188
2189 $rs = $DB->get_recordset_sql($sql, $params);
2190 $batch = array(); // will contain a set of all assessments of a single submission
2191 $previous = null; // a previous record in the recordset
2192
2193 foreach ($rs as $current) {
2194 if (is_null($previous)) {
2195 // we are processing the very first record in the recordset
2196 $previous = $current;
2197 }
2198 if ($current->reviewerid == $previous->reviewerid) {
2199 // we are still processing the current reviewer
2200 $batch[] = $current;
2201 } else {
2202 // process all the assessments of a sigle submission
2203 $this->aggregate_grading_grades_process($batch);
2204 // and then start to process another reviewer
2205 $batch = array($current);
2206 $previous = $current;
2207 }
2208 }
2209 // do not forget to process the last batch!
2210 $this->aggregate_grading_grades_process($batch);
2211 $rs->close();
89c1aa97
DM
2212 }
2213
77f43e7d 2214 /**
f6e8b318 2215 * Returns the mform the teachers use to put a feedback for the reviewer
77f43e7d 2216 *
c6b784f0 2217 * @param moodle_url $actionurl
5924db72 2218 * @param stdClass $assessment
c6b784f0 2219 * @param array $options editable, editableweight, overridablegradinggrade
f6e8b318 2220 * @return workshop_feedbackreviewer_form
77f43e7d 2221 */
c6b784f0 2222 public function get_feedbackreviewer_form(moodle_url $actionurl, stdclass $assessment, $options=array()) {
77f43e7d
DM
2223 global $CFG;
2224 require_once(dirname(__FILE__) . '/feedbackreviewer_form.php');
2225
7a789aa8 2226 $current = new stdclass();
e554671d 2227 $current->asid = $assessment->id;
c6b784f0 2228 $current->weight = $assessment->weight;
e554671d
DM
2229 $current->gradinggrade = $this->real_grading_grade($assessment->gradinggrade);
2230 $current->gradinggradeover = $this->real_grading_grade($assessment->gradinggradeover);
2231 $current->feedbackreviewer = $assessment->feedbackreviewer;
2232 $current->feedbackreviewerformat = $assessment->feedbackreviewerformat;
2233 if (is_null($current->gradinggrade)) {
2234 $current->gradinggrade = get_string('nullgrade', 'workshop');
2235 }
c6b784f0
DM
2236 if (!isset($options['editable'])) {
2237 $editable = true; // by default
2238 } else {
2239 $editable = (bool)$options['editable'];
2240 }
e554671d
DM
2241
2242 // prepare wysiwyg editor
2243 $current = file_prepare_standard_editor($current, 'feedbackreviewer', array());
2244
77f43e7d 2245 return new workshop_feedbackreviewer_form($actionurl,
c6b784f0 2246 array('workshop' => $this, 'current' => $current, 'editoropts' => array(), 'options' => $options),
77f43e7d
DM
2247 'post', '', null, $editable);
2248 }
2249
67cd00ba
DM
2250 /**
2251 * Returns the mform the teachers use to put a feedback for the author on their submission
2252 *
c6b784f0 2253 * @param moodle_url $actionurl
5924db72 2254 * @param stdClass $submission
c6b784f0 2255 * @param array $options editable
67cd00ba
DM
2256 * @return workshop_feedbackauthor_form
2257 */
c6b784f0 2258 public function get_feedbackauthor_form(moodle_url $actionurl, stdclass $submission, $options=array()) {
67cd00ba
DM
2259 global $CFG;
2260 require_once(dirname(__FILE__) . '/feedbackauthor_form.php');
2261
7a789aa8 2262 $current = new stdclass();
67cd00ba 2263 $current->submissionid = $submission->id;
232175e4 2264 $current->published = $submission->published;
557a1100
DM
2265 $current->grade = $this->real_grade($submission->grade);
2266 $current->gradeover = $this->real_grade($submission->gradeover);
2267 $current->feedbackauthor = $submission->feedbackauthor;
2268 $current->feedbackauthorformat = $submission->feedbackauthorformat;
67cd00ba
DM
2269 if (is_null($current->grade)) {
2270 $current->grade = get_string('nullgrade', 'workshop');
2271 }
c6b784f0
DM
2272 if (!isset($options['editable'])) {
2273 $editable = true; // by default
2274 } else {
2275 $editable = (bool)$options['editable'];
2276 }
67cd00ba
DM
2277
2278 // prepare wysiwyg editor
2279 $current = file_prepare_standard_editor($current, 'feedbackauthor', array());
2280
2281 return new workshop_feedbackauthor_form($actionurl,
232175e4 2282 array('workshop' => $this, 'current' => $current, 'editoropts' => array(), 'options' => $options),
67cd00ba
DM
2283 'post', '', null, $editable);
2284 }
2285
3cb4ce45
DM
2286 /**
2287 * Returns the information about the user's grades as they are stored in the gradebook
2288 *
2289 * The submission grade is returned for users with the capability mod/workshop:submit and the
2290 * assessment grade is returned for users with the capability mod/workshop:peerassess. Unless the
2291 * user has the capability to view hidden grades, grades must be visible to be returned. Null
2292 * grades are not returned. If none grade is to be returned, this method returns false.
2293 *
2294 * @param int $userid the user's id
2295 * @return workshop_final_grades|false
2296 */
2297 public function get_gradebook_grades($userid) {
2298 global $CFG;
2299 require_once($CFG->libdir.'/gradelib.php');
2300
2301 if (empty($userid)) {
2302 throw new coding_exception('User id expected, empty value given.');
2303 }
2304
2305 // Read data via the Gradebook API
2306 $gradebook = grade_get_grades($this->course->id, 'mod', 'workshop', $this->id, $userid);
2307
2308 $grades = new workshop_final_grades();
2309
2310 if (has_capability('mod/workshop:submit', $this->context, $userid)) {
2311 if (!empty($gradebook->items[0]->grades)) {
2312 $submissiongrade = reset($gradebook->items[0]->grades);
2313 if (!is_null($submissiongrade->grade)) {
2314 if (!$submissiongrade->hidden or has_capability('moodle/grade:viewhidden', $this->context, $userid)) {
2315 $grades->submissiongrade = $submissiongrade;
2316 }
2317 }
2318 }
2319 }
2320
d34ea7dc 2321 if (has_capability('mod/workshop:peerassess', $this->context, $userid)) {
3cb4ce45
DM
2322 if (!empty($gradebook->items[1]->grades)) {
2323 $assessmentgrade = reset($gradebook->items[1]->grades);
2324 if (!is_null($assessmentgrade->grade)) {
2325 if (!$assessmentgrade->hidden or has_capability('moodle/grade:viewhidden', $this->context, $userid)) {
2326 $grades->assessmentgrade = $assessmentgrade;
2327 }
2328 }
2329 }
2330 }
2331
2332 if (!is_null($grades->submissiongrade) or !is_null($grades->assessmentgrade)) {
2333 return $grades;
2334 }
2335
2336 return false;
2337 }
2338
77d746a2
DM
2339 /**
2340 * Return the editor options for the overall feedback for the author.
2341 *
2342 * @return array
2343 */
2344 public function overall_feedback_content_options() {
2345 return array(
2346 'subdirs' => 0,
2347 'maxbytes' => $this->overallfeedbackmaxbytes,
2348 'maxfiles' => $this->overallfeedbackfiles,
2349 'changeformat' => 1,
2350 'context' => $this->context,
2351 );
2352 }
2353
2354 /**
2355 * Return the filemanager options for the overall feedback for the author.
2356 *
2357 * @return array
2358 */
2359 public function overall_feedback_attachment_options() {
2360 return array(
2361 'subdirs' => 1,
2362 'maxbytes' => $this->overallfeedbackmaxbytes,
2363 'maxfiles' => $this->overallfeedbackfiles,
2364 'return_types' => FILE_INTERNAL,
2365 );
2366 }
2367
aa40adbf
DM
2368 ////////////////////////////////////////////////////////////////////////////////
2369 // Internal methods (implementation details) //
2370 ////////////////////////////////////////////////////////////////////////////////
6516b9e9 2371
e9a90e69
DM
2372 /**
2373 * Given an array of all assessments of a single submission, calculates the final grade for this submission
2374 *
2375 * This calculates the weighted mean of the passed assessment grades. If, however, the submission grade
2376 * was overridden by a teacher, the gradeover value is returned and the rest of grades are ignored.
2377 *
7a789aa8 2378 * @param array $assessments of stdclass(->submissionid ->submissiongrade ->gradeover ->weight ->grade)
1fed6ce3 2379 * @return void
e9a90e69
DM
2380 */
2381 protected function aggregate_submission_grades_process(array $assessments) {
2382 global $DB;
2383
2384 $submissionid = null; // the id of the submission being processed
2385 $current = null; // the grade currently saved in database
2386 $finalgrade = null; // the new grade to be calculated
2387 $sumgrades = 0;
2388 $sumweights = 0;
2389
2390 foreach ($assessments as $assessment) {
2391 if (is_null($submissionid)) {
2392 // the id is the same in all records, fetch it during the first loop cycle
2393 $submissionid = $assessment->submissionid;
2394 }
2395 if (is_null($current)) {
2396 // the currently saved grade is the same in all records, fetch it during the first loop cycle
2397 $current = $assessment->submissiongrade;
2398 }
e9a90e69
DM
2399 if (is_null($assessment->grade)) {
2400 // this was not assessed yet
2401 continue;
2402 }
2403 if ($assessment->weight == 0) {
2404 // this does not influence the calculation
2405 continue;
2406 }
2407 $sumgrades += $assessment->grade * $assessment->weight;
2408 $sumweights += $assessment->weight;
2409 }
2410 if ($sumweights > 0 and is_null($finalgrade)) {
2411 $finalgrade = grade_floatval($sumgrades / $sumweights);
2412 }
2413 // check if the new final grade differs from the one stored in the database
2414 if (grade_floats_different($finalgrade, $current)) {
2415 // we need to save new calculation into the database
7a789aa8 2416 $record = new stdclass();
10bc4bce
DM
2417 $record->id = $submissionid;
2418 $record->grade = $finalgrade;
2419 $record->timegraded = time();
2420 $DB->update_record('workshop_submissions', $record);
e9a90e69
DM
2421 }
2422 }
2423
39411930
DM
2424 /**
2425 * Given an array of all assessments done by a single reviewer, calculates the final grading grade
2426 *
2427 * This calculates the simple mean of the passed grading grades. If, however, the grading grade
2428 * was overridden by a teacher, the gradinggradeover value is returned and the rest of grades are ignored.
2429 *
7a789aa8 2430 * @param array $assessments of stdclass(->reviewerid ->gradinggrade ->gradinggradeover ->aggregationid ->aggregatedgrade)
a1373126 2431 * @param null|int $timegraded explicit timestamp of the aggregation, defaults to the current time
1fed6ce3 2432 * @return void
39411930 2433 */
a1373126 2434 protected function aggregate_grading_grades_process(array $assessments, $timegraded = null) {
39411930
DM
2435 global $DB;
2436
2437 $reviewerid = null; // the id of the reviewer being processed
2438 $current = null; // the gradinggrade currently saved in database
2439 $finalgrade = null; // the new grade to be calculated
2440 $agid = null; // aggregation id
2441 $sumgrades = 0;
2442 $count = 0;
2443
a1373126
DM
2444 if (is_null($timegraded)) {
2445 $timegraded = time();
2446 }
2447
39411930
DM
2448 foreach ($assessments as $assessment) {
2449 if (is_null($reviewerid)) {
2450 // the id is the same in all records, fetch it during the first loop cycle
2451 $reviewerid = $assessment->reviewerid;
2452 }
2453 if (is_null($agid)) {
2454 // the id is the same in all records, fetch it during the first loop cycle
2455 $agid = $assessment->aggregationid;
2456 }
2457 if (is_null($current)) {
2458 // the currently saved grade is the same in all records, fetch it during the first loop cycle
2459 $current = $assessment->aggregatedgrade;
2460 }
2461 if (!is_null($assessment->gradinggradeover)) {
5924db72 2462 // the grading grade for this assessment is overridden by a teacher
39411930
DM
2463 $sumgrades += $assessment->gradinggradeover;
2464 $count++;
2465 } else {
2466 if (!is_null($assessment->gradinggrade)) {
2467 $sumgrades += $assessment->gradinggrade;
2468 $count++;
2469 }
2470 }
2471 }
2472 if ($count > 0) {
2473 $finalgrade = grade_floatval($sumgrades / $count);
2474 }
1f013271
AG
2475
2476 // Event information.
2477 $params = array(
2478 'context' => $this->context,
2479 'courseid' => $this->course->id,
2480 'relateduserid' => $reviewerid
2481 );
2482
39411930
DM
2483 // check if the new final grade differs from the one stored in the database
2484 if (grade_floats_different($finalgrade, $current)) {
1f013271
AG
2485 $params['other'] = array(
2486 'currentgrade' => $current,
2487 'finalgrade' => $finalgrade
2488 );
2489
39411930
DM
2490 // we need to save new calculation into the database
2491 if (is_null($agid)) {
2492 // no aggregation record yet
7a789aa8 2493 $record = new stdclass();
39411930
DM
2494 $record->workshopid = $this->id;
2495 $record->userid = $reviewerid;
2496 $record->gradinggrade = $finalgrade;
a1373126 2497 $record->timegraded = $timegraded;
1f013271
AG
2498 $record->id = $DB->insert_record('workshop_aggregations', $record);
2499 $params['objectid'] = $record->id;
2500 $event = \mod_workshop\event\assessment_evaluated::create($params);
2501 $event->trigger();
39411930 2502 } else {
7a789aa8 2503 $record = new stdclass();
10bc4bce
DM
2504 $record->id = $agid;
2505 $record->gradinggrade = $finalgrade;
a1373126 2506 $record->timegraded = $timegraded;
10bc4bce 2507 $DB->update_record('workshop_aggregations', $record);
1f013271
AG
2508 $params['objectid'] = $agid;
2509 $event = \mod_workshop\event\assessment_reevaluated::create($params);
2510 $event->trigger();
39411930
DM
2511 }
2512 }
2513 }
2514
6516b9e9 2515 /**
21f58287 2516 * Returns SQL to fetch all enrolled users with the given capability in the current workshop
aa40adbf 2517 *
9691e2b1 2518 * The returned array consists of string $sql and the $params array. Note that the $sql can be
45ab2d9a 2519 * empty if a grouping is selected and it has no groups.
2520 *
2521 * The list is automatically restricted according to any availability restrictions
2522 * that apply to user lists (e.g. group, grouping restrictions).
9691e2b1 2523 *
21f58287
DM
2524 * @param string $capability the name of the capability
2525 * @param bool $musthavesubmission ff true, return only users who have already submitted
2526 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2527 * @return array of (string)sql, (array)params
6516b9e9 2528 */
21f58287 2529 protected function get_users_with_capability_sql($capability, $musthavesubmission, $groupid) {
8741ebb0 2530 global $CFG;
9691e2b1
DM
2531 /** @var int static counter used to generate unique parameter holders */
2532 static $inc = 0;
2533 $inc++;
2534
45ab2d9a 2535 // If the caller requests all groups and we are using a selected grouping,
2536 // recursively call this function for each group in the grouping (this is
2537 // needed because get_enrolled_sql only supports a single group).
2538 if (empty($groupid) and $this->cm->groupingid) {
9691e2b1
DM
2539 $groupingid = $this->cm->groupingid;
2540 $groupinggroupids = array_keys(groups_get_all_groups($this->cm->course, 0, $this->cm->groupingid, 'g.id'));
2541 $sql = array();
2542 $params = array();
2543 foreach ($groupinggroupids as $groupinggroupid) {
2544 if ($groupinggroupid > 0) { // just in case in order not to fall into the endless loop
2545 list($gsql, $gparams) = $this->get_users_with_capability_sql($capability, $musthavesubmission, $groupinggroupid);
2546 $sql[] = $gsql;
2547 $params = array_merge($params, $gparams);
2548 }
2549 }
2550 $sql = implode(PHP_EOL." UNION ".PHP_EOL, $sql);
2551 return array($sql, $params);
2552 }
aa40adbf 2553
21f58287
DM
2554 list($esql, $params) = get_enrolled_sql($this->context, $capability, $groupid, true);
2555
2556 $userfields = user_picture::fields('u');
2557
2558 $sql = "SELECT $userfields
2559 FROM {user} u
9691e2b1 2560 JOIN ($esql) je ON (je.id = u.id AND u.deleted = 0) ";
21f58287
DM
2561
2562 if ($musthavesubmission) {
9691e2b1
DM
2563 $sql .= " JOIN {workshop_submissions} ws ON (ws.authorid = u.id AND ws.example = 0 AND ws.workshopid = :workshopid{$inc}) ";
2564 $params['workshopid'.$inc] = $this->id;
aa40adbf
DM
2565 }
2566
45ab2d9a 2567 // If the activity is restricted so that only certain users should appear
2568 // in user lists, integrate this into the same SQL.
2569 $info = new \core_availability\info_module($this->cm);
2570 list ($listsql, $listparams) = $info->get_user_list_sql(false);
2571 if ($listsql) {
2572 $sql .= " JOIN ($listsql) restricted ON restricted.id = u.id ";
2573 $params = array_merge($params, $listparams);
2574 }
2575
21f58287 2576 return array($sql, $params);
6516b9e9
DM
2577 }
2578
8741ebb0
DM
2579 /**
2580 * Returns SQL statement that can be used to fetch all actively enrolled participants in the workshop
2581 *
2582 * @param bool $musthavesubmission if true, return only users who have already submitted
2583 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2584 * @return array of (string)sql, (array)params
2585 */
2586 protected function get_participants_sql($musthavesubmission=false, $groupid=0) {
2587
2588 list($sql1, $params1) = $this->get_users_with_capability_sql('mod/workshop:submit', $musthavesubmission, $groupid);
2589 list($sql2, $params2) = $this->get_users_with_capability_sql('mod/workshop:peerassess', $musthavesubmission, $groupid);
2590
2591 if (empty($sql1) or empty($sql2)) {
2592 if (empty($sql1) and empty($sql2)) {
2593 return array('', array());
2594 } else if (empty($sql1)) {
2595 $sql = $sql2;
2596 $params = $params2;
2597 } else {
2598 $sql = $sql1;
2599 $params = $params1;
2600 }
2601 } else {
2602 $sql = $sql1.PHP_EOL." UNION ".PHP_EOL.$sql2;
2603 $params = array_merge($params1, $params2);
2604 }
2605
2606 return array($sql, $params);
2607 }
2608
aa40adbf
DM
2609 /**
2610 * @return array of available workshop phases
2611 */
365c2cc2 2612 protected function available_phases_list() {
aa40adbf
DM
2613 return array(
2614 self::PHASE_SETUP => true,
2615 self::PHASE_SUBMISSION => true,
2616 self::PHASE_ASSESSMENT => true,
2617 self::PHASE_EVALUATION => true,
2618 self::PHASE_CLOSED => true,
2619 );
2620 }
2621
5450f7b6
DM
2622 /**
2623 * Converts absolute URL to relative URL needed by {@see add_to_log()}
2624 *
2625 * @param moodle_url $url absolute URL
2626 * @return string
2627 */
2628 protected function log_convert_url(moodle_url $fullurl) {
2629 static $baseurl;
2630
2631 if (!isset($baseurl)) {
2632 $baseurl = new moodle_url('/mod/workshop/');
2633 $baseurl = $baseurl->out();
2634 }
2635
2636 return substr($fullurl->out(), strlen($baseurl));
2637 }
6f760e01
MH
2638
2639 /**
2640 * Resets this activity's content
2641 * @param array The reset data object.
2642 * @return bool True if the reset was successful, false if there was an error
2643 */
2644 public function reset_userdata($data) {
2645 $componentstr = get_string('modulenameplural', 'workshop');
2646 $status = array();
2647 $this->reset_submissions();
2648 $delaggregations = $DB->delete_records('workshop_aggregations', array('workshopid' => $this->id));
2649 $this->reset_allocators();
2650 $this->reset_evaluators();
2651 $this->reset_strategies();
2652
2653 $events = $DB->get_records('event', array('modulename' => 'workshop', 'instance' => $this->id));\r
2654 foreach ($events as $event) {
2655 $event = calendar_event::load($event);
2656 $event->delete();\r
2657 }
2658
2659 // Set the phase.
2660 // $DB->set_field('workshop', 'phase', 0, array('id' => $workshop->id)); // Left in to give option to switch back after discussion.
2661 $this->switch_phase(self::PHASE_SETUP); // Use the API but we may not want to raise events about this....
2662
2663 $status[] = array('component' => $componentstr, 'item' => get_string('resetworkshopall', 'workshop'), 'error' => false);
2664 return $status;
2665 }
2666
2667 /**
2668 * Remove user content, including grades
2669 */
2670 protected function reset_submissions() {
2671 $submissions = $this->get_submissions();\r
2672 foreach ($submissions as $submission) {\r
2673 $this->delete_submission($submission);\r
2674 }
2675 // Clean up submission files.
2676 $fs = get_file_storage();
2677 $files = $fs->get_area_files($this->context, 'mod_workshop', 'submission_attachment', false);
2678 $numberfilestodelete = count($files);
2679 $numfilesdeleted = 0;
2680 foreach ($files as $file) {
2681 try {
2682 $file->delete();
2683 $numfilesdeleted += 1;
2684 }
2685 catch (Exception $exception) {
2686 // The delete can fail if necessary it just leaves an orphan in the DB. The record its attached to will have rady been removed.
2687 }
2688 }
2689 }
2690
2691 protected function reset_allocators() {
2692 $allocators = core_component::get_plugin_list('workshopallocation');
2693 foreach ($allocators as $allocator => $path) {\r
2694 require_once($path.'/lib.php');\r
2695 $classname = 'workshop_'.$allocator.'_allocator';\r
2696 call_user_func($classname.'::reset_user_data', $this->id);\r
2697 }
2698 }
2699
2700 protected function reset_strategies() {
2701 $evaluators = core_component::get_plugin_list('workshopeval');
2702 foreach ($evaluators as $evaluator => $path) {\r
2703 require_once($path.'/lib.php');\r
2704 $classname = 'workshop_'.$evaluator.'_evaluation';\r
2705 call_user_func($classname.'::reset_user_data', $this->id);\r
2706 }
2707 }
2708
2709 protected function reset_evaluators() {
2710 $evaluators = core_component::get_plugin_list('workshopeval');\r
2711 foreach ($evaluators as $evaluator => $path) {\r
2712 require_once($path.'/lib.php');\r
2713 $classname = 'workshop_'.$evaluator.'_evaluation';\r
2714 call_user_func($classname.'::reset_user_data', $this->id);\r
2715 }
2716 }
66c9894d 2717}
55fc1e59 2718
81b22887
DM
2719////////////////////////////////////////////////////////////////////////////////
2720// Renderable components
2721////////////////////////////////////////////////////////////////////////////////
2722
55fc1e59
DM
2723/**
2724 * Represents the user planner tool
2725 *
2726 * Planner contains list of phases. Each phase contains list of tasks. Task is a simple object with
2727 * title, link and completed (true/false/null logic).
2728 */
2729class workshop_user_plan implements renderable {
2730
cff28ef0
DM
2731 /** @var int id of the user this plan is for */
2732 public $userid;
55fc1e59
DM
2733 /** @var workshop */
2734 public $workshop;
2735 /** @var array of (stdclass)tasks */
2736 public $phases = array();
cff28ef0
DM
2737 /** @var null|array of example submissions to be assessed by the planner owner */
2738 protected $examples = null;
55fc1e59
DM
2739
2740 /**
2741 * Prepare an individual workshop plan for the given user.
2742 *
2743 * @param workshop $workshop instance
2744 * @param int $userid whom the plan is prepared for
2745 */
2746 public function __construct(workshop $workshop, $userid) {
2747 global $DB;
2748
2749 $this->workshop = $workshop;
cff28ef0 2750 $this->userid = $userid;
55fc1e59 2751
5bab64a3
DM
2752 //---------------------------------------------------------
2753 // * SETUP | submission | assessment | evaluation | closed
2754 //---------------------------------------------------------
55fc1e59
DM
2755 $phase = new stdclass();
2756 $phase->title = get_string('phasesetup', 'workshop');
2757 $phase->tasks = array();
cff28ef0 2758 if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
55fc1e59
DM
2759 $task = new stdclass();
2760 $task->title = get_string('taskintro', 'workshop');
cff28ef0 2761 $task->link = $workshop->updatemod_url();
bfbca63d 2762 $task->completed = !(trim($workshop->intro) == '');
55fc1e59
DM
2763 $phase->tasks['intro'] = $task;
2764 }
cff28ef0 2765 if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
55fc1e59
DM
2766 $task = new stdclass();
2767 $task->title = get_string('taskinstructauthors', 'workshop');
cff28ef0 2768 $task->link = $workshop->updatemod_url();
bfbca63d 2769 $task->completed = !(trim($workshop->instructauthors) == '');
55fc1e59
DM
2770 $phase->tasks['instructauthors'] = $task;
2771 }
cff28ef0 2772 if (has_capability('mod/workshop:editdimensions', $workshop->context, $userid)) {
55fc1e59
DM
2773 $task = new stdclass();
2774 $task->title = get_string('editassessmentform', 'workshop');
cff28ef0
DM
2775 $task->link = $workshop->editform_url();
2776 if ($workshop->grading_strategy_instance()->form_ready()) {
55fc1e59 2777 $task->completed = true;
cff28ef0 2778 } elseif ($workshop->phase > workshop::PHASE_SETUP) {
55fc1e59
DM
2779 $task->completed = false;
2780 }
2781 $phase->tasks['editform'] = $task;
2782 }
cff28ef0 2783 if ($workshop->useexamples and has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
55fc1e59
DM
2784 $task = new stdclass();
2785 $task->title = get_string('prepareexamples', 'workshop');
cff28ef0 2786 if ($DB->count_records('workshop_submissions', array('example' => 1, 'workshopid' => $workshop->id)) > 0) {
55fc1e59 2787 $task->completed = true;
cff28ef0 2788 } elseif ($workshop->phase > workshop::PHASE_SETUP) {
55fc1e59
DM
2789 $task->completed = false;
2790 }
2791 $phase->tasks['prepareexamples'] = $task;
2792 }
cff28ef0 2793 if (empty($phase->tasks) and $workshop->phase == workshop::PHASE_SETUP) {
55fc1e59
DM
2794 // if we are in the setup phase and there is no task (typical for students), let us
2795 // display some explanation what is going on
2796 $task = new stdclass();
2797 $task->title = get_string('undersetup', 'workshop');
2798 $task->completed = 'info';
2799 $phase->tasks['setupinfo'] = $task;
2800 }
2801 $this->phases[workshop::PHASE_SETUP] = $phase;
2802
5bab64a3
DM
2803 //---------------------------------------------------------
2804 // setup | * SUBMISSION | assessment | evaluation | closed
2805 //---------------------------------------------------------
55fc1e59
DM
2806 $phase = new stdclass();
2807 $phase->title = get_string('phasesubmission', 'workshop');
2808 $phase->tasks = array();
d34ea7dc 2809 if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
55fc1e59
DM
2810 $task = new stdclass();
2811 $task->title = get_string('taskinstructreviewers', 'workshop');
cff28ef0 2812 $task->link = $workshop->updatemod_url();
bfbca63d 2813 if (trim($workshop->instructreviewers)) {
55fc1e59 2814 $task->completed = true;
cff28ef0 2815 } elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
55fc1e59
DM
2816 $task->completed = false;
2817 }
2818 $phase->tasks['instructreviewers'] = $task;
2819 }
cff28ef0 2820 if ($workshop->useexamples and $workshop->examplesmode == workshop::EXAMPLES_BEFORE_SUBMISSION
514d8c22 2821 and has_capability('mod/workshop:submit', $workshop->context, $userid, false)
cff28ef0 2822 and !has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
514d8c22
DM
2823 $task = new stdclass();
2824 $task->title = get_string('exampleassesstask', 'workshop');
cff28ef0 2825 $examples = $this->get_examples();
514d8c22
DM
2826 $a = new stdclass();
2827 $a->expected = count($examples);
2828 $a->assessed = 0;
2829 foreach ($examples as $exampleid => $example) {
2830 if (!is_null($example->grade)) {
2831 $a->assessed++;
2832 }
2833 }
2834 $task->details = get_string('exampleassesstaskdetails', 'workshop', $a);
2835 if ($a->assessed == $a->expected) {
2836 $task->completed = true;
cff28ef0 2837 } elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
514d8c22
DM
2838 $task->completed = false;
2839 }
2840 $phase->tasks['examples'] = $task;
2841 }
cff28ef0 2842 if (has_capability('mod/workshop:submit', $workshop->context, $userid, false)) {
55fc1e59
DM
2843 $task = new stdclass();
2844 $task->title = get_string('tasksubmit', 'workshop');
cff28ef0
DM
2845 $task->link = $workshop->submission_url();
2846 if ($DB->record_exists('workshop_submissions', array('workshopid'=>$workshop->id, 'example'=>0, 'authorid'=>$userid))) {
55fc1e59 2847 $task->completed = true;
cff28ef0 2848 } elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
55fc1e59
DM
2849 $task->completed = false;
2850 } else {
2851 $task->completed = null; // still has a chance to submit
2852 }
2853 $phase->tasks['submit'] = $task;
2854 }
cff28ef0 2855 if (has_capability('mod/workshop:allocate', $workshop->context, $userid)) {
3fe6d622
DM
2856 if ($workshop->phaseswitchassessment) {
2857 $task = new stdClass();
2858 $allocator = $DB->get_record('workshopallocation_scheduled', array('workshopid' => $workshop->id));
2859 if (empty($allocator)) {
2860 $task->completed = false;
2861 } else if ($allocator->enabled and is_null($allocator->resultstatus)) {
2862 $task->completed = true;
2863 } else if ($workshop->submissionend > time()) {
2864 $task->completed = null;
2865 } else {
2866 $task->completed = false;
2867 }
2868 $task->title = get_string('setup', 'workshopallocation_scheduled');
2869 $task->link = $workshop->allocation_url('scheduled');
2870 $phase->tasks['allocatescheduled'] = $task;
2871 }
55fc1e59
DM
2872 $task = new stdclass();
2873 $task->title = get_string('allocate', 'workshop');
cff28ef0 2874 $task->link = $workshop->allocation_url();
a1df59be 2875 $numofauthors = $workshop->count_potential_authors(false);
cff28ef0 2876 $numofsubmissions = $DB->count_records('workshop_submissions', array('workshopid'=>$workshop->id, 'example'=>0));
55fc1e59
DM
2877 $sql = 'SELECT COUNT(s.id) AS nonallocated
2878 FROM {workshop_submissions} s
2879 LEFT JOIN {workshop_assessments} a ON (a.submissionid=s.id)
2880 WHERE s.workshopid = :workshopid AND s.example=0 AND a.submissionid IS NULL';
cff28ef0 2881 $params['workshopid'] = $workshop->id;
55fc1e59
DM
2882 $numnonallocated = $DB->count_records_sql($sql, $params);
2883 if ($numofsubmissions == 0) {
2884 $task->completed = null;
2885 } elseif ($numnonallocated == 0) {
2886 $task->completed = true;
cff28ef0 2887 } elseif ($workshop->phase > workshop::PHASE_SUBMISSION) {
55fc1e59
DM
2888 $task->completed = false;
2889 } else {
2890 $task->completed = null; // still has a chance to allocate
2891 }
2892 $a = new stdclass();
2893 $a->expected = $numofauthors;
2894 $a->submitted = $numofsubmissions;
2895 $a->allocate = $numnonallocated;
2896 $task->details = get_string('allocatedetails', 'workshop', $a);
2897 unset($a);
2898 $phase->tasks['allocate'] = $task;
2899
cff28ef0 2900 if ($numofsubmissions < $numofauthors and $workshop->phase >= workshop::PHASE_SUBMISSION) {
55fc1e59
DM
2901 $task = new stdclass();
2902 $task->title = get_string('someuserswosubmission', 'workshop');
2903 $task->completed = 'info';
2904 $phase->tasks['allocateinfo'] = $task;
2905 }
3fe6d622 2906
55fc1e59 2907 }
cff28ef0 2908 if ($workshop->submissionstart) {
5bab64a3 2909 $task = new stdclass();
cff28ef0 2910 $task->title = get_string('submissionstartdatetime', 'workshop', workshop::timestamp_formats($workshop->submissionstart));
5bab64a3
DM
2911 $task->completed = 'info';
2912 $phase->tasks['submissionstartdatetime'] = $task;
2913 }
cff28ef0 2914 if ($workshop->submissionend) {
5bab64a3 2915 $task = new stdclass();
cff28ef0 2916 $task->title = get_string('submissionenddatetime', 'workshop', workshop::timestamp_formats($workshop->submissionend));
5bab64a3
DM
2917 $task->completed = 'info';
2918 $phase->tasks['submissionenddatetime'] = $task;
2919 }
2f289d36
DM
2920 if (($workshop->submissionstart < time()) and $workshop->latesubmissions) {
2921 $task = new stdclass();
2922 $task->title = get_string('latesubmissionsallowed', 'workshop');
2923 $task->completed = 'info';
2924 $phase->tasks['latesubmissionsallowed'] = $task;
2925 }
9ddff589
DM
2926 if (isset($phase->tasks['submissionstartdatetime']) or isset($phase->tasks['submissionenddatetime'])) {
2927 if (has_capability('mod/workshop:ignoredeadlines', $workshop->context, $userid)) {
2928 $task = new stdclass();
2929 $task->title = get_string('deadlinesignored', 'workshop');
2930 $task->completed = 'info';
2931 $phase->tasks['deadlinesignored'] = $task;
2932 }
2933 }
55fc1e59
DM
2934 $this->phases[workshop::PHASE_SUBMISSION] = $phase;
2935
5bab64a3
DM
2936 //---------------------------------------------------------
2937 // setup | submission | * ASSESSMENT | evaluation | closed
2938 //---------------------------------------------------------
55fc1e59
DM
2939 $phase = new stdclass();
2940 $phase->title = get_string('phaseassessment', 'workshop');
2941 $phase->tasks = array();
cff28ef0 2942 $phase->isreviewer = has_capability('mod/workshop:peerassess', $workshop->context, $userid);
3fe6d622
DM
2943 if ($workshop->phase == workshop::PHASE_SUBMISSION and $workshop->phaseswitchassessment
2944 and has_capability('mod/workshop:switchphase', $workshop->context, $userid)) {
2945 $task = new stdClass();
2946 $task->title = get_string('switchphase30auto', 'mod_workshop', workshop::timestamp_formats($workshop->submissionend));
2947 $task->completed = 'info';
2948 $phase->tasks['autoswitchinfo'] = $task;
2949 }
cff28ef0
DM
2950 if ($workshop->useexamples and $workshop->examplesmode == workshop::EXAMPLES_BEFORE_ASSESSMENT
2951 and $phase->isreviewer and !has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
2952 $task = new stdclass();
2953 $task->title = get_string('exampleassesstask', 'workshop');
2954 $examples = $workshop->get_examples_for_reviewer($userid);
2955 $a = new stdclass();
2956 $a->expected = count($examples);
2957 $a->assessed = 0;
2958 foreach ($examples as $exampleid => $example) {
2959 if (!is_null($example->grade)) {
2960 $a->assessed++;
55fc1e59
DM
2961 }
2962 }
cff28ef0
DM
2963 $task->details = get_string('exampleassesstaskdetails', 'workshop', $a);
2964 if ($a->assessed == $a->expected) {
55fc1e59 2965 $task->completed = true;
cff28ef0 2966 } elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
55fc1e59
DM
2967 $task->completed = false;
2968 }
cff28ef0 2969 $phase->tasks['examples'] = $task;
55fc1e59 2970 }
cff28ef0
DM
2971 if (empty($phase->tasks['examples']) or !empty($phase->tasks['examples']->completed)) {
2972 $phase->assessments = $workshop->get_assessments_by_reviewer($userid);
2973 $numofpeers = 0; // number of allocated peer-assessments
2974 $numofpeerstodo = 0; // number of peer-assessments to do
2975 $numofself = 0; // number of allocated self-assessments - should be 0 or 1
2976 $numofselftodo = 0; // number of self-assessments to do - should be 0 or 1
2977 foreach ($phase->assessments as $a) {
2978 if ($a->authorid == $userid) {
2979 $numofself++;
2980 if (is_null($a->grade)) {
2981 $numofselftodo++;
2982 }
2983 } else {
2984 $numofpeers++;
2985 if (is_null($a->grade)) {
2986 $numofpeerstodo++;
2987 }
2988 }
2989 }
2990 unset($a);
d34ea7dc 2991 if ($numofpeers) {
cff28ef0
DM
2992 $task = new stdclass();
2993 if ($numofpeerstodo == 0) {
2994 $task->completed = true;
2995 } elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
2996 $task->completed = false;
2997 }
2998 $a = new stdclass();
2999 $a->total = $numofpeers;
3000 $a->todo = $numofpeerstodo;
3001 $task->title = get_string('taskassesspeers', 'workshop');
3002 $task->details = get_string('taskassesspeersdetails', 'workshop', $a);
3003 unset($a);
3004 $phase->tasks['assesspeers'] = $task;
3005 }
3006 if ($workshop->useselfassessment and $numofself) {
3007 $task = new stdclass();
3008 if ($numofselftodo == 0) {
3009 $task->completed = true;
3010 } elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
3011 $task->completed = false;
3012 }
3013 $task->title = get_string('taskassessself', 'workshop');
3014 $phase->tasks['assessself'] = $task;
55fc1e59 3015 }
55fc1e59 3016 }
cff28ef0 3017 if ($workshop->assessmentstart) {
5bab64a3 3018 $task = new stdclass();
cff28ef0 3019 $task->title = get_string('assessmentstartdatetime', 'workshop', workshop::timestamp_formats($workshop->assessmentstart));
5bab64a3
DM
3020 $task->completed = 'info';
3021 $phase->tasks['assessmentstartdatetime'] = $task;
3022 }
cff28ef0 3023 if ($workshop->assessmentend) {
5bab64a3 3024 $task = new stdclass();
cff28ef0 3025 $task->title = get_string('assessmentenddatetime', 'workshop', workshop::timestamp_formats($workshop->assessmentend));
5bab64a3
DM
3026 $task->completed = 'info';
3027 $phase->tasks['assessmentenddatetime'] = $task;
3028 }
9ddff589
DM
3029 if (isset($phase->tasks['assessmentstartdatetime']) or isset($phase->tasks['assessmentenddatetime'])) {
3030 if (has_capability('mod/workshop:ignoredeadlines', $workshop->context, $userid)) {
3031 $task = new stdclass();
3032 $task->title = get_string('deadlinesignored', 'workshop');
3033 $task->completed = 'info';
3034 $phase->tasks['deadlinesignored'] = $task;
3035 }
3036 }
55fc1e59
DM
3037 $this->phases[workshop::PHASE_ASSESSMENT] = $phase;
3038
5bab64a3
DM
3039 //---------------------------------------------------------
3040 // setup | submission | assessment | * EVALUATION | closed
3041 //---------------------------------------------------------
55fc1e59
DM
3042 $phase = new stdclass();
3043 $phase->title = get_string('phaseevaluation', 'workshop');
3044 $phase->tasks = array();
cff28ef0 3045 if (has_capability('mod/workshop:overridegrades', $workshop->context)) {
a1df59be 3046 $expected = $workshop->count_potential_authors(false);
55fc1e59 3047 $calculated = $DB->count_records_select('workshop_submissions',
cff28ef0 3048 'workshopid = ? AND (grade IS NOT NULL OR gradeover IS NOT NULL)', array($workshop->id));
55fc1e59
DM
3049 $task = new stdclass();
3050 $task->title = get_string('calculatesubmissiongrades', 'workshop');
3051 $a = new stdclass();
3052 $a->expected = $expected;
3053 $a->calculated = $calculated;
3054 $task->details = get_string('calculatesubmissiongradesdetails', 'workshop', $a);
3055 if ($calculated >= $expected) {
3056 $task->completed = true;
cff28ef0 3057 } elseif ($workshop->phase > workshop::PHASE_EVALUATION) {
55fc1e59
DM
3058 $task->completed = false;
3059 }
3060 $phase->tasks['calculatesubmissiongrade'] = $task;
3061
a1df59be 3062 $expected = $workshop->count_potential_reviewers(false);
55fc1e59 3063 $calculated = $DB->count_records_select('workshop_aggregations',
cff28ef0 3064 'workshopid = ? AND gradinggrade IS NOT NULL', array($workshop->id));
55fc1e59
DM
3065 $task = new stdclass();
3066 $task->title = get_string('calculategradinggrades', 'workshop');
3067 $a = new stdclass();
3068 $a->expected = $expected;
3069 $a->calculated = $calculated;
3070 $task->details = get_string('calculategradinggradesdetails', 'workshop', $a);
3071 if ($calculated >= $expected) {
3072 $task->completed = true;
cff28ef0 3073 } elseif ($workshop->phase > workshop::PHASE_EVALUATION) {
55fc1e59
DM
3074 $task->completed = false;
3075 }
3076 $phase->tasks['calculategradinggrade'] = $task;
3077
cff28ef0 3078 } elseif ($workshop->phase == workshop::PHASE_EVALUATION) {
55fc1e59
DM
3079 $task = new stdclass();
3080 $task->title = get_string('evaluategradeswait', 'workshop');
3081 $task->completed = 'info';
3082 $phase->tasks['evaluateinfo'] = $task;
3083 }
4c61fcd8
DM
3084
3085 if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
3086 $task = new stdclass();
3087 $task->title = get_string('taskconclusion', 'workshop');
3088 $task->link = $workshop->updatemod_url();
3089 if (trim($workshop->conclusion)) {
3090 $task->completed = true;
3091 } elseif ($workshop->phase >= workshop::PHASE_EVALUATION) {
3092 $task->completed = false;
3093 }
3094 $phase->tasks['conclusion'] = $task;
3095 }
3096
55fc1e59
DM
3097 $this->phases[workshop::PHASE_EVALUATION] = $phase;
3098
5bab64a3
DM
3099 //---------------------------------------------------------
3100 // setup | submission | assessment | evaluation | * CLOSED
3101 //---------------------------------------------------------
55fc1e59
DM
3102 $phase = new stdclass();
3103 $phase->title = get_string('phaseclosed', 'workshop');
3104 $phase->tasks = array();
3105 $this->phases[workshop::PHASE_CLOSED] = $phase;
3106
3107 // Polish data, set default values if not done explicitly
3108 foreach ($this->phases as $phasecode => $phase) {
3109 $phase->title = isset($phase->title) ? $phase->title : '';
3110 $phase->tasks = isset($phase->tasks) ? $phase->tasks : array();
cff28ef0 3111 if ($phasecode == $workshop->phase) {
55fc1e59
DM
3112 $phase->active = true;
3113 } else {
3114 $phase->active = false;
3115 }
3116 if (!isset($phase->actions)) {
3117 $phase->actions = array();
3118 }
3119
3120 foreach ($phase->tasks as $taskcode => $task) {
3121 $task->title = isset($task->title) ? $task->title : '';
3122 $task->link = isset($task->link) ? $task->link : null;
3123 $task->details = isset($task->details) ? $task->details : '';
3124 $task->completed = isset($task->completed) ? $task->completed : null;
3125 }
3126 }
3127
5924db72 3128 // Add phase switching actions
cff28ef0 3129 if (has_capability('mod/workshop:switchphase', $workshop->context, $userid)) {
55fc1e59
DM
3130 foreach ($this->phases as $phasecode => $phase) {
3131 if (! $phase->active) {
3132 $action = new stdclass();
3133 $action->type = 'switchphase';
cff28ef0 3134 $action->url = $workshop->switchphase_url($phasecode);
55fc1e59
DM
3135 $phase->actions[] = $action;
3136 }
3137 }
3138 }
3139 }
cff28ef0
DM
3140
3141 /**
3142 * Returns example submissions to be assessed by the owner of the planner
3143 *
3144 * This is here to cache the DB query because the same list is needed later in view.php
3145 *
3146 * @see workshop::get_examples_for_reviewer() for the format of returned value
3147 * @return array
3148 */
3149 public function get_examples() {
3150 if (is_null($this->examples)) {
3151 $this->examples = $this->workshop->get_examples_for_reviewer($this->userid);
3152 }
3153 return $this->examples;
3154 }
55fc1e59 3155}
81b22887
DM
3156
3157/**
3158 * Common base class for submissions and example submissions rendering
3159 *
3160 * Subclasses of this class convert raw submission record from
3161 * workshop_submissions table (as returned by {@see workshop::get_submission_by_id()}
3162 * for example) into renderable objects.
3163 */
3164abstract class workshop_submission_base {
3165
de6aaa72 3166 /** @var bool is the submission anonymous (i.e. contains author information) */
81b22887
DM
3167 protected $anonymous;
3168
3169 /* @var array of columns from workshop_submissions that are assigned as properties */
3170 protected $fields = array();
3171
77d746a2
DM
3172 /** @var workshop */
3173 protected $workshop;
3174
81b22887
DM
3175 /**
3176 * Copies the properties of the given database record into properties of $this instance
3177 *
77d746a2 3178 * @param workshop $workshop
81b22887
DM
3179 * @param stdClass $submission full record
3180 * @param bool $showauthor show the author-related information
3181 * @param array $options additional properties
3182 */
77d746a2
DM
3183 public function __construct(workshop $workshop, stdClass $submission, $showauthor = false) {
3184
3185 $this->workshop = $workshop;
81b22887
DM
3186
3187 foreach ($this->fields as $field) {
3188 if (!property_exists($submission, $field)) {
3189 throw new coding_exception('Submission record must provide public property ' . $field);
3190 }
3191 if (!property_exists($this, $field)) {
3192 throw new coding_exception('Renderable component must accept public property ' . $field);
3193 }
3194 $this->{$field} = $submission->{$field};
3195 }
3196
3197 if ($showauthor) {
3198 $this->anonymous = false;
3199 } else {
3200 $this->anonymize();
3201 }
3202 }
3203
3204 /**
3205 * Unsets all author-related properties so that the renderer does not have access to them
3206 *
3207 * Usually this is called by the contructor but can be called explicitely, too.
3208 */
3209 public function anonymize() {
3263a356
AG
3210 $authorfields = explode(',', user_picture::fields());
3211 foreach ($authorfields as $field) {
3212 $prefixedusernamefield = 'author' . $field;
3213 unset($this->{$prefixedusernamefield});
81b22887
DM
3214 }
3215 $this->anonymous = true;
3216 }
3217
3218 /**
3219 * Does the submission object contain author-related information?
3220 *
3221 * @return null|boolean
3222 */
3223 public function is_anonymous() {
3224 return $this->anonymous;
3225 }
3226}
3227
3228/**
3229 * Renderable object containing a basic set of information needed to display the submission summary
3230 *
3231 * @see workshop_renderer::render_workshop_submission_summary
3232 */
3233class workshop_submission_summary extends workshop_submission_base implements renderable {
3234
3235 /** @var int */
3236 public $id;
3237 /** @var string */
3238 public $title;
3239 /** @var string graded|notgraded */
3240 public $status;
3241 /** @var int */
3242 public $timecreated;
3243 /** @var int */
3244 public $timemodified;
3245 /** @var int */
3246 public $authorid;
3247 /** @var string */
3248 public $authorfirstname;
3249 /** @var string */
3250 public $authorlastname;
3263a356
AG
3251 /** @var string */
3252 public $authorfirstnamephonetic;
3253 /** @var string */
3254 public $authorlastnamephonetic;