Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * This file contains the moodle hooks for the assign module.

 *

 * It delegates most functions to the assignment class.

 *

 * @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

 */

defined('MOODLE_INTERNAL') || die();

require_once(__DIR__ . '/deprecatedlib.php');

/**

 * Adds an assignment instance

 *

 * This is done by calling the add_instance() method of the assignment type class

 * @param stdClass $data

 * @param mod_assign_mod_form $form

 * @return int The instance id of the new assignment

 */

function assign_add_instance(stdClass $data, mod_assign_mod_form $form = null) {

    global $CFG;

    require_once($CFG->dirroot . '/mod/assign/locallib.php');

    $assignment = new assign(context_module::instance($data->coursemodule), null, null);

    return $assignment->add_instance($data, true);

}

/**

 * delete an assignment instance

 * @param int $id

 * @return bool

 */

function assign_delete_instance($id) {

    global $CFG;

    require_once($CFG->dirroot . '/mod/assign/locallib.php');

    $cm = get_coursemodule_from_instance('assign', $id, 0, false, MUST_EXIST);

    $context = context_module::instance($cm->id);

    $assignment = new assign($context, null, null);

    return $assignment->delete_instance();

}

/**

 * This function is used by the reset_course_userdata function in moodlelib.

 * This function will remove all assignment submissions and feedbacks in the database

 * and clean up any related data.

 *

 * @param stdClass $data the data submitted from the reset course.

 * @return array

 */

function assign_reset_userdata($data) {

    global $CFG, $DB;

    require_once($CFG->dirroot . '/mod/assign/locallib.php');

    $status = array();

    $params = array('courseid'=>$data->courseid);

    $sql = "SELECT a.id FROM {assign} a WHERE a.course=:courseid";

    $course = $DB->get_record('course', array('id'=>$data->courseid), '*', MUST_EXIST);

    if ($assigns = $DB->get_records_sql($sql, $params)) {

        foreach ($assigns as $assign) {

            $cm = get_coursemodule_from_instance('assign',

                                                 $assign->id,

                                                 $data->courseid,

                                                 false,

                                                 MUST_EXIST);

            $context = context_module::instance($cm->id);

            $assignment = new assign($context, $cm, $course);

            $status = array_merge($status, $assignment->reset_userdata($data));

        }

    }

    return $status;

}

/**

 * This standard function will check all instances of this module

 * and make sure there are up-to-date events created for each of them.

 * If courseid = 0, then every assignment event in the site is checked, else

 * only assignment events belonging to the course specified are checked.

 *

 * @param int $courseid

 * @param int|stdClass $instance Assign module instance or ID.

 * @param int|stdClass $cm Course module object or ID (not used in this module).

 * @return bool

 */

function assign_refresh_events($courseid = 0, $instance = null, $cm = null) {

    global $CFG, $DB;

    require_once($CFG->dirroot . '/mod/assign/locallib.php');

    // If we have instance information then we can just update the one event instead of updating all events.

    if (isset($instance)) {

        if (!is_object($instance)) {

            $instance = $DB->get_record('assign', array('id' => $instance), '*', MUST_EXIST);

        }

        if (isset($cm)) {

            if (!is_object($cm)) {

                assign_prepare_update_events($instance);

                return true;

            } else {

                $course = get_course($instance->course);

                assign_prepare_update_events($instance, $course, $cm);

                return true;

            }

        }

    }

    if ($courseid) {

        // Make sure that the course id is numeric.

        if (!is_numeric($courseid)) {

            return false;

        }

        if (!$assigns = $DB->get_records('assign', array('course' => $courseid))) {

            return false;

        }

        // Get course from courseid parameter.

        if (!$course = $DB->get_record('course', array('id' => $courseid), '*')) {

            return false;

        }

    } else {

        if (!$assigns = $DB->get_records('assign')) {

            return false;

        }

    }

    foreach ($assigns as $assign) {

        assign_prepare_update_events($assign);

    }

    return true;

}

/**

 * This actually updates the normal and completion calendar events.

 *

 * @param  stdClass $assign Assignment object (from DB).

 * @param  stdClass $course Course object.

 * @param  stdClass $cm Course module object.

 */

function assign_prepare_update_events($assign, $course = null, $cm = null) {

    global $DB;

    if (!isset($course)) {

        // Get course and course module for the assignment.

        list($course, $cm) = get_course_and_cm_from_instance($assign->id, 'assign', $assign->course);

    }

    // Refresh the assignment's calendar events.

    $context = context_module::instance($cm->id);

    $assignment = new assign($context, $cm, $course);

    $assignment->update_calendar($cm->id);

    // Refresh the calendar events also for the assignment overrides.

    $overrides = $DB->get_records('assign_overrides', ['assignid' => $assign->id], '',

                                  'id, groupid, userid, duedate, sortorder, timelimit');

    foreach ($overrides as $override) {

        if (empty($override->userid)) {

            unset($override->userid);

        }

        if (empty($override->groupid)) {

            unset($override->groupid);

        }

        assign_update_events($assignment, $override);

    }

}

/**

 * Removes all grades from gradebook

 *

 * @param int $courseid The ID of the course to reset

 * @param string $type Optional type of assignment to limit the reset to a particular assignment type

 */

function assign_reset_gradebook($courseid, $type='') {

    global $CFG, $DB;

    $params = array('moduletype'=>'assign', 'courseid'=>$courseid);

    $sql = 'SELECT a.*, cm.idnumber as cmidnumber, a.course as courseid

            FROM {assign} a, {course_modules} cm, {modules} m

            WHERE m.name=:moduletype AND m.id=cm.module AND cm.instance=a.id AND a.course=:courseid';

    if ($assignments = $DB->get_records_sql($sql, $params)) {

        foreach ($assignments as $assignment) {

            assign_grade_item_update($assignment, 'reset');

        }

    }

}

/**

 * Implementation of the function for printing the form elements that control

 * whether the course reset functionality affects the assignment.

 * @param MoodleQuickForm $mform form passed by reference

 */

function assign_reset_course_form_definition(&$mform) {

    $mform->addElement('header', 'assignheader', get_string('modulenameplural', 'assign'));

    $name = get_string('deleteallsubmissions', 'assign');

    $mform->addElement('advcheckbox', 'reset_assign_submissions', $name);

    $mform->addElement('advcheckbox', 'reset_assign_user_overrides',

        get_string('removealluseroverrides', 'assign'));

    $mform->addElement('advcheckbox', 'reset_assign_group_overrides',

        get_string('removeallgroupoverrides', 'assign'));

}

/**

 * Course reset form defaults.

 * @param  object $course

 * @return array

 */

function assign_reset_course_form_defaults($course) {

    return array('reset_assign_submissions' => 1,

            'reset_assign_group_overrides' => 1,

            'reset_assign_user_overrides' => 1);

}

/**

 * Update an assignment instance

 *

 * This is done by calling the update_instance() method of the assignment type class

 * @param stdClass $data

 * @param stdClass $form - unused

 * @return object

 */

function assign_update_instance(stdClass $data, $form) {

    global $CFG;

    require_once($CFG->dirroot . '/mod/assign/locallib.php');

    $context = context_module::instance($data->coursemodule);

    $assignment = new assign($context, null, null);

    return $assignment->update_instance($data);

}

/**

 * This function updates the events associated to the assign.

 * If $override is non-zero, then it updates only the events

 * associated with the specified override.

 *

 * @param assign $assign the assign object.

 * @param object $override (optional) limit to a specific override

 */

function assign_update_events($assign, $override = null) {

    global $CFG, $DB;

    require_once($CFG->dirroot . '/calendar/lib.php');

    $assigninstance = $assign->get_instance();

    // Load the old events relating to this assign.

    $conds = array('modulename' => 'assign', 'instance' => $assigninstance->id);

    if (!empty($override)) {

        // Only load events for this override.

        if (isset($override->userid)) {

            $conds['userid'] = $override->userid;

        } else if (isset($override->groupid)) {

            $conds['groupid'] = $override->groupid;

        } else {

            // This is not a valid override, it may have been left from a bad import or restore.

            $conds['groupid'] = $conds['userid'] = 0;

        }

    }

    $oldevents = $DB->get_records('event', $conds, 'id ASC');

    // Now make a to-do list of all that needs to be updated.

    if (empty($override)) {

        // We are updating the primary settings for the assignment, so we need to add all the overrides.

        $overrides = $DB->get_records('assign_overrides', array('assignid' => $assigninstance->id), 'id ASC');

        // It is necessary to add an empty stdClass to the beginning of the array as the $oldevents

        // list contains the original (non-override) event for the module. If this is not included

        // the logic below will end up updating the wrong row when we try to reconcile this $overrides

        // list against the $oldevents list.

        array_unshift($overrides, new stdClass());

    } else {

        // Just do the one override.

        $overrides = array($override);

    }

    if (!empty($assign->get_course_module())) {

        $cmid = $assign->get_course_module()->id;

    } else {

        $cmid = get_coursemodule_from_instance('assign', $assigninstance->id, $assigninstance->course)->id;

    }

    foreach ($overrides as $current) {

        $groupid   = isset($current->groupid) ? $current->groupid : 0;

        $userid    = isset($current->userid) ? $current->userid : 0;

        $duedate = isset($current->duedate) ? $current->duedate : $assigninstance->duedate;

        $timelimit = isset($current->timelimit) ? $current->timelimit : 0;

        // Only add 'due' events for an override if they differ from the assign default.

        $addclose = empty($current->id) || !empty($current->duedate);

        $event = new stdClass();

        $event->type = CALENDAR_EVENT_TYPE_ACTION;

        $event->description = format_module_intro('assign', $assigninstance, $cmid, false);

        $event->format = FORMAT_HTML;

        // Events module won't show user events when the courseid is nonzero.

        $event->courseid    = ($userid) ? 0 : $assigninstance->course;

        $event->groupid     = $groupid;

        $event->userid      = $userid;

        $event->modulename  = 'assign';

        $event->instance    = $assigninstance->id;

        $event->timestart   = $duedate;

        $event->timeduration = $timelimit;

        $event->timesort    = $event->timestart + $event->timeduration;

        $event->visible     = instance_is_visible('assign', $assigninstance);

        $event->eventtype   = ASSIGN_EVENT_TYPE_DUE;

        $event->priority    = null;

        // Determine the event name and priority.

        if ($groupid) {

            // Group override event.

            $params = new stdClass();

            $params->assign = $assigninstance->name;

            $params->group = groups_get_group_name($groupid);

            if ($params->group === false) {

                // Group doesn't exist, just skip it.

                continue;

            }

            $eventname = get_string('overridegroupeventname', 'assign', $params);

            // Set group override priority.

            if (isset($current->sortorder)) {

                $event->priority = $current->sortorder;

            }

        } else if ($userid) {

            // User override event.

            $params = new stdClass();

            $params->assign = $assigninstance->name;

            $eventname = get_string('overrideusereventname', 'assign', $params);

            // Set user override priority.

            $event->priority = CALENDAR_EVENT_USER_OVERRIDE_PRIORITY;

        } else {

            // The parent event.

            $eventname = $assigninstance->name;

        }

        if ($duedate && $addclose) {

            if ($oldevent = array_shift($oldevents)) {

                $event->id = $oldevent->id;

            } else {

                unset($event->id);

            }

            $event->name      = $eventname.' ('.get_string('duedate', 'assign').')';

            calendar_event::create($event, false);

        }

    }

    // Delete any leftover events.

    foreach ($oldevents as $badevent) {

        $badevent = calendar_event::load($badevent);

        $badevent->delete();

    }

}

/**

 * Return the list if Moodle features this module supports

 *

 * @param string $feature FEATURE_xx constant for requested feature

 * @return mixed True if module supports feature, false if not, null if doesn't know or string for the module purpose.

 */

function assign_supports($feature) {

    switch($feature) {

        case FEATURE_GROUPS:

            return true;

        case FEATURE_GROUPINGS:

            return true;

        case FEATURE_MOD_INTRO:

            return true;

        case FEATURE_COMPLETION_TRACKS_VIEWS:

            return true;

        case FEATURE_COMPLETION_HAS_RULES:

            return true;

        case FEATURE_GRADE_HAS_GRADE:

            return true;

        case FEATURE_GRADE_OUTCOMES:

            return true;

        case FEATURE_BACKUP_MOODLE2:

            return true;

        case FEATURE_SHOW_DESCRIPTION:

            return true;

        case FEATURE_ADVANCED_GRADING:

            return true;

        case FEATURE_PLAGIARISM:

            return true;

        case FEATURE_COMMENT:

            return true;

        case FEATURE_MOD_PURPOSE:

            return MOD_PURPOSE_ASSESSMENT;

        default:

            return null;

    }

}

/**

 * extend an assigment navigation settings

 *

 * @param settings_navigation $settings

 * @param navigation_node $navref

 * @return void

 */

function assign_extend_settings_navigation(settings_navigation $settings, navigation_node $navref) {

    global $DB;

    // We want to add these new nodes after the Edit settings node, and before the

    // Locally assigned roles node. Of course, both of those are controlled by capabilities.

    $keys = $navref->get_children_key_list();

    $beforekey = null;

    $i = array_search('modedit', $keys);

    if ($i === false and array_key_exists(0, $keys)) {

        $beforekey = $keys[0];

    } else if (array_key_exists($i + 1, $keys)) {

        $beforekey = $keys[$i + 1];

    }

    $cm = $settings->get_page()->cm;

    if (!$cm) {

        return;

    }

    $context = $cm->context;

    $course = $settings->get_page()->course;

    if (!$course) {

        return;

    }

    if (has_capability('mod/assign:manageoverrides', $settings->get_page()->cm->context)) {

        $url = new moodle_url('/mod/assign/overrides.php', ['cmid' => $settings->get_page()->cm->id, 'mode' => 'user']);

        $node = navigation_node::create(get_string('overrides', 'assign'),

            $url,

            navigation_node::TYPE_SETTING, null, 'mod_assign_useroverrides');

        $navref->add_node($node, $beforekey);

    }

    if (has_capability('mod/assign:revealidentities', $context)) {

        $dbparams = array('id'=>$cm->instance);

        $assignment = $DB->get_record('assign', $dbparams, 'blindmarking, revealidentities');

        if ($assignment && $assignment->blindmarking && !$assignment->revealidentities) {

            $urlparams = array('id' => $cm->id, 'action'=>'revealidentities');

            $url = new moodle_url('/mod/assign/view.php', $urlparams);

            $linkname = get_string('revealidentities', 'assign');

            $node = $navref->add($linkname, $url, navigation_node::TYPE_SETTING);

        }

    }

}

/**

 * Add a get_coursemodule_info function in case any assignment type wants to add 'extra' information

 * for the course (see resource).

 *

 * Given a course_module object, this function returns any "extra" information that may be needed

 * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.

 *

 * @param stdClass $coursemodule The coursemodule object (record).

 * @return cached_cm_info An object on information that the courses

 *                        will know about (most noticeably, an icon).

 */

function assign_get_coursemodule_info($coursemodule) {

    global $DB;

    $dbparams = array('id'=>$coursemodule->instance);

    $fields = 'id, name, alwaysshowdescription, allowsubmissionsfromdate, intro, introformat, completionsubmit,

        duedate, cutoffdate, allowsubmissionsfromdate';

    if (! $assignment = $DB->get_record('assign', $dbparams, $fields)) {

        return false;

    }

    $result = new cached_cm_info();

    $result->name = $assignment->name;

    if ($coursemodule->showdescription) {

        if ($assignment->alwaysshowdescription || time() > $assignment->allowsubmissionsfromdate) {

            // Convert intro to html. Do not filter cached version, filters run at display time.

            $result->content = format_module_intro('assign', $assignment, $coursemodule->id, false);

        }

    }

    // Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.

    if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {

        $result->customdata['customcompletionrules']['completionsubmit'] = $assignment->completionsubmit;

    }

    // Populate some other values that can be used in calendar or on dashboard.

    if ($assignment->duedate) {

        $result->customdata['duedate'] = $assignment->duedate;

    }

    if ($assignment->cutoffdate) {

        $result->customdata['cutoffdate'] = $assignment->cutoffdate;

    }

    if ($assignment->allowsubmissionsfromdate) {

        $result->customdata['allowsubmissionsfromdate'] = $assignment->allowsubmissionsfromdate;

    }

    return $result;

}

/**

 * Sets dynamic information about a course module

 *

 * This function is called from cm_info when displaying the module

 *

 * @param cm_info $cm

 */

function mod_assign_cm_info_dynamic(cm_info $cm) {

    global $USER;

    $cache = cache::make('mod_assign', 'overrides');

    $override = $cache->get("{$cm->instance}_u_{$USER->id}");

    if (!$override) {

        $override = (object) [

            'allowsubmissionsfromdate' => null,

            'duedate' => null,

            'cutoffdate' => null,

        ];

    }

    // No need to look for group overrides if there are user overrides for all allowsubmissionsfromdate, duedate and cutoffdate.

    if (is_null($override->allowsubmissionsfromdate) || is_null($override->duedate) || is_null($override->cutoffdate)) {

        $selectedgroupoverride = (object) [

            'allowsubmissionsfromdate' => null,

            'duedate' => null,

            'cutoffdate' => null,

            'sortorder' => PHP_INT_MAX, // So that every sortorder read from DB is less than this.

        ];

        $groupings = groups_get_user_groups($cm->course, $USER->id);

        foreach ($groupings[0] as $groupid) {

            $groupoverride = $cache->get("{$cm->instance}_g_{$groupid}");

            if ($groupoverride) {

                if ($groupoverride->sortorder < $selectedgroupoverride->sortorder) {

                    $selectedgroupoverride = $groupoverride;

                }

            }

        }

        // If there is a user override for a setting, ignore the group override.

        if (is_null($override->allowsubmissionsfromdate)) {

            $override->allowsubmissionsfromdate = $selectedgroupoverride->allowsubmissionsfromdate;

        }

        if (is_null($override->duedate)) {

            $override->duedate = $selectedgroupoverride->duedate;

        }

        if (is_null($override->cutoffdate)) {

            $override->cutoffdate = $selectedgroupoverride->cutoffdate;

        }

    }

    // Calculate relative dates. The assignment module calculates relative date only for duedate.

    // A user or group override always has higher priority over any relative date calculation.

    if (empty($override->duedate) && !empty($cm->customdata['duedate'])) {

        $course = get_course($cm->course);

        $usercoursedates = course_get_course_dates_for_user_id($course, $USER->id);

        if ($usercoursedates['start']) {

            $override->duedate = $cm->customdata['duedate'] + $usercoursedates['startoffset'];

        }

    }

    // Populate some other values that can be used in calendar or on dashboard.

    if (!is_null($override->allowsubmissionsfromdate)) {

        $cm->override_customdata('allowsubmissionsfromdate', $override->allowsubmissionsfromdate);

    }

    if (!is_null($override->duedate)) {

        $cm->override_customdata('duedate', $override->duedate);

    }

    if (!is_null($override->cutoffdate)) {

        $cm->override_customdata('cutoffdate', $override->cutoffdate);

    }

}

/**

 * Callback which returns human-readable strings describing the active completion custom rules for the module instance.

 *

 * @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']

 * @return array $descriptions the array of descriptions for the custom rules.

 */

function mod_assign_get_completion_active_rule_descriptions($cm) {

    // Values will be present in cm_info, and we assume these are up to date.

    if (empty($cm->customdata['customcompletionrules'])

        || $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {

        return [];

    }

    $descriptions = [];

    foreach ($cm->customdata['customcompletionrules'] as $key => $val) {

        switch ($key) {

            case 'completionsubmit':

                if (!empty($val)) {

                    $descriptions[] = get_string('completionsubmit', 'assign');

                }

                break;

            default:

                break;

        }

    }

    return $descriptions;

}

/**

 * Return a list of page types

 * @param string $pagetype current page type

 * @param stdClass $parentcontext Block's parent context

 * @param stdClass $currentcontext Current context of block

 */

function assign_page_type_list($pagetype, $parentcontext, $currentcontext) {

    $modulepagetype = array(

        'mod-assign-*' => get_string('page-mod-assign-x', 'assign'),

        'mod-assign-view' => get_string('page-mod-assign-view', 'assign'),

    );

    return $modulepagetype;

}

/**

 * Print recent activity from all assignments in a given course

 *

 * This is used by the recent activity block

 * @param mixed $course the course to print activity for

 * @param bool $viewfullnames boolean to determine whether to show full names or not

 * @param int $timestart the time the rendering started

 * @return bool true if activity was printed, false otherwise.

 */

function assign_print_recent_activity($course, $viewfullnames, $timestart) {

    global $CFG, $USER, $DB, $OUTPUT;

    require_once($CFG->dirroot . '/mod/assign/locallib.php');

    // Do not use log table if possible, it may be huge.

    $dbparams = array($timestart, $course->id, 'assign', ASSIGN_SUBMISSION_STATUS_SUBMITTED);

    $userfieldsapi = \core_user\fields::for_userpic();

    $namefields = $userfieldsapi->get_sql('u', false, '', 'userid', false)->selects;;

    if (!$submissions = $DB->get_records_sql("SELECT asb.id, asb.timemodified, cm.id AS cmid, um.id as recordid,

                                                     $namefields

                                                FROM {assign_submission} asb

                                                     JOIN {assign} a      ON a.id = asb.assignment

                                                     JOIN {course_modules} cm ON cm.instance = a.id

                                                     JOIN {modules} md        ON md.id = cm.module

                                                     JOIN {user} u            ON u.id = asb.userid

                                                LEFT JOIN {assign_user_mapping} um ON um.userid = u.id AND um.assignment = a.id

                                               WHERE asb.timemodified > ? AND

                                                     asb.latest = 1 AND

                                                     a.course = ? AND

                                                     md.name = ? AND

                                                     asb.status = ?

                                            ORDER BY asb.timemodified ASC", $dbparams)) {

         return false;

    }

    $modinfo = get_fast_modinfo($course);

    $show    = array();

    $grader  = array();

    $showrecentsubmissions = get_config('assign', 'showrecentsubmissions');

    foreach ($submissions as $submission) {

        if (!array_key_exists($submission->cmid, $modinfo->get_cms())) {

            continue;

        }

        $cm = $modinfo->get_cm($submission->cmid);

        if (!$cm->uservisible) {

            continue;

        }

        if ($submission->userid == $USER->id) {

            $show[] = $submission;

            continue;

        }

        $context = context_module::instance($submission->cmid);

        // The act of submitting of assignment may be considered private -

        // only graders will see it if specified.

        if (empty($showrecentsubmissions)) {

            if (!array_key_exists($cm->id, $grader)) {

                $grader[$cm->id] = has_capability('moodle/grade:viewall', $context);

            }

            if (!$grader[$cm->id]) {

                continue;

            }

        }

        $groupmode = groups_get_activity_groupmode($cm, $course);

        if ($groupmode == SEPARATEGROUPS &&

                !has_capability('moodle/site:accessallgroups',  $context)) {

            if (isguestuser()) {

                // Shortcut - guest user does not belong into any group.

                continue;

            }

            // This will be slow - show only users that share group with me in this cm.

            if (!$modinfo->get_groups($cm->groupingid)) {

                continue;

            }

            $usersgroups =  groups_get_all_groups($course->id, $submission->userid, $cm->groupingid);

            if (is_array($usersgroups)) {

                $usersgroups = array_keys($usersgroups);

                $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));

                if (empty($intersect)) {

                    continue;

                }

            }

        }

        $show[] = $submission;

    }

    if (empty($show)) {

        return false;

    }

    echo $OUTPUT->heading(get_string('newsubmissions', 'assign') . ':', 6);

    foreach ($show as $submission) {

        $cm = $modinfo->get_cm($submission->cmid);

        $context = context_module::instance($submission->cmid);

        $assign = new assign($context, $cm, $cm->course);

        $link = $CFG->wwwroot.'/mod/assign/view.php?id='.$cm->id;

        // Obscure first and last name if blind marking enabled.

        if ($assign->is_blind_marking()) {

            $submission->firstname = get_string('participant', 'mod_assign');

            if (empty($submission->recordid)) {

                $submission->recordid = $assign->get_uniqueid_for_user($submission->userid);

            }

            $submission->lastname = $submission->recordid;

        }

        print_recent_activity_note($submission->timemodified,

                                   $submission,

                                   $cm->name,

                                   $link,

                                   false,

                                   $viewfullnames);

    }

    return true;

}

/**

 * Returns all assignments since a given time.

 *

 * @param array $activities The activity information is returned in this array

 * @param int $index The current index in the activities array

 * @param int $timestart The earliest activity to show

 * @param int $courseid Limit the search to this course

 * @param int $cmid The course module id

 * @param int $userid Optional user id

 * @param int $groupid Optional group id

 * @return void

 */

function assign_get_recent_mod_activity(&$activities,

                                        &$index,

                                        $timestart,

                                        $courseid,

                                        $cmid,

                                        $userid=0,

                                        $groupid=0) {

    global $CFG, $COURSE, $USER, $DB;

    require_once($CFG->dirroot . '/mod/assign/locallib.php');

    if ($COURSE->id == $courseid) {

        $course = $COURSE;

    } else {

        $course = $DB->get_record('course', array('id'=>$courseid));

    }

    $modinfo = get_fast_modinfo($course);

    $cm = $modinfo->get_cm($cmid);

    $params = array();

    if ($userid) {

        $userselect = 'AND u.id = :userid';

        $params['userid'] = $userid;

    } else {

        $userselect = '';

    }

    if ($groupid) {

        $groupselect = 'AND gm.groupid = :groupid';

        $groupjoin   = 'JOIN {groups_members} gm ON  gm.userid=u.id';

        $params['groupid'] = $groupid;

    } else {

        $groupselect = '';

        $groupjoin   = '';

    }

    $params['cminstance'] = $cm->instance;

    $params['timestart'] = $timestart;

    $params['submitted'] = ASSIGN_SUBMISSION_STATUS_SUBMITTED;

    $userfieldsapi = \core_user\fields::for_userpic();

    $userfields = $userfieldsapi->get_sql('u', false, '', 'userid', false)->selects;

    if (!$submissions = $DB->get_records_sql('SELECT asb.id, asb.timemodified, ' .

                                                     $userfields .

                                             '  FROM {assign_submission} asb

                                                JOIN {assign} a ON a.id = asb.assignment

                                                JOIN {user} u ON u.id = asb.userid ' .

                                          $groupjoin .

                                            '  WHERE asb.timemodified > :timestart AND

                                                     asb.status = :submitted AND

                                                     a.id = :cminstance

                                                     ' . $userselect . ' ' . $groupselect .

                                            ' ORDER BY asb.timemodified ASC', $params)) {

         return;

    }

    $groupmode       = groups_get_activity_groupmode($cm, $course);

    $cmcontext      = context_module::instance($cm->id);

    $grader          = has_capability('moodle/grade:viewall', $cmcontext);

    $accessallgroups = has_capability('moodle/site:accessallgroups', $cmcontext);

    $viewfullnames   = has_capability('moodle/site:viewfullnames', $cmcontext);

    $showrecentsubmissions = get_config('assign', 'showrecentsubmissions');

    $show = array();

    foreach ($submissions as $submission) {

        if ($submission->userid == $USER->id) {

            $show[] = $submission;

            continue;

        }

        // The act of submitting of assignment may be considered private -

        // only graders will see it if specified.

        if (empty($showrecentsubmissions)) {

            if (!$grader) {

                continue;

            }

        }

        if ($groupmode == SEPARATEGROUPS and !$accessallgroups) {

            if (isguestuser()) {

                // Shortcut - guest user does not belong into any group.

                continue;

            }

            // This will be slow - show only users that share group with me in this cm.

            if (!$modinfo->get_groups($cm->groupingid)) {

                continue;

            }

            $usersgroups =  groups_get_all_groups($course->id, $submission->userid, $cm->groupingid);

            if (is_array($usersgroups)) {

                $usersgroups = array_keys($usersgroups);

                $intersect = array_intersect($usersgroups, $modinfo->get_groups($cm->groupingid));

                if (empty($intersect)) {

                    continue;

                }

            }

        }

        $show[] = $submission;

    }

    if (empty($show)) {

        return;

    }

    if ($grader) {

        require_once($CFG->libdir.'/gradelib.php');

        $userids = array();

        foreach ($show as $id => $submission) {

            $userids[] = $submission->userid;

        }

        $grades = grade_get_grades($courseid, 'mod', 'assign', $cm->instance, $userids);

    }

    $aname = format_string($cm->name, true);

    foreach ($show as $submission) {

        $activity = new stdClass();

        $activity->type         = 'assign';

        $activity->cmid         = $cm->id;

        $activity->name         = $aname;

        $activity->sectionnum   = $cm->sectionnum;

        $activity->timestamp    = $submission->timemodified;

        $activity->user         = new stdClass();

        if ($grader) {

            $activity->grade = $grades->items[0]->grades[$submission->userid]->str_long_grade;

        }

        $userfields = explode(',', implode(',', \core_user\fields::get_picture_fields()));

        foreach ($userfields as $userfield) {

            if ($userfield == 'id') {

                // Aliased in SQL above.

                $activity->user->{$userfield} = $submission->userid;

            } else {

                $activity->user->{$userfield} = $submission->{$userfield};

            }

        }

        $activity->user->fullname = fullname($submission, $viewfullnames);

        $activities[$index++] = $activity;

    }

    return;

}

/**

 * Print recent activity from all assignments in a given course

 *

 * This is used by course/recent.php

 * @param stdClass $activity

 * @param int $courseid

 * @param bool $detail

 * @param array $modnames

 */

function assign_print_recent_mod_activity($activity, $courseid, $detail, $modnames) {

    global $CFG, $OUTPUT;

    echo '<table border="0" cellpadding="3" cellspacing="0" class="assignment-recent">';

    echo '<tr><td class="userpicture" valign="top">';

    echo $OUTPUT->user_picture($activity->user);

    echo '</td><td>';

    if ($detail) {

        $modname = $modnames[$activity->type];

        echo '<div class="title">';

        echo $OUTPUT->image_icon('monologo', $modname, 'assign');

        echo '<a href="' . $CFG->wwwroot . '/mod/assign/view.php?id=' . $activity->cmid . '">';

        echo $activity->name;

        echo '</a>';

        echo '</div>';

    }

    if (isset($activity->grade)) {

        echo '<div class="grade">';

        echo get_string('gradenoun') . ': ';

        echo $activity->grade;

        echo '</div>';

    }

    echo '<div class="user">';

    echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">";

    echo "{$activity->user->fullname}</a>  - " . userdate($activity->timestamp);

    echo '</div>';

    echo '</td></tr></table>';

}

/**

 * Checks if scale is being used by any instance of assignment

 *

 * This is used to find out if scale used anywhere

 * @param int $scaleid

 * @return boolean True if the scale is used by any assignment

 */

function assign_scale_used_anywhere($scaleid) {

    global $DB;

    if ($scaleid and $DB->record_exists('assign', array('grade'=>-$scaleid))) {

        return true;

    } else {

        return false;

    }

}

/**

 * List the actions that correspond to a view of this module.

 * This is used by the participation report.

 *

 * Note: This is not used by new logging system. Event with

 *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will

 *       be considered as view action.

 *

 * @return array

 */

function assign_get_view_actions() {

    return array('view submission', 'view feedback');

}

/**

 * List the actions that correspond to a post of this module.

 * This is used by the participation report.

 *

 * Note: This is not used by new logging system. Event with

 *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING

 *       will be considered as post action.

 *

 * @return array

 */

function assign_get_post_actions() {

    return array('upload', 'submit', 'submit for grading');

}

/**

 * Returns all other capabilities used by this module.

 * @return array Array of capability strings

 */

function assign_get_extra_capabilities() {

    return ['gradereport/grader:view', 'moodle/grade:viewall'];

}

/**

 * Create grade item for given assignment.

 *

 * @param stdClass $assign record with extra cmidnumber

 * @param array $grades optional array/object of grade(s); 'reset' means reset grades in gradebook

 * @return int 0 if ok, error code otherwise