WebSVN – Moodle – Diff – /mod/assign/locallib.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;
      * @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 (
-        if ($this->get_instance()->alwaysshowdescription ||
+            $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 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
     protected 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;
             $this->process_reveal_identities();
             $action = 'redirect';
             $nextpageparams['action'] = 'grading';
+        }
+        $returnparams = array(
-        $returnparams = array('rownum'=>optional_param('rownum', 0, PARAM_INT),
+            '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->view_remove_submission_confirm();
         } else if ($action == 'plugingradingbatchoperation') {
             $o .= $this->view_plugin_grading_batch_operation($mform);
         } else if ($action == 'viewpluginpage') {
-             $o .= $this->view_plugin_page();
+            $o .= $this->view_plugin_page();
         } else if ($action == 'viewcourseindex') {
-             $o .= $this->view_course_index();
+            $o .= $this->view_course_index();
         } else if ($action == 'viewbatchsetmarkingworkflowstate') {
-             $o .= $this->view_batch_set_workflow_state($mform);
+            $o .= $this->view_batch_set_workflow_state($mform);
         } else if ($action == 'viewbatchmarkingallocation') {
             $o .= $this->view_batch_markingallocation($mform);
         } else if ($action == 'viewsubmitforgradingerror') {
             $o .= $this->view_error_page(get_string('submitforgrading', 'assign'), $notices);
         } else if ($action == 'fixrescalednullgrades') {
      * @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();
             } else {
                 $update->markinganonymous = $formdata->markinganonymous;
+            }
+        }
         $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',
-                \core_completion\api::update_completion_date_event($formdata->coursemodule, 'assign', $this->instance,
+                    $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()
-     */
+    {
-    protected function delete_grades() {
+        global $CFG;
-        global $CFG;
+        $result = grade_update(
-        $result = grade_update('mod/assign',
+            'mod/assign',
-                               $this->get_course()->id,
+            $this->get_course()->id,
-                               'mod',
+            'mod',
+            'assign',
-                               'assign',
+            $this->get_instance()->id,
-                               $this->get_instance()->id,
+,
-,
+            null,
-                               null,
+            array('deleted' => 1)
-                               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');
                 foreach ($fileareas as $filearea => $notused) {
                     $fs->delete_area_files($this->context->id, $plugincomponent, $filearea);
+                }
+                if (!$plugin->delete_instance()) {
-                if (!$plugin->delete_instance()) {
+                    $status[] = array(
-                    $status[] = array('component'=>$componentstr,
+                        'component' => $componentstr,
-                                      'item'=>get_string('deleteallsubmissions', 'assign'),
+                        '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()) {
-                if (!$plugin->delete_instance()) {
+                    $status[] = array(
-                    $status[] = array('component'=>$componentstr,
+                        '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');
             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_submission', "assignment $sql", $params);
+            $DB->delete_records_select('assign_user_flags', "assignment $sql", $params);
-            $DB->delete_records_select('assign_user_flags', "assignment $sql", $params);
+            $status[] = array(
                 'component' => $componentstr,
-            $status[] = array('component'=>$componentstr,
+                'item' => get_string('deleteallsubmissions', 'assign'),
-                              '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.
         $purgeoverrides = false;
         // Remove user overrides.
+        if (!empty($data->reset_assign_user_overrides)) {
-        if (!empty($data->reset_assign_user_overrides)) {
+            $DB->delete_records_select(
+                'assign_overrides',
+                'assignid IN (SELECT id FROM {assign} WHERE course = ?) AND userid IS NOT NULL',
-            $DB->delete_records_select('assign_overrides',
+                array($data->courseid)
-                'assignid IN (SELECT id FROM {assign} WHERE course = ?) AND userid IS NOT NULL', array($data->courseid));
+            );
             $status[] = array(
                 'component' => $componentstr,
+                'item' => get_string('useroverridesdeleted', 'assign'),
-                'item' => get_string('useroverridesdeleted', 'assign'),
+                'error' => false
-                'error' => false);
+            );
             $purgeoverrides = true;
+        }
         // Remove group overrides.
+        if (!empty($data->reset_assign_group_overrides)) {
-        if (!empty($data->reset_assign_group_overrides)) {
+            $DB->delete_records_select(
+                'assign_overrides',
+                'assignid IN (SELECT id FROM {assign} WHERE course = ?) AND groupid IS NOT NULL',
-            $DB->delete_records_select('assign_overrides',
+                array($data->courseid)
-                'assignid IN (SELECT id FROM {assign} WHERE course = ?) AND groupid IS NOT NULL', array($data->courseid));
+            );
             $status[] = array(
                 'component' => $componentstr,
+                'item' => get_string('groupoverridesdeleted', 'assign'),
-                'item' => get_string('groupoverridesdeleted', 'assign'),
+                'error' => false
-                'error' => false);
+            );
             $purgeoverrides = true;
+        }
+        // Updating dates - shift may be negative too.
-        // Updating dates - shift may be negative too.
+        if ($data->timeshift) {
-        if ($data->timeshift) {
+            $DB->execute(
-            $DB->execute("UPDATE {assign_overrides}
+                "UPDATE {assign_overrides}
+                         SET allowsubmissionsfromdate = allowsubmissionsfromdate + ?
+                       WHERE assignid = ? AND allowsubmissionsfromdate <> 0",
-                         SET allowsubmissionsfromdate = allowsubmissionsfromdate + ?
+                array($data->timeshift, $this->get_instance()->id)
-                       WHERE assignid = ? AND allowsubmissionsfromdate <> 0",
+            );
-                array($data->timeshift, $this->get_instance()->id));
+            $DB->execute(
-            $DB->execute("UPDATE {assign_overrides}
+                "UPDATE {assign_overrides}
+                         SET duedate = duedate + ?
+                       WHERE assignid = ? AND duedate <> 0",
-                         SET duedate = duedate + ?
+                array($data->timeshift, $this->get_instance()->id)
-                       WHERE assignid = ? AND duedate <> 0",
+            );
-                array($data->timeshift, $this->get_instance()->id));
+            $DB->execute(
-            $DB->execute("UPDATE {assign_overrides}
+                "UPDATE {assign_overrides}
+                         SET cutoffdate = cutoffdate + ?
-                         SET cutoffdate = cutoffdate + ?
+                       WHERE assignid =? AND cutoffdate <> 0",
-                       WHERE assignid =? AND cutoffdate <> 0",
+                array($data->timeshift, $this->get_instance()->id)
-                array($data->timeshift, $this->get_instance()->id));
+            );
+            $purgeoverrides = true;
-            $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.
-            // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
+            shift_course_mod_dates(
+                'assign',
+                array('duedate', 'allowsubmissionsfromdate', 'cutoffdate'),
-            // See MDL-9367.
+                $data->timeshift,
-            shift_course_mod_dates('assign',
+                $data->courseid,
-                                    array('duedate', 'allowsubmissionsfromdate', 'cutoffdate'),
+                $this->get_instance()->id
+            );
-                                    $data->timeshift,
+            $status[] = array(
-                                    $data->courseid, $this->get_instance()->id);
+                'component' => $componentstr,
-            $status[] = array('component'=>$componentstr,
+                'item' => get_string('datechanged'),
-                              'item'=>get_string('datechanged'),
+                'error' => false
+     *
      * @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 (
-        if (isset($maxperpage) &&
+            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('modulename' => 'assign', 'instance' => $instance->id,
+            $DB->delete_records('event', array(
+                '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',
-            $event->id = $DB->get_field('event', 'id', array('modulename' => 'assign',
+                'instance' => $instance->id,
+                '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(
-        } else {
+                'modulename' => 'assign',
+                'instance' => $instance->id,
-            $DB->delete_records('event', array('modulename' => 'assign', 'instance' => $instance->id,
+                'eventtype' => $eventtype
-                '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 (empty($update->markingworkflow) || empty($update->blindmarking)) {
             $update->markinganonymous = 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',
-        \core_completion\api::update_completion_date_event($this->get_course_module()->id, 'assign', $this->instance,
+            $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;
+        $update->nosubmissions = (!$this->is_any_submission_plugin_enabled()) ? 1 : 0;
         $DB->update_record('assign', $update);
         return $result;
+    }
     /**
      * Save the attachments in the intro description.
+     *
      * @param stdClass $formdata
+     */
-     * @param stdClass $formdata
+    protected function save_intro_draft_files($formdata)
+    {
+        if (isset($formdata->introattachments)) {
-     */
+            file_save_draft_area_files(
+                $formdata->introattachments,
+                $this->get_context()->id,
-    protected function save_intro_draft_files($formdata) {
+                'mod_assign',
-        if (isset($formdata->introattachments)) {
+                ASSIGN_INTROATTACHMENT_FILEAREA,
             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
+    {
-    protected function save_editor_draft_files($formdata): string {
+        $text = '';
+        if (isset($formdata->activityeditor)) {
+            $text = $formdata->activityeditor['text'];
-        $text = '';
+            if (isset($formdata->activityeditor['itemid'])) {
+                $text = file_save_draft_area_files(
+                    $formdata->activityeditor['itemid'],
-        if (isset($formdata->activityeditor)) {
+                    $this->get_context()->id,
+                    'mod_assign',
-            $text = $formdata->activityeditor['text'];
+                    ASSIGN_ACTIVITYATTACHMENT_FILEAREA,
-            if (isset($formdata->activityeditor['itemid'])) {
+,
-                $text = file_save_draft_area_files($formdata->activityeditor['itemid'], $this->get_context()->id,
+                    array('subdirs' => true),
-                    'mod_assign', ASSIGN_ACTIVITYATTACHMENT_FILEAREA,
+                    $formdata->activityeditor['text']
      * @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);
+            }
+        }
     /**
      * 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');
         return self::$modulename;
     /**
      * 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(
-        $params = array('itemtype' => 'mod',
+            '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,
-        $fs = get_file_storage();
+            'mod_assign',
+            ASSIGN_INTROATTACHMENT_FILEAREA,
+,
-        $files = $fs->get_area_files($this->get_context()->id, 'mod_assign', ASSIGN_INTROATTACHMENT_FILEAREA,
+            'id',
+            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.
-     * @param int $userid User id.
+     * @return bool
-     * @return bool
+     */
-     */
+    public function should_provide_intro_attachments(int $userid): bool
     public function should_provide_intro_attachments(int $userid): bool {
      * @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
      * @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)
+    {
         global $DB;
         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"
                         $o .= '&nbsp;/&nbsp;' . format_float($this->get_instance()->grade, $item->get_decimals());
+                    }
+                }
                 return $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.
-            // Get all groups.
+            $allgroups = groups_get_all_groups(
-            $allgroups = groups_get_all_groups($this->get_course()->id,
+                $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(
-        $key = $this->context->id . '-' . $currentgroup . '-' . $this->show_only_active_users();
+                $this->context,
+                'mod/assign:submit',
-        if (!isset($this->participants[$key])) {
+                $currentgroup,
-            list($esql, $params) = get_enrolled_sql($this->context, 'mod/assign:submit', $currentgroup,
+                $this->show_only_active_users()
-                    $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 (
-            if ($instance->markingworkflow &&
+                $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
      * 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(
-            $groups = groups_get_all_groups($this->get_course()->id,
+                $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(
-                $groups = groups_get_all_groups($this->get_course()->id,
+                    $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($course->shortname,
+                    $courseshortname = format_string(
+                        $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($grader,
+                self::send_assignment_notification(
+                    $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(
-            $isreopened = $this->reopen_submission_if_required($grade->userid,
+                $grade->userid,
-                    $submission,
+                $submission,
+                $reopenattempt
-                    $reopenattempt);
+            );
             if ($isreopened) {
+                $completion = new completion_info($this->get_course());
-                $completion = new completion_info($this->get_course());
+                if (
-                if ($completion->is_enabled($this->get_course_module()) &&
+                    $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(
-        $header = 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('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.
     /**
      * View a summary listing of all assignments in the current course.
+     *
      * @return string
      */
-    private function view_course_index() {
+    private function view_course_index()
+    {
         global $USER;
         $o = '';
         $strsectionname = '';
         $usesections = course_format_uses_sections($course->format);
         $modinfo = get_fast_modinfo($course);
         if ($usesections) {
-            $strsectionname = get_string('sectionname', 'format_'.$course->format);
+            $strsectionname = get_string('sectionname', 'format_' . $course->format);
             $sections = $modinfo->get_section_info_all();
+        }
         $courseindexsummary = new assign_course_index_summary($usesections, $strsectionname);
             // Apply overrides.
             $assignment->update_effective_access($USER->id);
+            $timedue = $assignment->get_instance()->duedate;
-            $timedue = $assignment->get_instance()->duedate;
+            if (
+                has_capability('mod/assign:submit', $context) &&
-            if (has_capability('mod/assign:submit', $context) &&
+                !has_capability('moodle/site:config', $context)
-                !has_capability('moodle/site:config', $context)) {
+            ) {
                 $cangrade = false;
                 if ($assignment->get_instance()->teamsubmission) {
                     $usersubmission = $assignment->get_group_submission($USER->id, 0, false);
                 } else {
                     $submitted = get_string('submissionstatus_', 'assign');
+                }
+                $gradinginfo = grade_get_grades($course->id, 'mod', 'assign', $cm->instance, $USER->id);
-                $gradinginfo = grade_get_grades($course->id, 'mod', 'assign', $cm->instance, $USER->id);
+                if (
-                if (isset($gradinginfo->items[0]->grades[$USER->id]) &&
+                    isset($gradinginfo->items[0]->grades[$USER->id]) &&
+                    !$gradinginfo->items[0]->grades[$USER->id]->hidden
-                        !$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,
-            $courseindexsummary->add_assign_info($cm->id, $cm->get_formatted_name(),
+                $cangrade
-                $sectionname, $timedue, $submitted, $grade, $cangrade);
+            );
+        }
+     *
      * Uses url parameters 'pluginaction', 'pluginsubtype', 'plugin', and 'id'.
+     *
      * @return string
      */
-    protected function view_plugin_page() {
+    protected function view_plugin_page()
+    {
         global $USER;
         $o = '';
      * 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($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_submission_plugin_submission($plugin,
+            $o .= $this->get_renderer()->render(new assign_submission_plugin_submission(
+                $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(
-            $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_feedback_plugin_feedback(
-            $o .= $this->get_renderer()->render(new assign_feedback_plugin_feedback($plugin,
+                $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(
-        $finaltext = file_rewrite_pluginfile_urls($text,
+            $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();
-            $button = new portfolio_add_button();
+            $portfolioparams = array(
-            $portfolioparams = array('cmid' => $this->get_course_module()->id,
+                'cmid' => $this->get_course_module()->id,
-                                     'sid' => $submissionid,
+                'sid' => $submissionid,
+                'plugin' => $plugintype,
-                                     'plugin' => $plugintype,
+                'editor' => $editor,
-                                     'editor' => $editor,
+                'area' => $filearea
-                                     'area'=>$filearea);
+            );
+            $button->set_callback_options('assign_portfolio_caller', $portfolioparams, 'mod_assign');
-            $button->set_callback_options('assign_portfolio_caller', $portfolioparams, 'mod_assign');
+            $fs = get_file_storage();
-            $fs = get_file_storage();
+            if ($files = $fs->get_area_files(
-            if ($files = $fs->get_area_files($this->context->id,
+                $this->context->id,
-                                             $component,
+                $component,
+                $filearea,
-                                             $filearea,
+                $submissionid,
-                                             $submissionid,
+                'timemodified',
-                                             'timemodified',
+                false
-                                             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($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('savegradingresult', 'assign')));
+            get_string('savegradingresult', 'assign')
+        ));
-        $gradingresult = new assign_gradingmessage(get_string('savegradingresult', 'assign'),
+        $gradingresult = new assign_gradingmessage(
-                                                   $message,
+            get_string('savegradingresult', 'assign'),
+            $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($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('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(get_string('quickgradingresult', 'assign'),
+        $gradingresult = new assign_gradingmessage(
-                                                   $message,
+            get_string('quickgradingresult', 'assign'),
+            $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
      * @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();
+        }
         // Show some notification if we have nothing to download.
+    }
     /**
      * @deprecated since 2.7 - Use new events system instead.
      */
+    public function add_to_log()
     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) {
      * 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(
-            $submissionstatus = new assign_submission_status_compact($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);
+        }
         // Warning if required.
         $allsubmissions = $this->get_all_submissions($userid);
+        if ($attemptnumber != -1 && ($attemptnumber + 1) != count($allsubmissions)) {
-        if ($attemptnumber != -1 && ($attemptnumber + 1) != count($allsubmissions)) {
+            $params = array(
+                'attemptnumber' => $attemptnumber + 1,
-            $params = array('attemptnumber' => $attemptnumber + 1,
+                'totalattempts' => count($allsubmissions)
-                            'totalattempts' => count($allsubmissions));
+            );
             $message = get_string('editingpreviousfeedbackwarning', 'assign', $params);
+            $o .= $this->get_renderer()->notification($message);
-            $o .= $this->get_renderer()->notification($message);
+        }
-        }
+        $pagination = array(
-        $pagination = array('rownum' => $rownum,
+            'rownum' => $rownum,
-                            'useridlistid' => 0,
+            'useridlistid' => 0,
-                            'last' => $last,
+            'last' => $last,
+            'userid' => $userid,
-                            'userid' => $userid,
+            'attemptnumber' => $attemptnumber,
-                            'attemptnumber' => $attemptnumber,
+            'gradingpanel' => true
-                            '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);
-        $formparams = array($this, $data, $pagination);
+        $mform = new mod_assign_grade_form(
-        $mform = new mod_assign_grade_form(null,
+            null,
+            $formparams,
-                                           $formparams,
+            'post',
-                                           '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);
-            $allgrades = $this->get_all_grades($userid);
+            $history = new assign_attempt_history_chooser(
-            $history = new assign_attempt_history_chooser($allsubmissions,
+                $allsubmissions,
-                                                          $allgrades,
+                $allgrades,
+                $this->get_course_module()->id,
-                                                          $this->get_course_module()->id,
+                $userid
-                                                          $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.
-        // Need submit permission to submit an assignment.
+        require_capability('mod/assign:grade', $this->context);
-        require_capability('mod/assign:grade', $this->context);
+        $header = new assign_header(
-        $header = new assign_header($instance,
+            $instance,
+            $this->get_context(),
-                                    $this->get_context(),
+            false,
-                                    false,
+            $this->get_course_module()->id,
-                                    $this->get_course_module()->id,
+            get_string('grading', 'assign')
-                                    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(
-            $usersummary = new assign_user_summary($user,
+                $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($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($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)) {
-        if ($attemptnumber != -1 && ($attemptnumber + 1) != count($allsubmissions)) {
+            $params = array(
+                'attemptnumber' => $attemptnumber + 1,
-            $params = array('attemptnumber'=>$attemptnumber + 1,
+                'totalattempts' => count($allsubmissions)
-                            'totalattempts'=>count($allsubmissions));
+            );
             $message = get_string('editingpreviousfeedbackwarning', 'assign', $params);
             $o .= $this->get_renderer()->notification($message);
+        }
+        // Now show the grading form.
-        // Now show the grading form.
+        if (!$mform) {
-        if (!$mform) {
+            $pagination = array(
-            $pagination = array('rownum' => $rownum,
+                'rownum' => $rownum,
-                                'useridlistid' => $useridlistid,
+                'useridlistid' => $useridlistid,
+                'last' => $last,
-                                'last' => $last,
+                'userid' => $userid,
-                                'userid' => $userid,
+                'attemptnumber' => $attemptnumber
+            );
-                                'attemptnumber' => $attemptnumber);
+            $formparams = array($this, $data, $pagination);
-            $formparams = array($this, $data, $pagination);
+            $mform = new mod_assign_grade_form(
-            $mform = new mod_assign_grade_form(null,
+                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) {
-        if (count($allsubmissions) > 1 && $attemptnumber == -1) {
+            $allgrades = $this->get_all_grades($userid);
-            $allgrades = $this->get_all_grades($userid);
+            $history = new assign_attempt_history(
-            $history = new assign_attempt_history($allsubmissions,
+                $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(),
+                true,
-                                                  true,
+                $useridlistid,
     /**
      * 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 = '';
-        $o = '';
+        $header = new assign_header(
-        $header = new assign_header($this->get_instance(),
+            $this->get_instance(),
+            $this->get_context(),
-                                    $this->get_context(),
+            false,
+            $this->get_course_module()->id
-                                    false,
+        );
-                                    $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' => 'removesubmission',
+            'userid' => $userid,
-                           'action' => 'removesubmission',
+            'sesskey' => sesskey()
-                           'userid' => $userid,
+        );
+        $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,
-        $urlparams = array('id' => $this->get_course_module()->id,
+            'action' => 'view'
                 $confirmstr = get_string('removesubmissionconfirmforstudentwithtimelimit', 'assign', $this->fullname($user));
             } else {
                 $confirmstr = get_string('removesubmissionconfirmforstudent', 'assign', $this->fullname($user));
+            }
+        }
-        $o .= $this->get_renderer()->confirm($confirmstr,
+        $o .= $this->get_renderer()->confirm(
+            $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(
-        $header = new assign_header($this->get_instance(),
+            $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(
-        $urlparams = array('id'=>$this->get_course_module()->id,
+            'id' => $this->get_course_module()->id,
+            'action' => 'revealidentitiesconfirm',
-                           'action'=>'revealidentitiesconfirm',
+            'sesskey' => sesskey()
+        );
-                           'sesskey'=>sesskey());
+        $confirmurl = new moodle_url('/mod/assign/view.php', $urlparams);
-        $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,
+        );
-                           'action'=>'grading');
+        $cancelurl = new moodle_url('/mod/assign/view.php', $urlparams);
-        $cancelurl = new moodle_url('/mod/assign/view.php', $urlparams);
+        $o .= $this->get_renderer()->confirm(
             get_string('revealidentitiesconfirm', 'assign'),
-        $o .= $this->get_renderer()->confirm(get_string('revealidentitiesconfirm', 'assign'),
+            $confirmurl,
-                                             $confirmurl,
+            $cancelurl
     /**
      * 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;
         // 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();
-        $links = array();
+        if (
+            has_capability('gradereport/grader:view', $this->get_course_context()) &&
-        if (has_capability('gradereport/grader:view', $this->get_course_context()) &&
+            has_capability('moodle/grade:viewall', $this->get_course_context())
-                has_capability('moodle/grade:viewall', $this->get_course_context())) {
+        ) {
             $gradebookurl = '/grade/report/grader/index.php?id=' . $this->get_course()->id;
+            $links[$gradebookurl] = get_string('viewgradebook', 'assign');
-            $links[$gradebookurl] = get_string('viewgradebook', 'assign');
+        }
-        }
+        if (
+            $this->is_blind_marking() &&
-        if ($this->is_blind_marking() &&
+            has_capability('mod/assign:revealidentities', $this->get_context())
-                has_capability('mod/assign:revealidentities', $this->get_context())) {
+        ) {
             $revealidentitiesurl = '/mod/assign/view.php?id=' . $cmid . '&action=revealidentities';
             $links[$revealidentitiesurl] = get_string('revealidentities', 'assign');
+        }
         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 .
+                        '?id=' .  $cmid .
-                           '&plugin=' . $plugin->get_type() .
+                        '&plugin=' . $plugin->get_type() .
-                           '&pluginsubtype=assignfeedback' .
+                        '&pluginsubtype=assignfeedback' .
-                           '&action=viewpluginpage&pluginaction=' . $action;
+                        '&action=viewpluginpage&pluginaction=' . $action;
                     $links[$url] = $description;
+                }
         $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(
-        $gradingoptionsformparams = array('cm'=>$cmid,
+            'cm' => $cmid,
-                                          'contextid'=>$this->context->id,
+            'contextid' => $this->context->id,
-                                          'userid'=>$USER->id,
+            'userid' => $USER->id,
-                                          'submissionsenabled'=>$this->is_any_submission_plugin_enabled(),
+            'submissionsenabled' => $this->is_any_submission_plugin_enabled(),
-                                          'showquickgrading'=>$showquickgrading,
+            'showquickgrading' => $showquickgrading,
-                                          'quickgrading'=>$quickgrading,
+            'quickgrading' => $quickgrading,
-                                          'markingworkflowopt'=>$markingworkflowoptions,
+            'markingworkflowopt' => $markingworkflowoptions,
-                                          'markingallocationopt'=>$markingallocationoptions,
+            'markingallocationopt' => $markingallocationoptions,
-                                          'showonlyactiveenrolopt'=>$showonlyactiveenrolopt,
+            'showonlyactiveenrolopt' => $showonlyactiveenrolopt,
-                                          'showonlyactiveenrol' => $this->show_only_active_users(),
+            'showonlyactiveenrol' => $this->show_only_active_users(),
+            'downloadasfolders' => $downloadasfolders
-                                          'downloadasfolders' => $downloadasfolders);
+        );
-        $classoptions = array('class'=>'gradingoptionsform');
+        $classoptions = array('class' => 'gradingoptionsform');
+        $gradingoptionsform = new mod_assign_grading_options_form(
-        $gradingoptionsform = new mod_assign_grading_options_form(null,
+            null,
-                                                                  $gradingoptionsformparams,
+            $gradingoptionsformparams,
-                                                                  'post',
+            'post',
-                                                                  '',
+            '',
+            $classoptions
-                                                                  $classoptions);
+        );
+        $batchformparams = array(
-        $batchformparams = array('cm'=>$cmid,
+            'cm' => $cmid,
-                                 'submissiondrafts'=>$this->get_instance()->submissiondrafts,
+            'submissiondrafts' => $this->get_instance()->submissiondrafts,
-                                 'duedate'=>$this->get_instance()->duedate,
+            'duedate' => $this->get_instance()->duedate,
-                                 'attemptreopenmethod'=>$this->get_instance()->attemptreopenmethod,
+            'attemptreopenmethod' => $this->get_instance()->attemptreopenmethod,
-                                 'feedbackplugins'=>$this->get_feedback_plugins(),
+            'feedbackplugins' => $this->get_feedback_plugins(),
-                                 'context'=>$this->get_context(),
+            'context' => $this->get_context(),
-                                 'markingworkflow'=>$markingworkflow,
+            'markingworkflow' => $markingworkflow,
+            'markingallocation' => $markingallocation
-                                 'markingallocation'=>$markingallocation);
+        );
         $classoptions = [
             'class' => 'gradingbatchoperationsform',
             'data-double-submit-protection' => 'off',
         ];
+        $gradingbatchoperationsform = new mod_assign_grading_batch_operations_form(
-        $gradingbatchoperationsform = new mod_assign_grading_batch_operations_form(null,
+            null,
-                                                                                   $batchformparams,
+            $batchformparams,
-                                                                                   'post',
+            'post',
+            '',
-                                                                                   '',
+            $classoptions
-                                                                                   $classoptions);
+        );
         $gradingoptionsdata = new stdClass();
         $gradingoptionsdata->perpage = $perpage;
         $gradingoptionsdata->filter = $filter;
         $gradingoptionsdata->markerfilter = $markerfilter;
+        $gradingoptionsdata->workflowfilter = $workflowfilter;
-        $gradingoptionsdata->workflowfilter = $workflowfilter;
+        $gradingoptionsform->set_data($gradingoptionsdata);
+        $buttons = new \mod_assign\output\grading_actionmenu(
-        $gradingoptionsform->set_data($gradingoptionsdata);
+            $this->get_course_module()->id,
             $this->is_any_submission_plugin_enabled(),
-        $buttons = new \mod_assign\output\grading_actionmenu($this->get_course_module()->id,
+            $this->count_submissions()
-             $this->is_any_submission_plugin_enabled(), $this->count_submissions());
+        );
+        $actionformtext = $this->get_renderer()->render($buttons);
-        $actionformtext = $this->get_renderer()->render($buttons);
+        $PAGE->activityheader->set_attrs(['hidecompletion' => true]);
-        $PAGE->activityheader->set_attrs(['hidecompletion' => true]);
+        $currenturl = new moodle_url('/mod/assign/view.php', ['id' => $this->get_course_module()->id, 'action' => 'grading']);
-        $currenturl = new moodle_url('/mod/assign/view.php', ['id' => $this->get_course_module()->id, 'action' => 'grading']);
+        $header = new assign_header(
-        $header = new assign_header($this->get_instance(),
+            $this->get_instance(),
-                                    $this->get_context(),
+            $this->get_context(),
+            false,
-                                    false,
+            $this->get_course_module()->id,
-                                    $this->get_course_module()->id,
+            get_string('grading', 'assign'),
-                                    get_string('grading', 'assign'),
+            '',
         if ($this->is_blind_marking() && has_capability('mod/assign:viewblinddetails', $this->get_context())) {
             $o .= $this->get_renderer()->notification(get_string('blindmarkingenabledwarning', 'assign'), 'notifymessage');
+        }
+        // Load and print the table of submissions.
+        $assignform = new assign_form(
+            'gradingoptionsform',
+            $gradingoptionsform,
+            'M.mod_assign.init_grading_options'
+        );
-        // Load and print the table of submissions.
+        $o .= $this->get_renderer()->render($assignform);
-        if ($showquickgrading && $quickgrading) {
-            $gradingtable = new assign_grading_table($this, $perpage, $filter, 0, true);
+        if ($showquickgrading && $quickgrading) {
             $table = $this->get_renderer()->render($gradingtable);
+            $page = optional_param('page', null, PARAM_INT);
-            $page = optional_param('page', null, PARAM_INT);
+            $quickformparams = array(
-            $quickformparams = array('cm'=>$this->get_course_module()->id,
+                'cm' => $this->get_course_module()->id,
-                                     'gradingtable'=>$table,
+                'gradingtable' => $table,
-                                     'sendstudentnotifications' => $this->get_instance()->sendstudentnotifications,
+                'sendstudentnotifications' => $this->get_instance()->sendstudentnotifications,
+                'page' => $page
+            );
-                                     'page' => $page);
+            $gradingtable = new assign_grading_table($this, $perpage, $filter, 0, true);
             $quickgradingform = new mod_assign_quick_grading_form(null, $quickformparams);
             $o .= $this->get_renderer()->render(new assign_form('quickgradingform', $quickgradingform));
         if (count($users) != 0 && $this->can_grade()) {
             // If no enrolled user in a course then don't display the batch operations feature.
             $assignform = new assign_form('gradingbatchoperationsform', $gradingbatchoperationsform);
             $o .= $this->get_renderer()->render($assignform);
+        }
-        $assignform = new assign_form('gradingoptionsform',
-                                      $gradingoptionsform,
-                                      'M.mod_assign.init_grading_options');
-        $o .= $this->get_renderer()->render($assignform);
         return $o;
+    }
     /**
      * View entire grader app.
+     *
      * @return string
      */
+    protected function view_grader()
     protected function view_grader() {
         global $USER, $PAGE;
         $o = '';
     /**
      * View entire grading page.
+     *
      * @return string
      */
-    protected function view_grading_page() {
+    protected function view_grading_page()
+    {
         global $CFG;
         $o = '';
         // Need submit permission to submit an assignment.
     /**
      * 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(
-        $header = 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,
+            $title
-                                    $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(
-        $o .= $this->get_renderer()->render(
+            new assign_header(
-            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,
-                              $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;
      * Allows the plugin to show a batch grading operation page.
+     *
      * @param moodleform $mform
      * @return none
      */
-    protected function view_plugin_grading_batch_operation($mform) {
+    protected function view_plugin_grading_batch_operation($mform)
+    {
         require_capability('mod/assign:grade', $this->context);
         $prefix = 'plugingradingbatchoperation_';
         if ($data = $mform->get_data()) {
      * 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) {
+    protected function process_grading_batch_operation(&$mform)
+    {
         global $CFG;
         require_once($CFG->dirroot . '/mod/assign/gradingbatchoperationsform.php');
         require_sesskey();
         $markingallocation = $this->get_instance()->markingworkflow &&
             $this->get_instance()->markingallocation &&
+            has_capability('mod/assign:manageallocations', $this->context);
-            has_capability('mod/assign:manageallocations', $this->context);
+        $batchformparams = array(
-        $batchformparams = array('cm'=>$this->get_course_module()->id,
+            'cm' => $this->get_course_module()->id,
-                                 'submissiondrafts'=>$this->get_instance()->submissiondrafts,
+            'submissiondrafts' => $this->get_instance()->submissiondrafts,
-                                 'duedate'=>$this->get_instance()->duedate,
+            'duedate' => $this->get_instance()->duedate,
-                                 'attemptreopenmethod'=>$this->get_instance()->attemptreopenmethod,
+            'attemptreopenmethod' => $this->get_instance()->attemptreopenmethod,
-                                 'feedbackplugins'=>$this->get_feedback_plugins(),
+            'feedbackplugins' => $this->get_feedback_plugins(),
-                                 'context'=>$this->get_context(),
+            'context' => $this->get_context(),
+            'markingworkflow' => $this->get_instance()->markingworkflow,
-                                 'markingworkflow'=>$this->get_instance()->markingworkflow,
+            'markingallocation' => $markingallocation
-                                 'markingallocation'=>$markingallocation);
+        );
         $formclasses = [
             'class' => 'gradingbatchoperationsform',
             'data-double-submit-protection' => 'off'
+        ];
-        ];
+        $mform = new mod_assign_grading_batch_operations_form(
-        $mform = new mod_assign_grading_batch_operations_form(null,
+            null,
-                                                              $batchformparams,
+            $batchformparams,
+            'post',
-                                                              'post',
+            '',
-                                                              '',
+            $formclasses
-                                                              $formclasses);
+        );
      * 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
      */
-    protected function view_batch_set_workflow_state($mform) {
+    protected function view_batch_set_workflow_state($mform)
+    {
         global $CFG, $DB;
         require_once($CFG->dirroot . '/mod/assign/batchsetmarkingworkflowstateform.php');
         $o = '';
+        $submitteddata = $mform->get_data();
-        $submitteddata = $mform->get_data();
+        $users = $submitteddata->selectedusers;
-        $users = $submitteddata->selectedusers;
+        $userlist = explode(',', $users);
-        $userlist = explode(',', $users);
+        $formdata = array(
             'id' => $this->get_course_module()->id,
-        $formdata = array('id' => $this->get_course_module()->id,
+            'selectedusers' => $users
         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(
-            $usershtml .= $this->get_renderer()->render(new assign_user_summary($user,
+                $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(
-        $header = new assign_header($this->get_instance(),
+            $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();
      * Shows a form that allows the allocated marker 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
      */
-    public function view_batch_markingallocation($mform) {
+    public function view_batch_markingallocation($mform)
+    {
         global $CFG, $DB;
         require_once($CFG->dirroot . '/mod/assign/batchsetallocatedmarkerform.php');
         $o = '';
+        $submitteddata = $mform->get_data();
-        $submitteddata = $mform->get_data();
+        $users = $submitteddata->selectedusers;
-        $users = $submitteddata->selectedusers;
+        $userlist = explode(',', $users);
-        $userlist = explode(',', $users);
+        $formdata = array(
             'id' => $this->get_course_module()->id,
-        $formdata = array('id' => $this->get_course_module()->id,
+            'selectedusers' => $users
         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(
-            $usershtml .= $this->get_renderer()->render(new assign_user_summary($user,
+                $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.
-        $mform->set_data($formdata);    // Initialises the hidden elements.
+        $header = new assign_header(
-        $header = new assign_header($this->get_instance(),
+            $this->get_instance(),
             $this->get_context(),
             $this->show_intro(),
+            $this->get_course_module()->id,
-            $this->get_course_module()->id,
+            get_string('setmarkingallocation', 'assign')
-            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($requiresubmissionstatement,
+            $mform = new mod_assign_confirm_submission_form(null, array(
+                $requiresubmissionstatement,
-                                                                        $submissionstatement,
+                $submissionstatement,
-                                                                        $this->get_course_module()->id,
+                $this->get_course_module()->id,
+                $data
-                                                                        $data));
+            ));
+        }
         $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('confirmsubmissionheading', 'assign')
-                                                              get_string('confirmsubmissionheading', 'assign')));
+        ));
+        $submitforgradingpage = new assign_submit_for_grading_page(
-        $submitforgradingpage = new assign_submit_for_grading_page($notifications,
+            $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(
-        $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($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();
-        $instance = $this->get_instance();
+        $grade = $this->get_user_grade($user->id, false);
-        $grade = $this->get_user_grade($user->id, false);
+        $gradingstatus = $this->get_grading_status($user->id);
-        $gradingstatus = $this->get_grading_status($user->id);
+        $gradinginfo = grade_get_grades(
             $this->get_course()->id,
-        $gradinginfo = grade_get_grades($this->get_course()->id,
+            'mod',
-                                    'mod',
+            'assign',
-                                    'assign',
+            $instance->id,
             $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) {
                 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 (
-                        } else if (isset($gradebookgrade->usermodified)
+                            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.
                             $grader = $DB->get_record('user', array('id' => $gradebookgrade->usermodified));
      * 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(
-        $history = new assign_attempt_history($allsubmissions,
+            $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(
-        $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);
+        );
         $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;
+                }
+            }
             // 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(
-                $grade->gradefordisplay = $controller->render_grade($PAGE,
+                    $PAGE,
-                                                                     $grade->id,
+                    $grade->id,
-                                                                     $gradingitem,
+                    $gradingitem,
-                                                                     $grade->grade,
+                    $grade->grade,
+                    $cangrade
-                                                                     $cangrade);
+                );
             } else {
                 $grade->gradefordisplay = $this->display_grade($grade->grade, false);
-            }
+            }
+        }
      * 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).
      */
-    public function get_all_submissions($userid) {
+    public function get_all_submissions($userid)
+    {
         global $DB, $USER;
         // If the userid is not null then use userid.
         if (!$userid) {
             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(
-        $o .= $this->get_renderer()->render(new assign_header($instance,
+            $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()) {
             return false;
+        }
+        // If marking workflow is enabled and grade is not released then remove any grade that may exist in the gradebook.
-        // If marking workflow is enabled and grade is not released then remove any grade that may exist in the gradebook.
+        if (
+            $this->get_instance()->markingworkflow && !empty($grade) &&
-        if ($this->get_instance()->markingworkflow && !empty($grade) &&
+            $this->get_grading_status($grade->userid) != ASSIGN_MARKING_WORKFLOW_STATE_RELEASED
-                $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 no submission found for team member and member is active then everyone has not submitted.
+                if (
-                if (!$membersubmission || $membersubmission->status != ASSIGN_SUBMISSION_STATUS_SUBMITTED
+                    !$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($userid = 0,
+    public function submissions_open(
+        $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($this->get_course()->id,
+            $gradinginfo = grade_get_grades(
+                $this->get_course()->id,
-                                            'mod',
+                'mod',
-                                            'assign',
+                'assign',
-                                            $this->get_instance()->id,
+                $this->get_instance()->id,
+                array($userid)
-                                            array($userid));
+            );
+        }
-        }
+        if (
-        if ($gradinginfo &&
+            $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,
-        return $this->get_renderer()->assign_files($this->context, $submissionid, $area, $component,
+            $this->course,
-                                                   $this->course, $this->coursemodule);
+            $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();
-        $instance = $this->get_instance();
+        if (
+            $userid == $graderid &&
-        if ($userid == $graderid &&
+            $instance->teamsubmission &&
-            $instance->teamsubmission &&
+            $instance->preventsubmissionnotingroup &&
-            $instance->preventsubmissionnotingroup &&
+            $this->get_submission_group($userid) == false
+        ) {
-            $this->get_submission_group($userid) == false) {
+            return false;
-            return false;
+        }
         if ($userid == $graderid) {
             if (
-        if ($userid == $graderid) {
+                $this->submissions_open($userid) &&
-            if ($this->submissions_open($userid) &&
+                has_capability('mod/assign:submit', $this->context, $graderid)
-                    has_capability('mod/assign:submit', $this->context, $graderid)) {
+            ) {
+     *
      * @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($this->context, "mod/assign:receivegradernotifications",
+        $potentialusers = get_enrolled_users(
+            $this->context,
-                                             null, 'u.*', null, null, null, true);
+            "mod/assign:receivegradernotifications",
+            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)) {
      * @param stdClass $course
      * @param stdClass $context
      * @param string $modulename
      * @param string $assignmentname
      */
-    protected static function format_notification_message_text($messagetype,
+    protected static function format_notification_message_text(
+        $messagetype,
-                                                             $info,
+        $info,
-                                                             $course,
+        $course,
-                                                             $context,
+        $context,
-                                                             $modulename,
+        $modulename,
-                                                             $assignmentname) {
+        $assignmentname
+    ) {
         $formatparams = array('context' => $context->get_course_context());
         $posttext  = format_string($course->shortname, true, $formatparams) .
-                     ' -> ' .
+            ' -> ' .
-                     $modulename .
+            $modulename .
-                     ' -> ' .
+            ' -> ' .
-                     format_string($assignmentname, true, $formatparams) . "\n";
+            format_string($assignmentname, true, $formatparams) . "\n";
         $posttext .= '---------------------------------------------------------------------' . "\n";
-        $posttext .= get_string($messagetype . 'text', 'assign', $info)."\n";
+        $posttext .= get_string($messagetype . 'text', 'assign', $info) . "\n";
         $posttext .= "\n---------------------------------------------------------------------\n";
         return $posttext;
+    }
      * @param stdClass $context
      * @param string $modulename
      * @param stdClass $coursemodule
      * @param string $assignmentname
      */
-    protected static function format_notification_message_html($messagetype,
+    protected static function format_notification_message_html(
+        $messagetype,
-                                                             $info,
+        $info,
-                                                             $course,
+        $course,
-                                                             $context,
+        $context,
-                                                             $modulename,
+        $modulename,
-                                                             $coursemodule,
+        $coursemodule,
-                                                             $assignmentname) {
+        $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 . '">' .
+            '<a href="' . $CFG->wwwroot . '/course/view.php?id=' . $course->id . '">' .
-                     format_string($course->shortname, true, $formatparams) .
+            format_string($course->shortname, true, $formatparams) .
-                     '</a> ->' .
+            '</a> ->' .
-                     '<a href="' . $CFG->wwwroot . '/mod/assign/index.php?id=' . $course->id . '">' .
+            '<a href="' . $CFG->wwwroot . '/mod/assign/index.php?id=' . $course->id . '">' .
-                     $modulename .
+            $modulename .
-                     '</a> ->' .
+            '</a> ->' .
-                     '<a href="' . $CFG->wwwroot . '/mod/assign/view.php?id=' . $coursemodule->id . '">' .
+            '<a href="' . $CFG->wwwroot . '/mod/assign/view.php?id=' . $coursemodule->id . '">' .
-                     format_string($assignmentname, true, $formatparams) .
+            format_string($assignmentname, true, $formatparams) .
-                     '</a></font></p>';
+            '</a></font></p>';
         $posthtml .= '<hr /><font face="sans-serif">';
         $posthtml .= '<p>' . get_string($messagetype . 'html', 'assign', $info) . '</p>';
         $posthtml .= '</font><hr />';
         return $posthtml;
+    }
      * @param string $assignmentname
      * @param bool $blindmarking
      * @param int $uniqueidforuser
      * @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
+    ) {
         global $CFG, $PAGE;
         $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 = fullname($userfrom, true);
         }
-        $info->assignment = format_string($assignmentname, true, array('context'=>$context));
+        $info->assignment = format_string($assignmentname, true, array('context' => $context));
-        $info->url = $CFG->wwwroot.'/mod/assign/view.php?id='.$coursemodule->id;
+        $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);
-        $postsubject = get_string($messagetype . 'small', 'assign', $info);
+        $posttext = self::format_notification_message_text(
-        $posttext = self::format_notification_message_text($messagetype,
+            $messagetype,
-                                                           $info,
+            $info,
-                                                           $course,
+            $course,
-                                                           $context,
+            $context,
+            $modulename,
-                                                           $modulename,
+            $assignmentname
-                                                           $assignmentname);
+        );
         $posthtml = '';
+        if ($userto->mailformat == 1) {
-        if ($userto->mailformat == 1) {
+            $posthtml = self::format_notification_message_html(
-            $posthtml = self::format_notification_message_html($messagetype,
+                $messagetype,
-                                                               $info,
+                $info,
-                                                               $course,
+                $course,
-                                                               $context,
+                $context,
-                                                               $modulename,
+                $modulename,
+                $coursemodule,
-                                                               $coursemodule,
+                $assignmentname
-                                                               $assignmentname);
+            );
+        }
      * @param string $messagetype
      * @param string $eventtype
      * @param int $updatetime
      * @return void
      */
-    public function send_notification($userfrom, $userto, $messagetype, $eventtype, $updatetime) {
+    public function send_notification($userfrom, $userto, $messagetype, $eventtype, $updatetime)
+    {
         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($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
+        );
+    }
     /**
      * 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(
-        $this->send_notification($user,
+            $user,
-                                 $user,
+            $user,
-                                 'submissioncopied',
+            'submissioncopied',
+            'assign_notification',
-                                 'assign_notification',
+            $submission->timemodified
-                                 $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;
-            $user = $USER;
+        }
-        }
+        if ($submission->userid == $USER->id) {
-        if ($submission->userid == $USER->id) {
+            $this->send_notification(
-            $this->send_notification(core_user::get_noreply_user(),
+                core_user::get_noreply_user(),
-                                     $user,
+                $user,
+                'submissionreceipt',
-                                     'submissionreceipt',
+                'assign_notification',
-                                     'assign_notification',
+                $submission->timemodified
+            );
-                                     $submission->timemodified);
+        } else {
-        } else {
+            $this->send_notification(
-            $this->send_notification($USER,
+                $USER,
-                                     $user,
+                $user,
+                'submissionreceiptother',
-                                     'submissionreceiptother',
+                'assign_notification',
-                                     'assign_notification',
+                $submission->timemodified
-                                     $submission->timemodified);
+            );
+        }
+    }
     /**
      * Send notifications to graders upon student submissions.
      *
+     * @param stdClass $submission
-     * @param stdClass $submission
+     * @return void
-     * @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) {
-            foreach ($notifyusers as $notifyuser) {
+                $this->send_notification(
-                $this->send_notification($user,
+                    $user,
-                                         $notifyuser,
+                    $notifyuser,
-                                         'gradersubmissionupdated',
+                    'gradersubmissionupdated',
+                    'assign_notification',
-                                         'assign_notification',
+                    $submission->timemodified
-                                         $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 (
-        if (!empty($submissionstatement) && $instance->requiresubmissionstatement
+            !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(
-                $this->update_activity_completion_records($instance->teamsubmission,
+                    $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($requiresubmissionstatement,
+            $mform = new mod_assign_confirm_submission_form(null, array(
+                $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;
         // Need submit permission to submit an assignment.
      * Save extension date.
+     *
      * @param moodleform $mform The submitted form
      * @return boolean
      */
-    protected function process_save_extension(& $mform) {
+    protected function process_save_extension(&$mform)
+    {
         global $DB, $CFG;
         // Include extension form.
         require_once($CFG->dirroot . '/mod/assign/extensionform.php');
     /**
      * 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($this->get_course()->id,
+            $record->gradinginfo = grade_get_grades(
-                                                    'mod',
+                $this->get_course()->id,
+                '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('mod/assign',
+                    grade_update_outcomes(
+                        '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.
+     *
      * @return void
      */
-    protected function process_save_grading_options() {
+    protected function process_save_grading_options()
+    {
         global $USER, $CFG;
         // Include grading options form.
+        }
         // Get marking states to show in form.
+        $markingworkflowoptions = $this->get_marking_workflow_filters();
-        $markingworkflowoptions = $this->get_marking_workflow_filters();
+        $gradingoptionsparams = array(
-        $gradingoptionsparams = array('cm'=>$this->get_course_module()->id,
+            'cm' => $this->get_course_module()->id,
-                                      'contextid'=>$this->context->id,
+            'contextid' => $this->context->id,
-                                      'userid'=>$USER->id,
+            'userid' => $USER->id,
-                                      'submissionsenabled'=>$this->is_any_submission_plugin_enabled(),
+            'submissionsenabled' => $this->is_any_submission_plugin_enabled(),
-                                      'showquickgrading'=>$showquickgrading,
+            'showquickgrading' => $showquickgrading,
-                                      'quickgrading'=>false,
+            'quickgrading' => false,
-                                      'markingworkflowopt' => $markingworkflowoptions,
+            'markingworkflowopt' => $markingworkflowoptions,
-                                      'markingallocationopt' => $markingallocationoptions,
+            'markingallocationopt' => $markingallocationoptions,
-                                      'showonlyactiveenrolopt'=>$showonlyactiveenrolopt,
+            'showonlyactiveenrolopt' => $showonlyactiveenrolopt,
+            'showonlyactiveenrol' => $this->show_only_active_users(),
-                                      'showonlyactiveenrol' => $this->show_only_active_users(),
+            'downloadasfolders' => get_user_preferences('assign_downloadasfolders', 1)
-                                      '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);
+    }
     /**
      * @deprecated since 2.7
      */
+    public function format_grade_for_log()
     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()
     public function format_submission_for_log() {
         throw new coding_exception(__FUNCTION__ . ' has been deprecated, please do not use it any more');
+    }
     /**
      * 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($instance->teamsubmission,
+            $this->update_activity_completion_records(
+                $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 (
-            if ($plugin->is_enabled() && $plugin->is_visible() && $plugin->allow_submissions() &&
+                $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(
-            $gradinginfo = grade_get_grades($this->get_course()->id,
+                $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($instanceid,
+                    $gradinginstance = $controller->get_or_create_instance(
+                        $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;
         $settings = $this->get_instance();
         $rownum = isset($params['rownum']) ? $params['rownum'] : 0;
         $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(
-            $gradingelement = $mform->addElement('grading',
+                '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($this->get_course()->id,
+        $gradinginfo = grade_get_grades(
+            $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(
-                    $mform->addElement('static',
+                        '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(
-                    $mform->addElement('select',
+                        'select',
-                                       'outcome_' . $index . '[' . $userid . ']',
+                        'outcome_' . $index . '[' . $userid . ']',
-                                       $outcome->name.':',
+                        $outcome->name . ':',
-                                       $options,
+                        $options,
+                        $attributes
-                                       $attributes);
+                    );
+                    $mform->setType('outcome_' . $index . '[' . $userid . ']', PARAM_INT);
-                    $mform->setType('outcome_' . $index . '[' . $userid . ']', PARAM_INT);
+                    $mform->setDefault(
-                    $mform->setDefault('outcome_' . $index . '[' . $userid . ']',
+                        '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);
-            $gradestring = $this->get_renderer()->action_link($url, $usergrade);
+        } else {
-        } else {
+            if (
+                isset($gradinginfo->items[0]->grades[$userid]) &&
-            if (isset($gradinginfo->items[0]->grades[$userid]) &&
+                !$gradinginfo->items[0]->grades[$userid]->hidden
-                    !$gradinginfo->items[0]->grades[$userid]->hidden) {
+            ) {
                 $usergrade = $gradinginfo->items[0]->grades[$userid]->str_grade;
+            }
                     $mform->addElement('static', 'currentassigngrade', $label, $assigngradestring);
+                }
+            }
+        }
+        if (
-        if ($this->get_instance()->markingworkflow &&
+            $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->setDefault('applytoall', 1);
+        }
         // Do not show if we are editing a previous attempt.
         if (($attemptnumber == -1 ||
-            ($attemptnumber + 1) == count($this->get_all_submissions($userid))) &&
+                ($attemptnumber + 1) == count($this->get_all_submissions($userid))) &&
+            $this->get_instance()->attemptreopenmethod != ASSIGN_ATTEMPT_REOPEN_METHOD_NONE
-            $this->get_instance()->attemptreopenmethod != ASSIGN_ATTEMPT_REOPEN_METHOD_NONE) {
+        ) {
             $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($submission,
+    protected function add_plugin_submission_elements(
+        $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(
-            $mform->addElement('checkbox', 'submissionstatement', '', $submissionstatement);
+                'submissionstatement',
-            $mform->addRule('submissionstatement', get_string('submissionstatementrequired', 'mod_assign'),
+                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());
-        $completion = new completion_info($this->get_course());
+        if (
-        if ($completion->is_enabled($this->get_course_module()) &&
+            $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());
-        $completion = new completion_info($this->get_course());
+        if (
-        if ($completion->is_enabled($this->get_course_module()) &&
+            $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 (
-                if ($formdata->sendstudentnotifications && $cm->uservisible &&
+                    $formdata->sendstudentnotifications && $cm->uservisible &&
-                        $state == ASSIGN_MARKING_WORKFLOW_STATE_RELEASED) {
+                    $state == ASSIGN_MARKING_WORKFLOW_STATE_RELEASED
+                ) {
                     $flags->mailed = 0;
+                }
     /**
      * 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);
-                $flags = $this->get_user_flags($userid, true);
+                if (
-                if ($flags->workflowstate == ASSIGN_MARKING_WORKFLOW_STATE_READYFORREVIEW ||
+                    $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($formdata->advancedgrading,
+                $grade->grade = $gradinginstance->submit_and_get_grade(
+                    $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 (
-                if ($this->update_user_flags($flags) &&
+                    $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.
-        // We do not want to update the timemodified if no grade was added.
+        if (
-        if (!empty($formdata->addattempt) ||
+            !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.
-        // We never send notifications if we have marking workflow and the grade is not released.
+        if (
-        if ($this->get_instance()->markingworkflow &&
+            $this->get_instance()->markingworkflow &&
+            isset($formdata->workflowstate) &&
-                isset($formdata->workflowstate) &&
+            $formdata->workflowstate != ASSIGN_MARKING_WORKFLOW_STATE_RELEASED
-                $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();
-        $data = array();
+        $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($gradinginfo->outcomes)) {
-        if (!empty($gradinginfo->outcomes)) {
+            foreach ($gradinginfo->outcomes as $index => $oldoutcome) {
-            foreach ($gradinginfo->outcomes as $index => $oldoutcome) {
+                $name = 'outcome_' . $index;
+                $sourceuserid = $sourceuserid !== null ? $sourceuserid : $userid;
-                $name = 'outcome_'.$index;
+                if (
-                $sourceuserid = $sourceuserid !== null ? $sourceuserid : $userid;
+                    isset($formdata->{$name}[$sourceuserid]) &&
-                if (isset($formdata->{$name}[$sourceuserid]) &&
+                    $oldoutcome->grades[$userid]->grade != $formdata->{$name}[$sourceuserid]
-                        $oldoutcome->grades[$userid]->grade != $formdata->{$name}[$sourceuserid]) {
+                ) {
                     $data[$index] = $formdata->{$name}[$sourceuserid];
                 }
+            }
-            }
+        }
-        }
+        if (count($data) > 0) {
-        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);
+            );
      * @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;
         if ($instance->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_UNTILPASS) {
             // Check the gradetopass from the gradebook.
             $gradeitem = $this->get_grade_item();
             if ($gradeitem) {
                 if ($gradegrade && ($gradegrade->is_passed() === false)) {
                     $shouldreopen = true;
+                }
+            }
+        }
+        if (
-        if ($instance->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_MANUAL &&
+            $instance->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_MANUAL &&
-                !empty($addattempt)) {
+            !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(
-        $gradeformparams = array('rownum' => $rownum,
+            'rownum' => $rownum,
-                                 'useridlistid' => $useridlistid,
+            'useridlistid' => $useridlistid,
-                                 'last' => $last,
+            'last' => $last,
+            'attemptnumber' => $attemptnumber,
-                                 'attemptnumber' => $attemptnumber,
+            'userid' => $userid
+        );
-                                 'userid' => $userid);
+        $mform = new mod_assign_grade_form(
-        $mform = new mod_assign_grade_form(null,
+            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($oldcontextid,
+    public function copy_area_files_for_upgrade(
+        $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(
-        $oldfiles = $fs->get_area_files($oldcontextid,
+            $oldcontextid,
-                                        $oldcomponent,
+            $oldcomponent,
-                                        $oldfilearea,
+            $oldfilearea,
-                                        $olditemid,
+            $olditemid,
+            'id',
-                                        'id',
+            false
-                                        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 ($this->get_instance()->attemptreopenmethod == ASSIGN_ATTEMPT_REOPEN_METHOD_NONE) {
             return false;
         if (!$oldsubmission) {
             return false;
+        }
+        // No more than max attempts allowed.
-        // No more than max attempts allowed.
+        if (
-        if ($this->get_instance()->maxattempts != ASSIGN_UNLIMITED_ATTEMPTS &&
+            $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.
-        // When the gradebook asks us for grades - only return the last attempt for each user.
+        $params = array(
-        $params = array('assignid1'=>$assignmentid,
+            '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) {
-        foreach ($users as $user) {
+            $record = $DB->get_record(
-            $record = $DB->get_record('assign_user_mapping',
+                'assign_user_mapping',
+                array('assignment' => $assignid, 'userid' => $user->id),
-                                      array('assignment'=>$assignid, 'userid'=>$user->id),
+                '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.
-        // Search for a record.
+        if ($record = $DB->get_record(
-        if ($record = $DB->get_record('assign_user_mapping',
+            'assign_user_mapping',
-                                      array('assignment'=>$assignid, 'id'=>$uniqueid),
+            array('assignment' => $assignid, 'id' => $uniqueid),
+            'userid',
-                                      'userid',
+            IGNORE_MISSING
-                                      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('mod/assign:reviewgrades',
+        if (has_any_capability(array(
+            'mod/assign:reviewgrades',
-                                     'mod/assign:managegrades'), $this->context)) {
+            'mod/assign:managegrades'
+        ), $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('mod/assign:releasegrades',
+        if (has_any_capability(array(
+            'mod/assign:releasegrades',
-                                     'mod/assign:managegrades'), $this->context)) {
+            'mod/assign:managegrades'
+        ), $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($teamsubmission,
+    protected function update_activity_completion_records(
+        $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.
      * 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) {
             $notmarked = get_string('markingworkflowstatenotmarked', 'assign');
     /**
      * Return array of valid search filters for the grading interface.
+     *
      * @return array
      */
-    public function get_filters() {
+    public function get_filters()
+    {
         $filterkeys = [
             ASSIGN_FILTER_NOT_SUBMITTED,
             ASSIGN_FILTER_DRAFT,
             ASSIGN_FILTER_SUBMITTED,
             ASSIGN_FILTER_REQUIRE_GRADING,
      * @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(
-                $submissionstatement = format_text($adminconfig->submissionstatementteamsubmission,
+                    $adminconfig->submissionstatementteamsubmission,
-                    FORMAT_MOODLE, $options);
+                    FORMAT_MOODLE,
+                    $options
+                );
+            } else if (
-            } else if (!empty($adminconfig->submissionstatementteamsubmissionallsubmit) &&
+                !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(
-                $submissionstatement = format_text($adminconfig->submissionstatementteamsubmissionallsubmit,
+                    $adminconfig->submissionstatementteamsubmissionallsubmit,
-                    FORMAT_MOODLE, $options);
+                    FORMAT_MOODLE,
+                    $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);
+        }
+ *
  * @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
+{
     /** @var int callback arg - the id of submission we export */
     protected $sid;
     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->set_file_and_format_data($this->fileid,
+            $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 = format_text($text, $format, $options);
+            $html = portfolio_rewrite_pluginfile_urls(
-            $html = portfolio_rewrite_pluginfile_urls($html,
+                $html,
-                                                      $context->id,
+                $context->id,
-                                                      'mod_assign',
+                'mod_assign',
-                                                      $this->area,
+                $this->area,
+                $this->sid,
-                                                      $this->sid,
+                $this->exporter->get('format')
-                                                      $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($this->area . $this->cmid,
+                $entry = new portfolio_format_leap2a_entry(
+                    $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(
-                return $this->exporter->write_new_file($leapwriter->to_xml(),
+                    $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 {
-            } else {
+                throw new portfolio_caller_exception(
-                throw new portfolio_caller_exception('invalidpreparepackagefile',
+                    'invalidpreparepackagefile',
+                    'portfolio',
-                                                     'portfolio',
+                    $this->get_return_url()
-                                                     $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(
-                $entry = new portfolio_format_leap2a_entry($baseid . 'group',
+                    $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(
-            return $this->exporter->write_new_file($leapwriter->to_xml(),
+                $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(
-            $text = format_text($plugin->get_editor_text($this->editor, $this->sid),
+                $plugin->get_editor_text($this->editor, $this->sid),
+                $plugin->get_editor_format($this->editor, $this->sid),
-                                $plugin->get_editor_format($this->editor, $this->sid),
+                $options
-                                $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 1 → 1254