WebSVN – Moodle – Diff – /mod/assign/locallib.php

 define('ASSIGN_FILTER_NONE', 'none');
 define('ASSIGN_FILTER_SUBMITTED', 'submitted');
 define('ASSIGN_FILTER_NOT_SUBMITTED', 'notsubmitted');
 define('ASSIGN_FILTER_SINGLE_USER', 'singleuser');
 define('ASSIGN_FILTER_REQUIRE_GRADING', 'requiregrading');
+define('ASSIGN_FILTER_GRADED', 'graded');
 define('ASSIGN_FILTER_GRANTED_EXTENSION', 'grantedextension');
 define('ASSIGN_FILTER_DRAFT', 'draft');
 // Marker filter for grading page.
 define('ASSIGN_MARKER_FILTER_NO_MARKER', -1);
+// Reopen attempt methods.
+/**
+ * ASSIGN_ATTEMPT_REOPEN_METHOD_NONE - Reopening attempts is not allowed.
+ *
+ * @deprecated since Moodle 4.4
  * @todo MDL-81977 This will be deleted in Moodle 4.8.
-// Reopen attempt methods.
+ */
+define('ASSIGN_ATTEMPT_REOPEN_METHOD_NONE', 'none');
-define('ASSIGN_ATTEMPT_REOPEN_METHOD_NONE', 'none');
+define('ASSIGN_ATTEMPT_REOPEN_METHOD_MANUAL', 'manual');
-define('ASSIGN_ATTEMPT_REOPEN_METHOD_MANUAL', 'manual');
+define('ASSIGN_ATTEMPT_REOPEN_METHOD_AUTOMATIC', 'automatic');
 define('ASSIGN_ATTEMPT_REOPEN_METHOD_UNTILPASS', 'untilpass');
 // Event types.
 define('ASSIGN_EVENT_TYPE_DUE', 'due');
 define('ASSIGN_EVENT_TYPE_GRADINGDUE', 'gradingdue');
 define('ASSIGN_EVENT_TYPE_OPEN', 'open');
 define('ASSIGN_EVENT_TYPE_CLOSE', 'close');
+define('ASSIGN_EVENT_TYPE_EXTENSION', 'extension');
 require_once($CFG->libdir . '/accesslib.php');
 require_once($CFG->libdir . '/formslib.php');
 require_once($CFG->dirroot . '/repository/lib.php');
+ *
  * @package   mod_assign
  * @copyright 2012 NetSpot {@link http://www.netspot.com.au}
  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class assign
+class assign {
-{
     /** @var stdClass the assignment record that contains the global settings for this assign instance */
     private $instance;
     /** @var array cache for things like the coursemodule name or the scale menu -
      *             only lives for a single request.
      */
     private $cache;
-    /** @var array list of the installed submission plugins */
+    /** @var assign_submission_plugin[] list of the installed submission plugins */
     private $submissionplugins;
-    /** @var array list of the installed feedback plugins */
+    /** @var assign_feedback_plugin[] list of the installed feedback plugins */
     private $feedbackplugins;
     private $overridedata;
     /** @var float grade value. */
+    public $grade;
+    /** @var array $usersearch The content that the current user is looking for. */
-    public $grade;
+    protected array $usersearch = [];
     /**
      * Constructor for the base assign class.
+     *
      * @param mixed $coursemodule the current course module if it was already loaded,
      *                            otherwise this class will load one from the context as required.
      * @param mixed $course the current course  if it was already loaded,
      *                      otherwise this class will load one from the context as required.
      */
-    public function __construct($coursemodulecontext, $coursemodule, $course)
+    public function __construct($coursemodulecontext, $coursemodule, $course) {
-    {
         $this->context = $coursemodulecontext;
         $this->course = $course;
         // Ensure that $this->coursemodule is a cm_info object (or null).
      * @param string $action The action for the current page
      * @param array $params An array of name value pairs which form the parameters
      *                      to return to the current page.
      * @return void
      */
-    public function register_return_link($action, $params)
+    public function register_return_link($action, $params) {
-    {
         global $PAGE;
         $params['action'] = $action;
         $cm = $this->get_course_module();
         if ($cm) {
             $currenturl = new moodle_url('/mod/assign/view.php', array('id' => $cm->id));
     /**
      * Return an action that can be used to get back to the current page.
+     *
      * @return string action
      */
-    public function get_return_action()
+    public function get_return_action() {
-    {
         global $PAGE;
         // Web services don't set a URL, we should avoid debugging when ussing the url object.
         if (!WS_SERVER) {
     /**
      * Based on the current assignment settings should we display the intro.
+     *
      * @return bool showintro
      */
-    public function show_intro()
+    public function show_intro() {
-    {
-        if (
-            $this->get_instance()->alwaysshowdescription ||
+        if ($this->get_instance()->alwaysshowdescription ||
-            time() > $this->get_instance()->allowsubmissionsfromdate
+                time() > $this->get_instance()->allowsubmissionsfromdate) {
-        ) {
             return true;
+        }
         return false;
+    }
     /**
      * Return a list of parameters that can be used to get back to the current page.
+     *
      * @return array params
      */
-    public function get_return_params()
     public function get_return_params() {
         global $PAGE;
         $params = array();
     /**
      * Set the submitted form data.
+     *
      * @param stdClass $data The form data (instance)
      */
-    public function set_instance(stdClass $data)
+    public function set_instance(stdClass $data) {
-    {
         $this->instance = $data;
+    }
     /**
      * Set the context.
+     *
      * @param context $context The new context
      */
-    public function set_context(context $context)
     public function set_context(context $context) {
         $this->context = $context;
+    }
     /**
      * Set the course data.
+     *
      * @param stdClass $course The course data
-     */
-    public function set_course(stdClass $course)
+     */
     public function set_course(stdClass $course) {
         $this->course = $course;
+    }
+    /**
+     * Set usersearch to limit results when getting list of participants.
+     *
+     * @param int|null $userid User id to search for.
+     * @param int|null $groupid Group id to limit resuts to specific group.
+     * @param string $usersearch Search string to limit results.
+     */
+    public function set_usersearch(?int $userid, ?int $groupid, string $usersearch = ''): void {
+        $usersearcharray = [];
+        $usersearcharray['userid'] = $userid;
+        $usersearcharray['groupid'] = $groupid;
+        $usersearcharray['usersearch'] = $usersearch;
+        $this->usersearch = $usersearcharray;
+    }
     /**
      * Set error message.
      *
-     * @param string $message The error message
-     */
+     * @param string $message The error message
-    protected function set_error_message(string $message)
+     */
     protected function set_error_message(string $message) {
         $this->errors[] = $message;
+    }
     /**
      * Get error messages.
-     *
      * @return array The array of error messages
-     */
+     * @return array The array of error messages
-    protected function get_error_messages(): array
+     */
     public function get_error_messages(): array {
         return $this->errors;
+    }
     /**
-     * Get list of feedback plugins installed.
      * Get list of feedback plugins installed.
      * @return array
-     */
+     * @return array
-    public function get_feedback_plugins()
+     */
     public function get_feedback_plugins() {
         return $this->feedbackplugins;
+    }
-    /**
-     * Get list of submission plugins installed.
+    /**
      * Get list of submission plugins installed.
      * @return array
-     */
+     * @return array
-    public function get_submission_plugins()
+     */
     public function get_submission_plugins() {
         return $this->submissionplugins;
     }
     /**
-     * Is blind marking enabled and reveal identities not set yet?
+    /**
      * Is blind marking enabled and reveal identities not set yet?
      * @return bool
      * This just checks the assignment settings. Remember to check
      * the user has the 'showhiddengrader' capability too
+     *
      * @return bool
      */
-    public function is_hidden_grader()
+    public function is_hidden_grader() {
-    {
         return $this->get_instance()->hidegrader;
+    }
     /**
      * Does an assignment have submission(s) or grade(s) already?
+     *
      * @return bool
      */
-    public function has_submissions_or_grades()
     public function has_submissions_or_grades() {
         $allgrades = $this->count_grades();
         $allsubmissions = $this->count_submissions();
         if (($allgrades == 0) && ($allsubmissions == 0)) {
             return false;
+     *
      * @param string $subtype assignsubmission | assignfeedback
      * @param string $type
      * @return mixed assign_plugin|null
      */
-    public function get_plugin_by_type($subtype, $type)
+    public function get_plugin_by_type($subtype, $type) {
-    {
         $shortsubtype = substr($subtype, strlen('assign'));
         $name = $shortsubtype . 'plugins';
         if ($name != 'feedbackplugins' && $name != 'submissionplugins') {
             return null;
+        }
      * Get a feedback plugin by type.
+     *
      * @param string $type - The type of plugin e.g comments
      * @return mixed assign_feedback_plugin|null
      */
-    public function get_feedback_plugin_by_type($type)
+    public function get_feedback_plugin_by_type($type) {
-    {
         return $this->get_plugin_by_type('assignfeedback', $type);
+    }
     /**
      * Get a submission plugin by type.
+     *
      * @param string $type - The type of plugin e.g comments
      * @return mixed assign_submission_plugin|null
      */
-    public function get_submission_plugin_by_type($type)
     public function get_submission_plugin_by_type($type) {
         return $this->get_plugin_by_type('assignsubmission', $type);
+    }
     /**
      * Load the plugins from the sub folders under subtype.
+     *
      * @param string $subtype - either submission or feedback
      * @return array - The sorted list of plugins
-     */
-    public function load_plugins($subtype)
+     */
     public function load_plugins($subtype) {
         global $CFG;
                 $plugin = new $pluginclass($this, $name);
                 if ($plugin instanceof assign_plugin) {
                     $idx = $plugin->get_sort_order();
                     while (array_key_exists($idx, $result)) {
-                        $idx += 1;
+                        $idx +=1;
+                    }
                     $result[$idx] = $plugin;
+                }
+            }
+     *
      * @param string $action The current action if any.
      * @param array $args Optional arguments to pass to the view (instead of getting them from GET and POST).
      * @return string - The page output.
      */
-    public function view($action = '', $args = array())
+    public function view($action='', $args = array()) {
-    {
         global $PAGE;
         $o = '';
         $mform = null;
         if (!empty($this->get_course_module()->id)) {
             $nextpageparams['id'] = $this->get_course_module()->id;
-        }
-        if (empty($action)) {
-            $PAGE->add_body_class('limitedwidth');
+        }
         // Handle form submissions first.
         if ($action == 'savesubmission') {
             $action = 'editsubmission';
                 $nextpageparams['action'] = 'grading';
             } else {
                 $action = 'viewsubmitforgradingerror';
+            }
         } else if ($action == 'gradingbatchoperation') {
-            $action = $this->process_grading_batch_operation($mform);
+            $action = $this->process_grading_batch_operation();
             if ($action == 'grading') {
                 $action = 'redirect';
                 $nextpageparams['action'] = 'grading';
+            }
         } else if ($action == 'submitgrade') {
                 $nextpageparams['action'] = 'grading';
+            }
         } else if ($action == 'quickgrade') {
             $message = $this->process_save_quick_grades();
             $action = 'quickgradingresult';
-        } else if ($action == 'saveoptions') {
-            $this->process_save_grading_options();
-            $action = 'redirect';
-            $nextpageparams['action'] = 'grading';
         } else if ($action == 'saveextension') {
             $action = 'grantextension';
             if ($this->process_save_extension($mform)) {
                 $action = 'redirect';
                 $nextpageparams['action'] = 'grading';
             $this->process_reveal_identities();
             $action = 'redirect';
             $nextpageparams['action'] = 'grading';
+        }
-        $returnparams = array(
-            'rownum' => optional_param('rownum', 0, PARAM_INT),
+        $returnparams = array('rownum'=>optional_param('rownum', 0, PARAM_INT),
-            'useridlistid' => optional_param('useridlistid', $this->get_useridlist_key_id(), PARAM_ALPHANUM)
-        );
+                              'useridlistid' => optional_param('useridlistid', $this->get_useridlist_key_id(), PARAM_ALPHANUM));
         $this->register_return_link($action, $returnparams);
         // Include any page action as part of the body tag CSS id.
             $PAGE->add_body_class('limitedwidth');
             $o .= $this->check_submit_for_grading($mform);
         } else if ($action == 'grantextension') {
             $o .= $this->view_grant_extension($mform);
         } else if ($action == 'revealidentities') {
-            $o .= $this->view_reveal_identities_confirm($mform);
+            $o .= $this->view_reveal_identities_confirm();
         } else if ($action == 'removesubmissionconfirm') {
             $PAGE->add_body_class('limitedwidth');
             $o .= $this->view_remove_submission_confirm();
         } else if ($action == 'plugingradingbatchoperation') {
-            $o .= $this->view_plugin_grading_batch_operation($mform);
+            $o .= $this->view_plugin_grading_batch_operation();
         } else if ($action == 'viewpluginpage') {
-            $o .= $this->view_plugin_page();
+             $o .= $this->view_plugin_page();
-        } else if ($action == 'viewcourseindex') {
-            $o .= $this->view_course_index();
         } else if ($action == 'viewbatchsetmarkingworkflowstate') {
-            $o .= $this->view_batch_set_workflow_state($mform);
+             $o .= $this->view_batch_set_workflow_state();
         } else if ($action == 'viewbatchmarkingallocation') {
-            $o .= $this->view_batch_markingallocation($mform);
+            $o .= $this->view_batch_markingallocation();
         } else if ($action == 'viewsubmitforgradingerror') {
             $o .= $this->view_error_page(get_string('submitforgrading', 'assign'), $notices);
         } else if ($action == 'fixrescalednullgrades') {
             $o .= $this->view_fix_rescaled_null_grades();
         } else {
      * @param stdClass $formdata The data submitted from the form
      * @param bool $callplugins This is used to skip the plugin code
      *             when upgrading an old assignment to a new one (the plugins get called manually)
      * @return mixed false if an error occurs or the int id of the new instance
      */
-    public function add_instance(stdClass $formdata, $callplugins)
+    public function add_instance(stdClass $formdata, $callplugins) {
-    {
         global $DB;
         $adminconfig = $this->get_admin_config();
+        }
         $update->blindmarking = $formdata->blindmarking;
         if (isset($formdata->hidegrader)) {
             $update->hidegrader = $formdata->hidegrader;
+        }
-        $update->attemptreopenmethod = ASSIGN_ATTEMPT_REOPEN_METHOD_NONE;
-        if (!empty($formdata->attemptreopenmethod)) {
+        $update->maxattempts = $formdata->maxattempts ?? 1;
-            $update->attemptreopenmethod = $formdata->attemptreopenmethod;
+        $update->attemptreopenmethod = $formdata->attemptreopenmethod ?? ASSIGN_ATTEMPT_REOPEN_METHOD_UNTILPASS;
-        }
-        if (!empty($formdata->maxattempts)) {
-            $update->maxattempts = $formdata->maxattempts;
-        }
         if (isset($formdata->preventsubmissionnotingroup)) {
             $update->preventsubmissionnotingroup = $formdata->preventsubmissionnotingroup;
+        }
         $update->markingworkflow = $formdata->markingworkflow;
         $update->markingallocation = $formdata->markingallocation;
                 $update->markinganonymous = 0;
             } else {
                 $update->markinganonymous = $formdata->markinganonymous;
+            }
+        }
+        // Grade penalties.
+        $update->gradepenalty = $formdata->gradepenalty ?? 0;
         $returnid = $DB->insert_record('assign', $update);
-        $this->instance = $DB->get_record('assign', array('id' => $returnid), '*', MUST_EXIST);
+        $this->instance = $DB->get_record('assign', array('id'=>$returnid), '*', MUST_EXIST);
         // Cache the course record.
-        $this->course = $DB->get_record('course', array('id' => $formdata->course), '*', MUST_EXIST);
+        $this->course = $DB->get_record('course', array('id'=>$formdata->course), '*', MUST_EXIST);
         $this->save_intro_draft_files($formdata);
         $this->save_editor_draft_files($formdata);
             // In the case of upgrades the coursemodule has not been set,
             // so we need to wait before calling these two.
             $this->update_calendar($formdata->coursemodule);
             if (!empty($formdata->completionexpected)) {
-                \core_completion\api::update_completion_date_event(
-                    $formdata->coursemodule,
-                    'assign',
-                    $this->instance,
+                \core_completion\api::update_completion_date_event($formdata->coursemodule, 'assign', $this->instance,
-                    $formdata->completionexpected
-                );
+                        $formdata->completionexpected);
+            }
+            $this->update_gradebook(false, $formdata->coursemodule);
             $this->update_gradebook(false, $formdata->coursemodule);
+        }
         $update = new stdClass();
         $update->id = $this->get_instance()->id;
-        $update->nosubmissions = (!$this->is_any_submission_plugin_enabled()) ? 1 : 0;
+        $update->nosubmissions = (!$this->is_any_submission_plugin_enabled()) ? 1: 0;
         $DB->update_record('assign', $update);
         return $returnid;
+    }
     /**
      * Delete all grades from the gradebook for this assignment.
-     *
      * @return bool
-     */
+     * @return bool
-    protected function delete_grades()
-    {
+     */
-        global $CFG;
+    protected function delete_grades() {
+        global $CFG;
-        $result = grade_update(
-            'mod/assign',
+        $result = grade_update('mod/assign',
-            $this->get_course()->id,
+                               $this->get_course()->id,
-            'mod',
+                               'mod',
-            'assign',
-            $this->get_instance()->id,
+                               'assign',
-,
+                               $this->get_instance()->id,
-            null,
+,
-            array('deleted' => 1)
+                               null,
-        );
+                               array('deleted'=>1));
         return $result == GRADE_UPDATE_OK;
+    }
-    /**
-     * Delete this instance from the database.
+    /**
      * Delete this instance from the database.
      * @return bool false if an error occurs
-     */
+     * @return bool false if an error occurs
+            }
+        }
         // Delete files associated with this assignment.
         $fs = get_file_storage();
-        if (! $fs->delete_area_files($this->context->id)) {
+        if (! $fs->delete_area_files($this->context->id) ) {
             $result = false;
+        }
             $result = false;
+        }
         // Delete the instance.
         // We must delete the module record after we delete the grade item.
-        $DB->delete_records('assign', array('id' => $this->get_instance()->id));
+        $DB->delete_records('assign', array('id'=>$this->get_instance()->id));
         return $result;
+    }
     /**
      * Deletes a assign override from the database and clears any corresponding calendar events
+     *
      * @param int $overrideid The id of the override being deleted
-     * @return bool true on success
-     */
+     * @return bool true on success
-    public function delete_override($overrideid)
+     */
     public function delete_override($overrideid) {
+    }
     /**
      * Deletes all assign overrides from the database and clears any corresponding calendar events
      */
-    public function delete_all_overrides()
     public function delete_all_overrides() {
         global $DB;
         $overrides = $DB->get_records('assign_overrides', array('assignid' => $this->get_instance()->id), 'id');
      *   then use that otherwise, if there are group-specific overrides, return the most
      *   lenient combination of them.  If neither applies, leave the assign setting unchanged.
+     *
      * @param int $userid The userid.
      */
-    public function update_effective_access($userid)
+    public function update_effective_access($userid) {
-    {
         $override = $this->override_exists($userid);
         // Merge with assign defaults.
         $keys = array('duedate', 'cutoffdate', 'allowsubmissionsfromdate', 'timelimit');
         foreach ($keys as $key) {
             if (isset($override->{$key})) {
                 $this->get_instance($userid)->{$key} = $override->{$key};
+            }
+        }
+    }
     /**
      * Returns whether an assign has any overrides.
      *
-     * @return true if any, false if not
-     */
+     * @return true if any, false if not
-    public function has_overrides()
+     */
     public function has_overrides() {
      *   lowest sort order. If neither applies, leave the assign setting unchanged.
+     *
      * @param int $userid The userid.
      * @return stdClass The override
      */
-    public function override_exists($userid)
+    public function override_exists($userid) {
-    {
         global $DB;
         // Gets an assoc array containing the keys for defined user overrides only.
-        $getuseroverride = function ($userid) use ($DB) {
+        $getuseroverride = function($userid) use ($DB) {
             $useroverride = $DB->get_record('assign_overrides', ['assignid' => $this->get_instance()->id, 'userid' => $userid]);
             return $useroverride ? get_object_vars($useroverride) : [];
         };
         // Gets an assoc array containing the keys for defined group overrides only.
-        $getgroupoverride = function ($userid) use ($DB) {
+        $getgroupoverride = function($userid) use ($DB) {
             $groupings = groups_get_user_groups($this->get_instance()->course, $userid);
      * Check if the given calendar_event is either a user or group override
      * event.
+     *
      * @return bool
      */
-    public function is_override_calendar_event(\calendar_event $event)
+    public function is_override_calendar_event(\calendar_event $event) {
-    {
         global $DB;
         if (!isset($event->modulename)) {
             return false;
      * be returned.
+     *
      * @param calendar_event $event The calendar event to get the time range for
      * @return array
      */
-    function get_valid_calendar_event_timestart_range(\calendar_event $event)
+    function get_valid_calendar_event_timestart_range(\calendar_event $event) {
-    {
         $instance = $this->get_instance();
         $submissionsfromdate = $instance->allowsubmissionsfromdate;
         $cutoffdate = $instance->cutoffdate;
         $duedate = $instance->duedate;
         $gradingduedate = $instance->gradingduedate;
      * assignment submissions for course $data->courseid.
+     *
      * @param stdClass $data the data submitted from the reset course.
      * @return array status array
      */
-    public function reset_userdata($data)
+    public function reset_userdata($data) {
-    {
         global $CFG, $DB;
         $componentstr = get_string('modulenameplural', 'assign');
-        $status = array();
+        $status = [];
         $fs = get_file_storage();
         if (!empty($data->reset_assign_submissions)) {
             // Delete files associated with this assignment.
             foreach ($this->submissionplugins as $plugin) {
-                $fileareas = array();
+                $fileareas = [];
                 $plugincomponent = $plugin->get_subtype() . '_' . $plugin->get_type();
                 $fileareas = $plugin->get_file_areas();
                 foreach ($fileareas as $filearea => $notused) {
                     $fs->delete_area_files($this->context->id, $plugincomponent, $filearea);
                 }
                 if (!$plugin->delete_instance()) {
-                    $status[] = array(
+                    $status[] = [
                         'component' => $componentstr,
                         'item' => get_string('deleteallsubmissions', 'assign'),
-                        'error' => $plugin->get_error()
+                        'error' => $plugin->get_error(),
-                    );
+                    ];
+                }
                 foreach ($fileareas as $filearea => $notused) {
                     $fs->delete_area_files($this->context->id, $plugincomponent, $filearea);
+                }
                 if (!$plugin->delete_instance()) {
-                    $status[] = array(
+                    $status[] = [
                         'component' => $componentstr,
-                        'item' => get_string('deleteallsubmissions', 'assign'),
+                        'item ' => get_string('deleteallsubmissions', 'assign'),
-                        'error' => $plugin->get_error()
+                        'error' => $plugin->get_error(),
-                    );
+                    ];
+                }
             }
-            $assignids = $DB->get_records('assign', array('course' => $data->courseid), '', 'id');
+            $assignids = $DB->get_records('assign', ['course' => $data->courseid], '', 'id');
             list($sql, $params) = $DB->get_in_or_equal(array_keys($assignids));
             $DB->delete_records_select('assign_submission', "assignment $sql", $params);
             $DB->delete_records_select('assign_user_flags', "assignment $sql", $params);
-            $status[] = array(
+            $status[] = [
                 'component' => $componentstr,
                 'item' => get_string('deleteallsubmissions', 'assign'),
-                'error' => false
+                'error' => false,
-            );
+            ];
             if (!empty($data->reset_gradebook_grades)) {
                 $DB->delete_records_select('assign_grades', "assignment $sql", $params);
                 // Remove all grades from gradebook.
                 require_once($CFG->dirroot . '/mod/assign/lib.php');
                 assign_reset_gradebook($data->courseid);
+            }
             // Reset revealidentities for assign if blindmarking is enabled.
             if ($this->get_instance()->blindmarking) {
-                $DB->set_field('assign', 'revealidentities', 0, array('id' => $this->get_instance()->id));
+                $DB->set_field('assign', 'revealidentities', 0, ['id' => $this->get_instance()->id]);
-            }
-        }
+            }
-        $purgeoverrides = false;
+        }
         // Remove user overrides.
-        if (!empty($data->reset_assign_user_overrides)) {
+        $purgeoverrides = false;
-            $DB->delete_records_select(
-                'assign_overrides',
+        // Remove user overrides.
-                'assignid IN (SELECT id FROM {assign} WHERE course = ?) AND userid IS NOT NULL',
+        if (!empty($data->reset_assign_user_overrides)) {
-                array($data->courseid)
+            $DB->delete_records_select('assign_overrides',
-            );
+                'assignid IN (SELECT id FROM {assign} WHERE course = ?) AND userid IS NOT NULL', [$data->courseid]);
-            $status[] = array(
+            $status[] = [
                 'component' => $componentstr,
-                'item' => get_string('useroverridesdeleted', 'assign'),
-                'error' => false
+                'item' => get_string('useroverrides', 'assign'),
-            );
-            $purgeoverrides = true;
-        }
+                'error' => false,
-        // Remove group overrides.
+            ];
-        if (!empty($data->reset_assign_group_overrides)) {
+            $purgeoverrides = true;
-            $DB->delete_records_select(
+        }
-                'assign_overrides',
+        // Remove group overrides.
-                'assignid IN (SELECT id FROM {assign} WHERE course = ?) AND groupid IS NOT NULL',
+        if (!empty($data->reset_assign_group_overrides)) {
-                array($data->courseid)
+            $DB->delete_records_select('assign_overrides',
-            );
+                'assignid IN (SELECT id FROM {assign} WHERE course = ?) AND groupid IS NOT NULL', [$data->courseid]);
-            $status[] = array(
+            $status[] = [
+                'component' => $componentstr,
+                'item' => get_string('groupoverrides', 'assign'),
+                'error' => false,
-                'component' => $componentstr,
+            ];
-                'item' => get_string('groupoverridesdeleted', 'assign'),
+            $purgeoverrides = true;
-                'error' => false
-            );
-            $purgeoverrides = true;
+        }
+        // Updating dates - shift may be negative too.
+        if ($data->timeshift) {
+            $sql = "UPDATE {assign_overrides}
                        SET allowsubmissionsfromdate = allowsubmissionsfromdate + ?
-        // Updating dates - shift may be negative too.
+                     WHERE assignid = ? AND allowsubmissionsfromdate <> 0";
-        if ($data->timeshift) {
-            $DB->execute(
-                "UPDATE {assign_overrides}
+            $DB->execute(
-                         SET allowsubmissionsfromdate = allowsubmissionsfromdate + ?
+                $sql,
+                [$data->timeshift, $this->get_instance()->id],
+            );
+            $sql = "UPDATE {assign_overrides}
-                       WHERE assignid = ? AND allowsubmissionsfromdate <> 0",
+                       SET duedate = duedate + ?
-                array($data->timeshift, $this->get_instance()->id)
+                     WHERE assignid = ? AND duedate <> 0";
-            );
-            $DB->execute(
-                "UPDATE {assign_overrides}
+            $DB->execute(
-                         SET duedate = duedate + ?
+                $sql,
-                       WHERE assignid = ? AND duedate <> 0",
+                [$data->timeshift, $this->get_instance()->id],
-                array($data->timeshift, $this->get_instance()->id)
+            );
-            );
+            $sql = "UPDATE {assign_overrides}
-            $DB->execute(
+                       SET cutoffdate = cutoffdate + ?
-                "UPDATE {assign_overrides}
+                     WHERE assignid =? AND cutoffdate <> 0";
-                         SET cutoffdate = cutoffdate + ?
+            $DB->execute(
-                       WHERE assignid =? AND cutoffdate <> 0",
+                $sql,
-                array($data->timeshift, $this->get_instance()->id)
+                [$data->timeshift, $this->get_instance()->id],
             );
             $purgeoverrides = true;
             // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
             // See MDL-9367.
-            shift_course_mod_dates(
+            shift_course_mod_dates('assign', [
-                'assign',
+                'allowsubmissionsfromdate',
-                array('duedate', 'allowsubmissionsfromdate', 'cutoffdate'),
+                'duedate',
-                $data->timeshift,
+                'cutoffdate',
-                $data->courseid,
+                'gradingduedate',
+     *
      * @param assign_plugin $plugin The plugin to update
      * @param stdClass $formdata The form data
      * @return bool false if an error occurs
      */
-    protected function update_plugin_instance(assign_plugin $plugin, stdClass $formdata)
+    protected function update_plugin_instance(assign_plugin $plugin, stdClass $formdata) {
-    {
         if ($plugin->is_visible()) {
             $enabledname = $plugin->get_subtype() . '_' . $plugin->get_type() . '_enabled';
             if (!empty($formdata->$enabledname)) {
                 $plugin->enable();
                 if (!$plugin->save_settings($formdata)) {
+     *
      * @param bool $reset If true, will reset all grades in the gradbook for this assignment
      * @param int $coursemoduleid This is required because it might not exist in the database yet
      * @return bool
      */
-    public function update_gradebook($reset, $coursemoduleid)
+    public function update_gradebook($reset, $coursemoduleid) {
-    {
         global $CFG;
-        require_once($CFG->dirroot . '/mod/assign/lib.php');
+        require_once($CFG->dirroot.'/mod/assign/lib.php');
         $assign = clone $this->get_instance();
         $assign->cmidnumber = $coursemoduleid;
     /**
      * Get the marking table page size
+     *
      * @return integer
      */
-    public function get_assign_perpage()
+    public function get_assign_perpage() {
-    {
         $perpage = (int) get_user_preferences('assign_perpage', 10);
         $adminconfig = $this->get_admin_config();
         $maxperpage = -1;
         if (isset($adminconfig->maxperpage)) {
             $maxperpage = $adminconfig->maxperpage;
+        }
-        if (
-            isset($maxperpage) &&
+        if (isset($maxperpage) &&
             $maxperpage != -1 &&
-            ($perpage == -1 || $perpage > $maxperpage)
+            ($perpage == -1 || $perpage > $maxperpage)) {
-        ) {
             $perpage = $maxperpage;
+        }
         return $perpage;
+    }
     /**
      * Load and cache the admin config for this module.
+     *
      * @return stdClass the plugin config
      */
-    public function get_admin_config()
     public function get_admin_config() {
         if ($this->adminconfig) {
             return $this->adminconfig;
+        }
         $this->adminconfig = get_config('assign');
+     *
      * @param int $coursemoduleid - Required to pass this in because it might
      *                              not exist in the database yet.
      * @return bool
      */
-    public function update_calendar($coursemoduleid)
+    public function update_calendar($coursemoduleid) {
-    {
         global $DB, $CFG;
-        require_once($CFG->dirroot . '/calendar/lib.php');
+        require_once($CFG->dirroot.'/calendar/lib.php');
         // Special case for add_instance as the coursemodule has not been set yet.
         $instance = $this->get_instance();
                 $calendarevent->update($event, false);
             } else {
                 calendar_event::create($event, false);
+            }
         } else {
-            $DB->delete_records('event', array(
+            $DB->delete_records('event', array('modulename' => 'assign', 'instance' => $instance->id,
-                'modulename' => 'assign',
-                'instance' => $instance->id,
-                'eventtype' => $eventtype
+                'eventtype' => $eventtype));
-            ));
+        }
         $eventtype = ASSIGN_EVENT_TYPE_GRADINGDUE;
         if ($instance->gradingduedate) {
             $event->name = get_string('calendargradingdue', 'assign', $instance->name);
             $event->eventtype = $eventtype;
             $event->timestart = $instance->gradingduedate;
             $event->timesort = $instance->gradingduedate;
-            $event->id = $DB->get_field('event', 'id', array(
-                'modulename' => 'assign',
-                'instance' => $instance->id,
+            $event->id = $DB->get_field('event', 'id', array('modulename' => 'assign',
-                'eventtype' => $event->eventtype
-            ));
+                'instance' => $instance->id, 'eventtype' => $event->eventtype));
             // Now process the event.
             if ($event->id) {
                 $calendarevent = calendar_event::load($event->id);
                 $calendarevent->update($event, false);
             } else {
                 calendar_event::create($event, false);
             }
-        } else {
-            $DB->delete_records('event', array(
-                'modulename' => 'assign',
+        } else {
-                'instance' => $instance->id,
-                'eventtype' => $eventtype
+            $DB->delete_records('event', array('modulename' => 'assign', 'instance' => $instance->id,
-            ));
+                'eventtype' => $eventtype));
+        }
      * Update this instance in the database.
+     *
      * @param stdClass $formdata - the data submitted from the form
      * @return bool false if an error occurs
      */
-    public function update_instance($formdata)
+    public function update_instance($formdata) {
-    {
         global $DB;
         $adminconfig = $this->get_admin_config();
         $update = new stdClass();
+        }
         if (isset($formdata->hidegrader)) {
             $update->hidegrader = $formdata->hidegrader;
+        }
         $update->blindmarking = $formdata->blindmarking;
-        $update->attemptreopenmethod = ASSIGN_ATTEMPT_REOPEN_METHOD_NONE;
-        if (!empty($formdata->attemptreopenmethod)) {
+        $update->maxattempts = $formdata->maxattempts ?? 1;
-            $update->attemptreopenmethod = $formdata->attemptreopenmethod;
+        $update->attemptreopenmethod = $formdata->attemptreopenmethod ?? ASSIGN_ATTEMPT_REOPEN_METHOD_UNTILPASS;
-        }
-        if (!empty($formdata->maxattempts)) {
-            $update->maxattempts = $formdata->maxattempts;
-        }
         if (isset($formdata->preventsubmissionnotingroup)) {
             $update->preventsubmissionnotingroup = $formdata->preventsubmissionnotingroup;
+        }
         $update->markingworkflow = $formdata->markingworkflow;
         $update->markingallocation = $formdata->markingallocation;
         // If marking workflow is disabled, or blindmarking is disabled then make sure marking anonymous is disabled.
         if (empty($update->markingworkflow) || empty($update->blindmarking)) {
             $update->markinganonymous = 0;
+        }
+        // Grade penalties.
+        $update->gradepenalty = $formdata->gradepenalty ?? 0;
         $result = $DB->update_record('assign', $update);
-        $this->instance = $DB->get_record('assign', array('id' => $update->id), '*', MUST_EXIST);
+        $this->instance = $DB->get_record('assign', array('id'=>$update->id), '*', MUST_EXIST);
+            }
+        }
         $this->update_calendar($this->get_course_module()->id);
         $completionexpected = (!empty($formdata->completionexpected)) ? $formdata->completionexpected : null;
-        \core_completion\api::update_completion_date_event(
-            $this->get_course_module()->id,
-            'assign',
-            $this->instance,
+        \core_completion\api::update_completion_date_event($this->get_course_module()->id, 'assign', $this->instance,
-            $completionexpected
-        );
+                $completionexpected);
         $this->update_gradebook(false, $this->get_course_module()->id);
         $update = new stdClass();
         $update->id = $this->get_instance()->id;
+        $update->nosubmissions = (!$this->is_any_submission_plugin_enabled()) ? 1: 0;
+        $DB->update_record('assign', $update);
+        // Check if we need to recalculate penalty for existing grades.
+        if (!empty($formdata->recalculatepenalty) && $formdata->recalculatepenalty === 'yes') {
+            $assign = clone $this->get_instance();
+            $assign->cmidnumber = $this->get_course_module()->idnumber;
-        $update->nosubmissions = (!$this->is_any_submission_plugin_enabled()) ? 1 : 0;
+            assign_update_grades($assign);
         $DB->update_record('assign', $update);
         return $result;
+    }
     /**
      * Save the attachments in the intro description.
-     *
      * @param stdClass $formdata
-     */
-    protected function save_intro_draft_files($formdata)
+     * @param stdClass $formdata
-    {
-        if (isset($formdata->introattachments)) {
-            file_save_draft_area_files(
+     */
-                $formdata->introattachments,
-                $this->get_context()->id,
-                'mod_assign',
+    protected function save_intro_draft_files($formdata) {
-                ASSIGN_INTROATTACHMENT_FILEAREA,
+        if (isset($formdata->introattachments)) {
             file_save_draft_area_files($formdata->introattachments, $this->get_context()->id,
-            );
+                                       'mod_assign', ASSIGN_INTROATTACHMENT_FILEAREA, 0);
+        }
+    }
     /**
-     * Save the attachments in the editor description.
      * Save the attachments in the editor description.
      * @param stdClass $formdata
-     */
+     * @param stdClass $formdata
-    protected function save_editor_draft_files($formdata): string
+     */
-    {
-        $text = '';
+    protected function save_editor_draft_files($formdata): string {
-        if (isset($formdata->activityeditor)) {
-            $text = $formdata->activityeditor['text'];
-            if (isset($formdata->activityeditor['itemid'])) {
+        $text = '';
-                $text = file_save_draft_area_files(
-                    $formdata->activityeditor['itemid'],
-                    $this->get_context()->id,
+        if (isset($formdata->activityeditor)) {
-                    'mod_assign',
-                    ASSIGN_ACTIVITYATTACHMENT_FILEAREA,
+            $text = $formdata->activityeditor['text'];
-,
+            if (isset($formdata->activityeditor['itemid'])) {
-                    array('subdirs' => true),
+                $text = file_save_draft_area_files($formdata->activityeditor['itemid'], $this->get_context()->id,
-                    $formdata->activityeditor['text']
+                    'mod_assign', ASSIGN_ACTIVITYATTACHMENT_FILEAREA,
      * @param MoodleQuickForm $mform
      * @param stdClass $data
      * @param int $userid - The userid we are grading
      * @return void
      */
-    protected function add_plugin_grade_elements($grade, MoodleQuickForm $mform, stdClass $data, $userid)
+    protected function add_plugin_grade_elements($grade, MoodleQuickForm $mform, stdClass $data, $userid) {
-    {
         foreach ($this->feedbackplugins as $plugin) {
             if ($plugin->is_enabled() && $plugin->is_visible()) {
                 $plugin->get_form_elements_for_user($grade, $mform, $data, $userid);
+            }
+        }
      *                               This form is modified directly (not returned).
      * @param array $pluginsenabled A list of form elements to be added to a group.
      *                              The new element is added to this array by this function.
      * @return void
      */
-    protected function add_plugin_settings(assign_plugin $plugin, MoodleQuickForm $mform, &$pluginsenabled)
+    protected function add_plugin_settings(assign_plugin $plugin, MoodleQuickForm $mform, & $pluginsenabled) {
-    {
         global $CFG;
         if ($plugin->is_visible() && !$plugin->is_configurable() && $plugin->is_enabled()) {
             $name = $plugin->get_subtype() . '_' . $plugin->get_type() . '_enabled';
             $pluginsenabled[] = $mform->createElement('hidden', $name, 1);
             $mform->setType($name, PARAM_BOOL);
                 $default = $plugin->is_enabled();
+            }
             $mform->setDefault($plugin->get_subtype() . '_' . $plugin->get_type() . '_enabled', $default);
+            $plugin->get_settings($mform);
             $plugin->get_settings($mform);
+        }
+    }
     /**
      * Add settings to edit plugin form.
+     *
      * @param MoodleQuickForm $mform The form to add the configuration settings to.
      *                               This form is modified directly (not returned).
      * @return void
-     */
-    public function add_all_plugin_settings(MoodleQuickForm $mform)
+     */
     public function add_all_plugin_settings(MoodleQuickForm $mform) {
         $mform->addElement('header', 'submissiontypes', get_string('submissiontypes', 'assign'));
      * passed in to the settings form (needed to set up draft areas for
      * editor and filemanager elements)
+     *
      * @param array $defaultvalues
      */
-    public function plugin_data_preprocessing(&$defaultvalues)
+    public function plugin_data_preprocessing(&$defaultvalues) {
-    {
         foreach ($this->submissionplugins as $plugin) {
             if ($plugin->is_visible()) {
                 $plugin->data_preprocessing($defaultvalues);
+            }
+        }
+            }
+        }
+    }
+    /**
+     * Allow each plugin to validiate the data from the assignments settings form.
+     *
+     * @param array $data as passed to mod_assign_mod_form::validation().
+     * @param array $files as passed to mod_assign_mod_form::validation().
+     * @return array and validation errors that should be displayed.
+     */
+    public function plugin_settings_validation(array $data, array $files): array {
+        $errors = [];
+        foreach ($this->submissionplugins as $plugin) {
+            if ($plugin->is_visible()) {
+                $errors = array_merge($errors, $plugin->settings_validation($data, $files));
+            }
+        }
+        foreach ($this->feedbackplugins as $plugin) {
+            if ($plugin->is_visible()) {
+                $errors = array_merge($errors, $plugin->settings_validation($data, $files));
+            }
+        }
+        return $errors;
+    }
     /**
      * Get the name of the current module.
+     *
      * @return string the module name (Assignment)
      */
-    protected function get_module_name()
     protected function get_module_name() {
         if (isset(self::$modulename)) {
             return self::$modulename;
+        }
         self::$modulename = get_string('modulename', 'assign');
     /**
      * Get the plural name of the current module.
+     *
      * @return string the module name plural (Assignments)
      */
-    protected function get_module_name_plural()
+    protected function get_module_name_plural() {
-    {
         if (isset(self::$modulenameplural)) {
             return self::$modulenameplural;
+        }
         self::$modulenameplural = get_string('modulenameplural', 'assign');
         return self::$modulenameplural;
     /**
      * Has this assignment been constructed from an instance?
+     *
      * @return bool
      */
-    public function has_instance()
+    public function has_instance() {
-    {
         return $this->instance || $this->get_course_module();
+    }
     /**
      * Get the settings for the current instance of this assignment.
+     *
      * @return stdClass The settings
      * @throws dml_exception
      */
-    public function get_default_instance()
     public function get_default_instance() {
         global $DB;
         if (!$this->instance && $this->get_course_module()) {
             $params = array('id' => $this->get_course_module()->instance);
     /**
      * Get the settings for the current instance of this assignment
      * @param int|null $userid the id of the user to load the assign instance for.
      * @return stdClass The settings
      */
-    public function get_instance(int $userid = null): stdClass
+    public function get_instance(?int $userid = null): stdClass {
-    {
         global $USER;
         $userid = $userid ?? $USER->id;
+     *
      * @param stdClass $record the raw assign record.
      * @param int $userid the id of the user to calculate the properties for.
      * @return stdClass a new record having calculated properties.
      */
-    private function calculate_properties(\stdClass $record, int $userid): \stdClass
+    private function calculate_properties(\stdClass $record, int $userid): \stdClass {
-    {
         $record = clone ($record);
         // Relative dates.
         if (!empty($record->duedate)) {
     /**
      * Get the primary grade item for this assign instance.
+     *
      * @return grade_item The grade_item record
      */
-    public function get_grade_item()
+    public function get_grade_item() {
-    {
         if ($this->gradeitem) {
             return $this->gradeitem;
+        }
         $instance = $this->get_instance();
-        $params = array(
-            'itemtype' => 'mod',
+        $params = array('itemtype' => 'mod',
-            'itemmodule' => 'assign',
+                        'itemmodule' => 'assign',
-            'iteminstance' => $instance->id,
+                        'iteminstance' => $instance->id,
-            'courseid' => $instance->course,
+                        'courseid' => $instance->course,
-            'itemnumber' => 0
+                        'itemnumber' => 0);
-        );
         $this->gradeitem = grade_item::fetch($params);
         if (!$this->gradeitem) {
             throw new coding_exception('Improper use of the assignment class. ' .
-                'Cannot load the grade item.');
+                                       'Cannot load the grade item.');
+        }
         return $this->gradeitem;
+    }
     /**
      * Get the context of the current course.
+     *
      * @return mixed context|null The course context
      */
-    public function get_course_context()
     public function get_course_context() {
         if (!$this->context && !$this->course) {
             throw new coding_exception('Improper use of the assignment class. ' .
-                'Cannot load the course context.');
+                                       'Cannot load the course context.');
+        }
         if ($this->context) {
             return $this->context->get_course_context();
         } else {
     /**
      * Get the current course module.
+     *
      * @return cm_info|null The course module or null if not known
      */
-    public function get_course_module()
+    public function get_course_module() {
-    {
         if ($this->coursemodule) {
             return $this->coursemodule;
+        }
         if (!$this->context) {
             return null;
     /**
      * Get context module.
+     *
      * @return context
      */
-    public function get_context()
+    public function get_context() {
-    {
         return $this->context;
+    }
     /**
      * Get the current course.
+     *
      * @return mixed stdClass|null The course
      */
-    public function get_course()
     public function get_course() {
         global $DB;
         if ($this->course && is_object($this->course)) {
     /**
      * Count the number of intro attachments.
+     *
      * @return int
      */
-    protected function count_attachments()
+    protected function count_attachments() {
-    {
-        $fs = get_file_storage();
-        $files = $fs->get_area_files(
-            $this->get_context()->id,
-            'mod_assign',
+        $fs = get_file_storage();
-            ASSIGN_INTROATTACHMENT_FILEAREA,
-,
-            'id',
+        $files = $fs->get_area_files($this->get_context()->id, 'mod_assign', ASSIGN_INTROATTACHMENT_FILEAREA,
-            false
-        );
+, 'id', false);
         return count($files);
+    }
     /**
      * Are there any intro attachments to display?
      *
-     * @return boolean
-     */
+     * @return boolean
-    protected function has_visible_attachments()
+     */
     protected function has_visible_attachments() {
         return ($this->count_attachments() > 0);
+    }
     /**
      * Check if the intro attachments should be provided to the user.
      *
-     * @param int $userid User id.
-     * @return bool
+     * @param int $userid User id.
-     */
+     * @return bool
-    public function should_provide_intro_attachments(int $userid): bool
+     */
     public function should_provide_intro_attachments(int $userid): bool {
+     *
      * @param mixed $grade int|null
      * @param boolean $editing Are we allowing changes to this grade?
      * @param int $userid The user id the grade belongs to
      * @param int $modified Timestamp from when the grade was last modified
+     * @param float $deductedmark The deducted mark if penalty is applied
      * @return string User-friendly representation of grade
      */
-    public function display_grade($grade, $editing, $userid = 0, $modified = 0)
+    public function display_grade($grade, $editing, $userid = 0, $modified = 0, float $deductedmark = 0) {
-    {
-        global $DB;
+        global $DB, $PAGE;
         static $scalegrades = array();
                     $displaygrade = '';
                 } else {
                     $displaygrade = format_float($grade, $this->get_grade_item()->get_decimals());
+                }
                 $o .= '<label class="accesshide" for="quickgrade_' . $userid . '">' .
-                    get_string('usergrade', 'assign') .
+                       get_string('usergrade', 'assign') .
-                    '</label>';
+                       '</label>';
                 $o .= '<input type="text"
                               id="quickgrade_' . $userid . '"
                               name="quickgrade_' . $userid . '"
                               value="' .  $displaygrade . '"
                               size="6"
                               maxlength="10"
                               class="quickgrade"/>';
                 $o .= '&nbsp;/&nbsp;' . format_float($this->get_instance()->grade, $this->get_grade_item()->get_decimals());
-                return $o;
             } else {
                 if ($grade == -1 || $grade === null) {
                     $o .= '-';
                 } else {
                     $item = $this->get_grade_item();
                     if ($item->get_displaytype() == GRADE_DISPLAY_TYPE_REAL) {
                         // If displaying the raw grade, also display the total value.
                         $o .= '&nbsp;/&nbsp;' . format_float($this->get_instance()->grade, $item->get_decimals());
+                    }
+                }
-                return $o;
+            }
+            // Add penalty indicator, icon only.
+            $penaltyindicator = '';
+            if ($deductedmark > 0) {
+                $gradegrade = new \grade_grade();
+                $gradegrade->deductedmark = $deductedmark;
+                $gradegrade->overridden = $userid > 0 ? $this->get_grade_item()->get_grade($userid)->overridden : 0;
+                $penaltyindicator = \core_grades\penalty_manager::show_penalty_indicator($gradegrade);
+            }
+            return $penaltyindicator . $o;
         } else {
             // Scale.
             if (empty($this->cache['scale'])) {
-                if ($scale = $DB->get_record('scale', array('id' => - ($this->get_instance()->grade)))) {
+                if ($scale = $DB->get_record('scale', array('id'=>-($this->get_instance()->grade)))) {
                     $this->cache['scale'] = make_menu_from_list($scale->scale);
                 } else {
                     $o .= '-';
                     return $o;
+                }
+            }
             if ($editing) {
                 $o .= '<label class="accesshide"
                               for="quickgrade_' . $userid . '">' .
-                    get_string('usergrade', 'assign') .
+                      get_string('usergrade', 'assign') .
-                    '</label>';
+                      '</label>';
                 $o .= '<select name="quickgrade_' . $userid . '" class="quickgrade">';
                 $o .= '<option value="-1">' . get_string('nograde') . '</option>';
                 foreach ($this->cache['scale'] as $optionid => $option) {
                     $selected = '';
                     if ($grade == $optionid) {
      * @param array $participants an associative array where the key is the participant id and
      *                            the value is the participant record.
      * @return array an associative array where the key is the participant id and the value is
      *               the participant record.
      */
-    private function get_submission_info_for_participants($participants)
+    private function get_submission_info_for_participants($participants) {
-    {
         global $DB;
         if (empty($participants)) {
             return $participants;
         $records = $DB->get_records_sql($sql, $params);
         if ($this->get_instance()->teamsubmission) {
-            // Get all groups.
-            $allgroups = groups_get_all_groups(
+            // Get all groups.
-                $this->get_course()->id,
+            $allgroups = groups_get_all_groups($this->get_course()->id,
-                array_keys($participants),
+                                               array_keys($participants),
-                $this->get_instance()->teamsubmissiongroupingid,
+                                               $this->get_instance()->teamsubmissiongroupingid,
-                'DISTINCT g.id, g.name'
+                                               'DISTINCT g.id, g.name');
             );
+        }
         foreach ($participants as $userid => $participant) {
             $participants[$userid]->fullname = $this->fullname($participant);
             if (!empty($submissioninfo->stime) && $submissioninfo->status == ASSIGN_SUBMISSION_STATUS_SUBMITTED) {
                 $submitted = true;
+            }
             if ($submitted && ($submissioninfo->stime >= $submissioninfo->gtime ||
-                empty($submissioninfo->gtime) ||
+                    empty($submissioninfo->gtime) ||
-                $submissioninfo->grade === null)) {
+                    $submissioninfo->grade === null)) {
                 $requiregrading = true;
+            }
      * @param int $currentgroup
      * @param boolean $tablesort Apply current user table sorting preferences.
      * @return array List of user records with extra fields 'submitted', 'notsubmitted', 'requiregrading', 'grantedextension',
      *               'groupid', 'groupname'
      */
-    public function list_participants_with_filter_status_and_group($currentgroup, $tablesort = false)
+    public function list_participants_with_filter_status_and_group($currentgroup, $tablesort = false) {
-    {
         $participants = $this->list_participants($currentgroup, false, $tablesort);
         if (empty($participants)) {
             return $participants;
      * we are only concerned with a list of users so we can't search on anything
      * that is not part of the user information (like grading statud or last modified stuff).
+     *
      * @return string Order by clause for list_participants
      */
-    private function get_grading_sort_sql()
+    private function get_grading_sort_sql() {
-    {
         $usersort = flexible_table::get_sort_for_table('mod_assign_grading');
         // TODO Does not support custom user profile fields (MDL-70456).
         $userfieldsapi = \core_user\fields::for_identity($this->context, false)->with_userpic();
         $userfields = $userfieldsapi->get_required_fields();
         $orderfields = explode(',', $usersort);
      * Returns array with sql code and parameters returning all ids of users who have submitted an assignment.
+     *
      * @param int $group The group that the query is for.
      * @return array list($sql, $params)
      */
-    protected function get_submitted_sql($group = 0)
+    protected function get_submitted_sql($group = 0) {
-    {
         // We need to guarentee unique table names.
         static $i = 0;
         $i++;
         $prefix = 'sa' . $i . '_';
         $params = [
      * @param int $currentgroup
      * @param bool $idsonly
      * @param bool $tablesort
      * @return array List of user records
      */
-    public function list_participants($currentgroup, $idsonly, $tablesort = false)
+    public function list_participants($currentgroup, $idsonly, $tablesort = false) {
-    {
         global $DB, $USER;
         // Get the last known sort order for the grading table.
         if (empty($currentgroup)) {
             $currentgroup = 0;
+        }
-        $key = $this->context->id . '-' . $currentgroup . '-' . $this->show_only_active_users();
-        if (!isset($this->participants[$key])) {
-            list($esql, $params) = get_enrolled_sql(
-                $this->context,
+        $key = $this->context->id . '-' . $currentgroup . '-' . $this->show_only_active_users();
-                'mod/assign:submit',
-                $currentgroup,
+        if (!isset($this->participants[$key])) {
-                $this->show_only_active_users()
+            list($esql, $params) = get_enrolled_sql($this->context, 'mod/assign:submit', $currentgroup,
-            );
+                    $this->show_only_active_users());
             list($ssql, $sparams) = $this->get_submitted_sql($currentgroup);
                 if (empty($tablesort)) {
                     $orderby = "COALESCE(s.timecreated, " . time() . ") ASC, COALESCE(s.id, " . PHP_INT_MAX . ") ASC, um.id ASC";
+                }
+            }
-            if (
-                $instance->markingworkflow &&
+            if ($instance->markingworkflow &&
-                $instance->markingallocation &&
+                    $instance->markingallocation &&
-                !has_capability('mod/assign:manageallocations', $this->get_context()) &&
+                    !has_capability('mod/assign:manageallocations', $this->get_context()) &&
-                has_capability('mod/assign:grade', $this->get_context())
-            ) {
+                    has_capability('mod/assign:grade', $this->get_context())) {
                 $additionaljoins .= ' LEFT JOIN {assign_user_flags} uf
                 $additionalfilters .= ' AND uf.allocatedmarker = :markerid';
                 $params['markerid'] = $USER->id;
+            }
+            // A user wants to view a particular user rather than a set of users.
+            if ($this->usersearch) {
+                if (isset($this->usersearch['userid'])) {
+                    $additionalfilters .= " AND u.id = :uid";
+                    $params['uid'] = $this->usersearch['userid'];
+                } else if ($this->usersearch['usersearch'] !== '') { // A user wants to view a subset of learners that match the search criteria.
+                    [
+                        'where' => $keywordswhere,
+                        'params' => $keywordsparams,
+                    ] = \core_user::get_users_search_sql($this->context, $this->usersearch['usersearch']);
+                    $additionalfilters .= " AND $keywordswhere";
+                    $params = array_merge($params, $keywordsparams);
+                }
+            }
+            // Exclude suspended users from the list of participants.
             $additionalfilters .= " AND u.suspended = 0 AND u.auth <> 'nologin'";
             $sql = "SELECT $fields
                       FROM {user} u
                       JOIN ($esql UNION $ssql) je ON je.id = u.id
      * status for this assignment.
+     *
      * @param int $userid
      * @return null|stdClass user record
      */
-    public function get_participant($userid)
+    public function get_participant($userid) {
-    {
         global $DB, $USER;
         if ($userid == $USER->id) {
             $participant = clone ($USER);
      * Load a count of valid teams for this assignment.
+     *
      * @param int $activitygroup Activity active group
      * @return int number of valid teams
      */
-    public function count_teams($activitygroup = 0)
+    public function count_teams($activitygroup = 0) {
-    {
         $count = 0;
         // are the submission teams, but if no team submission grouping was specified
         // $groups will contain all participants groups.
         if ($this->get_instance()->teamsubmissiongroupingid) {
             // We restrict the users to the selected group ones.
-            $groups = groups_get_all_groups(
-                $this->get_course()->id,
+            $groups = groups_get_all_groups($this->get_course()->id,
-                array_keys($participants),
+                                            array_keys($participants),
-                $this->get_instance()->teamsubmissiongroupingid,
+                                            $this->get_instance()->teamsubmissiongroupingid,
-                'DISTINCT g.id, g.name'
-            );
+                                            'DISTINCT g.id, g.name');
             $count = count($groups);
      * 0 for no group.
+     *
      * @param int $currentgroup
      * @return int number of matching users
      */
-    public function count_participants($currentgroup)
+    public function count_participants($currentgroup) {
-    {
         return count($this->list_participants($currentgroup, true));
+    }
     /**
      * grading modification time and the status is SUBMITTED.
+     *
      * @param mixed $currentgroup int|null the group for counting (if null the function will determine it)
      * @return int number of matching submissions
      */
-    public function count_submissions_need_grading($currentgroup = null)
+    public function count_submissions_need_grading($currentgroup = null) {
-    {
         global $DB;
         if ($this->get_instance()->teamsubmission) {
             // This does not make sense for group assignment because the submission is shared.
                         s.latest = 1 AND
                         s.assignment = :assignid AND
                         s.timemodified IS NOT NULL AND
                         s.status = :submitted AND
                         (s.timemodified >= g.timemodified OR g.timemodified IS NULL OR g.grade IS NULL '
-            . $sqlscalegrade . ')';
+                            . $sqlscalegrade . ')';
         return $DB->count_records_sql($sql, $params);
+    }
     /**
      * Load a count of grades.
+     *
      * @return int number of grades
-     */
-    public function count_grades()
+     */
     public function count_grades() {
         global $DB;
      * Load a count of submissions.
+     *
      * @param bool $includenew When true, also counts the submissions with status 'new'.
      * @return int number of submissions
      */
-    public function count_submissions($includenew = false)
+    public function count_submissions($includenew = false) {
-    {
         global $DB;
         if (!$this->has_instance()) {
             return 0;
                         FROM {assign_submission} s
                         WHERE
                             s.assignment = :assignid AND
                             s.timemodified IS NOT NULL AND
                             s.userid = :groupuserid' .
-                $sqlnew;
+                            $sqlnew;
             $params['assignid'] = $this->get_instance()->id;
             $params['groupuserid'] = 0;
         } else {
                        FROM {assign_submission} s
                        JOIN(' . $esql . ') e ON e.id = s.userid
                        WHERE
                             s.assignment = :assignid AND
                             s.timemodified IS NOT NULL ' .
-                $sqlnew;
+                            $sqlnew;
+        }
         return $DB->count_records_sql($sql, $params);
+     *
      * @param string $status The submission status - should match one of the constants
      * @param mixed $currentgroup int|null the group for counting (if null the function will determine it)
      * @return int number of matching submissions
      */
-    public function count_submissions_with_status($status, $currentgroup = null)
+    public function count_submissions_with_status($status, $currentgroup = null) {
-    {
         global $DB;
         if ($currentgroup === null) {
             $currentgroup = groups_get_activity_group($this->get_course_module(), true);
             $groupsstr = '';
             if ($currentgroup != 0) {
                 // If there is an active group we should only display the current group users groups.
                 $participants = $this->list_participants($currentgroup, true);
-                $groups = groups_get_all_groups(
-                    $this->get_course()->id,
+                $groups = groups_get_all_groups($this->get_course()->id,
-                    array_keys($participants),
+                                                array_keys($participants),
-                    $this->get_instance()->teamsubmissiongroupingid,
+                                                $this->get_instance()->teamsubmissiongroupingid,
-                    'DISTINCT g.id, g.name'
-                );
+                                                'DISTINCT g.id, g.name');
                 if (empty($groups)) {
                     // If $groups is empty it means it is not part of $this->get_instance()->teamsubmissiongroupingid.
                     // All submissions from students that do not belong to any of teamsubmissiongroupingid groups
                     // count towards groupid = 0. Setting to true as only '0' key matters.
                         WHERE
                             s.latest = 1 AND
                             s.assignment = :assignid AND
                             s.timemodified IS NOT NULL AND
                             s.userid = :groupuserid AND '
-                . $groupsstr . '
+                            . $groupsstr . '
                             s.status = :submissionstatus';
             $params['groupuserid'] = 0;
         } else {
             $sql = 'SELECT COUNT(s.userid)
                         FROM {assign_submission} s
                         WHERE
                             s.latest = 1 AND
                             s.assignment = :assignid AND
                             s.timemodified IS NOT NULL AND
                             s.status = :submissionstatus';
+        }
         return $DB->count_records_sql($sql, $params);
+     *
      * @param boolean $cached If true, the cached list from the session could be returned.
      * @param string $useridlistid String value used for caching the participant list.
      * @return array An array of userids
      */
-    protected function get_grading_userid_list($cached = false, $useridlistid = '')
+    protected function get_grading_userid_list($cached = false, $useridlistid = '') {
-    {
         global $SESSION;
         if ($cached) {
             if (empty($useridlistid)) {
      * Is user id filtered by user filters and table preferences.
+     *
      * @param int $userid User id that needs to be checked.
      * @return bool
      */
-    public function is_userid_filtered($userid)
+    public function is_userid_filtered($userid) {
-    {
         $users = $this->get_grading_userid_list();
         return in_array($userid, $users);
+    }
+     *
      * Cron function to be run periodically according to the moodle cron.
+     *
      * @return bool
      */
-    public static function cron()
+    public static function cron() {
-    {
         global $DB;
         // Only ever send a max of one days worth of updates.
         $yesterday = time() - (24 * 3600);
             // Filter out duplicates.
             $courseids = array_unique($courseids);
             $ctxselect = context_helper::get_preload_record_columns_sql('ctx');
             list($courseidsql, $params) = $DB->get_in_or_equal($courseids, SQL_PARAMS_NAMED);
             $sql = 'SELECT c.*, ' . $ctxselect .
-                ' FROM {course} c
+                      ' FROM {course} c
                  LEFT JOIN {context} ctx ON ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel
                      WHERE c.id ' . $courseidsql;
             $params['contextlevel'] = CONTEXT_COURSE;
             foreach ($submissions as $submission) {
                 mtrace("Processing assignment submission $submission->id ...");
                 // Do not cache user lookups - could be too many.
-                if (!$user = $DB->get_record('user', array('id' => $submission->userid))) {
+                if (!$user = $DB->get_record('user', array('id'=>$submission->userid))) {
                     mtrace('Could not find user ' . $submission->userid);
                     continue;
                 \core\cron::setup_user($user, $course);
                 // Context lookups are already cached.
                 $coursecontext = context_course::instance($course->id);
                 if (!is_enrolled($coursecontext, $user->id)) {
-                    $courseshortname = format_string(
+                    $courseshortname = format_string($course->shortname,
-                        $course->shortname,
-                        true,
+                                                     true,
-                        array('context' => $coursecontext)
-                    );
+                                                     array('context' => $coursecontext));
                     mtrace(fullname($user) . ' not an active participant in ' . $courseshortname);
                     continue;
                 }
-                if (!$grader = $DB->get_record('user', array('id' => $submission->grader))) {
+                if (!$grader = $DB->get_record('user', array('id'=>$submission->grader))) {
                     mtrace('Could not find grader ' . $submission->grader);
                     continue;
                     } else {
                         $uniqueid = $submission->recordid;
+                    }
+                }
                 $showusers = $submission->blindmarking && !$submission->revealidentities;
-                self::send_assignment_notification(
+                self::send_assignment_notification($grader,
-                    $grader,
-                    $user,
+                                                   $user,
-                    $messagetype,
+                                                   $messagetype,
-                    $eventtype,
+                                                   $eventtype,
-                    $updatetime,
+                                                   $updatetime,
-                    $cm,
+                                                   $cm,
-                    $contextmodule,
+                                                   $contextmodule,
-                    $course,
+                                                   $course,
-                    $modulename,
+                                                   $modulename,
-                    $submission->name,
+                                                   $submission->name,
-                    $showusers,
+                                                   $showusers,
-                    $uniqueid
+                                                   $uniqueid);
-                );
-                $flags = $DB->get_record('assign_user_flags', array('userid' => $user->id, 'assignment' => $submission->assignment));
+                $flags = $DB->get_record('assign_user_flags', array('userid'=>$user->id, 'assignment'=>$submission->assignment));
                 if ($flags) {
                     $flags->mailed = 1;
                     $DB->update_record('assign_user_flags', $flags);
                 } else {
+     *
      * @param stdClass $grade a grade record keyed on id
      * @param bool $mailedoverride when true, flag notification to be sent again.
      * @return bool true for success
      */
-    public function notify_grade_modified($grade, $mailedoverride = false)
+    public function notify_grade_modified($grade, $mailedoverride = false) {
-    {
         global $DB;
         $flags = $this->get_user_flags($grade->userid, true);
         if ($flags->mailed != 1 || $mailedoverride) {
      * Update user flags for this user in this assignment.
+     *
      * @param stdClass $flags a flags record keyed on id
      * @return bool true for success
      */
-    public function update_user_flags($flags)
+    public function update_user_flags($flags) {
-    {
         global $DB;
         if ($flags->userid <= 0 || $flags->assignment <= 0 || $flags->id <= 0) {
             return false;
+        }
+     *
      * @param stdClass $grade a grade record keyed on id
      * @param bool $reopenattempt If the attempt reopen method is manual, allow another attempt at this assignment.
      * @return bool true for success
      */
-    public function update_grade($grade, $reopenattempt = false)
+    public function update_grade($grade, $reopenattempt = false) {
-    {
         global $DB;
         $grade->timemodified = time();
                 } else if ($grade->grade < 0) {
                     return false;
+                }
             } else {
                 // This is a scale.
-                if ($scale = $DB->get_record('scale', array('id' => - ($this->get_instance()->grade)))) {
+                if ($scale = $DB->get_record('scale', array('id' => -($this->get_instance()->grade)))) {
                     $scaleoptions = make_menu_from_list($scale->scale);
                     if (!array_key_exists((int) $grade->grade, $scaleoptions)) {
                         return false;
+                    }
+                }
             \mod_assign\event\submission_graded::create_from_grade($this, $grade)->trigger();
+        }
         // If the conditions are met, allow another attempt.
         if ($submission) {
-            $isreopened = $this->reopen_submission_if_required(
-                $grade->userid,
+            $isreopened = $this->reopen_submission_if_required($grade->userid,
-                $submission,
+                    $submission,
-                $reopenattempt
-            );
+                    $reopenattempt);
             if ($isreopened) {
-                $completion = new completion_info($this->get_course());
-                if (
+                $completion = new completion_info($this->get_course());
-                    $completion->is_enabled($this->get_course_module()) &&
+                if ($completion->is_enabled($this->get_course_module()) &&
-                    $this->get_instance()->completionsubmit
-                ) {
+                    $this->get_instance()->completionsubmit) {
                     $completion->update_state($this->get_course_module(), COMPLETION_INCOMPLETE, $grade->userid);
+                }
+            }
      * or from parameter 'selectedusers'
+     *
      * @param moodleform $mform - Used for validation of the submitted data
      * @return string
      */
-    protected function view_grant_extension($mform)
+    protected function view_grant_extension($mform) {
-    {
         global $CFG;
         require_once($CFG->dirroot . '/mod/assign/extensionform.php');
         if (empty($mform)) {
             $mform = new mod_assign_extension_form(null, $formparams);
+        }
         $mform->set_data($data);
-        $header = new assign_header(
-            $this->get_instance(),
+        $header = new assign_header($this->get_instance(),
-            $this->get_context(),
+                                    $this->get_context(),
-            $this->show_intro(),
+                                    $this->show_intro(),
-            $this->get_course_module()->id,
+                                    $this->get_course_module()->id,
-            get_string('grantextension', 'assign')
-        );
+                                    get_string('grantextension', 'assign'));
         $o .= $this->get_renderer()->render($header);
         $o .= $this->get_renderer()->render(new assign_form('extensionform', $mform));
         $o .= $this->view_footer();
         return $o;
      * @param int $groupid The id of the group whose members we want or 0 for the default group
      * @param bool $onlyids Whether to retrieve only the user id's
      * @param bool $excludesuspended Whether to exclude suspended users
      * @return array The users (possibly id's only)
      */
-    public function get_submission_group_members($groupid, $onlyids, $excludesuspended = false)
+    public function get_submission_group_members($groupid, $onlyids, $excludesuspended = false) {
-    {
         $members = array();
         if ($groupid != 0) {
             $allusers = $this->list_participants($groupid, $onlyids);
             foreach ($allusers as $user) {
                 if ($this->get_submission_group($user->id)) {
+     *
      * @param int $groupid The id of the group whose members we want or 0 for the default group
      * @param bool $onlyids Whether to retrieve only the user id's
      * @return array The users (possibly id's only)
      */
-    public function get_submission_group_members_who_have_not_submitted($groupid, $onlyids)
+    public function get_submission_group_members_who_have_not_submitted($groupid, $onlyids) {
-    {
         $instance = $this->get_instance();
         if (!$instance->teamsubmission || !$instance->requireallteammemberssubmit) {
             return array();
+        }
         $members = $this->get_submission_group_members($groupid, $onlyids);
             if ($submission && $submission->status == ASSIGN_SUBMISSION_STATUS_SUBMITTED) {
                 unset($members[$id]);
             } else {
                 if ($this->is_blind_marking()) {
                     $members[$id]->alias = get_string('hiddenuser', 'assign') .
-                        $this->get_uniqueid_for_user($id);
+                                           $this->get_uniqueid_for_user($id);
+                }
+            }
+        }
         return $members;
+    }
      * @param bool $create If set to true a new submission object will be created in the database
      *                     with the status set to "new".
      * @param int $attemptnumber - -1 means the latest attempt
      * @return stdClass|false The submission
      */
-    public function get_group_submission($userid, $groupid, $create, $attemptnumber = -1)
+    public function get_group_submission($userid, $groupid, $create, $attemptnumber=-1) {
-    {
         global $DB;
         if ($groupid == 0) {
             $group = $this->get_submission_group($userid);
             if ($group) {
                 $groupid = $group->id;
+            }
+        }
         // Now get the group submission.
-        $params = array('assignment' => $this->get_instance()->id, 'groupid' => $groupid, 'userid' => 0);
+        $params = array('assignment'=>$this->get_instance()->id, 'groupid'=>$groupid, 'userid'=>0);
         if ($attemptnumber >= 0) {
             $params['attemptnumber'] = $attemptnumber;
             } else {
                 $submission->attemptnumber = 0;
+            }
             // Work out if this is the latest submission.
             $submission->latest = 0;
-            $params = array('assignment' => $this->get_instance()->id, 'groupid' => $groupid, 'userid' => 0);
+            $params = array('assignment'=>$this->get_instance()->id, 'groupid'=>$groupid, 'userid'=>0);
             if ($attemptnumber == -1) {
                 // This is a new submission so it must be the latest.
                 $submission->latest = 1;
             } else {
                 // We need to work this out.
+        }
         return false;
+    }
-    /**
-     * View a summary listing of all assignments in the current course.
-     *
-     * @return string
-     */
-    private function view_course_index()
-    {
-        global $USER;
-        $o = '';
-        $course = $this->get_course();
-        $strplural = get_string('modulenameplural', 'assign');
-        if (!$cms = get_coursemodules_in_course('assign', $course->id, 'm.duedate')) {
-            $o .= $this->get_renderer()->notification(get_string('thereareno', 'moodle', $strplural));
-            $o .= $this->get_renderer()->continue_button(new moodle_url('/course/view.php', array('id' => $course->id)));
-            return $o;
-        }
-        $strsectionname = '';
-        $usesections = course_format_uses_sections($course->format);
-        $modinfo = get_fast_modinfo($course);
-        if ($usesections) {
-            $strsectionname = get_string('sectionname', 'format_' . $course->format);
-            $sections = $modinfo->get_section_info_all();
-        }
-        $courseindexsummary = new assign_course_index_summary($usesections, $strsectionname);
-        $timenow = time();
-        $currentsection = '';
-        foreach ($modinfo->instances['assign'] as $cm) {
-            if (!$cm->uservisible) {
-                continue;
-            }
-            $timedue = $cms[$cm->id]->duedate;
-            $sectionname = '';
-            if ($usesections && $cm->sectionnum) {
-                $sectionname = get_section_name($course, $sections[$cm->sectionnum]);
-            }
-            $submitted = '';
-            $context = context_module::instance($cm->id);
-            $assignment = new assign($context, $cm, $course);
-            // Apply overrides.
-            $assignment->update_effective_access($USER->id);
-            $timedue = $assignment->get_instance()->duedate;
-            if (
-                has_capability('mod/assign:submit', $context) &&
-                !has_capability('moodle/site:config', $context)
-            ) {
-                $cangrade = false;
-                if ($assignment->get_instance()->teamsubmission) {
-                    $usersubmission = $assignment->get_group_submission($USER->id, 0, false);
-                } else {
-                    $usersubmission = $assignment->get_user_submission($USER->id, false);
-                }
-                if (!empty($usersubmission->status)) {
-                    $submitted = get_string('submissionstatus_' . $usersubmission->status, 'assign');
-                } else {
-                    $submitted = get_string('submissionstatus_', 'assign');
-                }
-                $gradinginfo = grade_get_grades($course->id, 'mod', 'assign', $cm->instance, $USER->id);
-                if (
-                    isset($gradinginfo->items[0]->grades[$USER->id]) &&
-                    !$gradinginfo->items[0]->grades[$USER->id]->hidden
-                ) {
-                    $grade = $gradinginfo->items[0]->grades[$USER->id]->str_grade;
-                } else {
-                    $grade = '-';
-                }
-            } else if (has_capability('mod/assign:grade', $context)) {
-                $submitted = $assignment->count_submissions_with_status(ASSIGN_SUBMISSION_STATUS_SUBMITTED);
-                $grade = $assignment->count_submissions_need_grading();
-                $cangrade = true;
-            }
-            $courseindexsummary->add_assign_info(
-                $cm->id,
-                $cm->get_formatted_name(),
-                $sectionname,
-                $timedue,
-                $submitted,
-                $grade,
-                $cangrade
-            );
-        }
-        $o .= $this->get_renderer()->render($courseindexsummary);
-        $o .= $this->view_footer();
-        return $o;
-    }
     /**
      * View a page rendered by a plugin.
+     *
      * Uses url parameters 'pluginaction', 'pluginsubtype', 'plugin', and 'id'.
+     *
      * @return string
      */
-    protected function view_plugin_page()
     protected function view_plugin_page() {
         global $USER;
      * If the user is a member of multiple or no groups this will return false
+     *
      * @param int $userid The id of the user whose submission we want
      * @return mixed The group or false
      */
-    public function get_submission_group($userid)
+    public function get_submission_group($userid) {
-    {
         if (isset($this->usersubmissiongroups[$userid])) {
             return $this->usersubmissiongroups[$userid];
      * Gets all groups the user is a member of.
+     *
      * @param int $userid Teh id of the user who's groups we are checking
      * @return array The group objects
      */
-    public function get_all_groups($userid)
+    public function get_all_groups($userid) {
-    {
         if (isset($this->usergroups[$userid])) {
             return $this->usergroups[$userid];
+        }
      * Uses url parameters 'sid', 'gid' and 'plugin'.
+     *
      * @param string $pluginsubtype
      * @return string
      */
-    protected function view_plugin_content($pluginsubtype)
+    protected function view_plugin_content($pluginsubtype) {
-    {
         $o = '';
         $submissionid = optional_param('sid', 0, PARAM_INT);
         $gradeid = optional_param('gid', 0, PARAM_INT);
                 // Group submission.
                 $this->require_view_group_submission($item->groupid);
             } else {
                 $this->require_view_submission($item->userid);
+            }
-            $o .= $this->get_renderer()->render(new assign_header(
+            $o .= $this->get_renderer()->render(new assign_header($this->get_instance(),
-                $this->get_instance(),
-                $this->get_context(),
+                                                              $this->get_context(),
-                $this->show_intro(),
+                                                              $this->show_intro(),
-                $this->get_course_module()->id,
+                                                              $this->get_course_module()->id,
-                $plugin->get_name()
+                                                              $plugin->get_name()));
-            ));
-            $o .= $this->get_renderer()->render(new assign_submission_plugin_submission(
+            $o .= $this->get_renderer()->render(new assign_submission_plugin_submission($plugin,
-                $plugin,
-                $item,
+                                                              $item,
-                assign_submission_plugin_submission::FULL,
+                                                              assign_submission_plugin_submission::FULL,
-                $this->get_course_module()->id,
+                                                              $this->get_course_module()->id,
-                $this->get_return_action(),
+                                                              $this->get_return_action(),
-                $this->get_return_params()
+                                                              $this->get_return_params()));
-            ));
             // Trigger event for viewing a submission.
+            \mod_assign\event\submission_viewed::create_from_submission($this, $item)->trigger();
             \mod_assign\event\submission_viewed::create_from_submission($this, $item)->trigger();
         } else {
             $plugin = $this->get_feedback_plugin_by_type($plugintype);
             if ($gradeid <= 0) {
                 throw new coding_exception('Grade id should not be 0');
+            }
             $item = $this->get_grade($gradeid);
             // Check permissions.
             $this->require_view_submission($item->userid);
-            $o .= $this->get_renderer()->render(new assign_header(
-                $this->get_instance(),
+            $o .= $this->get_renderer()->render(new assign_header($this->get_instance(),
-                $this->get_context(),
+                                                              $this->get_context(),
-                $this->show_intro(),
+                                                              $this->show_intro(),
-                $this->get_course_module()->id,
+                                                              $this->get_course_module()->id,
-                $plugin->get_name()
-            ));
+                                                              $plugin->get_name()));
-            $o .= $this->get_renderer()->render(new assign_feedback_plugin_feedback(
-                $plugin,
+            $o .= $this->get_renderer()->render(new assign_feedback_plugin_feedback($plugin,
-                $item,
+                                                              $item,
-                assign_feedback_plugin_feedback::FULL,
+                                                              assign_feedback_plugin_feedback::FULL,
-                $this->get_course_module()->id,
+                                                              $this->get_course_module()->id,
-                $this->get_return_action(),
+                                                              $this->get_return_action(),
-                $this->get_return_params()
-            ));
+                                                              $this->get_return_params()));
             // Trigger event for viewing feedback.
+     *
      * @param string $text - The replacement text
      * @param stdClass $user - The user record
      * @param assign_plugin $plugin - The assignment plugin
      */
-    public function download_rewrite_pluginfile_urls($text, $user, $plugin)
+    public function download_rewrite_pluginfile_urls($text, $user, $plugin) {
-    {
         // The groupname prefix for the urls doesn't depend on the group mode of the assignment instance.
         // Rather, it should be determined by checking the group submission settings of the instance,
         // which is what download_submission() does when generating the file name prefixes.
         $groupname = '';
         if ($this->get_instance()->teamsubmission) {
      * @param string $editor
      * @param string $component
      * @param bool $shortentext Whether to shorten the text content.
      * @return string
      */
-    public function render_editor_content($filearea, $submissionid, $plugintype, $editor, $component, $shortentext = false)
+    public function render_editor_content($filearea, $submissionid, $plugintype, $editor, $component, $shortentext = false) {
-    {
         global $CFG;
         $result = '';
         if ($shortentext) {
             $text = shorten_text($text, 140);
+        }
         $format = $plugin->get_editor_format($editor, $submissionid);
-        $finaltext = file_rewrite_pluginfile_urls(
-            $text,
+        $finaltext = file_rewrite_pluginfile_urls($text,
-            'pluginfile.php',
+                                                  'pluginfile.php',
-            $this->get_context()->id,
+                                                  $this->get_context()->id,
-            $component,
+                                                  $component,
-            $filearea,
+                                                  $filearea,
-            $submissionid
-        );
+                                                  $submissionid);
         $params = array('overflowdiv' => true, 'context' => $this->get_context());
         $result .= format_text($finaltext, $format, $params);
         if ($CFG->enableportfolios && has_capability('mod/assign:exportownsubmission', $this->context)) {
-            require_once($CFG->libdir . '/portfoliolib.php');
+            require_once($CFG->libdir . '/portfoliolib.php');
-            $button = new portfolio_add_button();
-            $portfolioparams = array(
+            $button = new portfolio_add_button();
-                'cmid' => $this->get_course_module()->id,
+            $portfolioparams = array('cmid' => $this->get_course_module()->id,
-                'sid' => $submissionid,
+                                     'sid' => $submissionid,
-                'plugin' => $plugintype,
-                'editor' => $editor,
+                                     'plugin' => $plugintype,
-                'area' => $filearea
+                                     'editor' => $editor,
-            );
+                                     'area'=>$filearea);
-            $button->set_callback_options('assign_portfolio_caller', $portfolioparams, 'mod_assign');
-            $fs = get_file_storage();
+            $button->set_callback_options('assign_portfolio_caller', $portfolioparams, 'mod_assign');
+            $fs = get_file_storage();
-            if ($files = $fs->get_area_files(
-                $this->context->id,
+            if ($files = $fs->get_area_files($this->context->id,
-                $component,
+                                             $component,
-                $filearea,
-                $submissionid,
+                                             $filearea,
-                'timemodified',
+                                             $submissionid,
-                false
+                                             'timemodified',
-            )) {
+                                             false)) {
                 $button->set_formats(PORTFOLIO_FORMAT_RICHHTML);
      * Display a continue page after grading.
+     *
      * @param string $message - The message to display.
      * @return string
      */
-    protected function view_savegrading_result($message)
+    protected function view_savegrading_result($message) {
-    {
         $o = '';
-        $o .= $this->get_renderer()->render(new assign_header(
+        $o .= $this->get_renderer()->render(new assign_header($this->get_instance(),
-            $this->get_instance(),
-            $this->get_context(),
+                                                      $this->get_context(),
-            $this->show_intro(),
+                                                      $this->show_intro(),
-            $this->get_course_module()->id,
+                                                      $this->get_course_module()->id,
-            get_string('savegradingresult', 'assign')
+                                                      get_string('savegradingresult', 'assign')));
-        ));
-        $gradingresult = new assign_gradingmessage(
+        $gradingresult = new assign_gradingmessage(get_string('savegradingresult', 'assign'),
-            get_string('savegradingresult', 'assign'),
+                                                   $message,
-            $message,
-            $this->get_course_module()->id
+                                                   $this->get_course_module()->id);
-        );
         $o .= $this->get_renderer()->render($gradingresult);
         $o .= $this->view_footer();
         return $o;
+    }
     /**
      * Display a continue page after quickgrading.
+     *
      * @param string $message - The message to display.
      * @return string
      */
-    protected function view_quickgrading_result($message)
+    protected function view_quickgrading_result($message) {
-    {
         $o = '';
-        $o .= $this->get_renderer()->render(new assign_header(
+        $o .= $this->get_renderer()->render(new assign_header($this->get_instance(),
-            $this->get_instance(),
-            $this->get_context(),
+                                                      $this->get_context(),
-            $this->show_intro(),
+                                                      $this->show_intro(),
-            $this->get_course_module()->id,
+                                                      $this->get_course_module()->id,
-            get_string('quickgradingresult', 'assign')
+                                                      get_string('quickgradingresult', 'assign')));
-        ));
         $gradingerror = in_array($message, $this->get_error_messages());
         $lastpage = optional_param('lastpage', null, PARAM_INT);
-        $gradingresult = new assign_gradingmessage(
+        $gradingresult = new assign_gradingmessage(get_string('quickgradingresult', 'assign'),
-            get_string('quickgradingresult', 'assign'),
+                                                   $message,
-            $message,
-            $this->get_course_module()->id,
+                                                   $this->get_course_module()->id,
-            $gradingerror,
+                                                   $gradingerror,
-            $lastpage
+                                                   $lastpage);
-        );
         $o .= $this->get_renderer()->render($gradingresult);
         $o .= $this->view_footer();
         return $o;
+    }
     /**
      * Display the page footer.
+     *
      * @return string
      */
-    protected function view_footer()
     protected function view_footer() {
         // When viewing the footer during PHPUNIT tests a set_state error is thrown.
         if (!PHPUNIT_TEST) {
             return $this->get_renderer()->render_footer();
      * Throw an error if the permissions to view this users' group submission are missing.
+     *
      * @param int $groupid Group id.
      * @throws required_capability_exception
      */
-    public function require_view_group_submission($groupid)
+    public function require_view_group_submission($groupid) {
-    {
         if (!$this->can_view_group_submission($groupid)) {
             throw new required_capability_exception($this->context, 'mod/assign:viewgrades', 'nopermission', '');
+        }
+    }
      * Throw an error if the permissions to view this users submission are missing.
+     *
      * @throws required_capability_exception
      * @return none
      */
-    public function require_view_submission($userid)
+    public function require_view_submission($userid) {
-    {
         if (!$this->can_view_submission($userid)) {
             throw new required_capability_exception($this->context, 'mod/assign:viewgrades', 'nopermission', '');
+        }
+    }
      * Throw an error if the permissions to view grades in this assignment are missing.
+     *
      * @throws required_capability_exception
      * @return none
      */
-    public function require_view_grades()
+    public function require_view_grades() {
-    {
         if (!$this->can_view_grades()) {
             throw new required_capability_exception($this->context, 'mod/assign:viewgrades', 'nopermission', '');
+        }
+    }
      * Does this user have view grade or grade permission for this assignment?
+     *
      * @param mixed $groupid int|null when is set to a value, use this group instead calculating it
      * @return bool
      */
-    public function can_view_grades($groupid = null)
+    public function can_view_grades($groupid = null) {
-    {
         // Permissions check.
         if (!has_any_capability(array('mod/assign:viewgrades', 'mod/assign:grade'), $this->context)) {
             return false;
+        }
         // Checks for the edge case when user belongs to no groups and groupmode is sep.
      * Does this user have grade permission for this assignment?
+     *
      * @param int|stdClass $user The object or id of the user who will do the editing (default to current user).
      * @return bool
      */
-    public function can_grade($user = null)
+    public function can_grade($user = null) {
-    {
         // Permissions check.
         if (!has_capability('mod/assign:grade', $this->context, $user)) {
             return false;
+        }
+    }
     /**
      * Download a zip file of all assignment submissions.
      *
-     * @param array|null $userids Array of user ids to download assignment submissions in a zip file
+     * @param int[]|null $userids Array of user ids to download assignment submissions in a zip file
      * @return string - If an error occurs, this will contain the error page.
      */
-    protected function download_submissions($userids = null)
     protected function download_submissions($userids = null) {
         $downloader = new downloader($this, $userids ?: null);
         if ($downloader->load_filelist()) {
             $downloader->download_zip();
+        }
         $result .= $this->view_footer();
         return $result;
+    }
-    /**
-     * @deprecated since 2.7 - Use new events system instead.
-     */
-    public function add_to_log()
-    {
-        throw new coding_exception(__FUNCTION__ . ' has been deprecated, please do not use it any more');
-    }
     /**
      * Lazy load the page renderer and expose the renderer to plugins.
+     *
      * @return assign_renderer
      */
-    public function get_renderer()
     public function get_renderer() {
         global $PAGE;
         if ($this->output) {
             return $this->output;
+        }
      * @param int $userid The id of the user whose submission we want or 0 in which case USER->id is used
      * @param bool $create If set to true a new submission object will be created in the database with the status set to "new".
      * @param int $attemptnumber - -1 means the latest attempt
      * @return stdClass|false The submission
      */
-    public function get_user_submission($userid, $create, $attemptnumber = -1)
+    public function get_user_submission($userid, $create, $attemptnumber=-1) {
-    {
         global $DB, $USER;
         if (!$userid) {
             $userid = $USER->id;
+        }
         // If the userid is not null then use userid.
-        $params = array('assignment' => $this->get_instance()->id, 'userid' => $userid, 'groupid' => 0);
+        $params = array('assignment'=>$this->get_instance()->id, 'userid'=>$userid, 'groupid'=>0);
         if ($attemptnumber >= 0) {
             $params['attemptnumber'] = $attemptnumber;
+        }
             } else {
                 $submission->attemptnumber = 0;
+            }
             // Work out if this is the latest submission.
             $submission->latest = 0;
-            $params = array('assignment' => $this->get_instance()->id, 'userid' => $userid, 'groupid' => 0);
+            $params = array('assignment'=>$this->get_instance()->id, 'userid'=>$userid, 'groupid'=>0);
             if ($attemptnumber == -1) {
                 // This is a new submission so it must be the latest.
                 $submission->latest = 1;
             } else {
                 // We need to work this out.
      * Load the submission object from it's id.
+     *
      * @param int $submissionid The id of the submission we want
      * @return stdClass The submission
      */
-    protected function get_submission($submissionid)
+    protected function get_submission($submissionid) {
-    {
         global $DB;
-        $params = array('assignment' => $this->get_instance()->id, 'id' => $submissionid);
+        $params = array('assignment'=>$this->get_instance()->id, 'id'=>$submissionid);
         return $DB->get_record('assign_submission', $params, '*', MUST_EXIST);
+    }
+     *
      * @param int $userid The user we are getting the flags for.
      * @param bool $create If true the flags record will be created if it does not exist
      * @return stdClass The flags record
      */
-    public function get_user_flags($userid, $create)
+    public function get_user_flags($userid, $create) {
-    {
         global $DB, $USER;
         // If the userid is not null then use userid.
         if (!$userid) {
             $userid = $USER->id;
         }
-        $params = array('assignment' => $this->get_instance()->id, 'userid' => $userid);
+        $params = array('assignment'=>$this->get_instance()->id, 'userid'=>$userid);
      * @param int $userid The user we are grading
      * @param bool $create If true the grade will be created if it does not exist
      * @param int $attemptnumber The attempt number to retrieve the grade for. -1 means the latest submission.
      * @return stdClass The grade record
      */
-    public function get_user_grade($userid, $create, $attemptnumber = -1)
+    public function get_user_grade($userid, $create, $attemptnumber=-1) {
-    {
         global $DB, $USER;
         // If the userid is not null then use userid.
         if (!$userid) {
             $userid = $USER->id;
+        }
         $submission = null;
-        $params = array('assignment' => $this->get_instance()->id, 'userid' => $userid);
+        $params = array('assignment'=>$this->get_instance()->id, 'userid'=>$userid);
         if ($attemptnumber < 0 || $create) {
             // Make sure this grade matches the latest submission attempt.
             if ($this->get_instance()->teamsubmission) {
             // Do not set the grader id here as it would be the admin users which is incorrect.
             $grade->grader = -1;
             if ($attemptnumber >= 0) {
                 $grade->attemptnumber = $attemptnumber;
+            }
+            $grade->penalty = 0.0;
             $gid = $DB->insert_record('assign_grades', $grade);
             $grade->id = $gid;
             return $grade;
      * This will retrieve a grade object from the db.
+     *
      * @param int $gradeid The id of the grade
      * @return stdClass The grade record
      */
-    protected function get_grade($gradeid)
+    protected function get_grade($gradeid) {
-    {
         global $DB;
-        $params = array('assignment' => $this->get_instance()->id, 'id' => $gradeid);
+        $params = array('assignment'=>$this->get_instance()->id, 'id'=>$gradeid);
         return $DB->get_record('assign_grades', $params, '*', MUST_EXIST);
+    }
     /**
      * Print the grading page for a single user submission.
+     *
      * @param array $args Optional args array (better than pulling args from _GET and _POST)
      * @return string
-     */
-    protected function view_single_grading_panel($args)
+     */
     protected function view_single_grading_panel($args) {
         global $DB, $CFG;
             $groupid = 0;
             if ($submissiongroup) {
                 $groupid = $submissiongroup->id;
+            }
             $notsubmitted = $this->get_submission_group_members_who_have_not_submitted($groupid, false);
+        }
         // Get the requested grade.
         $grade = $this->get_user_grade($userid, false, $attemptnumber);
+            }
             $showedit = $this->submissions_open($userid) && ($this->is_any_submission_plugin_enabled());
             $viewfullnames = has_capability('moodle/site:viewfullnames', $this->get_context());
             $usergroups = $this->get_all_groups($user->id);
-            $submissionstatus = new assign_submission_status_compact(
-                $instance->allowsubmissionsfromdate,
+            $submissionstatus = new assign_submission_status_compact($instance->allowsubmissionsfromdate,
-                $instance->alwaysshowdescription,
+                                                                     $instance->alwaysshowdescription,
-                $submission,
+                                                                     $submission,
-                $instance->teamsubmission,
+                                                                     $instance->teamsubmission,
-                $teamsubmission,
+                                                                     $teamsubmission,
-                $submissiongroup,
+                                                                     $submissiongroup,
-                $notsubmitted,
+                                                                     $notsubmitted,
-                $this->is_any_submission_plugin_enabled(),
+                                                                     $this->is_any_submission_plugin_enabled(),
-                $submissionlocked,
+                                                                     $submissionlocked,
-                $this->is_graded($userid),
+                                                                     $this->is_graded($userid),
-                $instance->duedate,
+                                                                     $instance->duedate,
-                $instance->cutoffdate,
+                                                                     $instance->cutoffdate,
-                $this->get_submission_plugins(),
+                                                                     $this->get_submission_plugins(),
-                $this->get_return_action(),
+                                                                     $this->get_return_action(),
-                $this->get_return_params(),
+                                                                     $this->get_return_params(),
-                $this->get_course_module()->id,
+                                                                     $this->get_course_module()->id,
-                $this->get_course()->id,
+                                                                     $this->get_course()->id,
-                assign_submission_status::GRADER_VIEW,
+                                                                     assign_submission_status::GRADER_VIEW,
-                $showedit,
+                                                                     $showedit,
-                false,
+                                                                     false,
-                $viewfullnames,
+                                                                     $viewfullnames,
-                $extensionduedate,
+                                                                     $extensionduedate,
-                $this->get_context(),
+                                                                     $this->get_context(),
-                $this->is_blind_marking(),
+                                                                     $this->is_blind_marking(),
-                '',
+                                                                     '',
-                $instance->attemptreopenmethod,
+                                                                     $instance->attemptreopenmethod,
-                $instance->maxattempts,
+                                                                     $instance->maxattempts,
-                $this->get_grading_status($userid),
+                                                                     $this->get_grading_status($userid),
-                $instance->preventsubmissionnotingroup,
+                                                                     $instance->preventsubmissionnotingroup,
-                $usergroups,
+                                                                     $usergroups,
-                $instance->timelimit
-            );
+                                                                     $instance->timelimit);
             $o .= $this->get_renderer()->render($submissionstatus);
+        }
         // Warning if required.
         $allsubmissions = $this->get_all_submissions($userid);
-        if ($attemptnumber != -1 && ($attemptnumber + 1) != count($allsubmissions)) {
-            $params = array(
+        if ($attemptnumber != -1 && ($attemptnumber + 1) != count($allsubmissions)) {
-                'attemptnumber' => $attemptnumber + 1,
-                'totalattempts' => count($allsubmissions)
+            $params = array('attemptnumber' => $attemptnumber + 1,
-            );
+                            'totalattempts' => count($allsubmissions));
             $message = get_string('editingpreviousfeedbackwarning', 'assign', $params);
-            $o .= $this->get_renderer()->notification($message);
-        }
+            $o .= $this->get_renderer()->notification($message);
+        }
-        $pagination = array(
-            'rownum' => $rownum,
+        $pagination = array('rownum' => $rownum,
-            'useridlistid' => 0,
+                            'useridlistid' => 0,
-            'last' => $last,
+                            'last' => $last,
-            'userid' => $userid,
-            'attemptnumber' => $attemptnumber,
+                            'userid' => $userid,
-            'gradingpanel' => true
+                            'attemptnumber' => $attemptnumber,
-        );
+                            'gradingpanel' => true);
         if (!empty($args['formdata'])) {
             $data = (array) $data;
-            $data = (object) array_merge($data, $args['formdata']);
-        }
+            $data = (object) array_merge($data, $args['formdata']);
-        $formparams = array($this, $data, $pagination);
+        }
-        $mform = new mod_assign_grade_form(
+        $formparams = array($this, $data, $pagination);
-            null,
+        $mform = new mod_assign_grade_form(null,
-            $formparams,
-            'post',
+                                           $formparams,
-            '',
+                                           'post',
-            array('class' => 'gradeform')
+                                           '',
-        );
+                                           array('class' => 'gradeform'));
         $o .= $this->get_renderer()->render(new assign_form('gradingform', $mform));
         if (count($allsubmissions) > 1) {
-            $allgrades = $this->get_all_grades($userid);
-            $history = new assign_attempt_history_chooser(
+            $allgrades = $this->get_all_grades($userid);
-                $allsubmissions,
+            $history = new assign_attempt_history_chooser($allsubmissions,
-                $allgrades,
+                                                          $allgrades,
-                $this->get_course_module()->id,
-                $userid
+                                                          $this->get_course_module()->id,
-            );
+                                                          $userid);
      * Print the grading page for a single user submission.
+     *
      * @param moodleform $mform
      * @return string
      */
-    protected function view_single_grade_page($mform)
+    protected function view_single_grade_page($mform) {
-    {
         global $DB, $CFG, $SESSION;
         $o = '';
         $instance = $this->get_instance();
         require_once($CFG->dirroot . '/mod/assign/gradeform.php');
-        // Need submit permission to submit an assignment.
-        require_capability('mod/assign:grade', $this->context);
+        // Need submit permission to submit an assignment.
+        require_capability('mod/assign:grade', $this->context);
-        $header = new assign_header(
-            $instance,
+        $header = new assign_header($instance,
-            $this->get_context(),
-            false,
+                                    $this->get_context(),
-            $this->get_course_module()->id,
+                                    false,
-            get_string('grading', 'assign')
+                                    $this->get_course_module()->id,
-        );
+                                    get_string('grading', 'assign'));
         $user = $DB->get_record('user', array('id' => $userid));
         if ($user) {
             $this->update_effective_access($userid);
             $viewfullnames = has_capability('moodle/site:viewfullnames', $this->get_context());
-            $usersummary = new assign_user_summary(
-                $user,
+            $usersummary = new assign_user_summary($user,
-                $this->get_course()->id,
+                                                   $this->get_course()->id,
-                $viewfullnames,
+                                                   $viewfullnames,
-                $this->is_blind_marking(),
+                                                   $this->is_blind_marking(),
-                $this->get_uniqueid_for_user($user->id),
+                                                   $this->get_uniqueid_for_user($user->id),
-                // TODO Does not support custom user profile fields (MDL-70456).
+                                                   // TODO Does not support custom user profile fields (MDL-70456).
-                \core_user\fields::get_identity_fields($this->get_context(), false),
+                                                   \core_user\fields::get_identity_fields($this->get_context(), false),
-                !$this->is_active_user($userid)
-            );
+                                                   !$this->is_active_user($userid));
             $o .= $this->get_renderer()->render($usersummary);
+        }
         $submission = $this->get_user_submission($userid, false, $attemptnumber);
         $submissiongroup = null;
             $groupid = 0;
             if ($submissiongroup) {
                 $groupid = $submissiongroup->id;
+            }
             $notsubmitted = $this->get_submission_group_members_who_have_not_submitted($groupid, false);
+        }
         // Get the requested grade.
         $grade = $this->get_user_grade($userid, false, $attemptnumber);
                 $extensionduedate = $flags->extensionduedate;
+            }
             $showedit = $this->submissions_open($userid) && ($this->is_any_submission_plugin_enabled());
             $viewfullnames = has_capability('moodle/site:viewfullnames', $this->get_context());
             $usergroups = $this->get_all_groups($user->id);
-            $submissionstatus = new assign_submission_status(
+            $submissionstatus = new assign_submission_status($instance->allowsubmissionsfromdate,
-                $instance->allowsubmissionsfromdate,
-                $instance->alwaysshowdescription,
+                                                             $instance->alwaysshowdescription,
-                $submission,
+                                                             $submission,
-                $instance->teamsubmission,
+                                                             $instance->teamsubmission,
-                $teamsubmission,
+                                                             $teamsubmission,
-                $submissiongroup,
+                                                             $submissiongroup,
-                $notsubmitted,
+                                                             $notsubmitted,
-                $this->is_any_submission_plugin_enabled(),
+                                                             $this->is_any_submission_plugin_enabled(),
-                $submissionlocked,
+                                                             $submissionlocked,
-                $this->is_graded($userid),
+                                                             $this->is_graded($userid),
-                $instance->duedate,
+                                                             $instance->duedate,
-                $instance->cutoffdate,
+                                                             $instance->cutoffdate,
-                $this->get_submission_plugins(),
+                                                             $this->get_submission_plugins(),
-                $this->get_return_action(),
+                                                             $this->get_return_action(),
-                $this->get_return_params(),
+                                                             $this->get_return_params(),
-                $this->get_course_module()->id,
+                                                             $this->get_course_module()->id,
-                $this->get_course()->id,
+                                                             $this->get_course()->id,
-                assign_submission_status::GRADER_VIEW,
+                                                             assign_submission_status::GRADER_VIEW,
-                $showedit,
+                                                             $showedit,
-                false,
+                                                             false,
-                $viewfullnames,
+                                                             $viewfullnames,
-                $extensionduedate,
+                                                             $extensionduedate,
-                $this->get_context(),
+                                                             $this->get_context(),
-                $this->is_blind_marking(),
+                                                             $this->is_blind_marking(),
-                '',
+                                                             '',
-                $instance->attemptreopenmethod,
+                                                             $instance->attemptreopenmethod,
-                $instance->maxattempts,
+                                                             $instance->maxattempts,
-                $this->get_grading_status($userid),
+                                                             $this->get_grading_status($userid),
-                $instance->preventsubmissionnotingroup,
+                                                             $instance->preventsubmissionnotingroup,
-                $usergroups,
+                                                             $usergroups,
-                $instance->timelimit
+                                                             $instance->timelimit);
-            );
             $o .= $this->get_renderer()->render($submissionstatus);
+        }
         if ($grade) {
         // Warning if required.
         $allsubmissions = $this->get_all_submissions($userid);
-        if ($attemptnumber != -1 && ($attemptnumber + 1) != count($allsubmissions)) {
-            $params = array(
+        if ($attemptnumber != -1 && ($attemptnumber + 1) != count($allsubmissions)) {
-                'attemptnumber' => $attemptnumber + 1,
-                'totalattempts' => count($allsubmissions)
+            $params = array('attemptnumber'=>$attemptnumber + 1,
-            );
+                            'totalattempts'=>count($allsubmissions));
             $message = get_string('editingpreviousfeedbackwarning', 'assign', $params);
             $o .= $this->get_renderer()->notification($message);
+        }
-        // Now show the grading form.
-        if (!$mform) {
+        // Now show the grading form.
-            $pagination = array(
+        if (!$mform) {
-                'rownum' => $rownum,
+            $pagination = array('rownum' => $rownum,
-                'useridlistid' => $useridlistid,
+                                'useridlistid' => $useridlistid,
-                'last' => $last,
-                'userid' => $userid,
+                                'last' => $last,
-                'attemptnumber' => $attemptnumber
+                                'userid' => $userid,
-            );
-            $formparams = array($this, $data, $pagination);
+                                'attemptnumber' => $attemptnumber);
-            $mform = new mod_assign_grade_form(
+            $formparams = array($this, $data, $pagination);
-                null,
+            $mform = new mod_assign_grade_form(null,
-                $formparams,
+                                               $formparams,
-                'post',
-                '',
+                                               'post',
-                array('class' => 'gradeform')
+                                               '',
-            );
+                                               array('class'=>'gradeform'));
+        }
-        $o .= $this->get_renderer()->render(new assign_form('gradingform', $mform));
+        $o .= $this->get_renderer()->render(new assign_form('gradingform', $mform));
-        if (count($allsubmissions) > 1 && $attemptnumber == -1) {
-            $allgrades = $this->get_all_grades($userid);
+        if (count($allsubmissions) > 1 && $attemptnumber == -1) {
-            $history = new assign_attempt_history(
+            $allgrades = $this->get_all_grades($userid);
-                $allsubmissions,
+            $history = new assign_attempt_history($allsubmissions,
-                $allgrades,
+                                                  $allgrades,
-                $this->get_submission_plugins(),
+                                                  $this->get_submission_plugins(),
-                $this->get_feedback_plugins(),
+                                                  $this->get_feedback_plugins(),
-                $this->get_course_module()->id,
+                                                  $this->get_course_module()->id,
-                $this->get_return_action(),
-                $this->get_return_params(),
+                                                  $this->get_return_action(),
-                true,
+                                                  $this->get_return_params(),
-                $useridlistid,
+                                                  true,
     /**
      * Show a confirmation page to make sure they want to remove submission data.
+     *
      * @return string
      */
-    protected function view_remove_submission_confirm()
+    protected function view_remove_submission_confirm() {
-    {
         global $USER;
         $userid = optional_param('userid', $USER->id, PARAM_INT);
         if (!$this->can_edit_submission($userid, $USER->id)) {
             throw new \moodle_exception('nopermission');
+        }
         $user = core_user::get_user($userid, '*', MUST_EXIST);
-        $o = '';
-        $header = new assign_header(
+        $o = '';
-            $this->get_instance(),
+        $header = new assign_header($this->get_instance(),
-            $this->get_context(),
-            false,
+                                    $this->get_context(),
-            $this->get_course_module()->id
-        );
+                                    false,
-        $o .= $this->get_renderer()->render($header);
+                                    $this->get_course_module()->id);
+        $o .= $this->get_renderer()->render($header);
-        $urlparams = array(
-            'id' => $this->get_course_module()->id,
-            'action' => 'removesubmission',
+        $urlparams = array('id' => $this->get_course_module()->id,
-            'userid' => $userid,
-            'sesskey' => sesskey()
+                           'action' => 'removesubmission',
-        );
+                           'userid' => $userid,
-        $confirmurl = new moodle_url('/mod/assign/view.php', $urlparams);
                            'sesskey' => sesskey());
-        $urlparams = array(
+        $confirmurl = new moodle_url('/mod/assign/view.php', $urlparams);
             'id' => $this->get_course_module()->id,
-            'action' => 'view'
+        $urlparams = array('id' => $this->get_course_module()->id,
                 $confirmstr = get_string('removesubmissionconfirmforstudentwithtimelimit', 'assign', $this->fullname($user));
             } else {
                 $confirmstr = get_string('removesubmissionconfirmforstudent', 'assign', $this->fullname($user));
+            }
+        }
-        $o .= $this->get_renderer()->confirm(
+        $o .= $this->get_renderer()->confirm($confirmstr,
-            $confirmstr,
-            $confirmurl,
+                                             $confirmurl,
-            $cancelurl
+                                             $cancelurl);
-        );
         $o .= $this->view_footer();
         \mod_assign\event\remove_submission_form_viewed::create_from_user($this, $user)->trigger();
     /**
      * Show a confirmation page to make sure they want to release student identities.
+     *
      * @return string
      */
-    protected function view_reveal_identities_confirm()
+    protected function view_reveal_identities_confirm() {
-    {
         require_capability('mod/assign:revealidentities', $this->get_context());
         $o = '';
-        $header = new assign_header(
-            $this->get_instance(),
+        $header = new assign_header($this->get_instance(),
-            $this->get_context(),
+                                    $this->get_context(),
-            false,
+                                    false,
-            $this->get_course_module()->id
-        );
+                                    $this->get_course_module()->id);
-        $o .= $this->get_renderer()->render($header);
+        $o .= $this->get_renderer()->render($header);
-        $urlparams = array(
-            'id' => $this->get_course_module()->id,
+        $urlparams = array('id'=>$this->get_course_module()->id,
-            'action' => 'revealidentitiesconfirm',
-            'sesskey' => sesskey()
+                           'action'=>'revealidentitiesconfirm',
-        );
-        $confirmurl = new moodle_url('/mod/assign/view.php', $urlparams);
+                           'sesskey'=>sesskey());
+        $confirmurl = new moodle_url('/mod/assign/view.php', $urlparams);
-        $urlparams = array(
             'id' => $this->get_course_module()->id,
-            'action' => 'grading'
-        );
+        $urlparams = array('id'=>$this->get_course_module()->id,
-        $cancelurl = new moodle_url('/mod/assign/view.php', $urlparams);
+                           'action'=>'grading');
+        $cancelurl = new moodle_url('/mod/assign/view.php', $urlparams);
-        $o .= $this->get_renderer()->confirm(
             get_string('revealidentitiesconfirm', 'assign'),
-            $confirmurl,
+        $o .= $this->get_renderer()->confirm(get_string('revealidentitiesconfirm', 'assign'),
-            $cancelurl
+                                             $confirmurl,
     /**
      * View a link to go back to the previous page. Uses url parameters returnaction and returnparams.
+     *
      * @return string
      */
-    protected function view_return_links()
+    protected function view_return_links() {
-    {
         $returnaction = optional_param('returnaction', '', PARAM_ALPHA);
         $returnparams = optional_param('returnparams', '', PARAM_TEXT);
         $params = array();
     /**
      * View the grading table of all submissions for this assignment.
+     *
      * @return string
      */
-    protected function view_grading_table()
+    protected function view_grading_table() {
-    {
-        global $USER, $CFG, $SESSION, $PAGE;
+        global $USER, $CFG, $SESSION, $PAGE, $OUTPUT;
-        // Include grading options form.
         require_once($CFG->dirroot . '/mod/assign/gradingoptionsform.php');
-        require_once($CFG->dirroot . '/mod/assign/quickgradingform.php');
-        require_once($CFG->dirroot . '/mod/assign/gradingbatchoperationsform.php');
-        $o = '';
-        $cmid = $this->get_course_module()->id;
-        $links = array();
-        if (
-            has_capability('gradereport/grader:view', $this->get_course_context()) &&
-            has_capability('moodle/grade:viewall', $this->get_course_context())
-        ) {
+        require_once($CFG->dirroot . '/mod/assign/quickgradingform.php');
-            $gradebookurl = '/grade/report/grader/index.php?id=' . $this->get_course()->id;
-            $links[$gradebookurl] = get_string('viewgradebook', 'assign');
-        }
-        if (
+        $submittedfilter = optional_param('status', null, PARAM_ALPHA);
-            $this->is_blind_marking() &&
-            has_capability('mod/assign:revealidentities', $this->get_context())
+        if (isset($submittedfilter)) {
-        ) {
-            $revealidentitiesurl = '/mod/assign/view.php?id=' . $cmid . '&action=revealidentities';
-            $links[$revealidentitiesurl] = get_string('revealidentities', 'assign');
-        }
+            $validfilters = array_column($this->get_filters(), 'key');
-        foreach ($this->get_feedback_plugins() as $plugin) {
-            if ($plugin->is_enabled() && $plugin->is_visible()) {
-                foreach ($plugin->get_grading_actions() as $action => $description) {
-                    $url = '/mod/assign/view.php' .
-                        '?id=' .  $cmid .
+            $validfilters = array_diff($validfilters, [ASSIGN_FILTER_NONE]); // The 'none' filter is not a real filter.
-                        '&plugin=' . $plugin->get_type() .
-                        '&pluginsubtype=assignfeedback' .
-                        '&action=viewpluginpage&pluginaction=' . $action;
-                    $links[$url] = $description;
+            if ($submittedfilter === '' || in_array($submittedfilter, $validfilters)) {
                 set_user_preference('assign_filter', $submittedfilter);
             }
         }
+        $submittedquickgrading = optional_param('quickgrading', null, PARAM_BOOL);
+        if (isset($submittedquickgrading)) {
+            set_user_preference('assign_quickgrading', $submittedquickgrading);
+        }
+        $submitteddownloadasfolders = optional_param('downloadasfolders', null, PARAM_BOOL);
+        if (isset($submitteddownloadasfolders)) {
+            set_user_preference('assign_downloadasfolders', $submitteddownloadasfolders);
-        // Sort links alphabetically based on the link description.
+        }
+        $submittedperpage = optional_param('perpage', null, PARAM_INT);
+        if (isset($submittedperpage)) {
-        core_collator::asort($links);
+            set_user_preference('assign_perpage', $submittedperpage);
+        }
         $gradingactions = new url_select($links);
-        $gradingactions->set_label(get_string('choosegradingaction', 'assign'));
+        $o = '';
+        $cmid = $this->get_course_module()->id;
+        $gradingmanager = get_grading_manager($this->get_context(), 'mod_assign', 'submissions');
+        $perpage = $this->get_assign_perpage();
+        $filter = get_user_preferences('assign_filter', '');
-        $gradingactions->class .= ' mb-1';
+        // Retrieve the 'workflowfilter' parameter, or set it to null if not provided.
+        $workflowfilter = optional_param('workflowfilter', null, PARAM_ALPHA);
+        // Check if the parameter is not null and if it exists in the list of valid workflow filters.
+        if ($workflowfilter !== null && array_key_exists($workflowfilter, $this->get_marking_workflow_filters())) {
+            // Save the valid 'workflowfilter' value as a user preference.
+            set_user_preference('assign_workflowfilter', $workflowfilter);
+        }
+        // Retrieve the 'markingallocationfilter' parameter, or set it to null if not provided.
+        $markingallocationfilter = optional_param('markingallocationfilter', null, PARAM_ALPHANUMEXT);
+        // Check if the parameter is not null and if it exists in the list of valid marking allocation filters.
+        if ($markingallocationfilter !== null &&
+                array_key_exists($markingallocationfilter, $this->get_marking_allocation_filters())) {
+            // Save the valid 'markingallocationfilter' value as a user preference.
+            set_user_preference('assign_markerfilter', $markingallocationfilter);
+        }
+        // Retrieve the 'suspendedparticipantsfilter' parameter, or set it to null if not provided.
+        $suspendedparticipantsfilter = optional_param('suspendedparticipantsfilter', null, PARAM_BOOL);
-        $gradingmanager = get_grading_manager($this->get_context(), 'mod_assign', 'submissions');
+        if ($suspendedparticipantsfilter !== null &&
                 has_capability('moodle/course:viewsuspendedusers', $this->get_context())) {
-        $perpage = $this->get_assign_perpage();
+            // Save the 'suspendedparticipantsfilter' value as a user preference.
-        $filter = get_user_preferences('assign_filter', '');
-        $markerfilter = get_user_preferences('assign_markerfilter', '');
-        $workflowfilter = get_user_preferences('assign_workflowfilter', '');
+            set_user_preference('grade_report_showonlyactiveenrol', !$suspendedparticipantsfilter);
         $controller = $gradingmanager->get_active_controller();
         $showquickgrading = empty($controller) && $this->can_grade();
-        $quickgrading = get_user_preferences('assign_quickgrading', false);
-        $showonlyactiveenrolopt = has_capability('moodle/course:viewsuspendedusers', $this->context);
-        $downloadasfolders = get_user_preferences('assign_downloadasfolders', 1);
-        $markingallocation = $this->get_instance()->markingworkflow &&
-            $this->get_instance()->markingallocation &&
-            has_capability('mod/assign:manageallocations', $this->context);
-        // Get markers to use in drop lists.
-        $markingallocationoptions = array();
-        if ($markingallocation) {
-            list($sort, $params) = users_order_by_sql('u');
-            // Only enrolled users could be assigned as potential markers.
-            $markers = get_enrolled_users($this->context, 'mod/assign:grade', 0, 'u.*', $sort);
-            $markingallocationoptions[''] = get_string('filternone', 'assign');
+        $controller = $gradingmanager->get_active_controller();
-            $markingallocationoptions[ASSIGN_MARKER_FILTER_NO_MARKER] = get_string('markerfilternomarker', 'assign');
-            $viewfullnames = has_capability('moodle/site:viewfullnames', $this->context);
-            foreach ($markers as $marker) {
-                $markingallocationoptions[$marker->id] = fullname($marker, $viewfullnames);
-            }
-        }
-        $markingworkflow = $this->get_instance()->markingworkflow;
-        // Get marking states to show in form.
-        $markingworkflowoptions = $this->get_marking_workflow_filters();
-        // Print options for changing the filter and changing the number of results per page.
-        $gradingoptionsformparams = array(
-            'cm' => $cmid,
-            'contextid' => $this->context->id,
-            'userid' => $USER->id,
-            'submissionsenabled' => $this->is_any_submission_plugin_enabled(),
-            'showquickgrading' => $showquickgrading,
-            'quickgrading' => $quickgrading,
-            'markingworkflowopt' => $markingworkflowoptions,
-            'markingallocationopt' => $markingallocationoptions,
-            'showonlyactiveenrolopt' => $showonlyactiveenrolopt,
-            'showonlyactiveenrol' => $this->show_only_active_users(),
-            'downloadasfolders' => $downloadasfolders
-        );
-        $classoptions = array('class' => 'gradingoptionsform');
-        $gradingoptionsform = new mod_assign_grading_options_form(
-            null,
-            $gradingoptionsformparams,
-            'post',
-            '',
-            $classoptions
-        );
-        $batchformparams = array(
-            'cm' => $cmid,
-            'submissiondrafts' => $this->get_instance()->submissiondrafts,
-            'duedate' => $this->get_instance()->duedate,
-            'attemptreopenmethod' => $this->get_instance()->attemptreopenmethod,
-            'feedbackplugins' => $this->get_feedback_plugins(),
-            'context' => $this->get_context(),
-            'markingworkflow' => $markingworkflow,
-            'markingallocation' => $markingallocation
-        );
-        $classoptions = [
-            'class' => 'gradingbatchoperationsform',
-            'data-double-submit-protection' => 'off',
-        ];
-        $gradingbatchoperationsform = new mod_assign_grading_batch_operations_form(
-            null,
-            $batchformparams,
-            'post',
-            '',
-            $classoptions
+        $showquickgrading = empty($controller) && $this->can_grade();
+        $quickgrading = get_user_preferences('assign_quickgrading', false);
+        $markingallocation = $this->get_instance()->markingworkflow &&
+            $this->get_instance()->markingallocation &&
+            has_capability('mod/assign:manageallocations', $this->context);
-        );
+        $markingworkflow = $this->get_instance()->markingworkflow;
-        $gradingoptionsdata = new stdClass();
+        // Load the table of submissions, to be printed further down.
-        $gradingoptionsdata->perpage = $perpage;
+        $usequickgrading = $showquickgrading && $quickgrading;
+        $gradingtable = new assign_grading_table($this, $perpage, $filter, 0, $usequickgrading);
+        $gradingtable->responsive = false;
+        $table = $this->get_renderer()->render($gradingtable);
-        $gradingoptionsdata->filter = $filter;
+        // This initialises the selected first/last initials for the action menu.
-        $gradingoptionsdata->markerfilter = $markerfilter;
+        $gradingtable->initialbars(true);
+        $buttons = new \mod_assign\output\grading_actionmenu(
-        $gradingoptionsdata->workflowfilter = $workflowfilter;
+            cmid: $this->get_course_module()->id,
-        $gradingoptionsform->set_data($gradingoptionsdata);
+            assign: $this,
+            userinitials: [
+                'firstname' => $gradingtable->get_initial_first(),
+                'lastname' => $gradingtable->get_initial_last(),
+            ]
+        );
-        $buttons = new \mod_assign\output\grading_actionmenu(
+        $actionformtext = $this->get_renderer()->render($buttons);
-            $this->get_course_module()->id,
+        $currenturl = new moodle_url('/mod/assign/view.php', ['id' => $this->get_course_module()->id, 'action' => 'grading']);
-            $this->is_any_submission_plugin_enabled(),
+        $PAGE->activityheader->set_attrs(['hidecompletion' => true]);
-            $this->count_submissions()
-        );
+        $PAGE->requires->js_call_amd('mod_assign/user', 'init', [$currenturl->out(false)]);
-        $actionformtext = $this->get_renderer()->render($buttons);
-        $PAGE->activityheader->set_attrs(['hidecompletion' => true]);
+        // Conditionally add the group JS if we have groups enabled.
+        if (groups_get_activity_groupmode($this->get_course_module(), $this->get_course())) {
-        $currenturl = new moodle_url('/mod/assign/view.php', ['id' => $this->get_course_module()->id, 'action' => 'grading']);
             $PAGE->requires->js_call_amd('core_course/actionbar/group', 'init', [$currenturl->out(false), $cmid]);
         $header = new assign_header(
-            $this->get_instance(),
-            $this->get_context(),
-            false,
-            $this->get_course_module()->id,
-            get_string('grading', 'assign'),
-            '',
-            '',
-            $currenturl
-        );
-        $o .= $this->get_renderer()->render($header);
         $o .= $actionformtext;
+        $header = new assign_header($this->get_instance(),
+                                    $this->get_context(),
+                                    false,
+                                    $this->get_course_module()->id,
+                                    get_string('gradeitem:submissions', 'assign'),
-        $o .= $this->get_renderer()->heading(get_string('gradeitem:submissions', 'mod_assign'), 2);
+                                    '',
-        $o .= $this->get_renderer()->render($gradingactions);
+                                    '',
+                                    $currenturl);
-        $o .= groups_print_activity_menu($this->get_course_module(), $currenturl, true);
+        $o .= $this->get_renderer()->render($header);
-        // Plagiarism update status apearring in the grading book.
+        $o .= $actionformtext;
-        if (!empty($CFG->enableplagiarism)) {
+        if ($this->is_blind_marking() && has_capability('mod/assign:viewblinddetails', $this->get_context())) {
-            require_once($CFG->libdir . '/plagiarismlib.php');
-            $o .= plagiarism_update_status($this->get_course(), $this->get_course_module());
-        }
-        if ($this->is_blind_marking() && has_capability('mod/assign:viewblinddetails', $this->get_context())) {
-            $o .= $this->get_renderer()->notification(get_string('blindmarkingenabledwarning', 'assign'), 'notifymessage');
+            if ($this->is_marking_anonymous()) {
-        }
+                $o .= $this->get_renderer()->notification(get_string('blindmarkingenabledwarning', 'assign'), 'notifymessage');
-        // Load and print the table of submissions.
+            } else {
-        $assignform = new assign_form(
+                $o .= $this->get_renderer()->notification(get_string('blindmarkingnogradewarning', 'assign'), 'notifymessage');
-            'gradingoptionsform',
-            $gradingoptionsform,
+            }
-            'M.mod_assign.init_grading_options'
-        );
+        }
         $o .= $this->get_renderer()->render($assignform);
-        $currentgroup = groups_get_activity_group($this->get_course_module(), true);
+        // Print the table of submissions.
-        $users = array_keys($this->list_participants($currentgroup, true));
-        if (count($users) != 0 && $this->can_grade()) {
+        $footerdata = [
+            'perpage' => $gradingtable->get_paging_selector(),
-            // If no enrolled user in a course then don't display the batch operations feature.
+            'pagingbar' => $gradingtable->get_paging_bar(),
+            'hassubmit' => $usequickgrading,
-            $assignform = new assign_form('gradingbatchoperationsform', $gradingbatchoperationsform);
+            'sendstudentnotifications' => $this->get_instance()->sendstudentnotifications,
-            $o .= $this->get_renderer()->render($assignform);
+        ];
-        }
+        $footer = new core\output\sticky_footer($OUTPUT->render_from_template('mod_assign/grading_sticky_footer', $footerdata));
-        if ($showquickgrading && $quickgrading) {
-            $page = optional_param('page', null, PARAM_INT);
+        if ($usequickgrading) {
-            $gradingtable = new assign_grading_table($this, $perpage, $filter, 0, true);
+            $page = optional_param('page', null, PARAM_INT);
-            $quickgradingform = new mod_assign_quick_grading_form(null, $quickformparams);
+            $PAGE->requires->js_call_amd('mod_assign/quick_grading', 'init', []);
-            $table = $this->get_renderer()->render($gradingtable);
+            $quickformparams = [
+                'cm' => $this->get_course_module()->id,
-            $quickformparams = array(
+                'gradingtable' => $table,
-                'cm' => $this->get_course_module()->id,
+                'page' => $page,
-                'gradingtable' => $table,
+                'footer' => $this->get_renderer()->render($footer),
+            ];
+            $quickgradingform = new mod_assign_quick_grading_form(null, $quickformparams);
+            $o .= $this->get_renderer()->render(new assign_form('quickgradingform', $quickgradingform));
+        } else {
+            $o .= $table;
+            $o .= $this->get_renderer()->render($footer);
+        }
+        if ($this->can_grade()) {
+            // We need to store the order of uses in the table as the person may wish to grade them.
+            // This is done based on the row number of the user.
+            // Pagination has be added before this because calling get_column_data will reset the pagination.
+            $useridlist = $gradingtable->get_column_data('userid');
+            $SESSION->mod_assign_useridlist[$this->get_useridlist_key()] = $useridlist;
+        }
+        $currentgroup = groups_get_activity_group($this->get_course_module(), true);
+        $users = array_keys($this->list_participants($currentgroup, true));
+        if (count($users) != 0 && $this->can_grade()) {
+            $jsparams = [];
+            $jsparams['message'] = !empty($CFG->messaging)
+                && has_all_capabilities(['moodle/site:sendmessage', 'moodle/course:bulkmessaging'], $this->context);
+            $jsparams['submissiondrafts'] = !empty($this->get_instance()->submissiondrafts);
+            $jsparams['removesubmission'] = has_capability('mod/assign:editothersubmission', $this->context);
+            $jsparams['extend'] = $this->get_instance()->duedate && has_capability('mod/assign:grantextension', $this->context);
+            $multipleattemptsallowed = $this->get_instance()->maxattempts > 1
+                || $this->get_instance()->maxattempts == ASSIGN_UNLIMITED_ATTEMPTS;
+            $jsparams['grantattempt'] =
+                $multipleattemptsallowed && $this->get_instance()->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_MANUAL;
+            $jsparams['pluginoperations'] = [];
+            foreach ($this->get_feedback_plugins() as $plugin) {
+                if ($plugin->is_visible() && $plugin->is_enabled()) {
+                    foreach ($plugin->get_grading_batch_operation_details() as $operation) {
+                        $jsparams['pluginoperations'][] = [
+                            'key' => 'plugingradingbatchoperation_' . $plugin->get_type() . '_' . $operation->key,
+                            'label' => $operation->label,
-                'sendstudentnotifications' => $this->get_instance()->sendstudentnotifications,
+                            'icon' => $operation->icon,
-                'page' => $page
+                            'confirmationtitle' => $operation->confirmationtitle,
-            );
+                            'confirmationquestion' => $operation->confirmationquestion,
                         ];
             $o .= $this->get_renderer()->render(new assign_form('quickgradingform', $quickgradingform));
         } else {
             $gradingtable = new assign_grading_table($this, $perpage, $filter, 0, false);
-            $o .= $this->get_renderer()->render($gradingtable);
-        }
             $jsparams['workflowstate'] = !empty($this->get_instance()->markingworkflow);
-        if ($this->can_grade()) {
+            $jsparams['markingallocation'] = !empty($this->get_instance()->markingallocation);
-            // We need to store the order of uses in the table as the person may wish to grade them.
+            $jsparams['cmid'] = $this->get_course_module()->id;
-            // This is done based on the row number of the user.
+            $jsparams['sesskey'] = sesskey();
     /**
      * View entire grading page.
+     *
      * @return string
      */
-    protected function view_grading_page()
+    protected function view_grading_page() {
-    {
-        global $CFG;
+        global $CFG, $PAGE;
+        // Ensure that the 'Submissions' navigation node is highlighted as 'active' in the secondary navigation.
+        $PAGE->set_secondary_active_tab('mod_assign_submissions');
         $o = '';
         // Need submit permission to submit an assignment.
         $this->require_view_grades();
     /**
      * Capture the output of the plagiarism plugins disclosures and return it as a string.
+     *
      * @return string
      */
-    protected function plagiarism_print_disclosure()
+    protected function plagiarism_print_disclosure() {
-    {
         global $CFG;
         $o = '';
         if (!empty($CFG->enableplagiarism)) {
+     *
      * @param string $title The page title
      * @param array $notices The array of notices to show.
      * @return string
      */
-    protected function view_notices($title, $notices)
+    protected function view_notices($title, $notices) {
-    {
         global $CFG;
         $o = '';
-        $header = new assign_header(
-            $this->get_instance(),
+        $header = new assign_header($this->get_instance(),
-            $this->get_context(),
+                                    $this->get_context(),
-            $this->show_intro(),
+                                    $this->show_intro(),
-            $this->get_course_module()->id,
-            $title
+                                    $this->get_course_module()->id,
-        );
+                                    $title);
         $o .= $this->get_renderer()->render($header);
         foreach ($notices as $notice) {
             $o .= $this->get_renderer()->notification($notice);
+        }
      * Get the name for a user - hiding their real name if blind marking is on.
+     *
      * @param stdClass $user The user record as required by fullname()
      * @return string The name.
      */
-    public function fullname($user)
+    public function fullname($user) {
-    {
         if ($this->is_blind_marking()) {
             $hasviewblind = has_capability('mod/assign:viewblinddetails', $this->get_context());
             if (empty($user->recordid)) {
                 $uniqueid = $this->get_uniqueid_for_user($user->id);
             } else {
                 $uniqueid = $user->recordid;
+            }
             if ($hasviewblind) {
                 return get_string('participant', 'assign') . ' ' . $uniqueid . ' (' .
-                    fullname($user, has_capability('moodle/site:viewfullnames', $this->get_context())) . ')';
+                        fullname($user, has_capability('moodle/site:viewfullnames', $this->get_context())) . ')';
             } else {
                 return get_string('participant', 'assign') . ' ' . $uniqueid;
+            }
         } else {
             return fullname($user, has_capability('moodle/site:viewfullnames', $this->get_context()));
      * @param moodleform $mform
      * @param array $notices A list of notices to display at the top of the
      *                       edit submission form (e.g. from plugins).
      * @return string The page output.
      */
-    protected function view_edit_submission_page($mform, $notices)
+    protected function view_edit_submission_page($mform, $notices) {
-    {
         global $CFG, $USER, $DB, $PAGE;
         $o = '';
         require_once($CFG->dirroot . '/mod/assign/submission_form.php');
         // Need submit permission to submit an assignment.
         $userid = optional_param('userid', $USER->id, PARAM_INT);
-        $user = $DB->get_record('user', array('id' => $userid), '*', MUST_EXIST);
+        $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
         $timelimitenabled = get_config('assign', 'enabletimelimit');
         // This variation on the url will link direct to this student.
             $bc->content = $navbc;
             $PAGE->blocks->add_fake_block($bc, reset($regions));
+        }
-        $o .= $this->get_renderer()->render(
-            new assign_header(
+        $o .= $this->get_renderer()->render(
-                $this->get_instance(),
+            new assign_header($this->get_instance(),
-                $this->get_context(),
+                              $this->get_context(),
-                $this->show_intro(),
+                              $this->show_intro(),
-                $this->get_course_module()->id,
+                              $this->get_course_module()->id,
-                $title,
+                              $title,
-                '',
+                              '',
-                $postfix,
+                              $postfix,
-                null,
+                              null,
-                true
+                              true
+            )
         );
      * Get the time limit panel object for this submission attempt.
+     *
      * @param stdClass $submission assign submission.
      * @return string the panel output.
      */
-    public function get_timelimit_panel(stdClass $submission): string
+    public function get_timelimit_panel(stdClass $submission): string {
-    {
         global $USER;
         // Apply overrides.
         $this->update_effective_access($USER->id);
      * See if this assignment has a grade yet.
+     *
      * @param int $userid
      * @return bool
      */
-    protected function is_graded($userid)
+    protected function is_graded($userid) {
-    {
         $grade = $this->get_user_grade($userid, false);
         if ($grade) {
             return ($grade->grade !== null && $grade->grade >= 0);
+        }
         return false;
      * Perform an access check to see if the current $USER can edit this group submission.
+     *
      * @param int $groupid
      * @return bool
      */
-    public function can_edit_group_submission($groupid)
+    public function can_edit_group_submission($groupid) {
-    {
         global $USER;
         $members = $this->get_submission_group_members($groupid, true);
         foreach ($members as $member) {
      * Perform an access check to see if the current $USER can view this group submission.
+     *
      * @param int $groupid
      * @return bool
      */
-    public function can_view_group_submission($groupid)
+    public function can_view_group_submission($groupid) {
-    {
         global $USER;
         $members = $this->get_submission_group_members($groupid, true);
         foreach ($members as $member) {
      * Perform an access check to see if the current $USER can view this users submission.
+     *
      * @param int $userid
      * @return bool
      */
-    public function can_view_submission($userid)
+    public function can_view_submission($userid) {
-    {
         global $USER;
         if (!$this->is_active_user($userid) && !has_capability('moodle/course:viewsuspendedusers', $this->context)) {
             return false;
         return false;
+    }
     /**
+     * Allows the plugin to show a batch grading operation page.
-     * Allows the plugin to show a batch grading operation page.
+     * You should confirm sesskey before calling this function.
-     *
      * @param moodleform $mform
      * @return none
      */
-    protected function view_plugin_grading_batch_operation($mform)
     protected function view_plugin_grading_batch_operation() {
         require_capability('mod/assign:grade', $this->context);
-        $prefix = 'plugingradingbatchoperation_';
+        $prefix = 'plugingradingbatchoperation_';
-        if ($data = $mform->get_data()) {
+        $operation = required_param('operation', PARAM_ALPHAEXT);
-            $tail = substr($data->operation, strlen($prefix));
+        $tail = substr($operation, strlen($prefix));
-            list($plugintype, $action) = explode('_', $tail, 2);
+        list($plugintype, $action) = explode('_', $tail, 2);
-            $plugin = $this->get_feedback_plugin_by_type($plugintype);
+        $plugin = $this->get_feedback_plugin_by_type($plugintype);
-            if ($plugin) {
+        if ($plugin) {
-                $users = $data->selectedusers;
+            $users = required_param('selectedusers', PARAM_SEQUENCE);
-                $userlist = explode(',', $users);
-                echo $plugin->grading_batch_operation($action, $userlist);
+            $userlist = explode(',', $users);
+            echo $plugin->grading_batch_operation($action, $userlist);
-                return;
+            return;
+        }
         throw new \moodle_exception('invalidformdata', '');
+    }
     /**
-     * Ask the user to confirm they want to perform this batch operation
+    /**
-     *
+     * Ask the user to confirm they want to perform this batch operation
-     * @param moodleform $mform Set to a grading batch operations form
-     * @return string - the page to view after processing these actions
-     */
     protected function process_grading_batch_operation(&$mform)
-    {
-        global $CFG;
-        require_once($CFG->dirroot . '/mod/assign/gradingbatchoperationsform.php');
+     * @return string - the page to view after processing these actions
-        require_sesskey();
-        $markingallocation = $this->get_instance()->markingworkflow &&
-            $this->get_instance()->markingallocation &&
-            has_capability('mod/assign:manageallocations', $this->context);
-        $batchformparams = array(
+     */
-            'cm' => $this->get_course_module()->id,
-            'submissiondrafts' => $this->get_instance()->submissiondrafts,
-            'duedate' => $this->get_instance()->duedate,
-            'attemptreopenmethod' => $this->get_instance()->attemptreopenmethod,
-            'feedbackplugins' => $this->get_feedback_plugins(),
-            'context' => $this->get_context(),
-            'markingworkflow' => $this->get_instance()->markingworkflow,
-            'markingallocation' => $markingallocation
-        );
-        $formclasses = [
-            'class' => 'gradingbatchoperationsform',
+    protected function process_grading_batch_operation() {
-            'data-double-submit-protection' => 'off'
-        ];
+        require_sesskey();
-        $mform = new mod_assign_grading_batch_operations_form(
-            null,
-            $batchformparams,
-            'post',
-            '',
+        $operation = required_param('operation', PARAM_ALPHAEXT);
+        $selectedusers = required_param('selectedusers', PARAM_SEQUENCE);
+        // Get the list of users.
+        $userlist = explode(',', $selectedusers);
-            $formclasses
+        $prefix = 'plugingradingbatchoperation_';
+        if ($operation == 'grantextension') {
-        );
-        if ($data = $mform->get_data()) {
-            // Get the list of users.
-            $users = $data->selectedusers;
-            $userlist = explode(',', $users);
-            $prefix = 'plugingradingbatchoperation_';
-            if ($data->operation == 'grantextension') {
-                // Reset the form so the grant extension page will create the extension form.
-                $mform = null;
-                return 'grantextension';
+            return 'grantextension';
-            } else if ($data->operation == 'setmarkingworkflowstate') {
+        } else if ($operation == 'setmarkingworkflowstate') {
-                return 'viewbatchsetmarkingworkflowstate';
+            return 'viewbatchsetmarkingworkflowstate';
-            } else if ($data->operation == 'setmarkingallocation') {
-                return 'viewbatchmarkingallocation';
+        } else if ($operation == 'setmarkingallocation') {
+            return 'viewbatchmarkingallocation';
-            } else if (strpos($data->operation, $prefix) === 0) {
+        } else if (strpos($operation, $prefix) === 0) {
-                $tail = substr($data->operation, strlen($prefix));
+            $tail = substr($operation, strlen($prefix));
-                list($plugintype, $action) = explode('_', $tail, 2);
+            list($plugintype, $action) = explode('_', $tail, 2);
-                $plugin = $this->get_feedback_plugin_by_type($plugintype);
+            $plugin = $this->get_feedback_plugin_by_type($plugintype);
-                if ($plugin) {
+            if ($plugin) {
-                    return 'plugingradingbatchoperation';
+                return 'plugingradingbatchoperation';
-                }
+            }
-            }
+        }
-            if ($data->operation == 'downloadselected') {
+        if ($operation == 'downloadselected') {
-                $this->download_submissions($userlist);
+            $this->download_submissions($userlist);
-            } else {
+        } else {
-                foreach ($userlist as $userid) {
+            foreach ($userlist as $userid) {
-                    if ($data->operation == 'lock') {
+                if ($operation == 'lock') {
-                        $this->process_lock_submission($userid);
-                    } else if ($data->operation == 'unlock') {
+                    $this->process_lock_submission($userid);
-                        $this->process_unlock_submission($userid);
+                } else if ($operation == 'unlock') {
-                    } else if ($data->operation == 'reverttodraft') {
+                    $this->process_unlock_submission($userid);
+                } else if ($operation == 'reverttodraft') {
-                        $this->process_revert_to_draft($userid);
+                    $this->process_revert_to_draft($userid);
-                    } else if ($data->operation == 'removesubmission') {
+                } else if ($operation == 'removesubmission') {
-                        $this->process_remove_submission($userid);
+                    $this->process_remove_submission($userid);
-                    } else if ($data->operation == 'addattempt') {
-                        if (!$this->get_instance()->teamsubmission) {
+                } else if ($operation == 'addattempt') {
-                            $this->process_add_attempt($userid);
+                    if (!$this->get_instance()->teamsubmission) {
                         $this->process_add_attempt($userid);
+                    }
+                }
+            }
+        }
-            if ($this->get_instance()->teamsubmission && $data->operation == 'addattempt') {
-                // This needs to be handled separately so that each team submission is only re-opened one time.
+        if ($this->get_instance()->teamsubmission && $operation == 'addattempt') {
-                $this->process_add_attempt_group($userlist);
+            // This needs to be handled separately so that each team submission is only re-opened one time.
-            }
+            $this->process_add_attempt_group($userlist);
-        }
+        }
         return 'grading';
         return 'grading';
-    /**
+    }
      * Shows a form that allows the workflow state for selected submissions to be changed.
-     *
-     * @param moodleform $mform Set to a grading batch operations form
+    /**
-     * @return string - the page to view after processing these actions
+     * Shows a form that allows the workflow state for selected submissions to be changed.
-     */
-    protected function view_batch_set_workflow_state($mform)
+     * You should confirm sesskey before calling this function.
+     *
-        global $CFG, $DB;
+     * @return string - the page to view after processing these actions
         foreach ($userlist as $userid) {
             if ($usercount >= 5) {
                 $usershtml .= get_string('moreusers', 'assign', count($userlist) - 5);
                 break;
+            }
-            $user = $DB->get_record('user', array('id' => $userid), '*', MUST_EXIST);
+            $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
-            $usershtml .= $this->get_renderer()->render(new assign_user_summary(
-                $user,
+            $usershtml .= $this->get_renderer()->render(new assign_user_summary($user,
-                $this->get_course()->id,
+                                                                $this->get_course()->id,
-                $viewfullnames,
+                                                                $viewfullnames,
-                $this->is_blind_marking(),
+                                                                $this->is_blind_marking(),
-                $this->get_uniqueid_for_user($user->id),
+                                                                $this->get_uniqueid_for_user($user->id),
-                $extrauserfields,
+                                                                $extrauserfields,
-                !$this->is_active_user($userid)
-            ));
+                                                                !$this->is_active_user($userid)));
             $usercount += 1;
+        }
             'markingworkflowstates' => $this->get_marking_workflow_states_for_current_user()
         );
         $mform = new mod_assign_batch_set_marking_workflow_state_form(null, $formparams);
         $mform->set_data($formdata);    // Initialises the hidden elements.
-        $header = new assign_header(
-            $this->get_instance(),
+        $header = new assign_header($this->get_instance(),
             $this->get_context(),
             $this->show_intro(),
             $this->get_course_module()->id,
-            get_string('setmarkingworkflowstate', 'assign')
-        );
+            get_string('setmarkingworkflowstate', 'assign'));
         $o .= $this->get_renderer()->render($header);
         $o .= $this->get_renderer()->render(new assign_form('setworkflowstate', $mform));
         $o .= $this->view_footer();
         return $o;
+    }
     /**
+     * Shows a form that allows the allocated marker for selected submissions to be changed.
-     * Shows a form that allows the allocated marker for selected submissions to be changed.
+     * You should confirm sesskey before calling this function.
-     *
      * @param moodleform $mform Set to a grading batch operations form
      * @return string - the page to view after processing these actions
      */
-    public function view_batch_markingallocation($mform)
     public function view_batch_markingallocation() {
         global $CFG, $DB;
-        require_once($CFG->dirroot . '/mod/assign/batchsetallocatedmarkerform.php');
+        require_once($CFG->dirroot . '/mod/assign/batchsetallocatedmarkerform.php');
         $o = '';
-        $submitteddata = $mform->get_data();
+        $o = '';
-        $users = $submitteddata->selectedusers;
-        $userlist = explode(',', $users);
         $users = required_param('selectedusers', PARAM_SEQUENCE);
-        $formdata = array(
+        $userlist = explode(',', $users);
             'id' => $this->get_course_module()->id,
         foreach ($userlist as $userid) {
             if ($usercount >= 5) {
                 $usershtml .= get_string('moreusers', 'assign', count($userlist) - 5);
                 break;
+            }
-            $user = $DB->get_record('user', array('id' => $userid), '*', MUST_EXIST);
+            $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
-            $usershtml .= $this->get_renderer()->render(new assign_user_summary(
-                $user,
+            $usershtml .= $this->get_renderer()->render(new assign_user_summary($user,
                 $this->get_course()->id,
                 $viewfullnames,
                 $this->is_blind_marking(),
                 $this->get_uniqueid_for_user($user->id),
                 $extrauserfields,
-                !$this->is_active_user($userid)
-            ));
+                !$this->is_active_user($userid)));
             $usercount += 1;
+        }
         $formparams['markers'] = $markerlist;
         $mform = new mod_assign_batch_set_allocatedmarker_form(null, $formparams);
-        $mform->set_data($formdata);    // Initialises the hidden elements.
-        $header = new assign_header(
+        $mform->set_data($formdata);    // Initialises the hidden elements.
-            $this->get_instance(),
+        $header = new assign_header($this->get_instance(),
             $this->get_context(),
             $this->show_intro(),
-            $this->get_course_module()->id,
-            get_string('setmarkingallocation', 'assign')
+            $this->get_course_module()->id,
-        );
+            get_string('setmarkingallocation', 'assign'));
         $o .= $this->get_renderer()->render($header);
         $o .= $this->get_renderer()->render(new assign_form('setworkflowstate', $mform));
      * Ask the user to confirm they want to submit their work for grading.
+     *
      * @param moodleform $mform - null unless form validation has failed
      * @return string
      */
-    protected function check_submit_for_grading($mform)
+    protected function check_submit_for_grading($mform) {
-    {
         global $USER, $CFG;
         require_once($CFG->dirroot . '/mod/assign/submissionconfirmform.php');
         if (empty($submissionstatement)) {
             $requiresubmissionstatement = false;
+        }
         if ($mform == null) {
-            $mform = new mod_assign_confirm_submission_form(null, array(
+            $mform = new mod_assign_confirm_submission_form(null, array($requiresubmissionstatement,
-                $requiresubmissionstatement,
-                $submissionstatement,
+                                                                        $submissionstatement,
-                $this->get_course_module()->id,
+                                                                        $this->get_course_module()->id,
-                $data
-            ));
+                                                                        $data));
+        }
         $o = '';
-        $o .= $this->get_renderer()->render(new assign_header(
-            $this->get_instance(),
+        $o .= $this->get_renderer()->render(new assign_header($this->get_instance(),
-            $this->get_context(),
+                                                              $this->get_context(),
-            $this->show_intro(),
+                                                              $this->show_intro(),
-            $this->get_course_module()->id,
+                                                              $this->get_course_module()->id,
-            get_string('confirmsubmissionheading', 'assign')
-        ));
+                                                              get_string('confirmsubmissionheading', 'assign')));
-        $submitforgradingpage = new assign_submit_for_grading_page(
-            $notifications,
+        $submitforgradingpage = new assign_submit_for_grading_page($notifications,
-            $this->get_course_module()->id,
+                                                                   $this->get_course_module()->id,
-            $mform
-        );
+                                                                   $mform);
         $o .= $this->get_renderer()->render($submitforgradingpage);
         $o .= $this->view_footer();
+     *
      * @param stdClass $user the user to get the report for
      * @param bool $showlinks return plain text or links to the profile
      * @return assign_submission_status renderable object
      */
-    public function get_assign_submission_status_renderable($user, $showlinks)
+    public function get_assign_submission_status_renderable($user, $showlinks) {
-    {
         global $PAGE;
         $instance = $this->get_instance();
         $flags = $this->get_user_flags($user->id, false);
+            }
             $notsubmitted = $this->get_submission_group_members_who_have_not_submitted($groupid, false);
+        }
         $showedit = $showlinks &&
-            ($this->is_any_submission_plugin_enabled()) &&
+                    ($this->is_any_submission_plugin_enabled()) &&
-            $this->can_edit_submission($user->id);
+                    $this->can_edit_submission($user->id);
         $submissionlocked = ($flags && $flags->locked);
+        }
         $viewfullnames = has_capability('moodle/site:viewfullnames', $this->get_context());
         $gradingstatus = $this->get_grading_status($user->id);
         $usergroups = $this->get_all_groups($user->id);
-        $submissionstatus = new assign_submission_status(
-            $instance->allowsubmissionsfromdate,
+        $submissionstatus = new assign_submission_status($instance->allowsubmissionsfromdate,
-            $instance->alwaysshowdescription,
+                                                          $instance->alwaysshowdescription,
-            $submission,
+                                                          $submission,
-            $instance->teamsubmission,
+                                                          $instance->teamsubmission,
-            $teamsubmission,
+                                                          $teamsubmission,
-            $submissiongroup,
+                                                          $submissiongroup,
-            $notsubmitted,
+                                                          $notsubmitted,
-            $this->is_any_submission_plugin_enabled(),
+                                                          $this->is_any_submission_plugin_enabled(),
-            $submissionlocked,
+                                                          $submissionlocked,
-            $this->is_graded($user->id),
+                                                          $this->is_graded($user->id),
-            $instance->duedate,
+                                                          $instance->duedate,
-            $instance->cutoffdate,
+                                                          $instance->cutoffdate,
-            $this->get_submission_plugins(),
+                                                          $this->get_submission_plugins(),
-            $this->get_return_action(),
+                                                          $this->get_return_action(),
-            $this->get_return_params(),
+                                                          $this->get_return_params(),
-            $this->get_course_module()->id,
+                                                          $this->get_course_module()->id,
-            $this->get_course()->id,
+                                                          $this->get_course()->id,
-            assign_submission_status::STUDENT_VIEW,
+                                                          assign_submission_status::STUDENT_VIEW,
-            $showedit,
+                                                          $showedit,
-            $showsubmit,
+                                                          $showsubmit,
-            $viewfullnames,
+                                                          $viewfullnames,
-            $extensionduedate,
+                                                          $extensionduedate,
-            $this->get_context(),
+                                                          $this->get_context(),
-            $this->is_blind_marking(),
+                                                          $this->is_blind_marking(),
-            $gradingcontrollerpreview,
+                                                          $gradingcontrollerpreview,
-            $instance->attemptreopenmethod,
+                                                          $instance->attemptreopenmethod,
-            $instance->maxattempts,
+                                                          $instance->maxattempts,
-            $gradingstatus,
+                                                          $gradingstatus,
-            $instance->preventsubmissionnotingroup,
+                                                          $instance->preventsubmissionnotingroup,
-            $usergroups,
+                                                          $usergroups,
-            $instance->timelimit
-        );
+                                                          $instance->timelimit);
         return $submissionstatus;
+    }
     /**
      * Creates an assign_feedback_status renderable.
+     *
      * @param stdClass $user the user to get the report for
-     * @return assign_feedback_status renderable object
-     */
+     * @return assign_feedback_status renderable object
-    public function get_assign_feedback_status_renderable($user)
+     */
-    {
+    public function get_assign_feedback_status_renderable($user) {
         global $CFG, $DB, $PAGE;
-        require_once($CFG->libdir . '/gradelib.php');
+        require_once($CFG->libdir.'/gradelib.php');
-        require_once($CFG->dirroot . '/grade/grading/lib.php');
+        require_once($CFG->dirroot.'/grade/grading/lib.php');
-        $instance = $this->get_instance();
-        $grade = $this->get_user_grade($user->id, false);
+        $instance = $this->get_instance();
-        $gradingstatus = $this->get_grading_status($user->id);
+        $grade = $this->get_user_grade($user->id, false);
+        $gradingstatus = $this->get_grading_status($user->id);
-        $gradinginfo = grade_get_grades(
             $this->get_course()->id,
-            'mod',
+        $gradinginfo = grade_get_grades($this->get_course()->id,
-            'assign',
+                                    'mod',
-            $instance->id,
+                                    'assign',
             $emptyplugins = true; // Don't show feedback plugins until released either.
+        }
         $cangrade = has_capability('mod/assign:grade', $this->get_context());
         $hasgrade = $this->get_instance()->grade != GRADE_TYPE_NONE &&
-            !is_null($gradebookgrade) && !is_null($gradebookgrade->grade);
+                        !is_null($gradebookgrade) && !is_null($gradebookgrade->grade);
         $gradevisible = $cangrade || $this->get_instance()->grade == GRADE_TYPE_NONE ||
-            (!is_null($gradebookgrade) && !$gradebookgrade->hidden);
+                        (!is_null($gradebookgrade) && !$gradebookgrade->hidden);
         // If there is a visible grade, show the summary.
         if (($hasgrade || !$emptyplugins) && $gradevisible) {
                         $grade->id,
                         $gradingitem,
                         '',
                         $cangrade
                     );
+                    // Display the penalty indicator next to the penalized grade, if applicable.
+                    $penaltyindicator = \core_grades\penalty_manager::show_penalty_indicator(
+                        new \grade_grade([
+                            'deductedmark' => $gradebookgrade->deductedmark ?? 0,
+                            'overridden' => $gradebookgrade->overridden ?? 0,
+                        ], false)
+                    );
-                    $gradefordisplay = $gradebookgrade->str_long_grade;
+                    $gradefordisplay = $penaltyindicator . $gradebookgrade->str_long_grade;
                 } else {
+                    // This grade info is the grade from gradebook.
+                    // We need user id to determine if the grade is overridden or not.
-                    $gradefordisplay = $this->display_grade($gradebookgrade->grade, false);
+                    $gradefordisplay = $this->display_grade(
+                        $gradebookgrade->grade,
+                        false,
+                        $user->id,
+,
+                        $gradebookgrade->deductedmark
+                    );
+                }
                 $gradeddate = $gradebookgrade->dategraded;
                 // Show the grader's identity if 'Hide Grader' is disabled or has the 'Show Hidden Grader' capability.
                 if (has_capability('mod/assign:showhiddengrader', $this->context) || !$this->is_hidden_grader()) {
                     // Only display the grader if it is in the right state.
                     if (in_array($gradingstatus, [ASSIGN_GRADING_STATUS_GRADED, ASSIGN_MARKING_WORKFLOW_STATE_RELEASED])) {
                         if (isset($grade->grader) && $grade->grader > 0) {
-                            $grader = $DB->get_record('user', array('id' => $grade->grader));
-                        } else if (
+                            $grader = $DB->get_record('user', array('id' => $grade->grader));
-                            isset($gradebookgrade->usermodified)
+                        } else if (isset($gradebookgrade->usermodified)
                             && $gradebookgrade->usermodified > 0
-                            && has_capability('mod/assign:grade', $this->get_context(), $gradebookgrade->usermodified)
-                        ) {
+                            && has_capability('mod/assign:grade', $this->get_context(), $gradebookgrade->usermodified)) {
                             // Grader not provided. Check that usermodified is a user who can grade.
                             // Case 1: When an assignment is reopened an empty assign_grade is created so the feedback
                             // plugin can know which attempt it's referring to. In this case, usermodifed is a student.
                             // Case 2: When an assignment's grade is overrided via the gradebook, usermodified is a grader.
      * Creates an assign_attempt_history renderable.
+     *
      * @param stdClass $user the user to get the report for
      * @return assign_attempt_history renderable object
      */
-    public function get_assign_attempt_history_renderable($user)
+    public function get_assign_attempt_history_renderable($user) {
-    {
         $allsubmissions = $this->get_all_submissions($user->id);
         $allgrades = $this->get_all_grades($user->id);
-        $history = new assign_attempt_history(
-            $allsubmissions,
+        $history = new assign_attempt_history($allsubmissions,
-            $allgrades,
+                                              $allgrades,
-            $this->get_submission_plugins(),
+                                              $this->get_submission_plugins(),
-            $this->get_feedback_plugins(),
+                                              $this->get_feedback_plugins(),
-            $this->get_course_module()->id,
+                                              $this->get_course_module()->id,
-            $this->get_return_action(),
+                                              $this->get_return_action(),
-            $this->get_return_params(),
+                                              $this->get_return_params(),
-            false,
+                                              false,
-,
 ,
-        );
+);
         return $history;
+    }
+     *
      * @param stdClass $user the user to print the report for
      * @param bool $showlinks - Return plain text or links to the profile
      * @return string - the html summary
      */
-    public function view_student_summary($user, $showlinks)
+    public function view_student_summary($user, $showlinks) {
-    {
         $o = '';
      * @param stdClass $submission The users own submission record.
      * @param stdClass $teamsubmission The users team submission record if there is one
      * @param int $userid The user
      * @return bool
      */
-    protected function show_submit_button($submission = null, $teamsubmission = null, $userid = null)
+    protected function show_submit_button($submission = null, $teamsubmission = null, $userid = null) {
-    {
         if (!has_capability('mod/assign:submit', $this->get_context(), $userid, false)) {
             // The user does not have the capability to submit.
             return false;
+        }
         if ($teamsubmission) {
      * and gradefordisplay is added (rendered from grading manager).
+     *
      * @param int $userid If not set, $USER->id will be used.
      * @return array $grades All grade records for this user.
      */
-    protected function get_all_grades($userid)
+    protected function get_all_grades($userid) {
-    {
         global $DB, $USER, $PAGE;
         // If the userid is not null then use userid.
         if (!$userid) {
             $userid = $USER->id;
         }
-        $params = array('assignment' => $this->get_instance()->id, 'userid' => $userid);
+        $params = array('assignment'=>$this->get_instance()->id, 'userid'=>$userid);
         // Need gradingitem and gradingmanager.
         $gradingmanager = get_grading_manager($this->get_context(), 'mod_assign', 'submissions');
         $controller = $gradingmanager->get_active_controller();
-        $gradinginfo = grade_get_grades(
-            $this->get_course()->id,
+        $gradinginfo = grade_get_grades($this->get_course()->id,
-            'mod',
+                                        'mod',
-            'assign',
+                                        'assign',
-            $this->get_instance()->id,
-            $userid
+                                        $this->get_instance()->id,
-        );
+                                        $userid);
         $gradingitem = null;
                 $grade->grader = null;
             } else if (isset($gradercache[$grade->grader])) {
                 $grade->grader = $gradercache[$grade->grader];
             } else if ($grade->grader > 0) {
                 // Not in cache - need to load the grader record.
-                $grade->grader = $DB->get_record('user', array('id' => $grade->grader));
+                $grade->grader = $DB->get_record('user', array('id'=>$grade->grader));
                 if ($grade->grader) {
                     $gradercache[$grade->grader->id] = $grade->grader;
+                }
+            }
+            // The assign grade for each attempt is not stored in the gradebook.
+            // We need to calculate them from assign_grade records.
+            [$penalisedgrade, $deductedmark] = $this->calculate_penalised_grade($grade);
             // Now get the gradefordisplay.
             if ($controller) {
                 $controller->set_grade_range(make_grades_menu($this->get_instance()->grade), $this->get_instance()->grade > 0);
-                $grade->gradefordisplay = $controller->render_grade(
+                // Display the penalty indicator next to the penalized grade, if applicable.
-                    $PAGE,
+                $penaltyindicator = \core_grades\penalty_manager::show_penalty_indicator(
-                    $grade->id,
+                    new \grade_grade([
-                    $gradingitem,
+                        'deductedmark' => $deductedmark,
-                    $grade->grade,
+                        'overridden' => $userid > 0 ? $this->get_grade_item()->get_grade($userid)->overridden : 0,
-                    $cangrade
+                    ], false)
+                );
+                $gradeoutput = $penaltyindicator . format_float($penalisedgrade, $this->get_grade_item()->get_decimals());
-                );
+                $grade->gradefordisplay = $controller->render_grade($PAGE, $grade->id, $gradingitem, $gradeoutput, $cangrade);
+            } else {
-            } else {
+                // We do not need user id here as the overriden grade should not affect the previous attempts.
-                $grade->gradefordisplay = $this->display_grade($grade->grade, false);
+                $grade->gradefordisplay = $this->display_grade($penalisedgrade, false, 0, 0, $deductedmark);
+            }
+        }
         return $grades;
+    }
+    /**
+     * Calculate penalised grade and deducted mark.
+     *
+     * @param stdClass $grade The grade object
+     * @return array [$penalisedgrade, $deductedmark] the penalised grade and the deducted mark
+     */
+    public function calculate_penalised_grade(stdClass $grade): array {
+        $penalisedgrade = $grade->grade;
+        $deductedmark = 0;
+        // No calculation needed if the grade is null or negative.
+        if (is_null($penalisedgrade) || $penalisedgrade < 0) {
+            return [$penalisedgrade, $deductedmark];
+        }
+        if ($grade->penalty > 0) {
+            $deductedmark = $grade->grade * $grade->penalty / 100;
+            $penalisedgrade = $grade->grade - $deductedmark;
+        }
+        return [$penalisedgrade, $deductedmark];
+    }
     /**
      * Get the submissions for all previous attempts.
+     *
      * @param int $userid If not set, $USER->id will be used.
-     * @return array $submissions All submission records for this user (or group).
-     */
+     * @return array $submissions All submission records for this user (or group).
-    public function get_all_submissions($userid)
+     */
     public function get_all_submissions($userid) {
         global $DB, $USER;
             if ($group) {
                 $groupid = $group->id;
+            }
             // Params to get the group submissions.
-            $params = array('assignment' => $this->get_instance()->id, 'groupid' => $groupid, 'userid' => 0);
+            $params = array('assignment'=>$this->get_instance()->id, 'groupid'=>$groupid, 'userid'=>0);
         } else {
             // Params to get the user submissions.
-            $params = array('assignment' => $this->get_instance()->id, 'userid' => $userid);
+            $params = array('assignment'=>$this->get_instance()->id, 'userid'=>$userid);
+        }
      * Creates an assign_grading_summary renderable.
+     *
      * @param mixed $activitygroup int|null the group for calculating the grading summary (if null the function will determine it)
      * @return assign_grading_summary renderable object
      */
-    public function get_assign_grading_summary_renderable($activitygroup = null)
+    public function get_assign_grading_summary_renderable($activitygroup = null) {
-    {
         $instance = $this->get_default_instance(); // Grading summary requires the raw dates, regardless of relativedates mode.
         $cm = $this->get_course_module();
      * Helper function to allow up to fetch the group overrides via one query as opposed to many calls.
+     *
      * @param int $activitygroup The group we want to check the overrides of
      * @return mixed Can return either a fetched DB object, local object or false
      */
-    private function get_override_data(int $activitygroup)
+    private function get_override_data(int $activitygroup) {
-    {
         global $DB;
         $instanceid = $this->get_instance()->id;
         $cachekey = "$instanceid-$activitygroup";
      * Return group override duedate.
+     *
      * @param int $activitygroup Activity active group
      * @return int $duedate
      */
-    private function get_duedate($activitygroup = null)
+    private function get_duedate($activitygroup = null) {
-    {
         if ($activitygroup === null) {
             $activitygroup = groups_get_activity_group($this->get_course_module());
+        }
         if ($this->can_view_grades() && !empty($activitygroup)) {
             $groupoverride = $this->get_override_data($activitygroup);
      * Return group override timelimit.
+     *
      * @param null|int $activitygroup Activity active group
      * @return int $timelimit
      */
-    private function get_timelimit(?int $activitygroup = null): int
+    private function get_timelimit(?int $activitygroup = null): int {
-    {
         if ($activitygroup === null) {
             $activitygroup = groups_get_activity_group($this->get_course_module());
+        }
         if ($this->can_view_grades() && !empty($activitygroup)) {
             $groupoverride = $this->get_override_data($activitygroup);
      * Return group override cutoffdate.
+     *
      * @param null|int $activitygroup Activity active group
      * @return int $cutoffdate
      */
-    private function get_cutoffdate(?int $activitygroup = null): int
+    private function get_cutoffdate(?int $activitygroup = null): int {
-    {
         if ($activitygroup === null) {
             $activitygroup = groups_get_activity_group($this->get_course_module());
+        }
         if ($this->can_view_grades() && !empty($activitygroup)) {
             $groupoverride = $this->get_override_data($activitygroup);
     /**
      * View submissions page (contains details of current submission).
+     *
      * @return string
      */
-    protected function view_submission_page()
+    protected function view_submission_page() {
-    {
         global $CFG, $DB, $USER, $PAGE;
         $instance = $this->get_instance();
         $postfix = '';
         if ($this->has_visible_attachments() && (!$this->get_instance($USER->id)->submissionattachments)) {
             $postfix = $this->render_area_files('mod_assign', ASSIGN_INTROATTACHMENT_FILEAREA, 0);
+        }
-        $o .= $this->get_renderer()->render(new assign_header(
-            $instance,
+        $o .= $this->get_renderer()->render(new assign_header($instance,
-            $this->get_context(),
+                                                      $this->get_context(),
-            $this->show_intro(),
+                                                      $this->show_intro(),
-            $this->get_course_module()->id,
-            '',
-            '',
+                                                      $this->get_course_module()->id,
-            $postfix
-        ));
+                                                      '', '', $postfix));
         // Display plugin specific headers.
         $plugins = array_merge($this->get_submission_plugins(), $this->get_feedback_plugins());
+     *
      * @param stdClass $instance The settings for the current instance of this assignment
      * @param stdClass $user The user to print the action bar for
      * @return string
      */
-    public function view_submission_action_bar(stdClass $instance, stdClass $user): string
+    public function view_submission_action_bar(stdClass $instance, stdClass $user): string {
-    {
         $submission = $this->get_user_submission($user->id, false);
         // Figure out if we are team or solitary submission.
         $teamsubmission = null;
         if ($instance->teamsubmission) {
             $teamsubmission = $this->get_group_submission($user->id, 0, false);
      * Convert the final raw grade(s) in the grading table for the gradebook.
+     *
      * @param stdClass $grade
      * @return array
      */
-    protected function convert_grade_for_gradebook(stdClass $grade)
+    protected function convert_grade_for_gradebook(stdClass $grade) {
-    {
         $gradebookgrade = array();
         if ($grade->grade >= 0) {
             $gradebookgrade['rawgrade'] = $grade->grade;
+        }
         // Allow "no grade" to be chosen.
      * Convert submission details for the gradebook.
+     *
      * @param stdClass $submission
      * @return array
      */
-    protected function convert_submission_for_gradebook(stdClass $submission)
+    protected function convert_submission_for_gradebook(stdClass $submission) {
-    {
         $gradebookgrade = array();
         $gradebookgrade['userid'] = $submission->userid;
         $gradebookgrade['usermodified'] = $submission->userid;
+     *
      * @param mixed $submission stdClass|null
      * @param mixed $grade stdClass|null
      * @return bool
      */
-    protected function gradebook_item_update($submission = null, $grade = null)
+    protected function gradebook_item_update($submission=null, $grade=null) {
-    {
         global $CFG;
-        require_once($CFG->dirroot . '/mod/assign/lib.php');
+        require_once($CFG->dirroot.'/mod/assign/lib.php');
         // Do not push grade to gradebook if blind marking is active as
         // the gradebook would reveal the students.
-        if ($this->is_blind_marking()) {
+        if ($this->is_blind_marking() && !$this->is_marking_anonymous()) {
             return false;
+        }
-        // If marking workflow is enabled and grade is not released then remove any grade that may exist in the gradebook.
-        if (
+        // If marking workflow is enabled and grade is not released then remove any grade that may exist in the gradebook.
-            $this->get_instance()->markingworkflow && !empty($grade) &&
-            $this->get_grading_status($grade->userid) != ASSIGN_MARKING_WORKFLOW_STATE_RELEASED
+        if ($this->get_instance()->markingworkflow && !empty($grade) &&
-        ) {
+                $this->get_grading_status($grade->userid) != ASSIGN_MARKING_WORKFLOW_STATE_RELEASED) {
             // Remove the grade (if it exists) from the gradebook as it is not 'final'.
             $grade->grade = -1;
             $grade->feedbacktext = '';
+                }
                 return;
+            }
+            $gradebookgrade = $this->convert_submission_for_gradebook($submission);
             $gradebookgrade = $this->convert_submission_for_gradebook($submission);
         } else {
             $gradebookgrade = $this->convert_grade_for_gradebook($grade);
+        }
         // Grading is disabled, return.
      * @param stdClass $submission
      * @param int $userid
      * @param bool $updatetime
      * @return bool
      */
-    protected function update_team_submission(stdClass $submission, $userid, $updatetime)
+    protected function update_team_submission(stdClass $submission, $userid, $updatetime) {
-    {
         global $DB;
         if ($updatetime) {
             $submission->timemodified = time();
         if (!in_array($submission->status, [ASSIGN_SUBMISSION_STATUS_NEW, ASSIGN_SUBMISSION_STATUS_REOPENED])) {
             foreach ($team as $member) {
                 $membersubmission = $this->get_user_submission($member->id, false, $submission->attemptnumber);
-                // If no submission found for team member and member is active then everyone has not submitted.
-                if (
+                // If no submission found for team member and member is active then everyone has not submitted.
-                    !$membersubmission || $membersubmission->status != ASSIGN_SUBMISSION_STATUS_SUBMITTED
+                if (!$membersubmission || $membersubmission->status != ASSIGN_SUBMISSION_STATUS_SUBMITTED
-                    && ($this->is_active_user($member->id))
-                ) {
+                        && ($this->is_active_user($member->id))) {
                     $allsubmitted = false;
                     if ($anysubmitted) {
                         break;
+                    }
      * @param int $userid
      * @param bool $updatetime
      * @param bool $teamsubmission
      * @return bool
      */
-    protected function update_submission(stdClass $submission, $userid, $updatetime, $teamsubmission)
+    protected function update_submission(stdClass $submission, $userid, $updatetime, $teamsubmission) {
-    {
         global $DB;
         if ($teamsubmission) {
             return $this->update_team_submission($submission, $userid, $updatetime);
+        }
         if ($updatetime) {
             $submission->timemodified = time();
+        }
-        $result = $DB->update_record('assign_submission', $submission);
+        $result= $DB->update_record('assign_submission', $submission);
         if ($result) {
             $this->gradebook_item_update($submission);
+        }
      * @param stdClass $submission - Pre-fetched submission record (or false to fetch it)
      * @param stdClass $flags - Pre-fetched user flags record (or false to fetch it)
      * @param stdClass $gradinginfo - Pre-fetched user gradinginfo record (or false to fetch it)
      * @return bool
      */
-    public function submissions_open(
+    public function submissions_open($userid = 0,
-        $userid = 0,
-        $skipenrolled = false,
+                                     $skipenrolled = false,
-        $submission = false,
+                                     $submission = false,
-        $flags = false,
+                                     $flags = false,
-        $gradinginfo = false
+                                     $gradinginfo = false) {
-    ) {
         global $USER;
         if (!$userid) {
             $userid = $USER->id;
+            }
+        }
         // See if this user grade is locked in the gradebook.
         if ($gradinginfo === false) {
-            $gradinginfo = grade_get_grades(
+            $gradinginfo = grade_get_grades($this->get_course()->id,
-                $this->get_course()->id,
-                'mod',
+                                            'mod',
-                'assign',
+                                            'assign',
-                $this->get_instance()->id,
+                                            $this->get_instance()->id,
-                array($userid)
-            );
+                                            array($userid));
-        }
-        if (
+        }
-            $gradinginfo &&
+        if ($gradinginfo &&
-            isset($gradinginfo->items[0]->grades[$userid]) &&
+                isset($gradinginfo->items[0]->grades[$userid]) &&
-            $gradinginfo->items[0]->grades[$userid]->locked
-        ) {
+                $gradinginfo->items[0]->grades[$userid]->locked) {
             return false;
+        }
      * @param string $component
      * @param string $area
      * @param int $submissionid
      * @return string
      */
-    public function render_area_files($component, $area, $submissionid)
+    public function render_area_files($component, $area, $submissionid) {
-    {
         global $USER;
-        return $this->get_renderer()->assign_files(
-            $this->context,
-            $submissionid,
-            $area,
-            $component,
-            $this->course,
+        return $this->get_renderer()->assign_files($this->context, $submissionid, $area, $component,
-            $this->coursemodule
+                                                   $this->course, $this->coursemodule);
         );
+    }
     /**
      * Capability check to make sure this grader can edit this submission.
+     *
      * @param int $userid - The user whose submission is to be edited
      * @param int $graderid (optional) - The user who will do the editing (default to $USER->id).
      * @return bool
-     */
-    public function can_edit_submission($userid, $graderid = 0)
+     */
     public function can_edit_submission($userid, $graderid = 0) {
         global $USER;
         if (empty($graderid)) {
-            $graderid = $USER->id;
-        }
+            $graderid = $USER->id;
+        }
         $instance = $this->get_instance();
-        if (
+        $instance = $this->get_instance();
-            $userid == $graderid &&
-            $instance->teamsubmission &&
+        if ($userid == $graderid &&
-            $instance->preventsubmissionnotingroup &&
+            $instance->teamsubmission &&
-            $this->get_submission_group($userid) == false
+            $instance->preventsubmissionnotingroup &&
-        ) {
-            return false;
+            $this->get_submission_group($userid) == false) {
-        }
+            return false;
         if ($userid == $graderid) {
             if (
-                $this->submissions_open($userid) &&
+        if ($userid == $graderid) {
-                has_capability('mod/assign:submit', $this->context, $graderid)
+            if ($this->submissions_open($userid) &&
-            ) {
+                    has_capability('mod/assign:submit', $this->context, $graderid)) {
         if (!has_capability('mod/assign:editothersubmission', $this->context, $graderid)) {
             return false;
+        }
         $cm = $this->get_course_module();
+        if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS &&
-        if (groups_get_activity_groupmode($cm) == SEPARATEGROUPS) {
+                !has_capability('moodle/site:accessallgroups', $this->context, $graderid)) {
             $sharedgroupmembers = $this->get_shared_group_members($cm, $graderid);
             return in_array($userid, $sharedgroupmembers);
+        }
         return true;
+     *
      * @param stdClass|cm_info $cm Course-module
      * @param int $userid User ID
      * @return array An array of ID of users.
      */
-    public function get_shared_group_members($cm, $userid)
+    public function get_shared_group_members($cm, $userid) {
-    {
         if (!isset($this->sharedgroupmembers[$userid])) {
             $this->sharedgroupmembers[$userid] = array();
             if ($members = groups_get_activity_shared_group_members($cm, $userid)) {
                 $this->sharedgroupmembers[$userid] = array_keys($members);
+            }
      * Returns a list of teachers that should be grading given submission.
+     *
      * @param int $userid The submission to grade
      * @return array
      */
-    protected function get_graders($userid)
+    protected function get_graders($userid) {
-    {
         // Potential graders should be active users only.
         $potentialgraders = get_enrolled_users($this->context, "mod/assign:grade", null, 'u.*', null, null, null, true);
         $graders = array();
      * Returns a list of users that should receive notification about given submission.
+     *
      * @param int $userid The submission to grade
      * @return array
      */
-    protected function get_notifiable_users($userid)
+    protected function get_notifiable_users($userid) {
-    {
         // Potential users should be active users only.
-        $potentialusers = get_enrolled_users(
+        $potentialusers = get_enrolled_users($this->context, "mod/assign:receivegradernotifications",
-            $this->context,
-            "mod/assign:receivegradernotifications",
+                                             null, 'u.*', null, null, null, true);
-            null,
-            'u.*',
-            null,
-            null,
-            null,
-            true
-        );
         $notifiableusers = array();
         if (groups_get_activity_groupmode($this->get_course_module()) == SEPARATEGROUPS) {
             if ($groups = groups_get_all_groups($this->get_course()->id, $userid, $this->get_course_module()->groupingid)) {
+        }
         return $notifiableusers;
+    }
-    /**
-     * Format a notification for plain text.
-     *
-     * @param string $messagetype
-     * @param stdClass $info
-     * @param stdClass $course
-     * @param stdClass $context
-     * @param string $modulename
-     * @param string $assignmentname
-     */
-    protected static function format_notification_message_text(
-        $messagetype,
-        $info,
-        $course,
-        $context,
-        $modulename,
-        $assignmentname
-    ) {
-        $formatparams = array('context' => $context->get_course_context());
-        $posttext  = format_string($course->shortname, true, $formatparams) .
-            ' -> ' .
-            $modulename .
-            ' -> ' .
-            format_string($assignmentname, true, $formatparams) . "\n";
-        $posttext .= '---------------------------------------------------------------------' . "\n";
-        $posttext .= get_string($messagetype . 'text', 'assign', $info) . "\n";
-        $posttext .= "\n---------------------------------------------------------------------\n";
-        return $posttext;
-    }
-    /**
-     * Format a notification for HTML.
-     *
-     * @param string $messagetype
-     * @param stdClass $info
-     * @param stdClass $course
-     * @param stdClass $context
-     * @param string $modulename
-     * @param stdClass $coursemodule
-     * @param string $assignmentname
-     */
-    protected static function format_notification_message_html(
-        $messagetype,
-        $info,
-        $course,
-        $context,
-        $modulename,
-        $coursemodule,
-        $assignmentname
-    ) {
-        global $CFG;
-        $formatparams = array('context' => $context->get_course_context());
-        $posthtml  = '<p><font face="sans-serif">' .
-            '<a href="' . $CFG->wwwroot . '/course/view.php?id=' . $course->id . '">' .
-            format_string($course->shortname, true, $formatparams) .
-            '</a> ->' .
-            '<a href="' . $CFG->wwwroot . '/mod/assign/index.php?id=' . $course->id . '">' .
-            $modulename .
-            '</a> ->' .
-            '<a href="' . $CFG->wwwroot . '/mod/assign/view.php?id=' . $coursemodule->id . '">' .
-            format_string($assignmentname, true, $formatparams) .
-            '</a></font></p>';
-        $posthtml .= '<hr /><font face="sans-serif">';
-        $posthtml .= '<p>' . get_string($messagetype . 'html', 'assign', $info) . '</p>';
-        $posthtml .= '</font><hr />';
-        return $posthtml;
-    }
     /**
      * Message someone about something (static so it can be called from cron).
+     *
      * @param stdClass $userfrom
      * @param stdClass $userto
      * @param string $messagetype
      * @param string $eventtype
      * @param int $updatetime
      * @param stdClass $coursemodule
-     * @param stdClass $context
+     * @param context $context
      * @param stdClass $course
-     * @param string $modulename
+     * @param string $modulename - no longer used.
      * @param string $assignmentname
      * @param bool $blindmarking
+     * @param int $uniqueidforuser
-     * @param int $uniqueidforuser
+     * @param array $extrainfo extra values to pass to any language strings or templates used in preparing the message.
      * @return void
      */
-    public static function send_assignment_notification(
-        $userfrom,
+    public static function send_assignment_notification($userfrom,
-        $userto,
+                                                        $userto,
-        $messagetype,
+                                                        $messagetype,
-        $eventtype,
+                                                        $eventtype,
-        $updatetime,
+                                                        $updatetime,
-        $coursemodule,
+                                                        $coursemodule,
-        $context,
+                                                        $context,
-        $course,
+                                                        $course,
-        $modulename,
+                                                        $modulename,
-        $assignmentname,
+                                                        $assignmentname,
-        $blindmarking,
+                                                        $blindmarking,
-        $uniqueidforuser
+                                                        $uniqueidforuser,
-    ) {
+                                                        $extrainfo = []) {
+        global $CFG, $PAGE;
+        // We put more data into info that is used by the default language strings,
+        // so that there is more flexibility for organisations that want to use
+        // Language Customisation to customise the messages.
         global $CFG, $PAGE;
         // Information about the sender - normally the user who performed the action.
         $info = new stdClass();
         if ($blindmarking) {
-            $userfrom = clone ($userfrom);
+            $userfrom = clone($userfrom);
             $info->username = get_string('participant', 'assign') . ' ' . $uniqueidforuser;
             $userfrom->firstname = get_string('participant', 'assign');
             $userfrom->lastname = $uniqueidforuser;
             $userfrom->email = $CFG->noreplyaddress;
         } else {
+            $info->username = core_user::get_fullname($userfrom, $context, ['override' => true]);
+        }
+        // Information about the recipient (for greeting, etc.).
+        $info->recipentname = core_user::get_fullname($userto, $context, ['override' => true]);
-            $info->username = fullname($userfrom, true);
         // Information about the assignment.
+        $info->assignment = format_string($assignmentname, true, ['context' => $context]);
+        $info->url = $CFG->wwwroot . '/mod/assign/view.php?id=' . $coursemodule->id;
+        // Note: URLs here avoid the & character to avoid escaping issues between text and HTML messages.
+        $info->assignmentlink  = '<a href="' . $info->url . '">' . s($info->assignment) . ' report</a>';
+        $info->assigncmid = $coursemodule->id;
+        // Information about the course.
+        $info->courseshortname = format_string($course->shortname, true, ['context' => $context]);
+        $info->coursefullname = format_string($course->fullname, true, ['context' => $context]);
+        // Note: URLs here avoid the & character to avoid escaping issues between text and HTML messages.
+        $info->courseurl = $CFG->wwwroot . '/course/view.php?id=' . $course->id;
+        $info->courseassignsurl = $CFG->wwwroot . '/mod/assign/index.php?id=' . $course->id;
-        $info->assignment = format_string($assignmentname, true, array('context' => $context));
+        // Time of the action.
+        $info->timeupdated = userdate($updatetime);
+        // Other data passed in.
+        $info = (object) array_merge((array) $info, $extrainfo);
+        // Since format_string returns text with HTML characters escaped,
+        // we need to un-escape before including in the plain text email and subject line.
+        // (Test with a course or assignment called "Escaping & unescaping" to understand).
+        $plaintextinfo = clone $info;
+        $plaintextinfo->assignment = html_entity_decode($info->assignment);
+        $plaintextinfo->courseshortname = html_entity_decode($info->courseshortname);
+        $plaintextinfo->coursefullname = html_entity_decode($info->coursefullname);
+        // Prepare the message subject and bodies.
+        $postsubject = get_string($messagetype . 'small', 'assign', $plaintextinfo);
+        $smsmessage = get_string($messagetype . 'sms', 'assign', $plaintextinfo);
+        $renderer = $PAGE->get_renderer('mod_assign');
+        $context = clone $plaintextinfo;
+        $context->messagetext = get_string($messagetype . 'text', 'assign', $plaintextinfo);
+        // Mustache strips off all training whitespace, but we want a newline at the end.
-        $info->url = $CFG->wwwroot . '/mod/assign/view.php?id=' . $coursemodule->id;
-        $info->timeupdated = userdate($updatetime, get_string('strftimerecentfull'));
-        $postsubject = get_string($messagetype . 'small', 'assign', $info);
-        $posttext = self::format_notification_message_text(
-            $messagetype,
-            $info,
-            $course,
-            $context,
-            $modulename,
+        $posttext = $renderer->render_from_template(
-            $assignmentname
+            'mod_assign/messages/notification_text', $context) . "\n";
-        );
-        $posthtml = '';
-        if ($userto->mailformat == 1) {
-            $posthtml = self::format_notification_message_html(
-                $messagetype,
-                $info,
+        $posthtml = '';
-                $course,
+        if ($userto->mailformat == 1) {
-                $context,
+            $context = clone $info;
-                $modulename,
-                $coursemodule,
+            $context->messagehtml = get_string($messagetype . 'html', 'assign', $info);
+            $posthtml = $renderer->render_from_template(
-                $assignmentname
+                'mod_assign/messages/notification_html', $context);
             );
         // Build the message object.
         $eventdata = new \core\message\message();
         $eventdata->courseid         = $course->id;
         $eventdata->modulename       = 'assign';
         $eventdata->userfrom         = $userfrom;
         $eventdata->userto           = $userto;
+        $eventdata->subject          = $postsubject;
-        $eventdata->subject          = $postsubject;
+        $eventdata->fullmessage      = $posttext;
-        $eventdata->fullmessage      = $posttext;
+        $eventdata->fullmessageformat = FORMAT_PLAIN;
-        $eventdata->fullmessageformat = FORMAT_PLAIN;
+        $eventdata->fullmessagehtml  = $posthtml;
-        $eventdata->fullmessagehtml  = $posthtml;
+        $eventdata->fullmessagesms   = $smsmessage;
      * @param stdClass $userfrom
      * @param stdClass $userto
      * @param string $messagetype
      * @param string $eventtype
      * @param int $updatetime
+     * @param array $extrainfo extra values to pass to any language strings or templates used in preparing the message.
      * @return void
      */
-    public function send_notification($userfrom, $userto, $messagetype, $eventtype, $updatetime)
+    public function send_notification($userfrom, $userto, $messagetype, $eventtype, $updatetime, $extrainfo = []) {
-    {
         global $USER;
         $userid = core_user::is_real_user($userfrom->id) ? $userfrom->id : $USER->id;
         $uniqueid = $this->get_uniqueid_for_user($userid);
-        self::send_assignment_notification(
+        $oldforcelang = force_current_language($userto->lang);
-            $userfrom,
+        self::send_assignment_notification($userfrom,
-            $userto,
+                                           $userto,
-            $messagetype,
+                                           $messagetype,
-            $eventtype,
+                                           $eventtype,
-            $updatetime,
+                                           $updatetime,
-            $this->get_course_module(),
+                                           $this->get_course_module(),
-            $this->get_context(),
+                                           $this->get_context(),
-            $this->get_course(),
+                                           $this->get_course(),
-            $this->get_module_name(),
+                                           $this->get_module_name(),
-            $this->get_instance()->name,
+                                           $this->get_instance()->name,
-            $this->is_blind_marking(),
+                                           $this->is_blind_marking(),
-            $uniqueid
+                                           $uniqueid,
+                                           $extrainfo);
-        );
+        force_current_language($oldforcelang);
+    }
     /**
      * Notify student upon successful submission copy.
+     *
      * @param stdClass $submission
      * @return void
      */
-    protected function notify_student_submission_copied(stdClass $submission)
     protected function notify_student_submission_copied(stdClass $submission) {
         global $DB, $USER;
         $adminconfig = $this->get_admin_config();
         // Use the same setting for this - no need for another one.
         if (empty($adminconfig->submissionreceipts)) {
             // No need to do anything.
             return;
         }
         if ($submission->userid) {
-            $user = $DB->get_record('user', array('id' => $submission->userid), '*', MUST_EXIST);
+            $user = $DB->get_record('user', array('id'=>$submission->userid), '*', MUST_EXIST);
         } else {
             $user = $USER;
-        }
-        $this->send_notification(
+        }
-            $user,
+        $this->send_notification($user,
-            $user,
+                                 $user,
-            'submissioncopied',
+                                 'submissioncopied',
-            'assign_notification',
-            $submission->timemodified
+                                 'assign_notification',
-        );
+                                 $submission->timemodified);
+    }
     /**
      * Notify student upon successful submission.
+     *
      * @param stdClass $submission
      * @return void
-     */
-    protected function notify_student_submission_receipt(stdClass $submission)
+     */
     protected function notify_student_submission_receipt(stdClass $submission) {
         global $DB, $USER;
         $adminconfig = $this->get_admin_config();
         if (empty($adminconfig->submissionreceipts)) {
             // No need to do anything.
             return;
+        }
         if ($submission->userid) {
-            $user = $DB->get_record('user', array('id' => $submission->userid), '*', MUST_EXIST);
+            $user = $DB->get_record('user', array('id'=>$submission->userid), '*', MUST_EXIST);
+        } else {
+            $user = $USER;
+        }
+        // Prepare extra data for submission receipt notification.
-        } else {
+        $oldforcelang = force_current_language($user->lang);
-            $user = $USER;
-        }
+        $extrainfo = $this->get_submission_summaries_for_messages($submission);
-        if ($submission->userid == $USER->id) {
+        force_current_language($oldforcelang);
-            $this->send_notification(
+        if ($submission->userid == $USER->id) {
-                core_user::get_noreply_user(),
+            $this->send_notification(core_user::get_noreply_user(),
-                $user,
+                                     $user,
-                'submissionreceipt',
+                                     'submissionreceipt',
-                'assign_notification',
+                                     'assign_notification',
-                $submission->timemodified
+                                     $submission->timemodified,
-            );
-        } else {
+                                     $extrainfo);
-            $this->send_notification(
+        } else {
-                $USER,
+            $this->send_notification($USER,
-                $user,
+                                     $user,
-                'submissionreceiptother',
+                                     'submissionreceiptother',
-                'assign_notification',
+                                     'assign_notification',
-                $submission->timemodified
+                                     $submission->timemodified,
-            );
+                                     $extrainfo);
+        }
+    }
+    /**
+     * Produce a summary of a submission that can be used in messages.
+     *
+     * This function iterates through all enabled submission plugins and calls their
+     * `get_submission_summary` method (if implemented). It aggregates the results
+     * into a formatted summary string.
+     *
+     * @param stdClass $submission the submission the message is about. Row from assign_submission table.
+     * @return string[] with two elements:
+     *      'submissionsummarytext' => a plain text summary,
+     *      'submissionsummaryhtml' => an HTML summary.
+     */
+    protected function get_submission_summaries_for_messages(stdClass $submission): array {
+        $textsummaries = [];
+        $htmlsummaries = [];
+        foreach ($this->submissionplugins as $plugin) {
+            if ($plugin->is_enabled() && $plugin->is_visible()) {
+                [$textsummary, $htmlsummary] = $plugin->submission_summary_for_messages($submission);
+                if ($textsummary) {
+                    $textsummaries[] = $textsummary;
+                }
+                if ($htmlsummary) {
+                    $htmlsummaries[] = $htmlsummary;
+                }
+            }
+        }
+        $textsummary = '';
+        if ($textsummaries) {
+            $textsummary = get_string('submissioncontains', 'assign') . "\n\n" .
+                implode("\n", $textsummaries);
+        }
+        $htmlsummary = '';
+        if ($htmlsummaries) {
+            $htmlsummary = html_writer::tag('h2', get_string('submissioncontains', 'assign')) .
+                implode('', $htmlsummaries);
+        }
+        return [
+            'submissionsummarytext' => $textsummary,
+            'submissionsummaryhtml' => $htmlsummary,
         ];
+    }
     /**
      * Send notifications to graders upon student submissions.
      *
-     * @param stdClass $submission
-     * @return void
+     * @param stdClass $submission
-     */
+     * @return void
-    protected function notify_graders(stdClass $submission)
+     */
             // No need to do anything.
             return;
+        }
         if ($submission->userid) {
-            $user = $DB->get_record('user', array('id' => $submission->userid), '*', MUST_EXIST);
+            $user = $DB->get_record('user', array('id'=>$submission->userid), '*', MUST_EXIST);
         } else {
             $user = $USER;
+        }
         if ($notifyusers = $this->get_notifiable_users($user->id)) {
-            foreach ($notifyusers as $notifyuser) {
-                $this->send_notification(
+            foreach ($notifyusers as $notifyuser) {
-                    $user,
+                $this->send_notification($user,
-                    $notifyuser,
+                                         $notifyuser,
-                    'gradersubmissionupdated',
+                                         'gradersubmissionupdated',
-                    'assign_notification',
-                    $submission->timemodified
+                                         'assign_notification',
-                );
+                                         $submission->timemodified);
+            }
+        }
+     *
      * @param stdClass $data - The form data
      * @param array $notices - List of error messages to display on an error condition.
      * @return bool Return false if the submission was not submitted.
      */
-    public function submit_for_grading($data, $notices)
+    public function submit_for_grading($data, $notices) {
-    {
         global $USER;
         $userid = $USER->id;
         if (!empty($data->userid)) {
         $submissionstatement = '';
         if ($instance->requiresubmissionstatement) {
             $submissionstatement = $this->get_submissionstatement($adminconfig, $instance, $this->context);
+        }
-        if (
-            !empty($submissionstatement) && $instance->requiresubmissionstatement
+        if (!empty($submissionstatement) && $instance->requiresubmissionstatement
-            && empty($data->submissionstatement) && $USER->id == $userid
-        ) {
+                && empty($data->submissionstatement) && $USER->id == $userid) {
             return false;
+        }
             $submission->status = ASSIGN_SUBMISSION_STATUS_SUBMITTED;
             $this->update_submission($submission, $userid, true, $instance->teamsubmission);
             $completion = new completion_info($this->get_course());
             if ($completion->is_enabled($this->get_course_module()) && $instance->completionsubmit) {
-                $this->update_activity_completion_records(
-                    $instance->teamsubmission,
+                $this->update_activity_completion_records($instance->teamsubmission,
-                    $instance->requireallteammemberssubmit,
+                                                          $instance->requireallteammemberssubmit,
-                    $submission,
+                                                          $submission,
-                    $userid,
+                                                          $userid,
-                    COMPLETION_COMPLETE,
+                                                          COMPLETION_COMPLETE,
-                    $completion
-                );
+                                                          $completion);
+            }
             if (!empty($data->submissionstatement) && $USER->id == $userid) {
     /**
      * A students submission is submitted for grading by a teacher.
+     *
      * @return bool
      */
-    protected function process_submit_other_for_grading($mform, $notices)
+    protected function process_submit_other_for_grading($mform, $notices) {
-    {
         global $USER, $CFG;
         require_sesskey();
+     *
      * @param moodleform|null $mform If validation failed when submitting this form - this is the moodleform.
      *               It can be null.
      * @return bool Return false if the validation fails. This affects which page is displayed next.
      */
-    protected function process_submit_for_grading($mform, $notices)
+    protected function process_submit_for_grading($mform, $notices) {
-    {
         global $CFG;
         require_once($CFG->dirroot . '/mod/assign/submissionconfirmform.php');
         if (empty($submissionstatement)) {
             $requiresubmissionstatement = false;
+        }
         if ($mform == null) {
-            $mform = new mod_assign_confirm_submission_form(null, array(
+            $mform = new mod_assign_confirm_submission_form(null, array($requiresubmissionstatement,
-                $requiresubmissionstatement,
-                $submissionstatement,
+                                                                    $submissionstatement,
-                $this->get_course_module()->id,
+                                                                    $this->get_course_module()->id,
-                $data
-            ));
+                                                                    $data));
+        }
         $data = $mform->get_data();
+     *
      * @param int $userid The user id
      * @param mixed $extensionduedate Either an integer date or null
      * @return boolean
      */
-    public function save_user_extension($userid, $extensionduedate)
+    public function save_user_extension($userid, $extensionduedate) {
-    {
-        global $DB;
+        global $DB, $CFG;
+        require_once($CFG->dirroot.'/calendar/lib.php');
         // Need submit permission to submit an assignment.
         require_capability('mod/assign:grantextension', $this->context);
         $result = $this->update_user_flags($flags);
+        if ($result) {
+            \mod_assign\event\extension_granted::create_from_assign($this, $userid)->trigger();
+            $cm = $this->get_course_module();
+            $instance = $this->get_instance();
+            if ($extensionduedate) {
+                $event = $DB->get_record('event', [
+                    'userid' => $userid,
+                    'eventtype' => ASSIGN_EVENT_TYPE_EXTENSION,
+                    'modulename' => 'assign',
+                    'instance' => $instance->id,
+                ]);
+                if ($event) {
+                    $event->timestart = $extensionduedate;
+                    $DB->update_record('event', $event);
+                } else {
+                    $event = new stdClass();
+                    $event->type          = CALENDAR_EVENT_TYPE_ACTION;
+                    $event->name          = get_string('calendarextension', 'assign', $instance->name);
+                    $event->description   = format_module_intro('assign', $instance, $cm->id);
+                    $event->format        = FORMAT_HTML;
+                    $event->courseid      = 0;
+                    $event->groupid       = 0;
+                    $event->userid        = $userid;
+                    $event->modulename    = 'assign';
+                    $event->instance      = $instance->id;
+                    $event->timestart     = $extensionduedate;
+                    $event->timeduration  = 0;
+                    $event->visible       = instance_is_visible('assign', $instance);
+                    $event->eventtype     = ASSIGN_EVENT_TYPE_EXTENSION;
+                    $event->priority      = null;
+                    calendar_event::create($event, false);
+                }
+            } else {
+                $DB->delete_records('event', [
+                  'userid' => $userid,
+                  'eventtype' => ASSIGN_EVENT_TYPE_EXTENSION,
+                  'modulename' => 'assign',
+                  'instance' => $instance->id,
-        if ($result) {
+                ]);
             \mod_assign\event\extension_granted::create_from_assign($this, $userid)->trigger();
+        }
         return $result;
+    }
     /**
      * Save extension date.
+     *
      * @param moodleform $mform The submitted form
-     * @return boolean
-     */
+     * @return boolean
-    protected function process_save_extension(&$mform)
+     */
     protected function process_save_extension(& $mform) {
         global $DB, $CFG;
     /**
      * Save quick grades.
+     *
      * @return string The result of the save operation
      */
-    protected function process_save_quick_grades()
+    protected function process_save_quick_grades() {
-    {
         global $USER, $DB, $CFG;
         // Need grade permission.
         require_capability('mod/assign:grade', $this->context);
             // Gather the userid, updated grade and last modified value.
             $record = new stdClass();
             $record->userid = $userid;
             if ($modified >= 0) {
                 $record->grade = unformat_float(optional_param('quickgrade_' . $record->userid, -1, PARAM_TEXT));
-                $record->workflowstate = optional_param('quickgrade_' . $record->userid . '_workflowstate', false, PARAM_ALPHA);
+                $record->workflowstate = optional_param('quickgrade_' . $record->userid.'_workflowstate', false, PARAM_ALPHA);
-                $record->allocatedmarker = optional_param('quickgrade_' . $record->userid . '_allocatedmarker', false, PARAM_INT);
+                $record->allocatedmarker = optional_param('quickgrade_' . $record->userid.'_allocatedmarker', false, PARAM_INT);
             } else {
                 // This user was not in the grading table.
                 continue;
+            }
             $record->attemptnumber = $attemptnumber;
             $record->lastmodified = $modified;
-            $record->gradinginfo = grade_get_grades(
+            $record->gradinginfo = grade_get_grades($this->get_course()->id,
-                $this->get_course()->id,
+                                                    'mod',
-                'mod',
-                'assign',
+                                                    'assign',
-                $this->get_instance()->id,
+                                                    $this->get_instance()->id,
-                array($userid)
+                                                    array($userid));
-            );
             $users[$userid] = $record;
+        }
         if (empty($users)) {
+                    }
+                }
+            }
             if (($current->grade < 0 || $current->grade === null) &&
-                ($modified->grade < 0 || $modified->grade === null)
-            ) {
+                ($modified->grade < 0 || $modified->grade === null)) {
                 // Different ways to indicate no grade.
                 $modified->grade = $current->grade; // Keep existing grade.
+            }
             // Treat 0 and null as different values.
             if ($current->grade !== null) {
                 $current->grade = floatval($current->grade);
+            }
             $gradechanged = $gradecolpresent && grade_floats_different($current->grade, $modified->grade);
             $markingallocationchanged = $this->get_instance()->markingworkflow &&
-                $this->get_instance()->markingallocation &&
+                                        $this->get_instance()->markingallocation &&
-                ($modified->allocatedmarker !== false) &&
+                                            ($modified->allocatedmarker !== false) &&
-                ($current->allocatedmarker != $modified->allocatedmarker);
+                                            ($current->allocatedmarker != $modified->allocatedmarker);
             $workflowstatechanged = $this->get_instance()->markingworkflow &&
-                ($modified->workflowstate !== false) &&
+                                            ($modified->workflowstate !== false) &&
-                ($current->workflowstate != $modified->workflowstate);
+                                            ($current->workflowstate != $modified->workflowstate);
             if ($gradechanged || $markingallocationchanged || $workflowstatechanged) {
                 // Grade changed.
                 if ($this->grading_disabled($modified->userid)) {
                     continue;
                     return $message;
                 } else {
                     $modifiedusers[$modified->userid] = $modified;
+                }
+            }
+        }
         $currentgrades->close();
         $adminconfig = $this->get_admin_config();
         $gradebookplugin = $adminconfig->feedback_plugin_for_gradebook;
         // Ok - ready to process the updates.
         foreach ($modifiedusers as $userid => $modified) {
             $grade = $this->get_user_grade($userid, true);
             $flags = $this->get_user_flags($userid, true);
-            $grade->grade = grade_floatval(unformat_float($modified->grade));
+            $grade->grade= grade_floatval(unformat_float($modified->grade));
-            $grade->grader = $USER->id;
+            $grade->grader= $USER->id;
             $gradecolpresent = optional_param('quickgrade_' . $userid, false, PARAM_INT) !== false;
+            }
             // These will be set to false if they are not present in the quickgrading
             // form (e.g. column hidden).
             $workflowstatemodified = ($modified->workflowstate !== false) &&
-                ($flags->workflowstate != $modified->workflowstate);
+                                        ($flags->workflowstate != $modified->workflowstate);
             $allocatedmarkermodified = ($modified->allocatedmarker !== false) &&
-                ($flags->allocatedmarker != $modified->allocatedmarker);
+                                        ($flags->allocatedmarker != $modified->allocatedmarker);
             if ($workflowstatemodified) {
                     if ($newoutcome !== false && ($oldoutcome != $newoutcome)) {
                         $data[$outcomeid] = $newoutcome;
+                    }
+                }
                 if (count($data) > 0) {
-                    grade_update_outcomes(
+                    grade_update_outcomes('mod/assign',
-                        'mod/assign',
-                        $this->course->id,
+                                          $this->course->id,
-                        'mod',
+                                          'mod',
-                        'assign',
+                                          'assign',
-                        $this->get_instance()->id,
+                                          $this->get_instance()->id,
-                        $userid,
+                                          $userid,
-                        $data
+                                          $data);
-                    );
+                }
+            }
+        }
     /**
      * Reveal student identities to markers (and the gradebook).
+     *
      * @return void
      */
-    public function reveal_identities()
+    public function reveal_identities() {
-    {
         global $DB;
         require_capability('mod/assign:revealidentities', $this->context);
         // Now release all grades.
         $adminconfig = $this->get_admin_config();
         $gradebookplugin = $adminconfig->feedback_plugin_for_gradebook;
         $gradebookplugin = str_replace('assignfeedback_', '', $gradebookplugin);
-        $grades = $DB->get_records('assign_grades', array('assignment' => $this->get_instance()->id));
+        $grades = $DB->get_records('assign_grades', array('assignment'=>$this->get_instance()->id));
         $plugin = $this->get_feedback_plugin_by_type($gradebookplugin);
     /**
      * Reveal student identities to markers (and the gradebook).
+     *
      * @return void
      */
-    protected function process_reveal_identities()
+    protected function process_reveal_identities() {
-    {
         if (!confirm_sesskey()) {
             return false;
     /**
+     * Save grading options.
+     *
-     * Save grading options.
+     * @deprecated since Moodle 4.5
      * @todo Final deprecation in Moodle 6.0. See MDL-82876.
-     * @return void
-     */
-    protected function process_save_grading_options()
-    {
-        global $USER, $CFG;
-        // Include grading options form.
-        require_once($CFG->dirroot . '/mod/assign/gradingoptionsform.php');
+     * @return void
-        // Need submit permission to submit an assignment.
-        $this->require_view_grades();
-        require_sesskey();
-        // Is advanced grading enabled?
-        $gradingmanager = get_grading_manager($this->get_context(), 'mod_assign', 'submissions');
-        $controller = $gradingmanager->get_active_controller();
-        $showquickgrading = empty($controller);
-        if (!is_null($this->context)) {
+     */
-            $showonlyactiveenrolopt = has_capability('moodle/course:viewsuspendedusers', $this->context);
-        } else {
-            $showonlyactiveenrolopt = false;
-        }
-        $markingallocation = $this->get_instance()->markingworkflow &&
-            $this->get_instance()->markingallocation &&
-            has_capability('mod/assign:manageallocations', $this->context);
-        // Get markers to use in drop lists.
-        $markingallocationoptions = array();
-        if ($markingallocation) {
-            $markingallocationoptions[''] = get_string('filternone', 'assign');
-            $markingallocationoptions[ASSIGN_MARKER_FILTER_NO_MARKER] = get_string('markerfilternomarker', 'assign');
-            list($sort, $params) = users_order_by_sql('u');
-            // Only enrolled users could be assigned as potential markers.
-            $markers = get_enrolled_users($this->context, 'mod/assign:grade', 0, 'u.*', $sort);
-            foreach ($markers as $marker) {
+    #[\core\attribute\deprecated(
-                $markingallocationoptions[$marker->id] = fullname($marker);
-            }
-        }
+        'null',
-        // Get marking states to show in form.
-        $markingworkflowoptions = $this->get_marking_workflow_filters();
-        $gradingoptionsparams = array(
-            'cm' => $this->get_course_module()->id,
-            'contextid' => $this->context->id,
-            'userid' => $USER->id,
-            'submissionsenabled' => $this->is_any_submission_plugin_enabled(),
-            'showquickgrading' => $showquickgrading,
-            'quickgrading' => false,
-            'markingworkflowopt' => $markingworkflowoptions,
-            'markingallocationopt' => $markingallocationoptions,
-            'showonlyactiveenrolopt' => $showonlyactiveenrolopt,
-            'showonlyactiveenrol' => $this->show_only_active_users(),
-            'downloadasfolders' => get_user_preferences('assign_downloadasfolders', 1)
-        );
-        $mform = new mod_assign_grading_options_form(null, $gradingoptionsparams);
-        if ($formdata = $mform->get_data()) {
-            set_user_preference('assign_perpage', $formdata->perpage);
-            if (isset($formdata->filter)) {
-                set_user_preference('assign_filter', $formdata->filter);
-            }
-            if (isset($formdata->markerfilter)) {
-                set_user_preference('assign_markerfilter', $formdata->markerfilter);
-            }
-            if (isset($formdata->workflowfilter)) {
-                set_user_preference('assign_workflowfilter', $formdata->workflowfilter);
-            }
-            if ($showquickgrading) {
-                set_user_preference('assign_quickgrading', isset($formdata->quickgrading));
-            }
-            if (isset($formdata->downloadasfolders)) {
+        since: '4.5',
-                set_user_preference('assign_downloadasfolders', 1); // Enabled.
-            } else {
-                set_user_preference('assign_downloadasfolders', 0); // Disabled.
-            }
-            if (!empty($showonlyactiveenrolopt)) {
-                $showonlyactiveenrol = isset($formdata->showonlyactiveenrol);
-                set_user_preference('grade_report_showonlyactiveenrol', $showonlyactiveenrol);
-                $this->showonlyactiveenrol = $showonlyactiveenrol;
-            }
+        reason: 'It is no longer used.',
-        }
-    }
-    /**
-     * @deprecated since 2.7
+        mdl: 'MDL-82681',
-     */
-    public function format_grade_for_log()
-    {
-        throw new coding_exception(__FUNCTION__ . ' has been deprecated, please do not use it any more');
-    }
-    /**
-     * @deprecated since 2.7
-     */
-    public function format_submission_for_log()
+    )]
     protected function process_save_grading_options() {
-        throw new coding_exception(__FUNCTION__ . ' has been deprecated, please do not use it any more');
+        \core\deprecation::emit_deprecation([self::class, __FUNCTION__]);
+    }
     /**
      * Require a valid sess key and then call copy_previous_attempt.
+     *
      * @param  array $notices Any error messages that should be shown
      *                        to the user at the top of the edit submission form.
-     * @return bool
-     */
+     * @return bool
-    protected function process_copy_previous_attempt(&$notices)
+     */
     protected function process_copy_previous_attempt(&$notices) {
+     *
      * @param  array $notices Any error messages that should be shown
      *                        to the user at the top of the edit submission form.
      * @return bool
      */
-    public function copy_previous_attempt(&$notices)
+    public function copy_previous_attempt(&$notices) {
-    {
         global $USER, $CFG;
         require_capability('mod/assign:submit', $this->context);
         if ($submission->status == ASSIGN_SUBMISSION_STATUS_SUBMITTED) {
             $complete = COMPLETION_COMPLETE;
+        }
         $completion = new completion_info($this->get_course());
         if ($completion->is_enabled($this->get_course_module()) && $instance->completionsubmit) {
-            $this->update_activity_completion_records(
+            $this->update_activity_completion_records($instance->teamsubmission,
-                $instance->teamsubmission,
-                $instance->requireallteammemberssubmit,
+                                                      $instance->requireallteammemberssubmit,
-                $submission,
+                                                      $submission,
-                $USER->id,
+                                                      $USER->id,
-                $complete,
+                                                      $complete,
-                $completion
+                                                      $completion);
-            );
+        }
         if (!$instance->submissiondrafts) {
             // There is a case for not notifying the student about the submission copy,
      * Determine if the current submission is empty or not.
+     *
      * @param submission $submission the students submission record to check.
      * @return bool
      */
-    public function submission_empty($submission)
+    public function submission_empty($submission) {
-    {
         $allempty = true;
         foreach ($this->submissionplugins as $plugin) {
             if ($plugin->is_enabled() && $plugin->is_visible()) {
      * Determine if a new submission is empty or not
+     *
      * @param stdClass $data Submission data
      * @return bool
      */
-    public function new_submission_empty($data)
+    public function new_submission_empty($data) {
-    {
         foreach ($this->submissionplugins as $plugin) {
-            if (
-                $plugin->is_enabled() && $plugin->is_visible() && $plugin->allow_submissions() &&
+            if ($plugin->is_enabled() && $plugin->is_visible() && $plugin->allow_submissions() &&
-                !$plugin->submission_is_empty($data)
+                    !$plugin->submission_is_empty($data)) {
-            ) {
                 return false;
+            }
+        }
         return true;
+    }
      * @param  stdClass $data
      * @param  array $notices Any error messages that should be shown
      *                        to the user.
      * @return bool
      */
-    public function save_submission(stdClass $data, &$notices)
+    public function save_submission(stdClass $data, & $notices) {
-    {
         global $CFG, $USER, $DB;
         $userid = $USER->id;
         if (!empty($data->userid)) {
             $userid = $data->userid;
         }
-        $user = clone ($USER);
+        $user = clone($USER);
         if ($userid == $USER->id) {
             require_capability('mod/assign:submit', $this->context);
         } else {
-            $user = $DB->get_record('user', array('id' => $userid), '*', MUST_EXIST);
+            $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
             if (!$this->can_edit_submission($userid, $USER->id)) {
                 throw new \moodle_exception('nopermission');
+            }
         // Check that no one has modified the submission since we started looking at it.
         if (isset($data->lastmodified) && ($submission->timemodified > $data->lastmodified)) {
             // Another user has submitted something. Notify the current user.
             if ($submission->status !== ASSIGN_SUBMISSION_STATUS_NEW) {
                 $notices[] = $instance->teamsubmission ? get_string('submissionmodifiedgroup', 'mod_assign')
-                    : get_string('submissionmodified', 'mod_assign');
+                                                       : get_string('submissionmodified', 'mod_assign');
                 return false;
+            }
+        }
         if ($instance->teamsubmission && !$instance->requireallteammemberssubmit) {
             $team = $this->get_submission_group_members($submission->groupid, true);
             foreach ($team as $member) {
                 if ($member->id != $userid) {
-                    $membersubmission = clone ($submission);
+                    $membersubmission = clone($submission);
                     $this->update_submission($membersubmission, $member->id, true, $instance->teamsubmission);
                     $users[] = $member->id;
+                }
+            }
      * @param  moodleform $mform
      * @param  array $notices Any error messages that should be shown
      *                        to the user at the top of the edit submission form.
      * @return bool
      */
-    protected function process_save_submission(&$mform, &$notices)
+    protected function process_save_submission(&$mform, &$notices) {
-    {
         global $CFG, $USER;
         // Include submission form.
      * @param int $userid - The student userid
      * @param bool $checkworkflow - whether to include a check for the workflow state.
      * @param stdClass $gradinginfo - optional, allow gradinginfo to be passed for performance.
      * @return bool $gradingdisabled
      */
-    public function grading_disabled($userid, $checkworkflow = true, $gradinginfo = null)
+    public function grading_disabled($userid, $checkworkflow = true, $gradinginfo = null) {
-    {
         if ($checkworkflow && $this->get_instance()->markingworkflow) {
             $grade = $this->get_user_grade($userid, false);
             $validstates = $this->get_marking_workflow_states_for_current_user();
             if (!empty($grade) && !empty($grade->workflowstate) && !array_key_exists($grade->workflowstate, $validstates)) {
                 return true;
+            }
+        }
         if (is_null($gradinginfo)) {
-            $gradinginfo = grade_get_grades(
-                $this->get_course()->id,
+            $gradinginfo = grade_get_grades($this->get_course()->id,
                 'mod',
                 'assign',
                 $this->get_instance()->id,
-                array($userid)
-            );
+                array($userid));
+        }
         if (!$gradinginfo) {
             return false;
+        }
         if (!isset($gradinginfo->items[0]->grades[$userid])) {
             return false;
+        }
         $gradingdisabled = $gradinginfo->items[0]->grades[$userid]->locked ||
-            $gradinginfo->items[0]->grades[$userid]->overridden;
+                           $gradinginfo->items[0]->grades[$userid]->overridden;
      * @param int $userid - The student userid
      * @param stdClass|false $grade - The grade record
      * @param bool $gradingdisabled
      * @return mixed gradingform_instance|null $gradinginstance
      */
-    protected function get_grading_instance($userid, $grade, $gradingdisabled)
+    protected function get_grading_instance($userid, $grade, $gradingdisabled) {
-    {
         global $CFG, $USER;
         $grademenu = make_grades_menu($this->get_instance()->grade);
+                }
                 if ($gradingdisabled && $itemid) {
                     $gradinginstance = $controller->get_current_instance($USER->id, $itemid);
                 } else if (!$gradingdisabled) {
                     $instanceid = optional_param('advancedgradinginstanceid', 0, PARAM_INT);
-                    $gradinginstance = $controller->get_or_create_instance(
+                    $gradinginstance = $controller->get_or_create_instance($instanceid,
-                        $instanceid,
-                        $USER->id,
+                                                                           $USER->id,
-                        $itemid
+                                                                           $itemid);
-                    );
+                }
             } else {
                 $advancedgradingwarning = $controller->form_unavailable_notification();
+            }
+        }
      * @param MoodleQuickForm $mform
      * @param stdClass $data
      * @param array $params
      * @return void
      */
-    public function add_grade_form_elements(MoodleQuickForm $mform, stdClass $data, $params)
+    public function add_grade_form_elements(MoodleQuickForm $mform, stdClass $data, $params) {
-    {
-        global $USER, $CFG, $SESSION;
+        global $USER, $CFG, $SESSION, $PAGE;
         $settings = $this->get_instance();
         $rownum = isset($params['rownum']) ? $params['rownum'] : 0;
         $last = isset($params['last']) ? $params['last'] : true;
         $gradingdisabled = $this->grading_disabled($userid);
         $gradinginstance = $this->get_grading_instance($userid, $grade, $gradingdisabled);
         $mform->addElement('header', 'gradeheader', get_string('gradenoun'));
         if ($gradinginstance) {
-            $gradingelement = $mform->addElement(
-                'grading',
+            $gradingelement = $mform->addElement('grading',
-                'advancedgrading',
+                                                 'advancedgrading',
-                get_string('gradenoun') . ':',
+                                                 get_string('gradenoun') . ':',
-                array('gradinginstance' => $gradinginstance)
-            );
+                                                 array('gradinginstance' => $gradinginstance));
             if ($gradingdisabled) {
                 $gradingelement->freeze();
             } else {
                 $mform->addElement('hidden', 'advancedgradinginstanceid', $gradinginstance->get_id());
+                    }
+                }
+            }
+        }
-        $gradinginfo = grade_get_grades(
+        $gradinginfo = grade_get_grades($this->get_course()->id,
-            $this->get_course()->id,
-            'mod',
+                                        'mod',
-            'assign',
+                                        'assign',
-            $this->get_instance()->id,
+                                        $this->get_instance()->id,
-            $userid
-        );
+                                        $userid);
         if (!empty($CFG->enableoutcomes)) {
             foreach ($gradinginfo->outcomes as $index => $outcome) {
                 $options = make_grades_menu(-$outcome->scaleid);
                 $options[0] = get_string('nooutcome', 'grades');
                 if ($outcome->grades[$userid]->locked) {
-                    $mform->addElement(
-                        'static',
+                    $mform->addElement('static',
-                        'outcome_' . $index . '[' . $userid . ']',
+                                       'outcome_' . $index . '[' . $userid . ']',
-                        $outcome->name . ':',
+                                       $outcome->name . ':',
-                        $options[$outcome->grades[$userid]->grade]
-                    );
+                                       $options[$outcome->grades[$userid]->grade]);
                 } else {
-                    $attributes = array('id' => 'menuoutcome_' . $index);
+                    $attributes = array('id' => 'menuoutcome_' . $index );
-                    $mform->addElement(
-                        'select',
+                    $mform->addElement('select',
-                        'outcome_' . $index . '[' . $userid . ']',
+                                       'outcome_' . $index . '[' . $userid . ']',
-                        $outcome->name . ':',
+                                       $outcome->name.':',
-                        $options,
+                                       $options,
-                        $attributes
-                    );
+                                       $attributes);
-                    $mform->setType('outcome_' . $index . '[' . $userid . ']', PARAM_INT);
-                    $mform->setDefault(
+                    $mform->setType('outcome_' . $index . '[' . $userid . ']', PARAM_INT);
-                        'outcome_' . $index . '[' . $userid . ']',
+                    $mform->setDefault('outcome_' . $index . '[' . $userid . ']',
-                        $outcome->grades[$userid]->grade
-                    );
+                                       $outcome->grades[$userid]->grade);
+                }
+            }
+        }
         $capabilitylist = array('gradereport/grader:view', 'moodle/grade:viewall');
         $usergrade = get_string('notgraded', 'assign');
         if (has_all_capabilities($capabilitylist, $this->get_course_context())) {
-            $urlparams = array('id' => $this->get_course()->id);
+            $urlparams = array('id'=>$this->get_course()->id);
             $url = new moodle_url('/grade/report/grader/index.php', $urlparams);
             if (isset($gradinginfo->items[0]->grades[$userid]->grade)) {
                 $usergrade = $gradinginfo->items[0]->grades[$userid]->str_grade;
+            }
-            $gradestring = $this->get_renderer()->action_link($url, $usergrade);
-        } else {
+            $gradestring = $this->get_renderer()->action_link($url, $usergrade);
-            if (
+        } else {
-                isset($gradinginfo->items[0]->grades[$userid]) &&
-                !$gradinginfo->items[0]->grades[$userid]->hidden
+            if (isset($gradinginfo->items[0]->grades[$userid]) &&
-            ) {
+                    !$gradinginfo->items[0]->grades[$userid]->hidden) {
                 $usergrade = $gradinginfo->items[0]->grades[$userid]->str_grade;
+            }
+            $gradestring = $usergrade;
+        }
+        // Penalty indicator.
+        $userassigngrade = $gradinginfo->items[0]->grades[$userid];
+        if (isset($userassigngrade->grade)) {
+            $gradegrade = new \grade_grade();
+            $gradegrade->deductedmark = $userassigngrade->deductedmark;
+            $gradegrade->overridden = $userassigngrade->overridden;
+            $penaltyindicator = \core_grades\penalty_manager::show_penalty_indicator($gradegrade);
-            $gradestring = $usergrade;
+            $gradestring = $penaltyindicator . $gradestring;
+        }
         if ($this->get_instance()->markingworkflow) {
             $states = $this->get_marking_workflow_states_for_current_user();
                     $mform->addElement('static', 'currentassigngrade', $label, $assigngradestring);
+                }
+            }
+        }
-        if (
-            $this->get_instance()->markingworkflow &&
+        if ($this->get_instance()->markingworkflow &&
             $this->get_instance()->markingallocation &&
-            has_capability('mod/assign:manageallocations', $this->context)
-        ) {
+            has_capability('mod/assign:manageallocations', $this->context)) {
             list($sort, $params) = users_order_by_sql('u');
             // Only enrolled users could be assigned as potential markers.
         $gradestring = '<span class="currentgrade">' . $gradestring . '</span>';
         $mform->addElement('static', 'currentgrade', get_string('currentgrade', 'assign'), $gradestring);
         if (count($useridlist) > 1) {
-            $strparams = array('current' => $rownum + 1, 'total' => count($useridlist));
+            $strparams = array('current'=>$rownum+1, 'total'=>count($useridlist));
             $name = get_string('outof', 'assign', $strparams);
             $mform->addElement('static', 'gradingstudent', get_string('gradingstudent', 'assign'), $name);
             $mform->addElement('selectyesno', 'applytoall', get_string('applytoteam', 'assign'));
             $mform->setDefault('applytoall', 1);
+        }
-        // Do not show if we are editing a previous attempt.
-        if (($attemptnumber == -1 ||
+        // Do not show if we are editing a previous attempt.
-                ($attemptnumber + 1) == count($this->get_all_submissions($userid))) &&
+        if (($attemptnumber == -1 || ($attemptnumber + 1) == count($this->get_all_submissions($userid))) &&
-            $this->get_instance()->attemptreopenmethod != ASSIGN_ATTEMPT_REOPEN_METHOD_NONE
-        ) {
+                ($this->get_instance()->maxattempts > 1 || $this->get_instance()->maxattempts == ASSIGN_UNLIMITED_ATTEMPTS)) {
             $mform->addElement('header', 'attemptsettings', get_string('attemptsettings', 'assign'));
             $attemptreopenmethod = get_string('attemptreopenmethod_' . $this->get_instance()->attemptreopenmethod, 'assign');
             $mform->addElement('static', 'attemptreopenmethod', get_string('attemptreopenmethod', 'assign'), $attemptreopenmethod);
             $mform->addelement('static', 'attemptnumberlabel', get_string('attemptnumber', 'assign'), $attemptnumber + 1);
             $ismanual = $this->get_instance()->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_MANUAL;
             $issubmission = !empty($submission);
             $isunlimited = $this->get_instance()->maxattempts == ASSIGN_UNLIMITED_ATTEMPTS;
-            $islessthanmaxattempts = $issubmission && ($submission->attemptnumber < ($this->get_instance()->maxattempts - 1));
+            $islessthanmaxattempts = $issubmission && ($submission->attemptnumber < ($this->get_instance()->maxattempts-1));
             if ($ismanual && (!$issubmission || $isunlimited || $islessthanmaxattempts)) {
                 $mform->addElement('selectyesno', 'addattempt', get_string('addattempt', 'assign'));
      * @param MoodleQuickForm $mform
      * @param stdClass $data
      * @param int $userid The current userid (same as $USER->id)
      * @return void
      */
-    protected function add_plugin_submission_elements(
+    protected function add_plugin_submission_elements($submission,
-        $submission,
-        MoodleQuickForm $mform,
+                                                    MoodleQuickForm $mform,
-        stdClass $data,
+                                                    stdClass $data,
-        $userid
+                                                    $userid) {
-    ) {
         foreach ($this->submissionplugins as $plugin) {
             if ($plugin->is_enabled() && $plugin->is_visible() && $plugin->allow_submissions()) {
                 $plugin->get_form_elements_for_user($submission, $mform, $data, $userid);
+            }
+        }
     /**
      * Check if feedback plugins installed are enabled.
+     *
      * @return bool
      */
-    public function is_any_feedback_plugin_enabled()
+    public function is_any_feedback_plugin_enabled() {
-    {
         if (!isset($this->cache['any_feedback_plugin_enabled'])) {
             $this->cache['any_feedback_plugin_enabled'] = false;
             foreach ($this->feedbackplugins as $plugin) {
                 if ($plugin->is_enabled() && $plugin->is_visible()) {
                     $this->cache['any_feedback_plugin_enabled'] = true;
+                }
+            }
+        }
+        return $this->cache['any_feedback_plugin_enabled'];
         return $this->cache['any_feedback_plugin_enabled'];
+    }
     /**
      * Check if submission plugins installed are enabled.
+     *
      * @return bool
-     */
-    public function is_any_submission_plugin_enabled()
+     */
     public function is_any_submission_plugin_enabled() {
         if (!isset($this->cache['any_submission_plugin_enabled'])) {
             $this->cache['any_submission_plugin_enabled'] = false;
             foreach ($this->submissionplugins as $plugin) {
+                }
+            }
+        }
+        return $this->cache['any_submission_plugin_enabled'];
         return $this->cache['any_submission_plugin_enabled'];
+    }
     /**
      * Add elements to submission form.
      * @param MoodleQuickForm $mform
      * @param stdClass $data
      * @return void
-     */
-    public function add_submission_form_elements(MoodleQuickForm $mform, stdClass $data)
+     */
     public function add_submission_form_elements(MoodleQuickForm $mform, stdClass $data) {
         global $USER;
         $mform->addElement('header', 'submission header', get_string('addsubmission', 'mod_assign'));
         // Only show submission statement if we are editing our own submission.
         if ($requiresubmissionstatement && !$draftsenabled && $userid == $USER->id) {
-            $mform->addElement('checkbox', 'submissionstatement', '', $submissionstatement);
-            $mform->addRule(
-                'submissionstatement',
+            $mform->addElement('checkbox', 'submissionstatement', '', $submissionstatement);
-                get_string('submissionstatementrequired', 'mod_assign'),
+            $mform->addRule('submissionstatement', get_string('submissionstatementrequired', 'mod_assign'),
-                'required',
-                null,
-                'client'
-            );
+                'required', null, 'client');
+        }
+     *
      * @param int $userid
      * @return boolean
      * @throws coding_exception
      */
-    public function remove_submission($userid)
+    public function remove_submission($userid) {
-    {
         global $USER;
         if (!$this->can_edit_submission($userid, $USER->id)) {
             $user = core_user::get_user($userid);
                 $plugin->remove($submission);
+            }
+        }
-        $completion = new completion_info($this->get_course());
-        if (
+        $completion = new completion_info($this->get_course());
-            $completion->is_enabled($this->get_course_module()) &&
+        if ($completion->is_enabled($this->get_course_module()) &&
-            $this->get_instance()->completionsubmit
-        ) {
+                $this->get_instance()->completionsubmit) {
             $completion->update_state($this->get_course_module(), COMPLETION_INCOMPLETE, $userid);
+        }
      * Revert to draft.
+     *
      * @param int $userid
      * @return boolean
      */
-    public function revert_to_draft($userid)
+    public function revert_to_draft($userid) {
-    {
         global $DB, $USER;
         // Need grade permission.
         $grade = $this->get_user_grade($userid, true);
         $grade->grader = $USER->id;
         $this->update_grade($grade);
-        $completion = new completion_info($this->get_course());
-        if (
+        $completion = new completion_info($this->get_course());
-            $completion->is_enabled($this->get_course_module()) &&
+        if ($completion->is_enabled($this->get_course_module()) &&
-            $this->get_instance()->completionsubmit
-        ) {
+                $this->get_instance()->completionsubmit) {
             $completion->update_state($this->get_course_module(), COMPLETION_INCOMPLETE, $userid);
+        }
         \mod_assign\event\submission_status_updated::create_from_submission($this, $submission)->trigger();
         return true;
      * Remove the current submission.
+     *
      * @param int $userid
      * @return boolean
      */
-    protected function process_remove_submission($userid = 0)
+    protected function process_remove_submission($userid = 0) {
-    {
         require_sesskey();
         if (!$userid) {
             $userid = required_param('userid', PARAM_INT);
      * Uses url parameter userid if userid not supplied as a parameter.
+     *
      * @param int $userid
      * @return boolean
      */
-    protected function process_revert_to_draft($userid = 0)
+    protected function process_revert_to_draft($userid = 0) {
-    {
         require_sesskey();
         if (!$userid) {
             $userid = required_param('userid', PARAM_INT);
      * Prevent student updates to this submission
+     *
      * @param int $userid
      * @return bool
      */
-    public function lock_submission($userid)
+    public function lock_submission($userid) {
-    {
         global $USER, $DB;
         // Need grade permission.
         require_capability('mod/assign:grade', $this->context);
     /**
      * Set the workflow state for multiple users
+     *
      * @return void
      */
-    protected function process_set_batch_marking_workflow_state()
+    protected function process_set_batch_marking_workflow_state() {
-    {
         global $CFG, $DB;
         // Include batch marking workflow form.
                 // Clear the mailed flag if notification is requested, the student hasn't been
                 // notified previously, the student can access the assignment, and the state
                 // is "Released".
                 $modinfo = get_fast_modinfo($this->course, $userid);
                 $cm = $modinfo->get_cm($this->get_course_module()->id);
-                if (
-                    $formdata->sendstudentnotifications && $cm->uservisible &&
+                if ($formdata->sendstudentnotifications && $cm->uservisible &&
-                    $state == ASSIGN_MARKING_WORKFLOW_STATE_RELEASED
+                        $state == ASSIGN_MARKING_WORKFLOW_STATE_RELEASED) {
-                ) {
                     $flags->mailed = 0;
+                }
                         $grade->feedbacktext = $plugin->text_for_gradebook($grade);
                         $grade->feedbackformat = $plugin->format_for_gradebook($grade);
                         $grade->feedbackfiles = $plugin->files_for_gradebook($grade);
+                    }
                     $this->update_grade($grade);
-                    $assign = clone $this->get_instance();
-                    $assign->cmidnumber = $this->get_course_module()->idnumber;
-                    // Set assign gradebook feedback plugin status.
-                    $assign->gradefeedbackenabled = $this->is_gradebook_feedback_enabled();
-                    // If markinganonymous is enabled then allow to release grades anonymously.
-                    if (isset($assign->markinganonymous) && $assign->markinganonymous == 1) {
-                        assign_update_grades($assign, $userid);
-                    }
                     $user = $DB->get_record('user', array('id' => $userid), '*', MUST_EXIST);
                     \mod_assign\event\workflow_state_updated::create_from_user($this, $user, $state)->trigger();
+                }
+            }
+        }
     /**
      * Set the marking allocation for multiple users
+     *
      * @return void
      */
-    protected function process_set_batch_marking_allocation()
+    protected function process_set_batch_marking_allocation() {
-    {
         global $CFG, $DB;
         // Include batch marking allocation form.
             $useridlist = explode(',', $formdata->selectedusers);
             $marker = $DB->get_record('user', array('id' => $formdata->allocatedmarker), '*', MUST_EXIST);
             foreach ($useridlist as $userid) {
-                $flags = $this->get_user_flags($userid, true);
-                if (
+                $flags = $this->get_user_flags($userid, true);
-                    $flags->workflowstate == ASSIGN_MARKING_WORKFLOW_STATE_READYFORREVIEW ||
+                if ($flags->workflowstate == ASSIGN_MARKING_WORKFLOW_STATE_READYFORREVIEW ||
                     $flags->workflowstate == ASSIGN_MARKING_WORKFLOW_STATE_INREVIEW ||
                     $flags->workflowstate == ASSIGN_MARKING_WORKFLOW_STATE_READYFORRELEASE ||
-                    $flags->workflowstate == ASSIGN_MARKING_WORKFLOW_STATE_RELEASED
-                ) {
+                    $flags->workflowstate == ASSIGN_MARKING_WORKFLOW_STATE_RELEASED) {
                     continue; // Allocated marker can only be changed in certain workflow states.
      * Uses url parameter userid.
+     *
      * @param int $userid
      * @return void
      */
-    protected function process_lock_submission($userid = 0)
+    protected function process_lock_submission($userid = 0) {
-    {
         require_sesskey();
      * Unlock the student submission.
+     *
      * @param int $userid
      * @return bool
      */
-    public function unlock_submission($userid)
+    public function unlock_submission($userid) {
-    {
         global $USER, $DB;
         // Need grade permission.
      * Uses url parameter userid.
+     *
      * @param int $userid
      * @return bool
      */
-    protected function process_unlock_submission($userid = 0)
+    protected function process_unlock_submission($userid = 0) {
-    {
         require_sesskey();
      * @param stdClass $formdata - the data from the form
      * @param int $userid - the user to apply the grade to
      * @param int $attemptnumber - The attempt number to apply the grade to.
      * @return void
      */
-    protected function apply_grade_to_user($formdata, $userid, $attemptnumber)
+    protected function apply_grade_to_user($formdata, $userid, $attemptnumber) {
-    {
         global $USER, $CFG, $DB;
         $grade = $this->get_user_grade($userid, true, $attemptnumber);
         $originalgrade = $grade->grade;
         $gradingdisabled = $this->grading_disabled($userid);
         $gradinginstance = $this->get_grading_instance($userid, $grade, $gradingdisabled);
         if (!$gradingdisabled) {
             if ($gradinginstance) {
-                $grade->grade = $gradinginstance->submit_and_get_grade(
+                $grade->grade = $gradinginstance->submit_and_get_grade($formdata->advancedgrading,
-                    $formdata->advancedgrading,
-                    $grade->id
-                );
+                                                                       $grade->id);
             } else {
                 // Handle the case when grade is set to No Grade.
                 if (isset($formdata->grade)) {
                     $grade->grade = grade_floatval(unformat_float($formdata->grade));
             if (isset($formdata->workflowstate) || isset($formdata->allocatedmarker)) {
                 $flags = $this->get_user_flags($userid, true);
                 $oldworkflowstate = $flags->workflowstate;
                 $flags->workflowstate = isset($formdata->workflowstate) ? $formdata->workflowstate : $flags->workflowstate;
                 $flags->allocatedmarker = isset($formdata->allocatedmarker) ? $formdata->allocatedmarker : $flags->allocatedmarker;
-                if (
-                    $this->update_user_flags($flags) &&
+                if ($this->update_user_flags($flags) &&
-                    isset($formdata->workflowstate) &&
+                        isset($formdata->workflowstate) &&
-                    $formdata->workflowstate !== $oldworkflowstate
+                        $formdata->workflowstate !== $oldworkflowstate) {
-                ) {
                     $user = $DB->get_record('user', array('id' => $userid), '*', MUST_EXIST);
                     \mod_assign\event\workflow_state_updated::create_from_user($this, $user, $formdata->workflowstate)->trigger();
+                }
+            }
+        }
-        $grade->grader = $USER->id;
+        $grade->grader= $USER->id;
         $adminconfig = $this->get_admin_config();
         $gradebookplugin = $adminconfig->feedback_plugin_for_gradebook;
+                }
+            }
+        }
-        // We do not want to update the timemodified if no grade was added.
-        if (
+        // We do not want to update the timemodified if no grade was added.
-            !empty($formdata->addattempt) ||
+        if (!empty($formdata->addattempt) ||
-            ($originalgrade !== null && $originalgrade != -1) ||
+                ($originalgrade !== null && $originalgrade != -1) ||
-            ($grade->grade !== null && $grade->grade != -1) ||
+                ($grade->grade !== null && $grade->grade != -1) ||
-            $feedbackmodified
-        ) {
+                $feedbackmodified) {
             $this->update_grade($grade, !empty($formdata->addattempt));
+        }
-        // We never send notifications if we have marking workflow and the grade is not released.
-        if (
+        // We never send notifications if we have marking workflow and the grade is not released.
-            $this->get_instance()->markingworkflow &&
+        if ($this->get_instance()->markingworkflow &&
-            isset($formdata->workflowstate) &&
-            $formdata->workflowstate != ASSIGN_MARKING_WORKFLOW_STATE_RELEASED
+                isset($formdata->workflowstate) &&
-        ) {
+                $formdata->workflowstate != ASSIGN_MARKING_WORKFLOW_STATE_RELEASED) {
             $formdata->sendstudentnotifications = false;
+        }
      * @param int $userid
      * @param stdClass $formdata
      * @param int $sourceuserid The user ID under which the outcome data is accessible. This is relevant
      *                          for an outcome set to a user but applied to an entire group.
      */
-    protected function process_outcomes($userid, $formdata, $sourceuserid = null)
+    protected function process_outcomes($userid, $formdata, $sourceuserid = null) {
-    {
         global $CFG, $USER;
         if (empty($CFG->enableoutcomes)) {
             return;
+        }
         if ($this->grading_disabled($userid)) {
             return;
         }
-        require_once($CFG->libdir . '/gradelib.php');
+        require_once($CFG->libdir.'/gradelib.php');
-        $data = array();
-        $gradinginfo = grade_get_grades(
+        $data = array();
-            $this->get_course()->id,
+        $gradinginfo = grade_get_grades($this->get_course()->id,
-            'mod',
+                                        'mod',
-            'assign',
-            $this->get_instance()->id,
+                                        'assign',
-            $userid
+                                        $this->get_instance()->id,
-        );
+                                        $userid);
-        if (!empty($gradinginfo->outcomes)) {
-            foreach ($gradinginfo->outcomes as $index => $oldoutcome) {
+        if (!empty($gradinginfo->outcomes)) {
-                $name = 'outcome_' . $index;
+            foreach ($gradinginfo->outcomes as $index => $oldoutcome) {
-                $sourceuserid = $sourceuserid !== null ? $sourceuserid : $userid;
-                if (
+                $name = 'outcome_'.$index;
-                    isset($formdata->{$name}[$sourceuserid]) &&
+                $sourceuserid = $sourceuserid !== null ? $sourceuserid : $userid;
-                    $oldoutcome->grades[$userid]->grade != $formdata->{$name}[$sourceuserid]
+                if (isset($formdata->{$name}[$sourceuserid]) &&
-                ) {
+                        $oldoutcome->grades[$userid]->grade != $formdata->{$name}[$sourceuserid]) {
                     $data[$index] = $formdata->{$name}[$sourceuserid];
                 }
-            }
-        }
+            }
-        if (count($data) > 0) {
+        }
-            grade_update_outcomes(
+        if (count($data) > 0) {
-                'mod/assign',
+            grade_update_outcomes('mod/assign',
-                $this->course->id,
+                                  $this->course->id,
-                'mod',
+                                  'mod',
-                'assign',
-                $this->get_instance()->id,
+                                  'assign',
-                $userid,
+                                  $this->get_instance()->id,
-                $data
+                                  $userid,
-            );
+                                  $data);
      * @param int $userid The userid.
      * @param stdClass $submission The submission (may be a group submission).
      * @param bool $addattempt - True if the "allow another attempt" checkbox was checked.
      * @return bool - true if another attempt was added.
      */
-    protected function reopen_submission_if_required($userid, $submission, $addattempt)
+    protected function reopen_submission_if_required($userid, $submission, $addattempt) {
-    {
         $instance = $this->get_instance();
         $maxattemptsreached = !empty($submission) &&
-            $submission->attemptnumber >= ($instance->maxattempts - 1) &&
+                              $submission->attemptnumber >= ($instance->maxattempts - 1) &&
-            $instance->maxattempts != ASSIGN_UNLIMITED_ATTEMPTS;
+                              $instance->maxattempts != ASSIGN_UNLIMITED_ATTEMPTS;
         $shouldreopen = false;
+        switch ($instance->attemptreopenmethod) {
+            case ASSIGN_ATTEMPT_REOPEN_METHOD_AUTOMATIC:
+                $shouldreopen = true;
+                break;
-        if ($instance->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_UNTILPASS) {
+            case ASSIGN_ATTEMPT_REOPEN_METHOD_UNTILPASS:
-            // Check the gradetopass from the gradebook.
+                // Check the gradetopass from the gradebook.
-            $gradeitem = $this->get_grade_item();
+                $gradeitem = $this->get_grade_item();
-            if ($gradeitem) {
+                if ($gradeitem) {
-                $gradegrade = grade_grade::fetch(array('userid' => $userid, 'itemid' => $gradeitem->id));
+                    $gradegrade = grade_grade::fetch(['userid' => $userid, 'itemid' => $gradeitem->id]);
-                // Do not reopen if is_passed returns null, e.g. if there is no pass criterion set.
+                    // Do not reopen if is_passed returns null, e.g. if there is no pass criterion set.
-                if ($gradegrade && ($gradegrade->is_passed() === false)) {
+                    if ($gradegrade && ($gradegrade->is_passed() === false)) {
+                        $shouldreopen = true;
+                    }
+                }
+                break;
+            case ASSIGN_ATTEMPT_REOPEN_METHOD_MANUAL:
+                if (!empty($addattempt)) {
                     $shouldreopen = true;
+                }
-            }
+                break;
-        }
-        if (
-            $instance->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_MANUAL &&
-            !empty($addattempt)
-        ) {
-            $shouldreopen = true;
+        }
         if ($shouldreopen && !$maxattemptsreached) {
             $this->add_attempt($userid);
             return true;
+        }
+     *
      * @param int $userid
      * @param  stdClass $data
      * @return bool - was the grade saved
      */
-    public function save_grade($userid, $data)
+    public function save_grade($userid, $data) {
-    {
         // Need grade permission.
         require_capability('mod/assign:grade', $this->context);
      * Save grade.
+     *
      * @param  moodleform $mform
      * @return bool - was the grade saved
      */
-    protected function process_save_grade(&$mform)
+    protected function process_save_grade(&$mform) {
-    {
         global $CFG, $SESSION;
         // Include grade form.
         require_once($CFG->dirroot . '/mod/assign/gradeform.php');
             $last = true;
+        }
         $data = new stdClass();
-        $gradeformparams = array(
-            'rownum' => $rownum,
+        $gradeformparams = array('rownum' => $rownum,
-            'useridlistid' => $useridlistid,
+                                 'useridlistid' => $useridlistid,
-            'last' => $last,
+                                 'last' => $last,
-            'attemptnumber' => $attemptnumber,
-            'userid' => $userid
+                                 'attemptnumber' => $attemptnumber,
-        );
-        $mform = new mod_assign_grade_form(
+                                 'userid' => $userid);
-            null,
+        $mform = new mod_assign_grade_form(null,
-            array($this, $data, $gradeformparams),
+                                           array($this, $data, $gradeformparams),
-            'post',
+                                           'post',
-            '',
-            array('class' => 'gradeform')
+                                           '',
-        );
+                                           array('class'=>'gradeform'));
         if ($formdata = $mform->get_data()) {
+     *
      * @param string $type The plugin type
      * @param int $version The plugin version
      * @return bool
      */
-    public static function can_upgrade_assignment($type, $version)
+    public static function can_upgrade_assignment($type, $version) {
-    {
         $assignment = new assign(null, null, null);
         return $assignment->can_upgrade($type, $version);
+    }
+     *
      * @param string $type The plugin type
      * @param int $version The plugin version
      * @return bool
      */
-    public function can_upgrade($type, $version)
+    public function can_upgrade($type, $version) {
-    {
         if ($type == 'offline' && $version >= 2011112900) {
             return true;
+        }
         foreach ($this->submissionplugins as $plugin) {
             if ($plugin->can_upgrade($type, $version)) {
      * @param int $newcomponent The new assignment component ('assignment')
      * @param int $newfilearea The new assignment filearea ('submissions')
      * @param int $newitemid The new submissionid (can be null e.g. intro)
      * @return int The number of files copied
      */
-    public function copy_area_files_for_upgrade(
+    public function copy_area_files_for_upgrade($oldcontextid,
-        $oldcontextid,
-        $oldcomponent,
+                                                $oldcomponent,
-        $oldfilearea,
+                                                $oldfilearea,
-        $olditemid,
+                                                $olditemid,
-        $newcontextid,
+                                                $newcontextid,
-        $newcomponent,
+                                                $newcomponent,
-        $newfilearea,
+                                                $newfilearea,
-        $newitemid
+                                                $newitemid) {
-    ) {
         // Note, this code is based on some code in filestorage - but that code
         // deleted the old files (which we don't want).
         $count = 0;
         $fs = get_file_storage();
-        $oldfiles = $fs->get_area_files(
-            $oldcontextid,
+        $oldfiles = $fs->get_area_files($oldcontextid,
-            $oldcomponent,
+                                        $oldcomponent,
-            $oldfilearea,
+                                        $oldfilearea,
-            $olditemid,
+                                        $olditemid,
-            'id',
-            false
+                                        'id',
-        );
+                                        false);
         foreach ($oldfiles as $oldfile) {
             $filerecord = new stdClass();
             $filerecord->contextid = $newcontextid;
      * at most 1 time.
+     *
      * @param array $useridlist Array of userids to reopen.
      * @return bool
      */
-    protected function process_add_attempt_group($useridlist)
+    protected function process_add_attempt_group($useridlist) {
-    {
         $groupsprocessed = array();
         $result = true;
         foreach ($useridlist as $userid) {
      * Check for a sess key and then call add_attempt.
+     *
      * @param int $userid int The user to add the attempt for
      * @return bool - true if successful.
      */
-    protected function process_add_attempt($userid)
+    protected function process_add_attempt($userid) {
-    {
         require_sesskey();
         return $this->add_attempt($userid);
      * Add a new attempt for a user.
+     *
      * @param int $userid int The user to add the attempt for
      * @return bool - true if successful.
      */
-    protected function add_attempt($userid)
+    protected function add_attempt($userid) {
-    {
         require_capability('mod/assign:grade', $this->context);
+        // If additional attempts are disallowed.
-        if ($this->get_instance()->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_NONE) {
+        if ($this->get_instance()->maxattempts == 1) {
             return false;
+        }
         if (!$oldsubmission) {
             return false;
+        }
-        // No more than max attempts allowed.
-        if (
+        // No more than max attempts allowed.
-            $this->get_instance()->maxattempts != ASSIGN_UNLIMITED_ATTEMPTS &&
+        if ($this->get_instance()->maxattempts != ASSIGN_UNLIMITED_ATTEMPTS &&
-            $oldsubmission->attemptnumber >= ($this->get_instance()->maxattempts - 1)
-        ) {
+            $oldsubmission->attemptnumber >= ($this->get_instance()->maxattempts - 1)) {
             return false;
+        }
      *                                                   feedbackformat,
      *                                                   usermodified,
      *                                                   dategraded,
      *                                                   datesubmitted
      */
-    public function get_user_grades_for_gradebook($userid)
+    public function get_user_grades_for_gradebook($userid) {
-    {
         global $DB, $CFG;
         $grades = array();
         $assignmentid = $this->get_instance()->id;
         } else {
             $where = ' WHERE u.id != :userid ';
+        }
-        // When the gradebook asks us for grades - only return the last attempt for each user.
-        $params = array(
+        // When the gradebook asks us for grades - only return the last attempt for each user.
-            'assignid1' => $assignmentid,
+        $params = array('assignid1'=>$assignmentid,
-            'assignid2' => $assignmentid,
+                        'assignid2'=>$assignmentid,
-            'userid' => $userid
-        );
+                        'userid'=>$userid);
         $graderesults = $DB->get_recordset_sql('SELECT
                                                     u.id as userid,
                                                     s.timemodified as datesubmitted,
                                                     g.grade as rawgrade,
                                                     ON u.id = s.userid and s.assignment = :assignid1 AND
                                                     s.latest = 1
                                                 JOIN {assign_grades} g
                                                     ON u.id = g.userid and g.assignment = :assignid2 AND
                                                     g.attemptnumber = s.attemptnumber' .
-            $where, $params);
+                                                $where, $params);
         foreach ($graderesults as $result) {
             $gradingstatus = $this->get_grading_status($result->userid);
             if (!$this->get_instance()->markingworkflow || $gradingstatus == ASSIGN_MARKING_WORKFLOW_STATE_RELEASED) {
      * Call the static version of this function
+     *
      * @param int $userid The userid to lookup
      * @return int The unique id
      */
-    public function get_uniqueid_for_user($userid)
+    public function get_uniqueid_for_user($userid) {
-    {
         return self::get_uniqueid_for_user_static($this->get_instance()->id, $userid);
+    }
     /**
      * Foreach participant in the course - assign them a random id.
+     *
      * @param int $assignid The assignid to lookup
      */
-    public static function allocate_unique_ids($assignid)
     public static function allocate_unique_ids($assignid) {
         global $DB;
         // Shuffle the users.
         shuffle($users);
-        foreach ($users as $user) {
-            $record = $DB->get_record(
+        foreach ($users as $user) {
-                'assign_user_mapping',
+            $record = $DB->get_record('assign_user_mapping',
-                array('assignment' => $assignid, 'userid' => $user->id),
-                'id'
+                                      array('assignment'=>$assignid, 'userid'=>$user->id),
-            );
+                                     'id');
             if (!$record) {
                 $record = new stdClass();
                 $record->assignment = $assignid;
+     *
      * @param int $assignid The assignment id
      * @param int $userid The userid to lookup
      * @return int The unique id
      */
-    public static function get_uniqueid_for_user_static($assignid, $userid)
+    public static function get_uniqueid_for_user_static($assignid, $userid) {
-    {
         global $DB;
         // Search for a record.
-        $params = array('assignment' => $assignid, 'userid' => $userid);
+        $params = array('assignment'=>$assignid, 'userid'=>$userid);
         if ($record = $DB->get_record('assign_user_mapping', $params, 'id')) {
             return $record->id;
+        }
      * Call the static version of this function.
+     *
      * @param int $uniqueid The uniqueid to lookup
      * @return int The user id or false if they don't exist
      */
-    public function get_user_id_for_uniqueid($uniqueid)
+    public function get_user_id_for_uniqueid($uniqueid) {
-    {
         return self::get_user_id_for_uniqueid_static($this->get_instance()->id, $uniqueid);
+    }
     /**
      * Lookup this unique id and return the user id for this assignment.
+     *
      * @param int $assignid The id of the assignment this user mapping is in
      * @param int $uniqueid The uniqueid to lookup
      * @return int The user id or false if they don't exist
      */
-    public static function get_user_id_for_uniqueid_static($assignid, $uniqueid)
     public static function get_user_id_for_uniqueid_static($assignid, $uniqueid) {
         global $DB;
-        // Search for a record.
-        if ($record = $DB->get_record(
+        // Search for a record.
-            'assign_user_mapping',
+        if ($record = $DB->get_record('assign_user_mapping',
-            array('assignment' => $assignid, 'id' => $uniqueid),
+                                      array('assignment'=>$assignid, 'id'=>$uniqueid),
-            'userid',
-            IGNORE_MISSING
+                                      'userid',
-        )) {
+                                      IGNORE_MISSING)) {
             return $record->userid;
+        }
     /**
      * Get the list of marking_workflow states the current user has permission to transition a grade to.
+     *
      * @return array of state => description
      */
-    public function get_marking_workflow_states_for_current_user()
+    public function get_marking_workflow_states_for_current_user() {
-    {
         if (!empty($this->markingworkflowstates)) {
             return $this->markingworkflowstates;
+        }
         $states = array();
         if (has_capability('mod/assign:grade', $this->context)) {
             $states[ASSIGN_MARKING_WORKFLOW_STATE_INMARKING] = get_string('markingworkflowstateinmarking', 'assign');
             $states[ASSIGN_MARKING_WORKFLOW_STATE_READYFORREVIEW] = get_string('markingworkflowstatereadyforreview', 'assign');
+        }
-        if (has_any_capability(array(
+        if (has_any_capability(array('mod/assign:reviewgrades',
-            'mod/assign:reviewgrades',
-            'mod/assign:managegrades'
+                                     'mod/assign:managegrades'), $this->context)) {
-        ), $this->context)) {
             $states[ASSIGN_MARKING_WORKFLOW_STATE_INREVIEW] = get_string('markingworkflowstateinreview', 'assign');
             $states[ASSIGN_MARKING_WORKFLOW_STATE_READYFORRELEASE] = get_string('markingworkflowstatereadyforrelease', 'assign');
+        }
-        if (has_any_capability(array(
+        if (has_any_capability(array('mod/assign:releasegrades',
-            'mod/assign:releasegrades',
-            'mod/assign:managegrades'
+                                     'mod/assign:managegrades'), $this->context)) {
-        ), $this->context)) {
             $states[ASSIGN_MARKING_WORKFLOW_STATE_RELEASED] = get_string('markingworkflowstatereleased', 'assign');
+        }
         $this->markingworkflowstates = $states;
         return $this->markingworkflowstates;
+    }
     /**
      * Get the list of marking_workflow states.
+     *
      * @return array Array of multiple state => description.
      */
-    public function get_all_marking_workflow_states(): array
+    public function get_all_marking_workflow_states(): array {
-    {
         if (!empty($this->allmarkingworkflowstates)) {
             return $this->allmarkingworkflowstates;
+        }
     /**
      * Check is only active users in course should be shown.
+     *
      * @return bool true if only active users should be shown.
      */
-    public function show_only_active_users()
+    public function show_only_active_users() {
-    {
         global $CFG;
         if (is_null($this->showonlyactiveenrol)) {
             $defaultgradeshowactiveenrol = !empty($CFG->grade_report_showonlyactiveenrol);
             $this->showonlyactiveenrol = get_user_preferences('grade_report_showonlyactiveenrol', $defaultgradeshowactiveenrol);
             if (!is_null($this->context)) {
                 $this->showonlyactiveenrol = $this->showonlyactiveenrol ||
-                    !has_capability('moodle/course:viewsuspendedusers', $this->context);
+                            !has_capability('moodle/course:viewsuspendedusers', $this->context);
+            }
+        }
      * Return true is user is active user in course else false
+     *
      * @param int $userid
      * @return bool true is user is active in course.
      */
-    public function is_active_user($userid)
+    public function is_active_user($userid) {
-    {
         return !in_array($userid, get_suspended_userids($this->context, true));
+    }
     /**
      * Returns true if gradebook feedback plugin is enabled
+     *
      * @return bool true if gradebook feedback plugin is enabled and visible else false.
      */
-    public function is_gradebook_feedback_enabled()
     public function is_gradebook_feedback_enabled() {
         // Get default grade book feedback plugin.
         $adminconfig = $this->get_admin_config();
         $gradebookplugin = $adminconfig->feedback_plugin_for_gradebook;
      * Returns the grading status.
+     *
      * @param int $userid the user id
      * @return string returns the grading status
      */
-    public function get_grading_status($userid)
+    public function get_grading_status($userid) {
-    {
         if ($this->get_instance()->markingworkflow) {
             $flags = $this->get_user_flags($userid, false);
             if (!empty($flags->workflowstate)) {
                 return $flags->workflowstate;
+            }
     /**
      * The id used to uniquily identify the cache for this instance of the assign object.
+     *
      * @return string
      */
-    public function get_useridlist_key_id()
+    public function get_useridlist_key_id() {
-    {
         return $this->useridlistid;
+    }
     /**
      * Generates the key that should be used for an entry in the useridlist cache.
+     *
      * @param string $id Generate a key for this instance (optional)
      * @return string The key for the id, or new entry if no $id is passed.
      */
-    public function get_useridlist_key($id = null)
     public function get_useridlist_key($id = null) {
         global $SESSION;
         // Ensure the user id list cache is initialised.
      * @param int $complete
      * @param obj $completion
+     *
      * @return null
      */
-    protected function update_activity_completion_records(
+    protected function update_activity_completion_records($teamsubmission,
-        $teamsubmission,
-        $requireallteammemberssubmit,
+                                                          $requireallteammemberssubmit,
-        $submission,
+                                                          $submission,
-        $userid,
+                                                          $userid,
-        $complete,
+                                                          $complete,
-        $completion
+                                                          $completion) {
-    ) {
         if (($teamsubmission && $submission->groupid > 0 && !$requireallteammemberssubmit) ||
             ($teamsubmission && $submission->groupid > 0 && $requireallteammemberssubmit &&
-                $submission->status == ASSIGN_SUBMISSION_STATUS_SUBMITTED)
-        ) {
+             $submission->status == ASSIGN_SUBMISSION_STATUS_SUBMITTED)) {
             $members = groups_get_members($submission->groupid);
     /**
      * Update the module completion status (set it viewed) and trigger module viewed event.
+     *
      * @since Moodle 3.2
      */
-    public function set_module_viewed()
+    public function set_module_viewed() {
-    {
         $completion = new completion_info($this->get_course());
         $completion->set_module_viewed($this->get_course_module());
         // Trigger the course module viewed event.
     /**
      * Checks for any grade notices, and adds notifications. Will display on assignment main page and grading table.
+     *
      * @return void The notifications API will render the notifications at the appropriate part of the page.
      */
-    protected function add_grade_notices()
+    protected function add_grade_notices() {
-    {
         if (has_capability('mod/assign:grade', $this->get_context()) && get_config('assign', 'has_rescaled_null_grades_' . $this->get_instance()->id)) {
             $link = new \moodle_url('/mod/assign/view.php', array('id' => $this->get_course_module()->id, 'action' => 'fixrescalednullgrades'));
             \core\notification::warning(get_string('fixrescalednullgrades', 'mod_assign', ['link' => $link->out()]));
+        }
+    }
     /**
      * View fix rescaled null grades.
+     *
      * @return bool True if null all grades are now fixed.
      */
-    protected function fix_null_grades()
+    protected function fix_null_grades() {
-    {
         global $DB;
         $result = $DB->set_field_select(
             'assign_grades',
             'grade',
             ASSIGN_GRADE_NOT_SET,
     /**
      * View fix rescaled null grades.
+     *
      * @return void The notifications API will render the notifications at the appropriate part of the page.
      */
-    protected function view_fix_rescaled_null_grades()
+    protected function view_fix_rescaled_null_grades() {
-    {
         global $OUTPUT;
         $o = '';
      * attempt on a group assignment, and whether the gradebook should be updated.
+     *
      * @since Moodle 3.4
      * @param stdClass $submission The most recent submission of the group.
      */
-    public function set_most_recent_team_submission($submission)
+    public function set_most_recent_team_submission($submission) {
-    {
         $this->mostrecentteamsubmission = $submission;
+    }
     /**
      * Return array of valid grading allocation filters for the grading interface.
+     *
      * @param boolean $export Export the list of filters for a template.
      * @return array
      */
-    public function get_marking_allocation_filters($export = false)
     public function get_marking_allocation_filters($export = false) {
         $markingallocation = $this->get_instance()->markingworkflow &&
             $this->get_instance()->markingallocation &&
             has_capability('mod/assign:manageallocations', $this->context);
         // Get markers to use in drop lists.
                     'active' => ($allocationfilter == $option),
                 ]);
+            }
             return $result;
+        }
-        return $markingworkflowoptions;
+        return $markingallocationoptions;
+    }
     /**
      * Return array of valid grading workflow filters for the grading interface.
+     *
      * @param boolean $export Export the list of filters for a template.
      * @return array
      */
-    public function get_marking_workflow_filters($export = false)
     public function get_marking_workflow_filters($export = false) {
         $markingworkflow = $this->get_instance()->markingworkflow;
         // Get marking states to show in form.
         $markingworkflowoptions = array();
         if ($markingworkflow) {
+    }
     /**
      * Return array of valid search filters for the grading interface.
+     *
      * @param bool $grouped Whether to return the filters grouped or not.
      * @return array
      */
-    public function get_filters()
-    {
+    public function get_filters(bool $grouped = false): array {
+        $groupedfilterkeys = [
-        $filterkeys = [
+            [
-            ASSIGN_FILTER_NOT_SUBMITTED,
+                ASSIGN_FILTER_NOT_SUBMITTED,
-            ASSIGN_FILTER_DRAFT,
+                ASSIGN_FILTER_DRAFT,
-            ASSIGN_FILTER_SUBMITTED,
+                ASSIGN_FILTER_SUBMITTED,
+                ASSIGN_FILTER_REQUIRE_GRADING,
+                ASSIGN_FILTER_GRADED,
+            ],
-            ASSIGN_FILTER_REQUIRE_GRADING,
+            [
+                ASSIGN_FILTER_GRANTED_EXTENSION,
-            ASSIGN_FILTER_GRANTED_EXTENSION
+            ],
         ];
         $current = get_user_preferences('assign_filter', '');
+        $filters = [];
-        $filters = [];
+        // First is always "no filter" option.
-        // First is always "no filter" option.
+        $filters[0] = [
-        array_push($filters, [
+            [
+                'key' => ASSIGN_FILTER_NONE,
-            'key' => 'none',
+                'name' => get_string('filterall', 'assign'),
-            'name' => get_string('filternone', 'assign'),
+                'active' => ($current == ''),
+            ],
-            'active' => ($current == '')
+        ];
-        ]);
+        foreach ($groupedfilterkeys as $group => $filterkeys) {
+            foreach ($filterkeys as $key) {
-        foreach ($filterkeys as $key) {
+                $filters[$group] = $filters[$group] ?? [];
-            array_push($filters, [
+                $filters[$group][] = [
+                    'key' => $key,
-                'key' => $key,
+                    'name' => get_string('filter' . $key, 'assign'),
-                'name' => get_string('filter' . $key, 'assign'),
+                    'active' => ($current == $key),
+                ];
-                'active' => ($current == $key)
+            }
             ]);
-        return $filters;
+        return $grouped ? $filters : array_merge(...$filters);
+    }
      * @param stdClass $instance
      * @param context $context
+     *
      * @return string
      */
-    protected function get_submissionstatement($adminconfig, $instance, $context)
+    protected function get_submissionstatement($adminconfig, $instance, $context) {
-    {
         $submissionstatement = '';
         if (!($context instanceof context)) {
             return $submissionstatement;
                 // a form element.
                 $options = array(
                     'context' => $context,
                     'para'    => false
                 );
-                $submissionstatement = format_text(
-                    $adminconfig->submissionstatementteamsubmission,
+                $submissionstatement = format_text($adminconfig->submissionstatementteamsubmission,
-                    FORMAT_MOODLE,
+                    FORMAT_MOODLE, $options);
-                    $options
-                );
-            } else if (
-                !empty($adminconfig->submissionstatementteamsubmissionallsubmit) &&
+            } else if (!empty($adminconfig->submissionstatementteamsubmissionallsubmit) &&
-                $instance->requireallteammemberssubmit
+                $instance->requireallteammemberssubmit) {
-            ) {
                 // All team members must submit.
                 // Format the submission statement before its sent. We turn off para because this is going within
                 // a form element.
                 $options = array(
                     'context' => $context,
                     'para'    => false
                 );
-                $submissionstatement = format_text(
-                    $adminconfig->submissionstatementteamsubmissionallsubmit,
+                $submissionstatement = format_text($adminconfig->submissionstatementteamsubmissionallsubmit,
-                    FORMAT_MOODLE,
+                    FORMAT_MOODLE, $options);
-                    $options
-                );
+            }
+        }
         return $submissionstatement;
      * Check if time limit for assignment enabled and set up.
+     *
      * @param int|null $userid User ID. If null, use global user.
      * @return bool
      */
-    public function is_time_limit_enabled(?int $userid = null): bool
+    public function is_time_limit_enabled(?int $userid = null): bool {
-    {
         $instance = $this->get_instance($userid);
         return get_config('assign', 'enabletimelimit') && !empty($instance->timelimit);
+    }
      * @param int|null $userid User ID. If null, use global user.
      * @param int $groupid Group ID. If 0, use user id to determine group.
      * @param int $attemptnumber Attempt number. If -1, check latest submission.
      * @return bool
      */
-    public function is_attempt_in_progress(?int $userid = null, int $groupid = 0, int $attemptnumber = -1): bool
+    public function is_attempt_in_progress(?int $userid = null, int $groupid = 0, int $attemptnumber = -1): bool {
-    {
         if ($this->get_instance($userid)->teamsubmission) {
             $submission = $this->get_group_submission($userid, $groupid, false, $attemptnumber);
         } else {
             $submission = $this->get_user_submission($userid, false, $attemptnumber);
+        }
             $timedattemptstarted = !empty($submission) && !empty($submission->timestarted);
+        }
         return !empty($submission) && $submission->status !== ASSIGN_SUBMISSION_STATUS_SUBMITTED && $timedattemptstarted;
+    }
+    /**
+     * Is "Allow partial release of grades while marking anonymously" enabled?
+     *
+     * @return bool
+     */
+    public function is_marking_anonymous(): bool {
+        return isset($this->get_instance()->markinganonymous) && $this->get_instance()->markinganonymous;
+    }
+}
 /**
  * Portfolio caller class for mod_assign.
+ *
  * @package   mod_assign
  * @copyright 2012 NetSpot {@link http://www.netspot.com.au}
  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class assign_portfolio_caller extends portfolio_module_caller_base
+ */
 class assign_portfolio_caller extends portfolio_module_caller_base {
     protected $editor;
     /**
      * Callback arg for a single file export.
      */
-    public static function expected_callbackargs()
     public static function expected_callbackargs() {
         return array(
             'cmid' => true,
             'sid' => false,
             'area' => false,
     /**
      * The constructor.
+     *
      * @param array $callbackargs
      */
-    public function __construct($callbackargs)
+    public function __construct($callbackargs) {
-    {
         parent::__construct($callbackargs);
         $this->cm = get_coursemodule_from_id('assign', $this->cmid, 0, false, MUST_EXIST);
+    }
      * submissionid and filearea (to export all data attached to the given submission file area)
      * via callback arguments.
+     *
      * @throws     portfolio_caller_exception
      */
-    public function load_data()
+    public function load_data() {
-    {
         global $DB;
         $context = context_module::instance($this->cmid);
+        }
         // Export either an area of files or a single file (see function for more detail).
         // The first arg is an id or null. If it is an id, the rest of the args are ignored.
         // If it is null, the rest of the args are used to load a list of files from get_areafiles.
-        $this->set_file_and_format_data(
-            $this->fileid,
+        $this->set_file_and_format_data($this->fileid,
-            $context->id,
+                                        $context->id,
-            $this->component,
+                                        $this->component,
-            $this->area,
+                                        $this->area,
-            $this->sid,
+                                        $this->sid,
-            'timemodified',
+                                        'timemodified',
-            false
+                                        false);
         );
+    }
     /**
      * Prepares the package up before control is passed to the portfolio plugin.
+     *
      * @throws portfolio_caller_exception
      * @return mixed
-     */
-    public function prepare_package()
+     */
     public function prepare_package() {
         if ($this->plugin && $this->editor) {
             $text = $plugin->get_editor_text($this->editor, $this->sid);
             $format = $plugin->get_editor_format($this->editor, $this->sid);
-            $html = format_text($text, $format, $options);
-            $html = portfolio_rewrite_pluginfile_urls(
+            $html = format_text($text, $format, $options);
-                $html,
+            $html = portfolio_rewrite_pluginfile_urls($html,
-                $context->id,
+                                                      $context->id,
-                'mod_assign',
+                                                      'mod_assign',
-                $this->area,
+                                                      $this->area,
-                $this->sid,
-                $this->exporter->get('format')
+                                                      $this->sid,
-            );
+                                                      $this->exporter->get('format'));
             $exporterclass = $this->exporter->get('formatclass');
+                    }
+                }
                 return $this->exporter->write_new_file($html, 'assignment.html', !empty($files));
             } else if ($this->exporter->get('formatclass') == PORTFOLIO_FORMAT_LEAP2A) {
                 $leapwriter = $this->exporter->get('format')->leap2a_writer();
-                $entry = new portfolio_format_leap2a_entry(
+                $entry = new portfolio_format_leap2a_entry($this->area . $this->cmid,
-                    $this->area . $this->cmid,
-                    $context->get_context_name(),
+                                                           $context->get_context_name(),
-                    'resource',
+                                                           'resource',
-                    $html
+                                                           $html);
-                );
                 $entry->add_category('web', 'resource_type');
                 $entry->author = $this->user;
                 $leapwriter->add_entry($entry);
                 if ($files = $this->exporter->get('caller')->get('multifiles')) {
                     $leapwriter->link_files($entry, $files, $this->area . $this->cmid . 'file');
                     foreach ($files as $file) {
                         $this->exporter->copy_existing_file($file);
+                    }
                 }
-                return $this->exporter->write_new_file(
-                    $leapwriter->to_xml(),
+                return $this->exporter->write_new_file($leapwriter->to_xml(),
-                    $this->exporter->get('format')->manifest_name(),
+                                                       $this->exporter->get('format')->manifest_name(),
-                    true
-                );
+                                                       true);
             } else {
                 debugging('invalid format class: ' . $this->exporter->get('formatclass'));
+            }
+        }
         if ($this->exporter->get('formatclass') == PORTFOLIO_FORMAT_LEAP2A) {
             $leapwriter = $this->exporter->get('format')->leap2a_writer();
             $files = array();
             if ($this->singlefile) {
                 $files[] = $this->singlefile;
             } else if ($this->multifiles) {
                 $files = $this->multifiles;
-            } else {
-                throw new portfolio_caller_exception(
+            } else {
-                    'invalidpreparepackagefile',
+                throw new portfolio_caller_exception('invalidpreparepackagefile',
-                    'portfolio',
-                    $this->get_return_url()
+                                                     'portfolio',
-                );
+                                                     $this->get_return_url());
+            }
             if (count($files) > 1) {
                 $baseid = 'assign' . $this->cmid . $this->area;
                 $context = context_module::instance($this->cmid);
                 // If we have multiple files, they should be grouped together into a folder.
-                $entry = new portfolio_format_leap2a_entry(
-                    $baseid . 'group',
+                $entry = new portfolio_format_leap2a_entry($baseid . 'group',
-                    $context->get_context_name(),
+                                                           $context->get_context_name(),
-                    'selection'
-                );
+                                                           'selection');
                 $leapwriter->add_entry($entry);
                 $leapwriter->make_selection($entry, $entryids, 'Folder');
             }
-            return $this->exporter->write_new_file(
-                $leapwriter->to_xml(),
+            return $this->exporter->write_new_file($leapwriter->to_xml(),
-                $this->exporter->get('format')->manifest_name(),
+                                                   $this->exporter->get('format')->manifest_name(),
-                true
-            );
+                                                   true);
+        }
         return $this->prepare_package_file();
+    }
     /**
      * Fetch the plugin by its type.
+     *
      * @return assign_submission_plugin
-     */
-    protected function get_submission_plugin()
+     */
     protected function get_submission_plugin() {
         global $CFG;
         if (!$this->plugin || !$this->cmid) {
      * Calculate a sha1 has of either a single file or a list
      * of files based on the data set by load_data.
+     *
      * @return string
      */
-    public function get_sha1()
+    public function get_sha1() {
-    {
         if ($this->plugin && $this->editor) {
             $plugin = $this->get_submission_plugin();
             $options = portfolio_format_text_options();
-            $options->context = context_module::instance($this->cmid);
+            $options->context = context_module::instance($this->cmid);
-            $text = format_text(
-                $plugin->get_editor_text($this->editor, $this->sid),
+            $text = format_text($plugin->get_editor_text($this->editor, $this->sid),
-                $plugin->get_editor_format($this->editor, $this->sid),
-                $options
+                                $plugin->get_editor_format($this->editor, $this->sid),
-            );
+                                $options);
             $textsha1 = sha1($text);
             $filesha1 = '';
             try {
      * Calculate the time to transfer either a single file or a list
      * of files based on the data set by load_data.
+     *
      * @return int
      */
-    public function expected_time()
+    public function expected_time() {
-    {
         return $this->expected_time_file();
+    }
     /**
      * Checking the permissions.
+     *
      * @return bool
      */
-    public function check_permissions()
     public function check_permissions() {
         $context = context_module::instance($this->cmid);
         return has_capability('mod/assign:exportownsubmission', $context);
+    }
     /**
      * Display a module name.
+     *
      * @return string
-     */
-    public static function display_name()
+     */
     public static function display_name() {
         return get_string('modulename', 'assign');
+    }
     /**
      * Return array of formats supported by this portfolio call back.
      *
-     * @return array
-     */
+     * @return array
-    public static function base_supported_formats()
+     */
     public static function base_supported_formats() {
         return array(PORTFOLIO_FORMAT_FILE, PORTFOLIO_FORMAT_LEAP2A);
+ *
  * @param int $courseid The course ID.
  * @param int $groupid The group id if it is known
  * @return void
  */
-function assign_process_group_deleted_in_course($courseid, $groupid = null)
+function assign_process_group_deleted_in_course($courseid, $groupid = null) {
-{
     global $DB;
     $params = array('courseid' => $courseid);
     if ($groupid) {
  * @param int $id of the override
  * @param string $move direction of move
  * @param int $assignid of the assignment
  * @return bool success of operation
  */
-function move_group_override($id, $move, $assignid)
+function move_group_override($id, $move, $assignid) {
-{
     global $DB;
     // Get the override object.
     if (!$override = $DB->get_record('assign_overrides', ['id' => $id, 'assignid' => $assignid], 'id, sortorder, groupid')) {
         return false;
+    }
     // Count the number of group overrides.
     $overridecountgroup = $DB->count_records('assign_overrides', array('userid' => null, 'assignid' => $assignid));
     // Calculate the new sortorder.
-    if (($move == 'up') and ($override->sortorder > 1)) {
+    if ( ($move == 'up') and ($override->sortorder > 1)) {
         $neworder = $override->sortorder - 1;
     } else if (($move == 'down') and ($override->sortorder < $overridecountgroup)) {
         $neworder = $override->sortorder + 1;
 /**
  * Reorder the overrides starting at the override at the given startorder.
+ *
  * @param int $assignid of the assigment
  */
-function reorder_group_overrides($assignid)
+function reorder_group_overrides($assignid) {
-{
     global $DB;
     $i = 1;
     if ($overrides = $DB->get_records('assign_overrides', array('userid' => null, 'assignid' => $assignid), 'sortorder ASC')) {
 /**
  * Get the information about the standard assign JavaScript module.
  * @return array a standard jsmodule structure.
  */
-function assign_get_js_module()
 function assign_get_js_module() {
     return array(
         'name' => 'mod_assign',
         'fullpath' => '/mod/assign/module.js',
     );

Proyectos de Subversion Moodle

(root)/mod/assign/locallib.php – Rev 1267 → 1441