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