MDL-31936 workshop: Delete attachments on record removal
[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));
4a44c660
DM
1062
1063 $fs = get_file_storage();
1064 $fs->delete_area_files($this->context->id, 'mod_workshop', 'submission_content', $submission->id);
1065 $fs->delete_area_files($this->context->id, 'mod_workshop', 'submission_attachment', $submission->id);
1066
81eccf0a
DM
1067 $DB->delete_records('workshop_submissions', array('id' => $submission->id));
1068 }
1069
6e309973 1070 /**
3dc78e5b 1071 * Returns the list of all assessments in the workshop with some data added
6e309973
DM
1072 *
1073 * Fetches data from {workshop_assessments} and adds some useful information from other
de6aaa72 1074 * tables. The returned object does not contain textual fields (i.e. comments) to prevent memory
3dc78e5b
DM
1075 * lack issues.
1076 *
7a789aa8 1077 * @return array [assessmentid] => assessment stdclass
6e309973 1078 */
3dc78e5b 1079 public function get_all_assessments() {
6e309973 1080 global $DB;
53fad4b9 1081
38504a44
DM
1082 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
1083 $authorfields = user_picture::fields('author', null, 'authorid', 'author');
f68648e9 1084 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
9695ff81 1085 list($sort, $params) = users_order_by_sql('reviewer');
38504a44 1086 $sql = "SELECT a.id, a.submissionid, a.reviewerid, a.timecreated, a.timemodified,
3dc78e5b 1087 a.grade, a.gradinggrade, a.gradinggradeover, a.gradinggradeoverby,
f68648e9 1088 $reviewerfields, $authorfields, $overbyfields,
38504a44 1089 s.title
3d2924e9 1090 FROM {workshop_assessments} a
00aca3c1 1091 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
3d2924e9 1092 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
00aca3c1 1093 INNER JOIN {user} author ON (s.authorid = author.id)
f68648e9 1094 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
3dc78e5b 1095 WHERE s.workshopid = :workshopid AND s.example = 0
9695ff81
TH
1096 ORDER BY $sort";
1097 $params['workshopid'] = $this->id;
3d2924e9 1098
3dc78e5b 1099 return $DB->get_records_sql($sql, $params);
53fad4b9
DM
1100 }
1101
1102 /**
3dc78e5b 1103 * Get the complete information about the given assessment
53fad4b9
DM
1104 *
1105 * @param int $id Assessment ID
5a372494 1106 * @return stdclass
53fad4b9
DM
1107 */
1108 public function get_assessment_by_id($id) {
3dc78e5b
DM
1109 global $DB;
1110
38504a44
DM
1111 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
1112 $authorfields = user_picture::fields('author', null, 'authorid', 'author');
f68648e9
DM
1113 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
1114 $sql = "SELECT a.*, s.title, $reviewerfields, $authorfields, $overbyfields
3dc78e5b 1115 FROM {workshop_assessments} a
00aca3c1 1116 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
3dc78e5b 1117 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
00aca3c1 1118 INNER JOIN {user} author ON (s.authorid = author.id)
f68648e9 1119 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
38504a44 1120 WHERE a.id = :id AND s.workshopid = :workshopid";
3dc78e5b
DM
1121 $params = array('id' => $id, 'workshopid' => $this->id);
1122
1123 return $DB->get_record_sql($sql, $params, MUST_EXIST);
53fad4b9
DM
1124 }
1125
5a372494
DM
1126 /**
1127 * Get the complete information about the user's assessment of the given submission
1128 *
1129 * @param int $sid submission ID
1130 * @param int $uid user ID of the reviewer
1131 * @return false|stdclass false if not found, stdclass otherwise
1132 */
1133 public function get_assessment_of_submission_by_user($submissionid, $reviewerid) {
1134 global $DB;
1135
38504a44
DM
1136 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
1137 $authorfields = user_picture::fields('author', null, 'authorid', 'author');
f68648e9
DM
1138 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
1139 $sql = "SELECT a.*, s.title, $reviewerfields, $authorfields, $overbyfields
5a372494
DM
1140 FROM {workshop_assessments} a
1141 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
1142 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
1143 INNER JOIN {user} author ON (s.authorid = author.id)
f68648e9 1144 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
38504a44 1145 WHERE s.id = :sid AND reviewer.id = :rid AND s.workshopid = :workshopid";
5a372494
DM
1146 $params = array('sid' => $submissionid, 'rid' => $reviewerid, 'workshopid' => $this->id);
1147
1148 return $DB->get_record_sql($sql, $params, IGNORE_MISSING);
1149 }
1150
1151 /**
1152 * Get the complete information about all assessments of the given submission
1153 *
1154 * @param int $submissionid
1155 * @return array
1156 */
1157 public function get_assessments_of_submission($submissionid) {
1158 global $DB;
1159
38504a44 1160 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
f68648e9 1161 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
9695ff81 1162 list($sort, $params) = users_order_by_sql('reviewer');
f68648e9 1163 $sql = "SELECT a.*, s.title, $reviewerfields, $overbyfields
5a372494
DM
1164 FROM {workshop_assessments} a
1165 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
1166 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
f68648e9 1167 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
38504a44 1168 WHERE s.example = 0 AND s.id = :submissionid AND s.workshopid = :workshopid
9695ff81
TH
1169 ORDER BY $sort";
1170 $params['submissionid'] = $submissionid;
1171 $params['workshopid'] = $this->id;
5a372494
DM
1172
1173 return $DB->get_records_sql($sql, $params);
1174 }
1175
53fad4b9 1176 /**
3dc78e5b 1177 * Get the complete information about all assessments allocated to the given reviewer
53fad4b9 1178 *
00aca3c1 1179 * @param int $reviewerid
3dc78e5b 1180 * @return array
53fad4b9 1181 */
00aca3c1 1182 public function get_assessments_by_reviewer($reviewerid) {
3dc78e5b
DM
1183 global $DB;
1184
38504a44
DM
1185 $reviewerfields = user_picture::fields('reviewer', null, 'revieweridx', 'reviewer');
1186 $authorfields = user_picture::fields('author', null, 'authorid', 'author');
f68648e9
DM
1187 $overbyfields = user_picture::fields('overby', null, 'gradinggradeoverbyx', 'overby');
1188 $sql = "SELECT a.*, $reviewerfields, $authorfields, $overbyfields,
ddb59c77 1189 s.id AS submissionid, s.title AS submissiontitle, s.timecreated AS submissioncreated,
38504a44 1190 s.timemodified AS submissionmodified
3dc78e5b 1191 FROM {workshop_assessments} a
00aca3c1 1192 INNER JOIN {user} reviewer ON (a.reviewerid = reviewer.id)
3dc78e5b 1193 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
00aca3c1 1194 INNER JOIN {user} author ON (s.authorid = author.id)
f68648e9 1195 LEFT JOIN {user} overby ON (a.gradinggradeoverby = overby.id)
38504a44 1196 WHERE s.example = 0 AND reviewer.id = :reviewerid AND s.workshopid = :workshopid";
00aca3c1 1197 $params = array('reviewerid' => $reviewerid, 'workshopid' => $this->id);
3dc78e5b
DM
1198
1199 return $DB->get_records_sql($sql, $params);
53fad4b9 1200 }
6e309973 1201
0001eea6
DM
1202 /**
1203 * Get allocated assessments not graded yet by the given reviewer
1204 *
1205 * @see self::get_assessments_by_reviewer()
1206 * @param int $reviewerid the reviewer id
1207 * @param null|int|array $exclude optional assessment id (or list of them) to be excluded
1208 * @return array
1209 */
1210 public function get_pending_assessments_by_reviewer($reviewerid, $exclude = null) {
1211
1212 $assessments = $this->get_assessments_by_reviewer($reviewerid);
1213
1214 foreach ($assessments as $id => $assessment) {
1215 if (!is_null($assessment->grade)) {
1216 unset($assessments[$id]);
1217 continue;
1218 }
1219 if (!empty($exclude)) {
1220 if (is_array($exclude) and in_array($id, $exclude)) {
1221 unset($assessments[$id]);
1222 continue;
1223 } else if ($id == $exclude) {
1224 unset($assessments[$id]);
1225 continue;
1226 }
1227 }
1228 }
1229
1230 return $assessments;
1231 }
1232
6e309973
DM
1233 /**
1234 * Allocate a submission to a user for review
53fad4b9 1235 *
5924db72 1236 * @param stdClass $submission Submission object with at least id property
6e309973 1237 * @param int $reviewerid User ID
becec954 1238 * @param int $weight of the new assessment, from 0 to 16
67ae13d9 1239 * @param bool $bulk repeated inserts into DB expected
31cea236 1240 * @return int ID of the new assessment or an error code {@link self::ALLOCATION_EXISTS} if the allocation already exists
6e309973 1241 */
67ae13d9 1242 public function add_allocation(stdclass $submission, $reviewerid, $weight=1, $bulk=false) {
6e309973
DM
1243 global $DB;
1244
00aca3c1 1245 if ($DB->record_exists('workshop_assessments', array('submissionid' => $submission->id, 'reviewerid' => $reviewerid))) {
b761e6d9 1246 return self::ALLOCATION_EXISTS;
6e309973
DM
1247 }
1248
67ae13d9
DM
1249 $weight = (int)$weight;
1250 if ($weight < 0) {
1251 $weight = 0;
1252 }
1253 if ($weight > 16) {
1254 $weight = 16;
1255 }
1256
6e309973 1257 $now = time();
7a789aa8 1258 $assessment = new stdclass();
e554671d
DM
1259 $assessment->submissionid = $submission->id;
1260 $assessment->reviewerid = $reviewerid;
7a5f4be0 1261 $assessment->timecreated = $now; // do not set timemodified here
becec954 1262 $assessment->weight = $weight;
c6a793d5 1263 $assessment->feedbackauthorformat = editors_get_preferred_format();
884482fb 1264 $assessment->feedbackreviewerformat = editors_get_preferred_format();
6e309973 1265
235b31c8 1266 return $DB->insert_record('workshop_assessments', $assessment, true, $bulk);
6e309973
DM
1267 }
1268
6e309973 1269 /**
4a44c660
DM
1270 * Delete assessment record or records.
1271 *
1272 * Removes associated records from the workshop_grades table, too.
6e309973 1273 *
4a44c660
DM
1274 * @param int|array $id assessment id or array of assessments ids
1275 * @todo Give grading strategy plugins a chance to clean up their data, too.
1276 * @return bool true
6e309973
DM
1277 */
1278 public function delete_assessment($id) {
1279 global $DB;
1280
4a44c660
DM
1281 if (empty($id)) {
1282 return true;
1283 }
1284
1285 $fs = get_file_storage();
6e309973 1286
53fad4b9 1287 if (is_array($id)) {
4a44c660
DM
1288 $DB->delete_records_list('workshop_grades', 'assessmentid', $id);
1289 foreach ($id as $itemid) {
1290 $fs->delete_area_files($this->context->id, 'mod_workshop', 'overallfeedback_content', $itemid);
1291 $fs->delete_area_files($this->context->id, 'mod_workshop', 'overallfeedback_attachment', $itemid);
1292 }
1293 $DB->delete_records_list('workshop_assessments', 'id', $id);
1294
3d2924e9 1295 } else {
4a44c660
DM
1296 $DB->delete_records('workshop_grades', array('assessmentid' => $id));
1297 $fs->delete_area_files($this->context->id, 'mod_workshop', 'overallfeedback_content', $id);
1298 $fs->delete_area_files($this->context->id, 'mod_workshop', 'overallfeedback_attachment', $id);
1299 $DB->delete_records('workshop_assessments', array('id' => $id));
53fad4b9 1300 }
4a44c660
DM
1301
1302 return true;
53fad4b9 1303 }
6e309973
DM
1304
1305 /**
1306 * Returns instance of grading strategy class
53fad4b9 1307 *
7a789aa8 1308 * @return stdclass Instance of a grading strategy
6e309973
DM
1309 */
1310 public function grading_strategy_instance() {
3d2924e9
DM
1311 global $CFG; // because we require other libs here
1312
3fd2b0e1 1313 if (is_null($this->strategyinstance)) {
f05c168d 1314 $strategylib = dirname(__FILE__) . '/form/' . $this->strategy . '/lib.php';
6e309973
DM
1315 if (is_readable($strategylib)) {
1316 require_once($strategylib);
1317 } else {
f05c168d 1318 throw new coding_exception('the grading forms subplugin must contain library ' . $strategylib);
6e309973 1319 }
0dc47fb9 1320 $classname = 'workshop_' . $this->strategy . '_strategy';
3fd2b0e1
DM
1321 $this->strategyinstance = new $classname($this);
1322 if (!in_array('workshop_strategy', class_implements($this->strategyinstance))) {
b761e6d9 1323 throw new coding_exception($classname . ' does not implement workshop_strategy interface');
6e309973
DM
1324 }
1325 }
3fd2b0e1 1326 return $this->strategyinstance;
6e309973
DM
1327 }
1328
a93dc3ec
DM
1329 /**
1330 * Sets the current evaluation method to the given plugin.
1331 *
1332 * @param string $method the name of the workshopeval subplugin
1333 * @return bool true if successfully set
1334 * @throws coding_exception if attempting to set a non-installed evaluation method
1335 */
1336 public function set_grading_evaluation_method($method) {
1337 global $DB;
1338
1339 $evaluationlib = dirname(__FILE__) . '/eval/' . $method . '/lib.php';
1340
1341 if (is_readable($evaluationlib)) {
1342 $this->evaluationinstance = null;
1343 $this->evaluation = $method;
1344 $DB->set_field('workshop', 'evaluation', $method, array('id' => $this->id));
1345 return true;
1346 }
1347
1348 throw new coding_exception('Attempt to set a non-existing evaluation method.');
1349 }
1350
45d24d39
DM
1351 /**
1352 * Returns instance of grading evaluation class
1353 *
7a789aa8 1354 * @return stdclass Instance of a grading evaluation
45d24d39
DM
1355 */
1356 public function grading_evaluation_instance() {
1357 global $CFG; // because we require other libs here
1358
1359 if (is_null($this->evaluationinstance)) {
4f115176
DM
1360 if (empty($this->evaluation)) {
1361 $this->evaluation = 'best';
1362 }
45d24d39
DM
1363 $evaluationlib = dirname(__FILE__) . '/eval/' . $this->evaluation . '/lib.php';
1364 if (is_readable($evaluationlib)) {
1365 require_once($evaluationlib);
1366 } else {
4f115176
DM
1367 // Fall back in case the subplugin is not available.
1368 $this->evaluation = 'best';
1369 $evaluationlib = dirname(__FILE__) . '/eval/' . $this->evaluation . '/lib.php';
1370 if (is_readable($evaluationlib)) {
1371 require_once($evaluationlib);
1372 } else {
1373 // Fall back in case the subplugin is not available any more.
1374 throw new coding_exception('Missing default grading evaluation library ' . $evaluationlib);
1375 }
45d24d39
DM
1376 }
1377 $classname = 'workshop_' . $this->evaluation . '_evaluation';
1378 $this->evaluationinstance = new $classname($this);
4f115176
DM
1379 if (!in_array('workshop_evaluation', class_parents($this->evaluationinstance))) {
1380 throw new coding_exception($classname . ' does not extend workshop_evaluation class');
45d24d39
DM
1381 }
1382 }
1383 return $this->evaluationinstance;
1384 }
1385
66c9894d
DM
1386 /**
1387 * Returns instance of submissions allocator
53fad4b9 1388 *
130ae619 1389 * @param string $method The name of the allocation method, must be PARAM_ALPHA
7a789aa8 1390 * @return stdclass Instance of submissions allocator
66c9894d
DM
1391 */
1392 public function allocator_instance($method) {
3d2924e9
DM
1393 global $CFG; // because we require other libs here
1394
f05c168d 1395 $allocationlib = dirname(__FILE__) . '/allocation/' . $method . '/lib.php';
66c9894d
DM
1396 if (is_readable($allocationlib)) {
1397 require_once($allocationlib);
1398 } else {
f05c168d 1399 throw new coding_exception('Unable to find the allocation library ' . $allocationlib);
66c9894d
DM
1400 }
1401 $classname = 'workshop_' . $method . '_allocator';
1402 return new $classname($this);
1403 }
1404
b8ead2e6 1405 /**
454e8dd9 1406 * @return moodle_url of this workshop's view page
b8ead2e6
DM
1407 */
1408 public function view_url() {
1409 global $CFG;
a6855934 1410 return new moodle_url('/mod/workshop/view.php', array('id' => $this->cm->id));
b8ead2e6
DM
1411 }
1412
1413 /**
454e8dd9 1414 * @return moodle_url of the page for editing this workshop's grading form
b8ead2e6
DM
1415 */
1416 public function editform_url() {
1417 global $CFG;
a6855934 1418 return new moodle_url('/mod/workshop/editform.php', array('cmid' => $this->cm->id));
b8ead2e6
DM
1419 }
1420
1421 /**
454e8dd9 1422 * @return moodle_url of the page for previewing this workshop's grading form
b8ead2e6
DM
1423 */
1424 public function previewform_url() {
1425 global $CFG;
a6855934 1426 return new moodle_url('/mod/workshop/editformpreview.php', array('cmid' => $this->cm->id));
b8ead2e6
DM
1427 }
1428
1429 /**
1430 * @param int $assessmentid The ID of assessment record
454e8dd9 1431 * @return moodle_url of the assessment page
b8ead2e6 1432 */
a39d7d87 1433 public function assess_url($assessmentid) {
b8ead2e6 1434 global $CFG;
454e8dd9 1435 $assessmentid = clean_param($assessmentid, PARAM_INT);
a6855934 1436 return new moodle_url('/mod/workshop/assessment.php', array('asid' => $assessmentid));
b8ead2e6
DM
1437 }
1438
becec954
DM
1439 /**
1440 * @param int $assessmentid The ID of assessment record
1441 * @return moodle_url of the example assessment page
1442 */
1443 public function exassess_url($assessmentid) {
1444 global $CFG;
1445 $assessmentid = clean_param($assessmentid, PARAM_INT);
a6855934 1446 return new moodle_url('/mod/workshop/exassessment.php', array('asid' => $assessmentid));
becec954
DM
1447 }
1448
39861053 1449 /**
67cd00ba 1450 * @return moodle_url of the page to view a submission, defaults to the own one
39861053 1451 */
67cd00ba 1452 public function submission_url($id=null) {
39861053 1453 global $CFG;
a6855934 1454 return new moodle_url('/mod/workshop/submission.php', array('cmid' => $this->cm->id, 'id' => $id));
39861053
DM
1455 }
1456
81eccf0a
DM
1457 /**
1458 * @param int $id example submission id
1459 * @return moodle_url of the page to view an example submission
1460 */
becec954 1461 public function exsubmission_url($id) {
81eccf0a 1462 global $CFG;
a6855934 1463 return new moodle_url('/mod/workshop/exsubmission.php', array('cmid' => $this->cm->id, 'id' => $id));
81eccf0a
DM
1464 }
1465
cbf87967
DM
1466 /**
1467 * @param int $sid submission id
1468 * @param array $aid of int assessment ids
1469 * @return moodle_url of the page to compare assessments of the given submission
1470 */
1471 public function compare_url($sid, array $aids) {
1472 global $CFG;
1473
a6855934 1474 $url = new moodle_url('/mod/workshop/compare.php', array('cmid' => $this->cm->id, 'sid' => $sid));
cbf87967
DM
1475 $i = 0;
1476 foreach ($aids as $aid) {
1477 $url->param("aid{$i}", $aid);
1478 $i++;
1479 }
1480 return $url;
1481 }
1482
1483 /**
1484 * @param int $sid submission id
1485 * @param int $aid assessment id
1486 * @return moodle_url of the page to compare the reference assessments of the given example submission
1487 */
1488 public function excompare_url($sid, $aid) {
1489 global $CFG;
a6855934 1490 return new moodle_url('/mod/workshop/excompare.php', array('cmid' => $this->cm->id, 'sid' => $sid, 'aid' => $aid));
cbf87967
DM
1491 }
1492
da0b1f70 1493 /**
454e8dd9 1494 * @return moodle_url of the mod_edit form
da0b1f70
DM
1495 */
1496 public function updatemod_url() {
1497 global $CFG;
a6855934 1498 return new moodle_url('/course/modedit.php', array('update' => $this->cm->id, 'return' => 1));
da0b1f70
DM
1499 }
1500
454e8dd9 1501 /**
08af32af 1502 * @param string $method allocation method
454e8dd9
DM
1503 * @return moodle_url to the allocation page
1504 */
08af32af 1505 public function allocation_url($method=null) {
da0b1f70 1506 global $CFG;
08af32af
DM
1507 $params = array('cmid' => $this->cm->id);
1508 if (!empty($method)) {
1509 $params['method'] = $method;
1510 }
1511 return new moodle_url('/mod/workshop/allocation.php', $params);
da0b1f70
DM
1512 }
1513
454e8dd9
DM
1514 /**
1515 * @param int $phasecode The internal phase code
1516 * @return moodle_url of the script to change the current phase to $phasecode
1517 */
1518 public function switchphase_url($phasecode) {
1519 global $CFG;
1520 $phasecode = clean_param($phasecode, PARAM_INT);
a6855934 1521 return new moodle_url('/mod/workshop/switchphase.php', array('cmid' => $this->cm->id, 'phase' => $phasecode));
454e8dd9
DM
1522 }
1523
89c1aa97
DM
1524 /**
1525 * @return moodle_url to the aggregation page
1526 */
1527 public function aggregate_url() {
1528 global $CFG;
a6855934 1529 return new moodle_url('/mod/workshop/aggregate.php', array('cmid' => $this->cm->id));
89c1aa97
DM
1530 }
1531
32c78bc3
DM
1532 /**
1533 * @return moodle_url of this workshop's toolbox page
1534 */
1535 public function toolbox_url($tool) {
1536 global $CFG;
1537 return new moodle_url('/mod/workshop/toolbox.php', array('id' => $this->cm->id, 'tool' => $tool));
1538 }
1539
5450f7b6
DM
1540 /**
1541 * Workshop wrapper around {@see add_to_log()}
1a219fb6 1542 * @deprecated since 2.7 Please use the provided event classes for logging actions.
5450f7b6
DM
1543 *
1544 * @param string $action to be logged
1545 * @param moodle_url $url absolute url as returned by {@see workshop::submission_url()} and friends
1546 * @param mixed $info additional info, usually id in a table
cbf4b0e6
FM
1547 * @param bool $return true to return the arguments for add_to_log.
1548 * @return void|array array of arguments for add_to_log if $return is true
5450f7b6 1549 */
cbf4b0e6 1550 public function log($action, moodle_url $url = null, $info = null, $return = false) {
1a219fb6 1551 debugging('The log method is now deprecated, please use event classes instead', DEBUG_DEVELOPER);
5450f7b6
DM
1552
1553 if (is_null($url)) {
1554 $url = $this->view_url();
1555 }
1556
1557 if (is_null($info)) {
1558 $info = $this->id;
1559 }
1560
1561 $logurl = $this->log_convert_url($url);
cbf4b0e6
FM
1562 $args = array($this->course->id, 'workshop', $action, $logurl, $info, $this->cm->id);
1563 if ($return) {
1564 return $args;
1565 }
1566 call_user_func_array('add_to_log', $args);
5450f7b6
DM
1567 }
1568
b8ead2e6 1569 /**
9ddff589 1570 * Is the given user allowed to create their submission?
407b1e91 1571 *
9ddff589 1572 * @param int $userid
407b1e91 1573 * @return bool
b8ead2e6 1574 */
9ddff589
DM
1575 public function creating_submission_allowed($userid) {
1576
2f289d36 1577 $now = time();
9ddff589 1578 $ignoredeadlines = has_capability('mod/workshop:ignoredeadlines', $this->context, $userid);
2f289d36
DM
1579
1580 if ($this->latesubmissions) {
1581 if ($this->phase != self::PHASE_SUBMISSION and $this->phase != self::PHASE_ASSESSMENT) {
1582 // late submissions are allowed in the submission and assessment phase only
1583 return false;
1584 }
9ddff589 1585 if (!$ignoredeadlines and !empty($this->submissionstart) and $this->submissionstart > $now) {
2f289d36
DM
1586 // late submissions are not allowed before the submission start
1587 return false;
1588 }
1589 return true;
1590
1591 } else {
1592 if ($this->phase != self::PHASE_SUBMISSION) {
1593 // submissions are allowed during the submission phase only
1594 return false;
1595 }
9ddff589 1596 if (!$ignoredeadlines and !empty($this->submissionstart) and $this->submissionstart > $now) {
2f289d36
DM
1597 // if enabled, submitting is not allowed before the date/time defined in the mod_form
1598 return false;
1599 }
9ddff589 1600 if (!$ignoredeadlines and !empty($this->submissionend) and $now > $this->submissionend ) {
2f289d36
DM
1601 // if enabled, submitting is not allowed after the date/time defined in the mod_form unless late submission is allowed
1602 return false;
1603 }
1604 return true;
1605 }
1606 }
1607
1608 /**
9ddff589 1609 * Is the given user allowed to modify their existing submission?
2f289d36 1610 *
9ddff589 1611 * @param int $userid
2f289d36
DM
1612 * @return bool
1613 */
9ddff589
DM
1614 public function modifying_submission_allowed($userid) {
1615
2f289d36 1616 $now = time();
9ddff589 1617 $ignoredeadlines = has_capability('mod/workshop:ignoredeadlines', $this->context, $userid);
2f289d36 1618
74bf8a94 1619 if ($this->phase != self::PHASE_SUBMISSION) {
2f289d36 1620 // submissions can be edited during the submission phase only
74bf8a94
DM
1621 return false;
1622 }
9ddff589 1623 if (!$ignoredeadlines and !empty($this->submissionstart) and $this->submissionstart > $now) {
c1ab2b10 1624 // if enabled, re-submitting is not allowed before the date/time defined in the mod_form
74bf8a94
DM
1625 return false;
1626 }
c1ab2b10
DM
1627 if (!$ignoredeadlines and !empty($this->submissionend) and $now > $this->submissionend) {
1628 // if enabled, re-submitting is not allowed after the date/time defined in the mod_form even if late submission is allowed
74bf8a94
DM
1629 return false;
1630 }
407b1e91 1631 return true;
b8ead2e6
DM
1632 }
1633
c1e883bb 1634 /**
9ddff589 1635 * Is the given reviewer allowed to create/edit their assessments?
c1e883bb 1636 *
9ddff589 1637 * @param int $userid
c1e883bb
DM
1638 * @return bool
1639 */
9ddff589
DM
1640 public function assessing_allowed($userid) {
1641
74bf8a94 1642 if ($this->phase != self::PHASE_ASSESSMENT) {
4affa724
DM
1643 // assessing is allowed in the assessment phase only, unless the user is a teacher
1644 // providing additional assessment during the evaluation phase
1645 if ($this->phase != self::PHASE_EVALUATION or !has_capability('mod/workshop:overridegrades', $this->context, $userid)) {
1646 return false;
1647 }
74bf8a94 1648 }
9ddff589 1649
74bf8a94 1650 $now = time();
9ddff589
DM
1651 $ignoredeadlines = has_capability('mod/workshop:ignoredeadlines', $this->context, $userid);
1652
1653 if (!$ignoredeadlines and !empty($this->assessmentstart) and $this->assessmentstart > $now) {
74bf8a94
DM
1654 // if enabled, assessing is not allowed before the date/time defined in the mod_form
1655 return false;
1656 }
9ddff589 1657 if (!$ignoredeadlines and !empty($this->assessmentend) and $now > $this->assessmentend) {
74bf8a94
DM
1658 // if enabled, assessing is not allowed after the date/time defined in the mod_form
1659 return false;
1660 }
1661 // here we go, assessing is allowed
c1e883bb
DM
1662 return true;
1663 }
1664
becec954
DM
1665 /**
1666 * Are reviewers allowed to create/edit their assessments of the example submissions?
1667 *
514d8c22
DM
1668 * Returns null if example submissions are not enabled in this workshop. Otherwise returns
1669 * true or false. Note this does not check other conditions like the number of already
1670 * assessed examples, examples mode etc.
becec954 1671 *
74bf8a94 1672 * @return null|bool
becec954
DM
1673 */
1674 public function assessing_examples_allowed() {
74bf8a94
DM
1675 if (empty($this->useexamples)) {
1676 return null;
1677 }
1678 if (self::EXAMPLES_VOLUNTARY == $this->examplesmode) {
1679 return true;
1680 }
1681 if (self::EXAMPLES_BEFORE_SUBMISSION == $this->examplesmode and self::PHASE_SUBMISSION == $this->phase) {
1682 return true;
1683 }
1684 if (self::EXAMPLES_BEFORE_ASSESSMENT == $this->examplesmode and self::PHASE_ASSESSMENT == $this->phase) {
1685 return true;
1686 }
1687 return false;
becec954 1688 }
407b1e91 1689
3dc78e5b
DM
1690 /**
1691 * Are the peer-reviews available to the authors?
1692 *
3dc78e5b
DM
1693 * @return bool
1694 */
1695 public function assessments_available() {
5a372494 1696 return $this->phase == self::PHASE_CLOSED;
3dc78e5b
DM
1697 }
1698
454e8dd9
DM
1699 /**
1700 * Switch to a new workshop phase
1701 *
1702 * Modifies the underlying database record. You should terminate the script shortly after calling this.
1703 *
1704 * @param int $newphase new phase code
1705 * @return bool true if success, false otherwise
1706 */
1707 public function switch_phase($newphase) {
1708 global $DB;
1709
365c2cc2 1710 $known = $this->available_phases_list();
454e8dd9
DM
1711 if (!isset($known[$newphase])) {
1712 return false;
1713 }
f6e8b318
DM
1714
1715 if (self::PHASE_CLOSED == $newphase) {
f27b70fb 1716 // push the grades into the gradebook
7a789aa8 1717 $workshop = new stdclass();
10bc4bce
DM
1718 foreach ($this as $property => $value) {
1719 $workshop->{$property} = $value;
1720 }
1721 $workshop->course = $this->course->id;
1722 $workshop->cmidnumber = $this->cm->id;
1723 $workshop->modname = 'workshop';
1724 workshop_update_grades($workshop);
f6e8b318
DM
1725 }
1726
454e8dd9 1727 $DB->set_field('workshop', 'phase', $newphase, array('id' => $this->id));
9260bb3c 1728 $this->phase = $newphase;
1a219fb6
AG
1729 $eventdata = array(
1730 'objectid' => $this->id,
1731 'context' => $this->context,
1732 'other' => array(
1733 'workshopphase' => $this->phase
1734 )
1735 );
1736 $event = \mod_workshop\event\phase_switched::create($eventdata);
1737 $event->trigger();
454e8dd9
DM
1738 return true;
1739 }
ddb59c77
DM
1740
1741 /**
1742 * Saves a raw grade for submission as calculated from the assessment form fields
1743 *
1744 * @param array $assessmentid assessment record id, must exists
00aca3c1 1745 * @param mixed $grade raw percentual grade from 0.00000 to 100.00000
ddb59c77
DM
1746 * @return false|float the saved grade
1747 */
1748 public function set_peer_grade($assessmentid, $grade) {
1749 global $DB;
1750
1751 if (is_null($grade)) {
1752 return false;
1753 }
7a789aa8 1754 $data = new stdclass();
ddb59c77
DM
1755 $data->id = $assessmentid;
1756 $data->grade = $grade;
7a5f4be0 1757 $data->timemodified = time();
ddb59c77
DM
1758 $DB->update_record('workshop_assessments', $data);
1759 return $grade;
1760 }
6516b9e9 1761
29dc43e7
DM
1762 /**
1763 * Prepares data object with all workshop grades to be rendered
1764 *
5e71cefb 1765 * @param int $userid the user we are preparing the report for
dda42a19 1766 * @param int $groupid if non-zero, prepare the report for the given group only
29dc43e7 1767 * @param int $page the current page (for the pagination)
5e71cefb 1768 * @param int $perpage participants per page (for the pagination)
f27b70fb 1769 * @param string $sortby lastname|firstname|submissiontitle|submissiongrade|gradinggrade
5e71cefb 1770 * @param string $sorthow ASC|DESC
7a789aa8 1771 * @return stdclass data for the renderer
29dc43e7 1772 */
dda42a19 1773 public function prepare_grading_report_data($userid, $groupid, $page, $perpage, $sortby, $sorthow) {
29dc43e7
DM
1774 global $DB;
1775
d895c6aa 1776 $canviewall = has_capability('mod/workshop:viewallassessments', $this->context, $userid);
8741ebb0 1777 $isparticipant = $this->is_participant($userid);
29dc43e7
DM
1778
1779 if (!$canviewall and !$isparticipant) {
1780 // who the hell is this?
1781 return array();
1782 }
1783
f27b70fb 1784 if (!in_array($sortby, array('lastname','firstname','submissiontitle','submissiongrade','gradinggrade'))) {
5e71cefb
DM
1785 $sortby = 'lastname';
1786 }
1787
1788 if (!($sorthow === 'ASC' or $sorthow === 'DESC')) {
1789 $sorthow = 'ASC';
1790 }
1791
1792 // get the list of user ids to be displayed
29dc43e7 1793 if ($canviewall) {
dda42a19 1794 $participants = $this->get_participants(false, $groupid);
29dc43e7
DM
1795 } else {
1796 // this is an ordinary workshop participant (aka student) - display the report just for him/her
1797 $participants = array($userid => (object)array('id' => $userid));
1798 }
1799
5e71cefb 1800 // we will need to know the number of all records later for the pagination purposes
29dc43e7
DM
1801 $numofparticipants = count($participants);
1802
deea6e7a
DM
1803 if ($numofparticipants > 0) {
1804 // load all fields which can be used for sorting and paginate the records
1805 list($participantids, $params) = $DB->get_in_or_equal(array_keys($participants), SQL_PARAMS_NAMED);
1806 $params['workshopid1'] = $this->id;
1807 $params['workshopid2'] = $this->id;
20e7fd83
DM
1808 $sqlsort = array();
1809 $sqlsortfields = array($sortby => $sorthow) + array('lastname' => 'ASC', 'firstname' => 'ASC', 'u.id' => 'ASC');
1810 foreach ($sqlsortfields as $sqlsortfieldname => $sqlsortfieldhow) {
1811 $sqlsort[] = $sqlsortfieldname . ' ' . $sqlsortfieldhow;
1812 }
1813 $sqlsort = implode(',', $sqlsort);
a327f25e
AG
1814 $picturefields = user_picture::fields('u', array(), 'userid');
1815 $sql = "SELECT $picturefields, s.title AS submissiontitle, s.grade AS submissiongrade, ag.gradinggrade
deea6e7a
DM
1816 FROM {user} u
1817 LEFT JOIN {workshop_submissions} s ON (s.authorid = u.id AND s.workshopid = :workshopid1 AND s.example = 0)
1818 LEFT JOIN {workshop_aggregations} ag ON (ag.userid = u.id AND ag.workshopid = :workshopid2)
1819 WHERE u.id $participantids
1820 ORDER BY $sqlsort";
1821 $participants = $DB->get_records_sql($sql, $params, $page * $perpage, $perpage);
1822 } else {
1823 $participants = array();
1824 }
29dc43e7
DM
1825
1826 // this will hold the information needed to display user names and pictures
5e71cefb
DM
1827 $userinfo = array();
1828
1829 // get the user details for all participants to display
a327f25e 1830 $additionalnames = get_all_user_name_fields();
5e71cefb
DM
1831 foreach ($participants as $participant) {
1832 if (!isset($userinfo[$participant->userid])) {
7a789aa8 1833 $userinfo[$participant->userid] = new stdclass();
5e71cefb 1834 $userinfo[$participant->userid]->id = $participant->userid;
5e71cefb
DM
1835 $userinfo[$participant->userid]->picture = $participant->picture;
1836 $userinfo[$participant->userid]->imagealt = $participant->imagealt;
3a11c09f 1837 $userinfo[$participant->userid]->email = $participant->email;
a327f25e
AG
1838 foreach ($additionalnames as $addname) {
1839 $userinfo[$participant->userid]->$addname = $participant->$addname;
1840 }
5e71cefb
DM
1841 }
1842 }
29dc43e7 1843
5e71cefb 1844 // load the submissions details
29dc43e7 1845 $submissions = $this->get_submissions(array_keys($participants));
5e71cefb
DM
1846
1847 // get the user details for all moderators (teachers) that have overridden a submission grade
29dc43e7 1848 foreach ($submissions as $submission) {
29dc43e7 1849 if (!isset($userinfo[$submission->gradeoverby])) {
7a789aa8 1850 $userinfo[$submission->gradeoverby] = new stdclass();
29dc43e7 1851 $userinfo[$submission->gradeoverby]->id = $submission->gradeoverby;
29dc43e7
DM
1852 $userinfo[$submission->gradeoverby]->picture = $submission->overpicture;
1853 $userinfo[$submission->gradeoverby]->imagealt = $submission->overimagealt;
3a11c09f 1854 $userinfo[$submission->gradeoverby]->email = $submission->overemail;
a327f25e
AG
1855 foreach ($additionalnames as $addname) {
1856 $temp = 'over' . $addname;
1857 $userinfo[$submission->gradeoverby]->$addname = $submission->$temp;
1858 }
29dc43e7
DM
1859 }
1860 }
1861
5e71cefb 1862 // get the user details for all reviewers of the displayed participants
29dc43e7 1863 $reviewers = array();
a327f25e 1864
29dc43e7
DM
1865 if ($submissions) {
1866 list($submissionids, $params) = $DB->get_in_or_equal(array_keys($submissions), SQL_PARAMS_NAMED);
9695ff81 1867 list($sort, $sortparams) = users_order_by_sql('r');
a327f25e 1868 $picturefields = user_picture::fields('r', array(), 'reviewerid');
581878b8 1869 $sql = "SELECT a.id AS assessmentid, a.submissionid, a.grade, a.gradinggrade, a.gradinggradeover, a.weight,
a327f25e 1870 $picturefields, s.id AS submissionid, s.authorid
29dc43e7
DM
1871 FROM {workshop_assessments} a
1872 JOIN {user} r ON (a.reviewerid = r.id)
0324b6f1 1873 JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
c6b784f0 1874 WHERE a.submissionid $submissionids
9695ff81
TH
1875 ORDER BY a.weight DESC, $sort";
1876 $reviewers = $DB->get_records_sql($sql, array_merge($params, $sortparams));
29dc43e7
DM
1877 foreach ($reviewers as $reviewer) {
1878 if (!isset($userinfo[$reviewer->reviewerid])) {
7a789aa8 1879 $userinfo[$reviewer->reviewerid] = new stdclass();
29dc43e7 1880 $userinfo[$reviewer->reviewerid]->id = $reviewer->reviewerid;
29dc43e7
DM
1881 $userinfo[$reviewer->reviewerid]->picture = $reviewer->picture;
1882 $userinfo[$reviewer->reviewerid]->imagealt = $reviewer->imagealt;
3a11c09f 1883 $userinfo[$reviewer->reviewerid]->email = $reviewer->email;
a327f25e
AG
1884 foreach ($additionalnames as $addname) {
1885 $userinfo[$reviewer->reviewerid]->$addname = $reviewer->$addname;
1886 }
29dc43e7
DM
1887 }
1888 }
1889 }
1890
5e71cefb 1891 // get the user details for all reviewees of the displayed participants
934329e5
DM
1892 $reviewees = array();
1893 if ($participants) {
1894 list($participantids, $params) = $DB->get_in_or_equal(array_keys($participants), SQL_PARAMS_NAMED);
9695ff81 1895 list($sort, $sortparams) = users_order_by_sql('e');
934329e5 1896 $params['workshopid'] = $this->id;
a327f25e 1897 $picturefields = user_picture::fields('e', array(), 'authorid');
581878b8 1898 $sql = "SELECT a.id AS assessmentid, a.submissionid, a.grade, a.gradinggrade, a.gradinggradeover, a.reviewerid, a.weight,
a327f25e 1899 s.id AS submissionid, $picturefields
934329e5
DM
1900 FROM {user} u
1901 JOIN {workshop_assessments} a ON (a.reviewerid = u.id)
0324b6f1 1902 JOIN {workshop_submissions} s ON (a.submissionid = s.id AND s.example = 0)
934329e5 1903 JOIN {user} e ON (s.authorid = e.id)
c6b784f0 1904 WHERE u.id $participantids AND s.workshopid = :workshopid
9695ff81 1905 ORDER BY a.weight DESC, $sort";
462b4c12 1906 $reviewees = $DB->get_records_sql($sql, array_merge($params, $sortparams));
934329e5
DM
1907 foreach ($reviewees as $reviewee) {
1908 if (!isset($userinfo[$reviewee->authorid])) {
7a789aa8 1909 $userinfo[$reviewee->authorid] = new stdclass();
934329e5 1910 $userinfo[$reviewee->authorid]->id = $reviewee->authorid;
934329e5
DM
1911 $userinfo[$reviewee->authorid]->picture = $reviewee->picture;
1912 $userinfo[$reviewee->authorid]->imagealt = $reviewee->imagealt;
3a11c09f 1913 $userinfo[$reviewee->authorid]->email = $reviewee->email;
a327f25e
AG
1914 foreach ($additionalnames as $addname) {
1915 $userinfo[$reviewee->authorid]->$addname = $reviewee->$addname;
1916 }
934329e5 1917 }
29dc43e7
DM
1918 }
1919 }
1920
5e71cefb
DM
1921 // finally populate the object to be rendered
1922 $grades = $participants;
29dc43e7
DM
1923
1924 foreach ($participants as $participant) {
1925 // set up default (null) values
d183140d
DM
1926 $grades[$participant->userid]->submissionid = null;
1927 $grades[$participant->userid]->submissiontitle = null;
1928 $grades[$participant->userid]->submissiongrade = null;
1929 $grades[$participant->userid]->submissiongradeover = null;
1930 $grades[$participant->userid]->submissiongradeoverby = null;
232175e4 1931 $grades[$participant->userid]->submissionpublished = null;
5e71cefb
DM
1932 $grades[$participant->userid]->reviewedby = array();
1933 $grades[$participant->userid]->reviewerof = array();
29dc43e7
DM
1934 }
1935 unset($participants);
1936 unset($participant);
1937
1938 foreach ($submissions as $submission) {
1939 $grades[$submission->authorid]->submissionid = $submission->id;
1940 $grades[$submission->authorid]->submissiontitle = $submission->title;
b4857acb
DM
1941 $grades[$submission->authorid]->submissiongrade = $this->real_grade($submission->grade);
1942 $grades[$submission->authorid]->submissiongradeover = $this->real_grade($submission->gradeover);
29dc43e7 1943 $grades[$submission->authorid]->submissiongradeoverby = $submission->gradeoverby;
232175e4 1944 $grades[$submission->authorid]->submissionpublished = $submission->published;
29dc43e7
DM
1945 }
1946 unset($submissions);
1947 unset($submission);
1948
1949 foreach($reviewers as $reviewer) {
7a789aa8 1950 $info = new stdclass();
29dc43e7
DM
1951 $info->userid = $reviewer->reviewerid;
1952 $info->assessmentid = $reviewer->assessmentid;
1953 $info->submissionid = $reviewer->submissionid;
b4857acb
DM
1954 $info->grade = $this->real_grade($reviewer->grade);
1955 $info->gradinggrade = $this->real_grading_grade($reviewer->gradinggrade);
1956 $info->gradinggradeover = $this->real_grading_grade($reviewer->gradinggradeover);
581878b8 1957 $info->weight = $reviewer->weight;
29dc43e7
DM
1958 $grades[$reviewer->authorid]->reviewedby[$reviewer->reviewerid] = $info;
1959 }
1960 unset($reviewers);
1961 unset($reviewer);
1962
1963 foreach($reviewees as $reviewee) {
7a789aa8 1964 $info = new stdclass();
29dc43e7
DM
1965 $info->userid = $reviewee->authorid;
1966 $info->assessmentid = $reviewee->assessmentid;
1967 $info->submissionid = $reviewee->submissionid;
b4857acb
DM
1968 $info->grade = $this->real_grade($reviewee->grade);
1969 $info->gradinggrade = $this->real_grading_grade($reviewee->gradinggrade);
1970 $info->gradinggradeover = $this->real_grading_grade($reviewee->gradinggradeover);
581878b8 1971 $info->weight = $reviewee->weight;
29dc43e7
DM
1972 $grades[$reviewee->reviewerid]->reviewerof[$reviewee->authorid] = $info;
1973 }
1974 unset($reviewees);
1975 unset($reviewee);
1976
b4857acb
DM
1977 foreach ($grades as $grade) {
1978 $grade->gradinggrade = $this->real_grading_grade($grade->gradinggrade);
b4857acb
DM
1979 }
1980
7a789aa8 1981 $data = new stdclass();
29dc43e7
DM
1982 $data->grades = $grades;
1983 $data->userinfo = $userinfo;
1984 $data->totalcount = $numofparticipants;
b4857acb
DM
1985 $data->maxgrade = $this->real_grade(100);
1986 $data->maxgradinggrade = $this->real_grading_grade(100);
29dc43e7
DM
1987 return $data;
1988 }
1989
29dc43e7 1990 /**
b4857acb 1991 * Calculates the real value of a grade
29dc43e7 1992 *
b4857acb
DM
1993 * @param float $value percentual value from 0 to 100
1994 * @param float $max the maximal grade
1995 * @return string
1996 */
1997 public function real_grade_value($value, $max) {
1998 $localized = true;
557a1100 1999 if (is_null($value) or $value === '') {
b4857acb
DM
2000 return null;
2001 } elseif ($max == 0) {
2002 return 0;
2003 } else {
2004 return format_float($max * $value / 100, $this->gradedecimals, $localized);
2005 }
2006 }
2007
e554671d
DM
2008 /**
2009 * Calculates the raw (percentual) value from a real grade
2010 *
2011 * This is used in cases when a user wants to give a grade such as 12 of 20 and we need to save
2012 * this value in a raw percentual form into DB
2013 * @param float $value given grade
2014 * @param float $max the maximal grade
2015 * @return float suitable to be stored as numeric(10,5)
2016 */
2017 public function raw_grade_value($value, $max) {
557a1100 2018 if (is_null($value) or $value === '') {
e554671d
DM
2019 return null;
2020 }
2021 if ($max == 0 or $value < 0) {
2022 return 0;
2023 }
2024 $p = $value / $max * 100;
2025 if ($p > 100) {
2026 return $max;
2027 }
2028 return grade_floatval($p);
2029 }
2030
b4857acb
DM
2031 /**
2032 * Calculates the real value of grade for submission
2033 *
2034 * @param float $value percentual value from 0 to 100
2035 * @return string
2036 */
2037 public function real_grade($value) {
2038 return $this->real_grade_value($value, $this->grade);
2039 }
2040
2041 /**
2042 * Calculates the real value of grade for assessment
2043 *
2044 * @param float $value percentual value from 0 to 100
2045 * @return string
2046 */
2047 public function real_grading_grade($value) {
2048 return $this->real_grade_value($value, $this->gradinggrade);
29dc43e7
DM
2049 }
2050
e706b9c3
DM
2051 /**
2052 * Sets the given grades and received grading grades to null
2053 *
2054 * This does not clear the information about how the peers filled the assessment forms, but
2055 * clears the calculated grades in workshop_assessments. Therefore reviewers have to re-assess
2056 * the allocated submissions.
2057 *
2058 * @return void
2059 */
2060 public function clear_assessments() {
2061 global $DB;
2062
2063 $submissions = $this->get_submissions();
2064 if (empty($submissions)) {
2065 // no money, no love
2066 return;
2067 }
2068 $submissions = array_keys($submissions);
2069 list($sql, $params) = $DB->get_in_or_equal($submissions, SQL_PARAMS_NAMED);
2070 $sql = "submissionid $sql";
2071 $DB->set_field_select('workshop_assessments', 'grade', null, $sql, $params);
2072 $DB->set_field_select('workshop_assessments', 'gradinggrade', null, $sql, $params);
2073 }
2074
32c78bc3
DM
2075 /**
2076 * Sets the grades for submission to null
2077 *
2078 * @param null|int|array $restrict If null, update all authors, otherwise update just grades for the given author(s)
2079 * @return void
2080 */
2081 public function clear_submission_grades($restrict=null) {
2082 global $DB;
2083
2084 $sql = "workshopid = :workshopid AND example = 0";
2085 $params = array('workshopid' => $this->id);
2086
2087 if (is_null($restrict)) {
2088 // update all users - no more conditions
2089 } elseif (!empty($restrict)) {
2090 list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
2091 $sql .= " AND authorid $usql";
2092 $params = array_merge($params, $uparams);
2093 } else {
2094 throw new coding_exception('Empty value is not a valid parameter here');
2095 }
2096
2097 $DB->set_field_select('workshop_submissions', 'grade', null, $sql, $params);
2098 }
2099
89c1aa97 2100 /**
e9a90e69 2101 * Calculates grades for submission for the given participant(s) and updates it in the database
89c1aa97
DM
2102 *
2103 * @param null|int|array $restrict If null, update all authors, otherwise update just grades for the given author(s)
2104 * @return void
2105 */
8a1ba8ac 2106 public function aggregate_submission_grades($restrict=null) {
89c1aa97
DM
2107 global $DB;
2108
2109 // fetch a recordset with all assessments to process
1696f36c 2110 $sql = 'SELECT s.id AS submissionid, s.grade AS submissiongrade,
89c1aa97
DM
2111 a.weight, a.grade
2112 FROM {workshop_submissions} s
2113 LEFT JOIN {workshop_assessments} a ON (a.submissionid = s.id)
2114 WHERE s.example=0 AND s.workshopid=:workshopid'; // to be cont.
2115 $params = array('workshopid' => $this->id);
2116
2117 if (is_null($restrict)) {
2118 // update all users - no more conditions
2119 } elseif (!empty($restrict)) {
2120 list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
2121 $sql .= " AND s.authorid $usql";
2122 $params = array_merge($params, $uparams);
2123 } else {
2124 throw new coding_exception('Empty value is not a valid parameter here');
2125 }
2126
2127 $sql .= ' ORDER BY s.id'; // this is important for bulk processing
89c1aa97 2128
e9a90e69
DM
2129 $rs = $DB->get_recordset_sql($sql, $params);
2130 $batch = array(); // will contain a set of all assessments of a single submission
2131 $previous = null; // a previous record in the recordset
2132
89c1aa97
DM
2133 foreach ($rs as $current) {
2134 if (is_null($previous)) {
2135 // we are processing the very first record in the recordset
2136 $previous = $current;
89c1aa97 2137 }
e9a90e69 2138 if ($current->submissionid == $previous->submissionid) {
89c1aa97 2139 // we are still processing the current submission
e9a90e69
DM
2140 $batch[] = $current;
2141 } else {
2142 // process all the assessments of a sigle submission
2143 $this->aggregate_submission_grades_process($batch);
2144 // and then start to process another submission
2145 $batch = array($current);
2146 $previous = $current;
89c1aa97
DM
2147 }
2148 }
e9a90e69
DM
2149 // do not forget to process the last batch!
2150 $this->aggregate_submission_grades_process($batch);
89c1aa97
DM
2151 $rs->close();
2152 }
2153
32c78bc3
DM
2154 /**
2155 * Sets the aggregated grades for assessment to null
2156 *
2157 * @param null|int|array $restrict If null, update all reviewers, otherwise update just grades for the given reviewer(s)
2158 * @return void
2159 */
2160 public function clear_grading_grades($restrict=null) {
2161 global $DB;
2162
2163 $sql = "workshopid = :workshopid";
2164 $params = array('workshopid' => $this->id);
2165
2166 if (is_null($restrict)) {
2167 // update all users - no more conditions
2168 } elseif (!empty($restrict)) {
2169 list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
2170 $sql .= " AND userid $usql";
2171 $params = array_merge($params, $uparams);
2172 } else {
2173 throw new coding_exception('Empty value is not a valid parameter here');
2174 }
2175
2176 $DB->set_field_select('workshop_aggregations', 'gradinggrade', null, $sql, $params);
2177 }
2178
89c1aa97
DM
2179 /**
2180 * Calculates grades for assessment for the given participant(s)
2181 *
39411930
DM
2182 * Grade for assessment is calculated as a simple mean of all grading grades calculated by the grading evaluator.
2183 * The assessment weight is not taken into account here.
89c1aa97
DM
2184 *
2185 * @param null|int|array $restrict If null, update all reviewers, otherwise update just grades for the given reviewer(s)
2186 * @return void
2187 */
8a1ba8ac 2188 public function aggregate_grading_grades($restrict=null) {
89c1aa97
DM
2189 global $DB;
2190
39411930
DM
2191 // fetch a recordset with all assessments to process
2192 $sql = 'SELECT a.reviewerid, a.gradinggrade, a.gradinggradeover,
2193 ag.id AS aggregationid, ag.gradinggrade AS aggregatedgrade
2194 FROM {workshop_assessments} a
2195 INNER JOIN {workshop_submissions} s ON (a.submissionid = s.id)
2196 LEFT JOIN {workshop_aggregations} ag ON (ag.userid = a.reviewerid AND ag.workshopid = s.workshopid)
2197 WHERE s.example=0 AND s.workshopid=:workshopid'; // to be cont.
2198 $params = array('workshopid' => $this->id);
2199
2200 if (is_null($restrict)) {
2201 // update all users - no more conditions
2202 } elseif (!empty($restrict)) {
2203 list($usql, $uparams) = $DB->get_in_or_equal($restrict, SQL_PARAMS_NAMED);
2204 $sql .= " AND a.reviewerid $usql";
2205 $params = array_merge($params, $uparams);
2206 } else {
2207 throw new coding_exception('Empty value is not a valid parameter here');
2208 }
2209
2210 $sql .= ' ORDER BY a.reviewerid'; // this is important for bulk processing
2211
2212 $rs = $DB->get_recordset_sql($sql, $params);
2213 $batch = array(); // will contain a set of all assessments of a single submission
2214 $previous = null; // a previous record in the recordset
2215
2216 foreach ($rs as $current) {
2217 if (is_null($previous)) {
2218 // we are processing the very first record in the recordset
2219 $previous = $current;
2220 }
2221 if ($current->reviewerid == $previous->reviewerid) {
2222 // we are still processing the current reviewer
2223 $batch[] = $current;
2224 } else {
2225 // process all the assessments of a sigle submission
2226 $this->aggregate_grading_grades_process($batch);
2227 // and then start to process another reviewer
2228 $batch = array($current);
2229 $previous = $current;
2230 }
2231 }
2232 // do not forget to process the last batch!
2233 $this->aggregate_grading_grades_process($batch);
2234 $rs->close();
89c1aa97
DM
2235 }
2236
77f43e7d 2237 /**
f6e8b318 2238 * Returns the mform the teachers use to put a feedback for the reviewer
77f43e7d 2239 *
c6b784f0 2240 * @param moodle_url $actionurl
5924db72 2241 * @param stdClass $assessment
c6b784f0 2242 * @param array $options editable, editableweight, overridablegradinggrade
f6e8b318 2243 * @return workshop_feedbackreviewer_form
77f43e7d 2244 */
c6b784f0 2245 public function get_feedbackreviewer_form(moodle_url $actionurl, stdclass $assessment, $options=array()) {
77f43e7d
DM
2246 global $CFG;
2247 require_once(dirname(__FILE__) . '/feedbackreviewer_form.php');
2248
7a789aa8 2249 $current = new stdclass();
e554671d 2250 $current->asid = $assessment->id;
c6b784f0 2251 $current->weight = $assessment->weight;
e554671d
DM
2252 $current->gradinggrade = $this->real_grading_grade($assessment->gradinggrade);
2253 $current->gradinggradeover = $this->real_grading_grade($assessment->gradinggradeover);
2254 $current->feedbackreviewer = $assessment->feedbackreviewer;
2255 $current->feedbackreviewerformat = $assessment->feedbackreviewerformat;
2256 if (is_null($current->gradinggrade)) {
2257 $current->gradinggrade = get_string('nullgrade', 'workshop');
2258 }
c6b784f0
DM
2259 if (!isset($options['editable'])) {
2260 $editable = true; // by default
2261 } else {
2262 $editable = (bool)$options['editable'];
2263 }
e554671d
DM
2264
2265 // prepare wysiwyg editor
2266 $current = file_prepare_standard_editor($current, 'feedbackreviewer', array());
2267
77f43e7d 2268 return new workshop_feedbackreviewer_form($actionurl,
c6b784f0 2269 array('workshop' => $this, 'current' => $current, 'editoropts' => array(), 'options' => $options),
77f43e7d
DM
2270 'post', '', null, $editable);
2271 }
2272
67cd00ba
DM
2273 /**
2274 * Returns the mform the teachers use to put a feedback for the author on their submission
2275 *
c6b784f0 2276 * @param moodle_url $actionurl
5924db72 2277 * @param stdClass $submission
c6b784f0 2278 * @param array $options editable
67cd00ba
DM
2279 * @return workshop_feedbackauthor_form
2280 */
c6b784f0 2281 public function get_feedbackauthor_form(moodle_url $actionurl, stdclass $submission, $options=array()) {
67cd00ba
DM
2282 global $CFG;
2283 require_once(dirname(__FILE__) . '/feedbackauthor_form.php');
2284
7a789aa8 2285 $current = new stdclass();
67cd00ba 2286 $current->submissionid = $submission->id;
232175e4 2287 $current->published = $submission->published;
557a1100
DM
2288 $current->grade = $this->real_grade($submission->grade);
2289 $current->gradeover = $this->real_grade($submission->gradeover);
2290 $current->feedbackauthor = $submission->feedbackauthor;
2291 $current->feedbackauthorformat = $submission->feedbackauthorformat;
67cd00ba
DM
2292 if (is_null($current->grade)) {
2293 $current->grade = get_string('nullgrade', 'workshop');
2294 }
c6b784f0
DM
2295 if (!isset($options['editable'])) {
2296 $editable = true; // by default
2297 } else {
2298 $editable = (bool)$options['editable'];
2299 }
67cd00ba
DM
2300
2301 // prepare wysiwyg editor
2302 $current = file_prepare_standard_editor($current, 'feedbackauthor', array());
2303
2304 return new workshop_feedbackauthor_form($actionurl,
232175e4 2305 array('workshop' => $this, 'current' => $current, 'editoropts' => array(), 'options' => $options),
67cd00ba
DM
2306 'post', '', null, $editable);
2307 }
2308
3cb4ce45
DM
2309 /**
2310 * Returns the information about the user's grades as they are stored in the gradebook
2311 *
2312 * The submission grade is returned for users with the capability mod/workshop:submit and the
2313 * assessment grade is returned for users with the capability mod/workshop:peerassess. Unless the
2314 * user has the capability to view hidden grades, grades must be visible to be returned. Null
2315 * grades are not returned. If none grade is to be returned, this method returns false.
2316 *
2317 * @param int $userid the user's id
2318 * @return workshop_final_grades|false
2319 */
2320 public function get_gradebook_grades($userid) {
2321 global $CFG;
2322 require_once($CFG->libdir.'/gradelib.php');
2323
2324 if (empty($userid)) {
2325 throw new coding_exception('User id expected, empty value given.');
2326 }
2327
2328 // Read data via the Gradebook API
2329 $gradebook = grade_get_grades($this->course->id, 'mod', 'workshop', $this->id, $userid);
2330
2331 $grades = new workshop_final_grades();
2332
2333 if (has_capability('mod/workshop:submit', $this->context, $userid)) {
2334 if (!empty($gradebook->items[0]->grades)) {
2335 $submissiongrade = reset($gradebook->items[0]->grades);
2336 if (!is_null($submissiongrade->grade)) {
2337 if (!$submissiongrade->hidden or has_capability('moodle/grade:viewhidden', $this->context, $userid)) {
2338 $grades->submissiongrade = $submissiongrade;
2339 }
2340 }
2341 }
2342 }
2343
d34ea7dc 2344 if (has_capability('mod/workshop:peerassess', $this->context, $userid)) {
3cb4ce45
DM
2345 if (!empty($gradebook->items[1]->grades)) {
2346 $assessmentgrade = reset($gradebook->items[1]->grades);
2347 if (!is_null($assessmentgrade->grade)) {
2348 if (!$assessmentgrade->hidden or has_capability('moodle/grade:viewhidden', $this->context, $userid)) {
2349 $grades->assessmentgrade = $assessmentgrade;
2350 }
2351 }
2352 }
2353 }
2354
2355 if (!is_null($grades->submissiongrade) or !is_null($grades->assessmentgrade)) {
2356 return $grades;
2357 }
2358
2359 return false;
2360 }
2361
77d746a2
DM
2362 /**
2363 * Return the editor options for the overall feedback for the author.
2364 *
2365 * @return array
2366 */
2367 public function overall_feedback_content_options() {
2368 return array(
2369 'subdirs' => 0,
2370 'maxbytes' => $this->overallfeedbackmaxbytes,
2371 'maxfiles' => $this->overallfeedbackfiles,
2372 'changeformat' => 1,
2373 'context' => $this->context,
2374 );
2375 }
2376
2377 /**
2378 * Return the filemanager options for the overall feedback for the author.
2379 *
2380 * @return array
2381 */
2382 public function overall_feedback_attachment_options() {
2383 return array(
2384 'subdirs' => 1,
2385 'maxbytes' => $this->overallfeedbackmaxbytes,
2386 'maxfiles' => $this->overallfeedbackfiles,
2387 'return_types' => FILE_INTERNAL,
2388 );
2389 }
2390
aa40adbf
DM
2391 ////////////////////////////////////////////////////////////////////////////////
2392 // Internal methods (implementation details) //
2393 ////////////////////////////////////////////////////////////////////////////////
6516b9e9 2394
e9a90e69
DM
2395 /**
2396 * Given an array of all assessments of a single submission, calculates the final grade for this submission
2397 *
2398 * This calculates the weighted mean of the passed assessment grades. If, however, the submission grade
2399 * was overridden by a teacher, the gradeover value is returned and the rest of grades are ignored.
2400 *
7a789aa8 2401 * @param array $assessments of stdclass(->submissionid ->submissiongrade ->gradeover ->weight ->grade)
1fed6ce3 2402 * @return void
e9a90e69
DM
2403 */
2404 protected function aggregate_submission_grades_process(array $assessments) {
2405 global $DB;
2406
2407 $submissionid = null; // the id of the submission being processed
2408 $current = null; // the grade currently saved in database
2409 $finalgrade = null; // the new grade to be calculated
2410 $sumgrades = 0;
2411 $sumweights = 0;
2412
2413 foreach ($assessments as $assessment) {
2414 if (is_null($submissionid)) {
2415 // the id is the same in all records, fetch it during the first loop cycle
2416 $submissionid = $assessment->submissionid;
2417 }
2418 if (is_null($current)) {
2419 // the currently saved grade is the same in all records, fetch it during the first loop cycle
2420 $current = $assessment->submissiongrade;
2421 }
e9a90e69
DM
2422 if (is_null($assessment->grade)) {
2423 // this was not assessed yet
2424 continue;
2425 }
2426 if ($assessment->weight == 0) {
2427 // this does not influence the calculation
2428 continue;
2429 }
2430 $sumgrades += $assessment->grade * $assessment->weight;
2431 $sumweights += $assessment->weight;
2432 }
2433 if ($sumweights > 0 and is_null($finalgrade)) {
2434 $finalgrade = grade_floatval($sumgrades / $sumweights);
2435 }
2436 // check if the new final grade differs from the one stored in the database
2437 if (grade_floats_different($finalgrade, $current)) {
2438 // we need to save new calculation into the database
7a789aa8 2439 $record = new stdclass();
10bc4bce
DM
2440 $record->id = $submissionid;
2441 $record->grade = $finalgrade;
2442 $record->timegraded = time();
2443 $DB->update_record('workshop_submissions', $record);
e9a90e69
DM
2444 }
2445 }
2446
39411930
DM
2447 /**
2448 * Given an array of all assessments done by a single reviewer, calculates the final grading grade
2449 *
2450 * This calculates the simple mean of the passed grading grades. If, however, the grading grade
2451 * was overridden by a teacher, the gradinggradeover value is returned and the rest of grades are ignored.
2452 *
7a789aa8 2453 * @param array $assessments of stdclass(->reviewerid ->gradinggrade ->gradinggradeover ->aggregationid ->aggregatedgrade)
a1373126 2454 * @param null|int $timegraded explicit timestamp of the aggregation, defaults to the current time
1fed6ce3 2455 * @return void
39411930 2456 */
a1373126 2457 protected function aggregate_grading_grades_process(array $assessments, $timegraded = null) {
39411930
DM
2458 global $DB;
2459
2460 $reviewerid = null; // the id of the reviewer being processed
2461 $current = null; // the gradinggrade currently saved in database
2462 $finalgrade = null; // the new grade to be calculated
2463 $agid = null; // aggregation id
2464 $sumgrades = 0;
2465 $count = 0;
2466
a1373126
DM
2467 if (is_null($timegraded)) {
2468 $timegraded = time();
2469 }
2470
39411930
DM
2471 foreach ($assessments as $assessment) {
2472 if (is_null($reviewerid)) {
2473 // the id is the same in all records, fetch it during the first loop cycle
2474 $reviewerid = $assessment->reviewerid;
2475 }
2476 if (is_null($agid)) {
2477 // the id is the same in all records, fetch it during the first loop cycle
2478 $agid = $assessment->aggregationid;
2479 }
2480 if (is_null($current)) {
2481 // the currently saved grade is the same in all records, fetch it during the first loop cycle
2482 $current = $assessment->aggregatedgrade;
2483 }
2484 if (!is_null($assessment->gradinggradeover)) {
5924db72 2485 // the grading grade for this assessment is overridden by a teacher
39411930
DM
2486 $sumgrades += $assessment->gradinggradeover;
2487 $count++;
2488 } else {
2489 if (!is_null($assessment->gradinggrade)) {
2490 $sumgrades += $assessment->gradinggrade;
2491 $count++;
2492 }
2493 }
2494 }
2495 if ($count > 0) {
2496 $finalgrade = grade_floatval($sumgrades / $count);
2497 }
1f013271
AG
2498
2499 // Event information.
2500 $params = array(
2501 'context' => $this->context,
2502 'courseid' => $this->course->id,
2503 'relateduserid' => $reviewerid
2504 );
2505
39411930
DM
2506 // check if the new final grade differs from the one stored in the database
2507 if (grade_floats_different($finalgrade, $current)) {
1f013271
AG
2508 $params['other'] = array(
2509 'currentgrade' => $current,
2510 'finalgrade' => $finalgrade
2511 );
2512
39411930
DM
2513 // we need to save new calculation into the database
2514 if (is_null($agid)) {
2515 // no aggregation record yet
7a789aa8 2516 $record = new stdclass();
39411930
DM
2517 $record->workshopid = $this->id;
2518 $record->userid = $reviewerid;
2519 $record->gradinggrade = $finalgrade;
a1373126 2520 $record->timegraded = $timegraded;
1f013271
AG
2521 $record->id = $DB->insert_record('workshop_aggregations', $record);
2522 $params['objectid'] = $record->id;
2523 $event = \mod_workshop\event\assessment_evaluated::create($params);
2524 $event->trigger();
39411930 2525 } else {
7a789aa8 2526 $record = new stdclass();
10bc4bce
DM
2527 $record->id = $agid;
2528 $record->gradinggrade = $finalgrade;
a1373126 2529 $record->timegraded = $timegraded;
10bc4bce 2530 $DB->update_record('workshop_aggregations', $record);
1f013271
AG
2531 $params['objectid'] = $agid;
2532 $event = \mod_workshop\event\assessment_reevaluated::create($params);
2533 $event->trigger();
39411930
DM
2534 }
2535 }
2536 }
2537
6516b9e9 2538 /**
21f58287 2539 * Returns SQL to fetch all enrolled users with the given capability in the current workshop
aa40adbf 2540 *
9691e2b1 2541 * The returned array consists of string $sql and the $params array. Note that the $sql can be
45ab2d9a 2542 * empty if a grouping is selected and it has no groups.
2543 *
2544 * The list is automatically restricted according to any availability restrictions
2545 * that apply to user lists (e.g. group, grouping restrictions).
9691e2b1 2546 *
21f58287
DM
2547 * @param string $capability the name of the capability
2548 * @param bool $musthavesubmission ff true, return only users who have already submitted
2549 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2550 * @return array of (string)sql, (array)params
6516b9e9 2551 */
21f58287 2552 protected function get_users_with_capability_sql($capability, $musthavesubmission, $groupid) {
8741ebb0 2553 global $CFG;
9691e2b1
DM
2554 /** @var int static counter used to generate unique parameter holders */
2555 static $inc = 0;
2556 $inc++;
2557
45ab2d9a 2558 // If the caller requests all groups and we are using a selected grouping,
2559 // recursively call this function for each group in the grouping (this is
2560 // needed because get_enrolled_sql only supports a single group).
2561 if (empty($groupid) and $this->cm->groupingid) {
9691e2b1
DM
2562 $groupingid = $this->cm->groupingid;
2563 $groupinggroupids = array_keys(groups_get_all_groups($this->cm->course, 0, $this->cm->groupingid, 'g.id'));
2564 $sql = array();
2565 $params = array();
2566 foreach ($groupinggroupids as $groupinggroupid) {
2567 if ($groupinggroupid > 0) { // just in case in order not to fall into the endless loop
2568 list($gsql, $gparams) = $this->get_users_with_capability_sql($capability, $musthavesubmission, $groupinggroupid);
2569 $sql[] = $gsql;
2570 $params = array_merge($params, $gparams);
2571 }
2572 }
2573 $sql = implode(PHP_EOL." UNION ".PHP_EOL, $sql);
2574 return array($sql, $params);
2575 }
aa40adbf 2576
21f58287
DM
2577 list($esql, $params) = get_enrolled_sql($this->context, $capability, $groupid, true);
2578
2579 $userfields = user_picture::fields('u');
2580
2581 $sql = "SELECT $userfields
2582 FROM {user} u
9691e2b1 2583 JOIN ($esql) je ON (je.id = u.id AND u.deleted = 0) ";
21f58287
DM
2584
2585 if ($musthavesubmission) {
9691e2b1
DM
2586 $sql .= " JOIN {workshop_submissions} ws ON (ws.authorid = u.id AND ws.example = 0 AND ws.workshopid = :workshopid{$inc}) ";
2587 $params['workshopid'.$inc] = $this->id;
aa40adbf
DM
2588 }
2589
45ab2d9a 2590 // If the activity is restricted so that only certain users should appear
2591 // in user lists, integrate this into the same SQL.
2592 $info = new \core_availability\info_module($this->cm);
2593 list ($listsql, $listparams) = $info->get_user_list_sql(false);
2594 if ($listsql) {
2595 $sql .= " JOIN ($listsql) restricted ON restricted.id = u.id ";
2596 $params = array_merge($params, $listparams);
2597 }
2598
21f58287 2599 return array($sql, $params);
6516b9e9
DM
2600 }
2601
8741ebb0
DM
2602 /**
2603 * Returns SQL statement that can be used to fetch all actively enrolled participants in the workshop
2604 *
2605 * @param bool $musthavesubmission if true, return only users who have already submitted
2606 * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2607 * @return array of (string)sql, (array)params
2608 */
2609 protected function get_participants_sql($musthavesubmission=false, $groupid=0) {
2610
2611 list($sql1, $params1) = $this->get_users_with_capability_sql('mod/workshop:submit', $musthavesubmission, $groupid);
2612 list($sql2, $params2) = $this->get_users_with_capability_sql('mod/workshop:peerassess', $musthavesubmission, $groupid);
2613
2614 if (empty($sql1) or empty($sql2)) {
2615 if (empty($sql1) and empty($sql2)) {
2616 return array('', array());
2617 } else if (empty($sql1)) {
2618 $sql = $sql2;
2619 $params = $params2;
2620 } else {
2621 $sql = $sql1;
2622 $params = $params1;
2623 }
2624 } else {
2625 $sql = $sql1.PHP_EOL." UNION ".PHP_EOL.$sql2;
2626 $params = array_merge($params1, $params2);
2627 }
2628
2629 return array($sql, $params);
2630 }
2631
aa40adbf
DM
2632 /**
2633 * @return array of available workshop phases
2634 */
365c2cc2 2635 protected function available_phases_list() {
aa40adbf
DM
2636 return array(
2637 self::PHASE_SETUP => true,
2638 self::PHASE_SUBMISSION => true,
2639 self::PHASE_ASSESSMENT => true,
2640 self::PHASE_EVALUATION => true,
2641 self::PHASE_CLOSED => true,
2642 );
2643 }
2644
5450f7b6
DM
2645 /**
2646 * Converts absolute URL to relative URL needed by {@see add_to_log()}
2647 *
2648 * @param moodle_url $url absolute URL
2649 * @return string
2650 */
2651 protected function log_convert_url(moodle_url $fullurl) {
2652 static $baseurl;
2653
2654 if (!isset($baseurl)) {
2655 $baseurl = new moodle_url('/mod/workshop/');
2656 $baseurl = $baseurl->out();
2657 }
2658
2659 return substr($fullurl->out(), strlen($baseurl));
2660 }
6f760e01
MH
2661
2662 /**
2663 * Resets this activity's content
2664 * @param array The reset data object.
2665 * @return bool True if the reset was successful, false if there was an error
2666 */
2667 public function reset_userdata($data) {
2668 $componentstr = get_string('modulenameplural', 'workshop');
2669 $status = array();
2670 $this->reset_submissions();
2671 $delaggregations = $DB->delete_records('workshop_aggregations', array('workshopid' => $this->id));
2672 $this->reset_allocators();
2673 $this->reset_evaluators();
2674 $this->reset_strategies();
2675
2676 $events = $DB->get_records('event', array('modulename' => 'workshop', 'instance' => $this->id));\r
2677 foreach ($events as $event) {
2678 $event = calendar_event::load($event);
2679 $event->delete();\r
2680 }
2681
2682 // Set the phase.
2683 // $DB->set_field('workshop', 'phase', 0, array('id' => $workshop->id)); // Left in to give option to switch back after discussion.
2684 $this->switch_phase(self::PHASE_SETUP); // Use the API but we may not want to raise events about this....
2685
2686 $status[] = array('component' => $componentstr, 'item' => get_string('resetworkshopall', 'workshop'), 'error' => false);
2687 return $status;
2688 }
2689
2690 /**
2691 * Remove user content, including grades
2692 */
2693 protected function reset_submissions() {
2694 $submissions = $this->get_submissions();\r
2695 foreach ($submissions as $submission) {\r
2696 $this->delete_submission($submission);\r
2697 }
2698 // Clean up submission files.
2699 $fs = get_file_storage();
2700 $files = $fs->get_area_files($this->context, 'mod_workshop', 'submission_attachment', false);
2701 $numberfilestodelete = count($files);
2702 $numfilesdeleted = 0;
2703 foreach ($files as $file) {
2704 try {
2705 $file->delete();
2706 $numfilesdeleted += 1;
2707 }
2708 catch (Exception $exception) {
2709 // The delete can fail if necessary it just leaves an orphan in the DB. The record its attached to will have rady been removed.
2710 }
2711 }
2712 }
2713
2714 protected function reset_allocators() {
2715 $allocators = core_component::get_plugin_list('workshopallocation');
2716 foreach ($allocators as $allocator => $path) {\r
2717 require_once($path.'/lib.php');\r
2718 $classname = 'workshop_'.$allocator.'_allocator';\r
2719 call_user_func($classname.'::reset_user_data', $this->id);\r
2720 }
2721 }
2722
2723 protected function reset_strategies() {
2724 $evaluators = core_component::get_plugin_list('workshopeval');
2725 foreach ($evaluators as $evaluator => $path) {\r
2726 require_once($path.'/lib.php');\r
2727 $classname = 'workshop_'.$evaluator.'_evaluation';\r
2728 call_user_func($classname.'::reset_user_data', $this->id);\r
2729 }
2730 }
2731
2732 protected function reset_evaluators() {
2733 $evaluators = core_component::get_plugin_list('workshopeval');\r
2734 foreach ($evaluators as $evaluator => $path) {\r
2735 require_once($path.'/lib.php');\r
2736 $classname = 'workshop_'.$evaluator.'_evaluation';\r
2737 call_user_func($classname.'::reset_user_data', $this->id);\r
2738 }
2739 }
66c9894d 2740}
55fc1e59 2741
81b22887
DM
2742////////////////////////////////////////////////////////////////////////////////
2743// Renderable components
2744////////////////////////////////////////////////////////////////////////////////
2745
55fc1e59
DM
2746/**
2747 * Represents the user planner tool
2748 *
2749 * Planner contains list of phases. Each phase contains list of tasks. Task is a simple object with
2750 * title, link and completed (true/false/null logic).
2751 */
2752class workshop_user_plan implements renderable {
2753
cff28ef0
DM
2754 /** @var int id of the user this plan is for */
2755 public $userid;
55fc1e59
DM
2756 /** @var workshop */
2757 public $workshop;
2758 /** @var array of (stdclass)tasks */
2759 public $phases = array();
cff28ef0
DM
2760 /** @var null|array of example submissions to be assessed by the planner owner */
2761 protected $examples = null;
55fc1e59
DM
2762
2763 /**
2764 * Prepare an individual workshop plan for the given user.
2765 *
2766 * @param workshop $workshop instance
2767 * @param int $userid whom the plan is prepared for
2768 */
2769 public function __construct(workshop $workshop, $userid) {
2770 global $DB;
2771
2772 $this->workshop = $workshop;
cff28ef0 2773 $this->userid = $userid;
55fc1e59 2774
5bab64a3
DM
2775 //---------------------------------------------------------
2776 // * SETUP | submission | assessment | evaluation | closed
2777 //---------------------------------------------------------
55fc1e59
DM
2778 $phase = new stdclass();
2779 $phase->title = get_string('phasesetup', 'workshop');
2780 $phase->tasks = array();
cff28ef0 2781 if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
55fc1e59
DM
2782 $task = new stdclass();
2783 $task->title = get_string('taskintro', 'workshop');
cff28ef0 2784 $task->link = $workshop->updatemod_url();
bfbca63d 2785 $task->completed = !(trim($workshop->intro) == '');
55fc1e59
DM
2786 $phase->tasks['intro'] = $task;
2787 }
cff28ef0 2788 if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
55fc1e59
DM
2789 $task = new stdclass();
2790 $task->title = get_string('taskinstructauthors', 'workshop');
cff28ef0 2791 $task->link = $workshop->updatemod_url();
bfbca63d 2792 $task->completed = !(trim($workshop->instructauthors) == '');
55fc1e59
DM
2793 $phase->tasks['instructauthors'] = $task;
2794 }
cff28ef0 2795 if (has_capability('mod/workshop:editdimensions', $workshop->context, $userid)) {
55fc1e59
DM
2796 $task = new stdclass();
2797 $task->title = get_string('editassessmentform', 'workshop');
cff28ef0
DM
2798 $task->link = $workshop->editform_url();
2799 if ($workshop->grading_strategy_instance()->form_ready()) {
55fc1e59 2800 $task->completed = true;
cff28ef0 2801 } elseif ($workshop->phase > workshop::PHASE_SETUP) {
55fc1e59
DM
2802 $task->completed = false;
2803 }
2804 $phase->tasks['editform'] = $task;
2805 }
cff28ef0 2806 if ($workshop->useexamples and has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
55fc1e59
DM
2807 $task = new stdclass();
2808 $task->title = get_string('prepareexamples', 'workshop');
cff28ef0 2809 if ($DB->count_records('workshop_submissions', array('example' => 1, 'workshopid' => $workshop->id)) > 0) {
55fc1e59 2810 $task->completed = true;
cff28ef0 2811 } elseif ($workshop->phase > workshop::PHASE_SETUP) {
55fc1e59
DM
2812 $task->completed = false;
2813 }
2814 $phase->tasks['prepareexamples'] = $task;
2815 }
cff28ef0 2816 if (empty($phase->tasks) and $workshop->phase == workshop::PHASE_SETUP) {
55fc1e59
DM
2817 // if we are in the setup phase and there is no task (typical for students), let us
2818 // display some explanation what is going on
2819 $task = new stdclass();
2820 $task->title = get_string('undersetup', 'workshop');
2821 $task->completed = 'info';
2822 $phase->tasks['setupinfo'] = $task;
2823 }
2824 $this->phases[workshop::PHASE_SETUP] = $phase;
2825
5bab64a3
DM
2826 //---------------------------------------------------------
2827 // setup | * SUBMISSION | assessment | evaluation | closed
2828 //---------------------------------------------------------
55fc1e59
DM
2829 $phase = new stdclass();
2830 $phase->title = get_string('phasesubmission', 'workshop');
2831 $phase->tasks = array();
d34ea7dc 2832 if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
55fc1e59
DM
2833 $task = new stdclass();
2834 $task->title = get_string('taskinstructreviewers', 'workshop');
cff28ef0 2835 $task->link = $workshop->updatemod_url();
bfbca63d 2836 if (trim($workshop->instructreviewers)) {
55fc1e59 2837 $task->completed = true;
cff28ef0 2838 } elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
55fc1e59
DM
2839 $task->completed = false;
2840 }
2841 $phase->tasks['instructreviewers'] = $task;
2842 }
cff28ef0 2843 if ($workshop->useexamples and $workshop->examplesmode == workshop::EXAMPLES_BEFORE_SUBMISSION
514d8c22 2844 and has_capability('mod/workshop:submit', $workshop->context, $userid, false)
cff28ef0 2845 and !has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
514d8c22
DM
2846 $task = new stdclass();
2847 $task->title = get_string('exampleassesstask', 'workshop');
cff28ef0 2848 $examples = $this->get_examples();
514d8c22
DM
2849 $a = new stdclass();
2850 $a->expected = count($examples);
2851 $a->assessed = 0;
2852 foreach ($examples as $exampleid => $example) {
2853 if (!is_null($example->grade)) {
2854 $a->assessed++;
2855 }
2856 }
2857 $task->details = get_string('exampleassesstaskdetails', 'workshop', $a);
2858 if ($a->assessed == $a->expected) {
2859 $task->completed = true;
cff28ef0 2860 } elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
514d8c22
DM
2861 $task->completed = false;
2862 }
2863 $phase->tasks['examples'] = $task;
2864 }
cff28ef0 2865 if (has_capability('mod/workshop:submit', $workshop->context, $userid, false)) {
55fc1e59
DM
2866 $task = new stdclass();
2867 $task->title = get_string('tasksubmit', 'workshop');
cff28ef0
DM
2868 $task->link = $workshop->submission_url();
2869 if ($DB->record_exists('workshop_submissions', array('workshopid'=>$workshop->id, 'example'=>0, 'authorid'=>$userid))) {
55fc1e59 2870 $task->completed = true;
cff28ef0 2871 } elseif ($workshop->phase >= workshop::PHASE_ASSESSMENT) {
55fc1e59
DM
2872 $task->completed = false;
2873 } else {
2874 $task->completed = null; // still has a chance to submit
2875 }
2876 $phase->tasks['submit'] = $task;
2877 }
cff28ef0 2878 if (has_capability('mod/workshop:allocate', $workshop->context, $userid)) {
3fe6d622
DM
2879 if ($workshop->phaseswitchassessment) {
2880 $task = new stdClass();
2881 $allocator = $DB->get_record('workshopallocation_scheduled', array('workshopid' => $workshop->id));
2882 if (empty($allocator)) {
2883 $task->completed = false;
2884 } else if ($allocator->enabled and is_null($allocator->resultstatus)) {
2885 $task->completed = true;
2886 } else if ($workshop->submissionend > time()) {
2887 $task->completed = null;
2888 } else {
2889 $task->completed = false;
2890 }
2891 $task->title = get_string('setup', 'workshopallocation_scheduled');
2892 $task->link = $workshop->allocation_url('scheduled');
2893 $phase->tasks['allocatescheduled'] = $task;
2894 }
55fc1e59
DM
2895 $task = new stdclass();
2896 $task->title = get_string('allocate', 'workshop');
cff28ef0 2897 $task->link = $workshop->allocation_url();
a1df59be 2898 $numofauthors = $workshop->count_potential_authors(false);
cff28ef0 2899 $numofsubmissions = $DB->count_records('workshop_submissions', array('workshopid'=>$workshop->id, 'example'=>0));
55fc1e59
DM
2900 $sql = 'SELECT COUNT(s.id) AS nonallocated
2901 FROM {workshop_submissions} s
2902 LEFT JOIN {workshop_assessments} a ON (a.submissionid=s.id)
2903 WHERE s.workshopid = :workshopid AND s.example=0 AND a.submissionid IS NULL';
cff28ef0 2904 $params['workshopid'] = $workshop->id;
55fc1e59
DM
2905 $numnonallocated = $DB->count_records_sql($sql, $params);
2906 if ($numofsubmissions == 0) {
2907 $task->completed = null;
2908 } elseif ($numnonallocated == 0) {
2909 $task->completed = true;
cff28ef0 2910 } elseif ($workshop->phase > workshop::PHASE_SUBMISSION) {
55fc1e59
DM
2911 $task->completed = false;
2912 } else {
2913 $task->completed = null; // still has a chance to allocate
2914 }
2915 $a = new stdclass();
2916 $a->expected = $numofauthors;
2917 $a->submitted = $numofsubmissions;
2918 $a->allocate = $numnonallocated;
2919 $task->details = get_string('allocatedetails', 'workshop', $a);
2920 unset($a);
2921 $phase->tasks['allocate'] = $task;
2922
cff28ef0 2923 if ($numofsubmissions < $numofauthors and $workshop->phase >= workshop::PHASE_SUBMISSION) {
55fc1e59
DM
2924 $task = new stdclass();
2925 $task->title = get_string('someuserswosubmission', 'workshop');
2926 $task->completed = 'info';
2927 $phase->tasks['allocateinfo'] = $task;
2928 }
3fe6d622 2929
55fc1e59 2930 }
cff28ef0 2931 if ($workshop->submissionstart) {
5bab64a3 2932 $task = new stdclass();
cff28ef0 2933 $task->title = get_string('submissionstartdatetime', 'workshop', workshop::timestamp_formats($workshop->submissionstart));
5bab64a3
DM
2934 $task->completed = 'info';
2935 $phase->tasks['submissionstartdatetime'] = $task;
2936 }
cff28ef0 2937 if ($workshop->submissionend) {
5bab64a3 2938 $task = new stdclass();
cff28ef0 2939 $task->title = get_string('submissionenddatetime', 'workshop', workshop::timestamp_formats($workshop->submissionend));
5bab64a3
DM
2940 $task->completed = 'info';
2941 $phase->tasks['submissionenddatetime'] = $task;
2942 }
2f289d36
DM
2943 if (($workshop->submissionstart < time()) and $workshop->latesubmissions) {
2944 $task = new stdclass();
2945 $task->title = get_string('latesubmissionsallowed', 'workshop');
2946 $task->completed = 'info';
2947 $phase->tasks['latesubmissionsallowed'] = $task;
2948 }
9ddff589
DM
2949 if (isset($phase->tasks['submissionstartdatetime']) or isset($phase->tasks['submissionenddatetime'])) {
2950 if (has_capability('mod/workshop:ignoredeadlines', $workshop->context, $userid)) {
2951 $task = new stdclass();
2952 $task->title = get_string('deadlinesignored', 'workshop');
2953 $task->completed = 'info';
2954 $phase->tasks['deadlinesignored'] = $task;
2955 }
2956 }
55fc1e59
DM
2957 $this->phases[workshop::PHASE_SUBMISSION] = $phase;
2958
5bab64a3
DM
2959 //---------------------------------------------------------
2960 // setup | submission | * ASSESSMENT | evaluation | closed
2961 //---------------------------------------------------------
55fc1e59
DM
2962 $phase = new stdclass();
2963 $phase->title = get_string('phaseassessment', 'workshop');
2964 $phase->tasks = array();
cff28ef0 2965 $phase->isreviewer = has_capability('mod/workshop:peerassess', $workshop->context, $userid);
3fe6d622
DM
2966 if ($workshop->phase == workshop::PHASE_SUBMISSION and $workshop->phaseswitchassessment
2967 and has_capability('mod/workshop:switchphase', $workshop->context, $userid)) {
2968 $task = new stdClass();
2969 $task->title = get_string('switchphase30auto', 'mod_workshop', workshop::timestamp_formats($workshop->submissionend));
2970 $task->completed = 'info';
2971 $phase->tasks['autoswitchinfo'] = $task;
2972 }
cff28ef0
DM
2973 if ($workshop->useexamples and $workshop->examplesmode == workshop::EXAMPLES_BEFORE_ASSESSMENT
2974 and $phase->isreviewer and !has_capability('mod/workshop:manageexamples', $workshop->context, $userid)) {
2975 $task = new stdclass();
2976 $task->title = get_string('exampleassesstask', 'workshop');
2977 $examples = $workshop->get_examples_for_reviewer($userid);
2978 $a = new stdclass();
2979 $a->expected = count($examples);
2980 $a->assessed = 0;
2981 foreach ($examples as $exampleid => $example) {
2982 if (!is_null($example->grade)) {
2983 $a->assessed++;
55fc1e59
DM
2984 }
2985 }
cff28ef0
DM
2986 $task->details = get_string('exampleassesstaskdetails', 'workshop', $a);
2987 if ($a->assessed == $a->expected) {
55fc1e59 2988 $task->completed = true;
cff28ef0 2989 } elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
55fc1e59
DM
2990 $task->completed = false;
2991 }
cff28ef0 2992 $phase->tasks['examples'] = $task;
55fc1e59 2993 }
cff28ef0
DM
2994 if (empty($phase->tasks['examples']) or !empty($phase->tasks['examples']->completed)) {
2995 $phase->assessments = $workshop->get_assessments_by_reviewer($userid);
2996 $numofpeers = 0; // number of allocated peer-assessments
2997 $numofpeerstodo = 0; // number of peer-assessments to do
2998 $numofself = 0; // number of allocated self-assessments - should be 0 or 1
2999 $numofselftodo = 0; // number of self-assessments to do - should be 0 or 1
3000 foreach ($phase->assessments as $a) {
3001 if ($a->authorid == $userid) {
3002 $numofself++;
3003 if (is_null($a->grade)) {
3004 $numofselftodo++;
3005 }
3006 } else {
3007 $numofpeers++;
3008 if (is_null($a->grade)) {
3009 $numofpeerstodo++;
3010 }
3011 }
3012 }
3013 unset($a);
d34ea7dc 3014 if ($numofpeers) {
cff28ef0
DM
3015 $task = new stdclass();
3016 if ($numofpeerstodo == 0) {
3017 $task->completed = true;
3018 } elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
3019 $task->completed = false;
3020 }
3021 $a = new stdclass();
3022 $a->total = $numofpeers;
3023 $a->todo = $numofpeerstodo;
3024 $task->title = get_string('taskassesspeers', 'workshop');
3025 $task->details = get_string('taskassesspeersdetails', 'workshop', $a);
3026 unset($a);
3027 $phase->tasks['assesspeers'] = $task;
3028 }
3029 if ($workshop->useselfassessment and $numofself) {
3030 $task = new stdclass();
3031 if ($numofselftodo == 0) {
3032 $task->completed = true;
3033 } elseif ($workshop->phase > workshop::PHASE_ASSESSMENT) {
3034 $task->completed = false;
3035 }
3036 $task->title = get_string('taskassessself', 'workshop');
3037 $phase->tasks['assessself'] = $task;
55fc1e59 3038 }
55fc1e59 3039 }
cff28ef0 3040 if ($workshop->assessmentstart) {
5bab64a3 3041 $task = new stdclass();
cff28ef0 3042 $task->title = get_string('assessmentstartdatetime', 'workshop', workshop::timestamp_formats($workshop->assessmentstart));
5bab64a3
DM
3043 $task->completed = 'info';
3044 $phase->tasks['assessmentstartdatetime'] = $task;
3045 }
cff28ef0 3046 if ($workshop->assessmentend) {
5bab64a3 3047 $task = new stdclass();
cff28ef0 3048 $task->title = get_string('assessmentenddatetime', 'workshop', workshop::timestamp_formats($workshop->assessmentend));
5bab64a3
DM
3049 $task->completed = 'info';
3050 $phase->tasks['assessmentenddatetime'] = $task;
3051 }
9ddff589
DM
3052 if (isset($phase->tasks['assessmentstartdatetime']) or isset($phase->tasks['assessmentenddatetime'])) {
3053 if (has_capability('mod/workshop:ignoredeadlines', $workshop->context, $userid)) {
3054 $task = new stdclass();
3055 $task->title = get_string('deadlinesignored', 'workshop');
3056 $task->completed = 'info';
3057 $phase->tasks['deadlinesignored'] = $task;
3058 }
3059 }
55fc1e59
DM
3060 $this->phases[workshop::PHASE_ASSESSMENT] = $phase;
3061
5bab64a3
DM
3062 //---------------------------------------------------------
3063 // setup | submission | assessment | * EVALUATION | closed
3064 //---------------------------------------------------------
55fc1e59
DM
3065 $phase = new stdclass();
3066 $phase->title = get_string('phaseevaluation', 'workshop');
3067 $phase->tasks = array();
cff28ef0 3068 if (has_capability('mod/workshop:overridegrades', $workshop->context)) {
a1df59be 3069 $expected = $workshop->count_potential_authors(false);
55fc1e59 3070 $calculated = $DB->count_records_select('workshop_submissions',
cff28ef0 3071 'workshopid = ? AND (grade IS NOT NULL OR gradeover IS NOT NULL)', array($workshop->id));
55fc1e59
DM
3072 $task = new stdclass();
3073 $task->title = get_string('calculatesubmissiongrades', 'workshop');
3074 $a = new stdclass();
3075 $a->expected = $expected;
3076 $a->calculated = $calculated;
3077 $task->details = get_string('calculatesubmissiongradesdetails', 'workshop', $a);
3078 if ($calculated >= $expected) {
3079 $task->completed = true;
cff28ef0 3080 } elseif ($workshop->phase > workshop::PHASE_EVALUATION) {
55fc1e59
DM
3081 $task->completed = false;
3082 }
3083 $phase->tasks['calculatesubmissiongrade'] = $task;
3084
a1df59be 3085 $expected = $workshop->count_potential_reviewers(false);
55fc1e59 3086 $calculated = $DB->count_records_select('workshop_aggregations',
cff28ef0 3087 'workshopid = ? AND gradinggrade IS NOT NULL', array($workshop->id));
55fc1e59
DM
3088 $task = new stdclass();
3089 $task->title = get_string('calculategradinggrades', 'workshop');
3090 $a = new stdclass();
3091 $a->expected = $expected;
3092 $a->calculated = $calculated;
3093 $task->details = get_string('calculategradinggradesdetails', 'workshop', $a);
3094 if ($calculated >= $expected) {
3095 $task->completed = true;
cff28ef0 3096 } elseif ($workshop->phase > workshop::PHASE_EVALUATION) {
55fc1e59
DM
3097 $task->completed = false;
3098 }
3099 $phase->tasks['calculategradinggrade'] = $task;
3100
cff28ef0 3101 } elseif ($workshop->phase == workshop::PHASE_EVALUATION) {
55fc1e59
DM
3102 $task = new stdclass();
3103 $task->title = get_string('evaluategradeswait', 'workshop');
3104 $task->completed = 'info';
3105 $phase->tasks['evaluateinfo'] = $task;
3106 }
4c61fcd8
DM
3107
3108 if (has_capability('moodle/course:manageactivities', $workshop->context, $userid)) {
3109 $task = new stdclass();
3110 $task->title = get_string('taskconclusion', 'workshop');
3111 $task->link = $workshop->updatemod_url();
3112 if (trim($workshop->conclusion)) {
3113 $task->completed = true;
3114 } elseif ($workshop->phase >= workshop::PHASE_EVALUATION) {
3115 $task->completed = false;
3116 }
3117 $phase->tasks['conclusion'] = $task;
3118 }
3119
55fc1e59
DM
3120 $this->phases[workshop::PHASE_EVALUATION] = $phase;
3121
5bab64a3
DM
3122 //---------------------------------------------------------
3123 // setup | submission | assessment | evaluation | * CLOSED
3124 //---------------------------------------------------------
55fc1e59
DM
3125 $phase = new stdclass();
3126 $phase->title = get_string('phaseclosed', 'workshop');
3127 $phase->tasks = array();
3128 $this->phases[workshop::PHASE_CLOSED] = $phase;
3129
3130 // Polish data, set default values if not done explicitly
3131 foreach ($this->phases as $phasecode => $phase) {
3132 $phase->title = isset($phase->title) ? $phase->title : '';
3133 $phase->tasks = isset($phase->tasks) ? $phase->tasks : array();
cff28ef0 3134 if ($phasecode == $workshop->phase) {
55fc1e59
DM
3135 $phase->active = true;
3136 } else {
3137 $phase->active = false;
3138 }
3139 if (!isset($phase->actions)) {
3140 $phase->actions = array();
3141 }
3142
3143 foreach ($phase->tasks as $taskcode => $task) {
3144 $task->title = isset($task->title) ? $task->title : '';
3145 $task->link = isset($task->link) ? $task->link : null;
3146 $task->details = isset($task->details) ? $task->details : '';
3147 $task->completed = isset($task->completed) ? $task->completed : null;
3148 }
3149 }
3150
5924db72 3151 // Add phase switching actions
cff28ef0 3152 if (has_capability('mod/workshop:switchphase', $workshop->context, $userid)) {
55fc1e59
DM
3153 foreach ($this->phases as $phasecode => $phase) {
3154 if (! $phase->active) {
3155 $action = new stdclass();
3156 $action->type = 'switchphase';
cff28ef0 3157 $action->url = $workshop->switchphase_url($phasecode);
55fc1e59
DM
3158 $phase->actions[] = $action;
3159 }
3160 }
3161 }
3162 }
cff28ef0
DM
3163
3164 /**
3165 * Returns example submissions to be assessed by the owner of the planner
3166 *
3167 * This is here to cache the DB query because the same list is needed later in view.php
3168 *
3169 * @see workshop::get_examples_for_reviewer() for the format of returned value
3170 * @return array
3171 */
3172 public function get_examples() {
3173 if (is_null($this->examples)) {
3174 $this->examples = $this->workshop->get_examples_for_reviewer($this->userid);
3175 }
3176 return $this->examples;
3177 }
55fc1e59 3178}
81b22887
DM
3179
3180/**
3181 * Common base class for submissions and example submissions rendering
3182 *
3183 * Subclasses of this class convert raw submission record from
3184 * workshop_submissions table (as returned by {@see workshop::get_submission_by_id()}
3185 * for example) into renderable objects.
3186 */
3187abstract class workshop_submission_base {
3188
de6aaa72 3189 /** @var bool is the submission anonymous (i.e. contains author information) */
81b22887
DM
3190 protected $anonymous;
3191
3192 /* @var array of columns from workshop_submissions that are assigned as properties */
3193 protected $fields = array();
3194
77d746a2
DM
3195 /** @var workshop */
3196 protected $workshop;
3197
81b22887
DM
3198 /**
3199 * Copies the properties of the given database record into properties of $this instance
3200 *
77d746a2 3201 * @param workshop $workshop
81b22887
DM
3202 * @param stdClass $submission full record
3203 * @param bool $showauthor show the author-related information
3204 * @param array $options additional properties
3205 */
77d746a2
DM
3206 public function __construct(workshop $workshop, stdClass $submission, $showauthor = false) {
3207
3208 $this->workshop = $workshop;
81b22887
DM
3209
3210 foreach ($this->fields as $field) {
3211 if (!property_exists($submission, $field)) {
3212 throw new coding_exception('Submission record must provide public property ' . $field);
3213 }
3214 if (!property_exists($this, $field)) {
3215 throw new coding_exception('Renderable component must accept public property ' . $field);
3216 }
3217 $this->{$field} = $submission->{$field};
3218 }
3219
3220 if ($showauthor) {
3221 $this->anonymous = false;
3222 } else {
3223 $this->anonymize();
3224 }
3225 }
3226
3227 /**
3228 * Unsets all author-related properties so that the renderer does not have access to them
3229 *
3230 * Usually this is called by the contructor but can be called explicitely, too.
3231 */
3232 public function anonymize() {
3263a356
AG
3233 $authorfields = explode(',', user_picture::fields());
3234 foreach ($authorfields as $field) {
3235 $prefixedusernamefield = 'author' . $field;
3236 unset($this->{$prefixedusernamefield});
81b22887
DM
3237 }
3238 $this->anonymous = true;
3239 }
3240
3241 /**
3242 * Does the submission object contain author-related information?
3243 *
3244 * @return null|boolean
3245 */
3246 public function is_anonymous() {
3247 return $this->anonymous;
3248 }
3249</