PHP groups_course_module_visible函数代码示例

/**
 * Generates the HTML for a miniature calendar
 *
 * @param array $courses list of course to list events from
 * @param array $groups list of group
 * @param array $users user's info
 * @param int|bool $calmonth calendar month in numeric, default is set to false
 * @param int|bool $calyear calendar month in numeric, default is set to false
 * @param string|bool $placement the place/page the calendar is set to appear - passed on the the controls function
 * @param int|bool $courseid id of the course the calendar is displayed on - passed on the the controls function
 * @param int $time the unixtimestamp representing the date we want to view, this is used instead of $calmonth
 *     and $calyear to support multiple calendars
 * @return string $content return html table for mini calendar
 */
function calendar_get_mini($courses, $groups, $users, $calmonth = false, $calyear = false, $placement = false, $courseid = false, $time = 0)
{
    global $CFG, $OUTPUT;
    // Get the calendar type we are using.
    $calendartype = \core_calendar\type_factory::get_calendar_instance();
    $display = new stdClass();
    // Assume we are not displaying this month for now.
    $display->thismonth = false;
    $content = '';
    // Do this check for backwards compatibility. The core should be passing a timestamp rather than month and year.
    // If a month and year are passed they will be in Gregorian.
    if (!empty($calmonth) && !empty($calyear)) {
        // Ensure it is a valid date, else we will just set it to the current timestamp.
        if (checkdate($calmonth, 1, $calyear)) {
            $time = make_timestamp($calyear, $calmonth, 1);
        } else {
            $time = time();
        }
        $date = usergetdate($time);
        if ($calmonth == $date['mon'] && $calyear == $date['year']) {
            $display->thismonth = true;
        }
        // We can overwrite date now with the date used by the calendar type, if it is not Gregorian, otherwise
        // there is no need as it is already in Gregorian.
        if ($calendartype->get_name() != 'gregorian') {
            $date = $calendartype->timestamp_to_date_array($time);
        }
    } else {
        if (!empty($time)) {
            // Get the specified date in the calendar type being used.
            $date = $calendartype->timestamp_to_date_array($time);
            $thisdate = $calendartype->timestamp_to_date_array(time());
            if ($date['month'] == $thisdate['month'] && $date['year'] == $thisdate['year']) {
                $display->thismonth = true;
                // If we are the current month we want to set the date to the current date, not the start of the month.
                $date = $thisdate;
            }
        } else {
            // Get the current date in the calendar type being used.
            $time = time();
            $date = $calendartype->timestamp_to_date_array($time);
            $display->thismonth = true;
        }
    }
    list($d, $m, $y) = array($date['mday'], $date['mon'], $date['year']);
    // This is what we want to display.
    // Get Gregorian date for the start of the month.
    $gregoriandate = $calendartype->convert_to_gregorian($date['year'], $date['mon'], 1);
    // Store the gregorian date values to be used later.
    list($gy, $gm, $gd, $gh, $gmin) = array($gregoriandate['year'], $gregoriandate['month'], $gregoriandate['day'], $gregoriandate['hour'], $gregoriandate['minute']);
    // Get the max number of days in this month for this calendar type.
    $display->maxdays = calendar_days_in_month($m, $y);
    // Get the starting week day for this month.
    $startwday = dayofweek(1, $m, $y);
    // Get the days in a week.
    $daynames = calendar_get_days();
    // Store the number of days in a week.
    $numberofdaysinweek = $calendartype->get_num_weekdays();
    // Set the min and max weekday.
    $display->minwday = calendar_get_starting_weekday();
    $display->maxwday = $display->minwday + ($numberofdaysinweek - 1);
    // These are used for DB queries, so we want unixtime, so we need to use Gregorian dates.
    $display->tstart = make_timestamp($gy, $gm, $gd, $gh, $gmin, 0);
    $display->tend = $display->tstart + $display->maxdays * DAYSECS - 1;
    // Align the starting weekday to fall in our display range
    // This is simple, not foolproof.
    if ($startwday < $display->minwday) {
        $startwday += $numberofdaysinweek;
    }
    // Get the events matching our criteria. Don't forget to offset the timestamps for the user's TZ!
    $events = calendar_get_events($display->tstart, $display->tend, $users, $groups, $courses);
    // Set event course class for course events
    if (!empty($events)) {
        foreach ($events as $eventid => $event) {
            if (!empty($event->modulename)) {
                $cm = get_coursemodule_from_instance($event->modulename, $event->instance);
                if (!groups_course_module_visible($cm)) {
                    unset($events[$eventid]);
                }
            }
        }
    }
    // This is either a genius idea or an idiot idea: in order to not complicate things, we use this rule: if, after
    // possibly removing SITEID from $courses, there is only one course left, then clicking on a day in the month
    // will also set the $SESSION->cal_courses_shown variable to that one course. Otherwise, we 'd need to add extra
    // arguments to this function.
//.........这里部分代码省略.........

function calendar_show_month_detailed($m, $y, $courses, $groups, $users, $courseid)
{
    global $CFG, $SESSION, $USER, $CALENDARDAYS;
    global $day, $mon, $yr;
    $getvars = 'from=month&cal_d=' . $day . '&cal_m=' . $mon . '&cal_y=' . $yr;
    // For filtering
    $display =& new stdClass();
    $display->minwday = get_user_preferences('calendar_startwday', CALENDAR_STARTING_WEEKDAY);
    $display->maxwday = $display->minwday + 6;
    if (!empty($m) && !empty($y)) {
        $thisdate = usergetdate(time());
        // Time and day at the user's location
        if ($m == $thisdate['mon'] && $y == $thisdate['year']) {
            // Navigated to this month
            $date = $thisdate;
            $display->thismonth = true;
        } else {
            // Navigated to other month, let's do a nice trick and save us a lot of work...
            if (!checkdate($m, 1, $y)) {
                $date = array('mday' => 1, 'mon' => $thisdate['mon'], 'year' => $thisdate['year']);
                $display->thismonth = true;
            } else {
                $date = array('mday' => 1, 'mon' => $m, 'year' => $y);
                $display->thismonth = false;
            }
        }
    } else {
        $date = usergetdate(time());
        $display->thismonth = true;
    }
    // Fill in the variables we 're going to use, nice and tidy
    list($d, $m, $y) = array($date['mday'], $date['mon'], $date['year']);
    // This is what we want to display
    $display->maxdays = calendar_days_in_month($m, $y);
    $startwday = 0;
    if (get_user_timezone_offset() < 99) {
        // We 'll keep these values as GMT here, and offset them when the time comes to query the db
        $display->tstart = gmmktime(0, 0, 0, $m, 1, $y);
        // This is GMT
        $display->tend = gmmktime(23, 59, 59, $m, $display->maxdays, $y);
        // GMT
        $startwday = gmdate('w', $display->tstart);
        // $display->tstart is already GMT, so don't use date(): messes with server's TZ
    } else {
        // no timezone info specified
        $display->tstart = mktime(0, 0, 0, $m, 1, $y);
        $display->tend = mktime(23, 59, 59, $m, $display->maxdays, $y);
        $startwday = date('w', $display->tstart);
        // $display->tstart not necessarily GMT, so use date()
    }
    // Align the starting weekday to fall in our display range
    if ($startwday < $display->minwday) {
        $startwday += 7;
    }
    // Get events from database
    $events = calendar_get_events(usertime($display->tstart), usertime($display->tend), $users, $groups, $courses);
    if (!empty($events)) {
        foreach ($events as $eventid => $event) {
            if (!empty($event->modulename)) {
                $cm = get_coursemodule_from_instance($event->modulename, $event->instance);
                if (!groups_course_module_visible($cm)) {
                    unset($events[$eventid]);
                }
            }
        }
    }
    // Extract information: events vs. time
    calendar_events_by_day($events, $m, $y, $eventsbyday, $durationbyday, $typesbyday, $courses);
    $text = '';
    if (!isguest() && !empty($USER->id) && calendar_user_can_add_event()) {
        $text .= '<div class="buttons"><form action="' . CALENDAR_URL . 'event.php" method="get">';
        $text .= '<div>';
        $text .= '<input type="hidden" name="action" value="new" />';
        $text .= '<input type="hidden" name="course" value="' . $courseid . '" />';
        $text .= '<input type="hidden" name="cal_m" value="' . $m . '" />';
        $text .= '<input type="hidden" name="cal_y" value="' . $y . '" />';
        $text .= '<input type="submit" value="' . get_string('newevent', 'calendar') . '" />';
        $text .= '</div></form></div>';
    }
    $text .= '<label for="cal_course_flt_jump">' . get_string('detailedmonthview', 'calendar') . ':</label>' . calendar_course_filter_selector($getvars);
    echo '<div class="header">' . $text . '</div>';
    echo '<div class="controls">';
    echo calendar_top_controls('month', array('id' => $courseid, 'm' => $m, 'y' => $y));
    echo '</div>';
    // Start calendar display
    echo '<table class="calendarmonth"><tr class="weekdays">';
    // Begin table. First row: day names
    // Print out the names of the weekdays
    for ($i = $display->minwday; $i <= $display->maxwday; ++$i) {
        // This uses the % operator to get the correct weekday no matter what shift we have
        // applied to the $display->minwday : $display->maxwday range from the default 0 : 6
        echo '<th scope="col">' . get_string($CALENDARDAYS[$i % 7], 'calendar') . '</th>';
    }
    echo '</tr><tr>';
    // End of day names; prepare for day numbers
    // For the table display. $week is the row; $dayweek is the column.
    $week = 1;
    $dayweek = $startwday;
    // Paddding (the first week may have blank days in the beginning)
    for ($i = $display->minwday; $i < $startwday; ++$i) {
//.........这里部分代码省略.........

/**
 * Filters events that a user cannot see due to grouping constraints
 *
 * @param array  $events The possible events that can occur for modules
 * @param array  $userid The user's id
 * @param string $coursecontext the context value of the course
 * @param string $course the course for filtering visibility
 * @return array The array with restricted events removed
 */
function block_progress_filter_visibility($events, $userid, $coursecontext, $course = 0)
{
    global $CFG, $USER;
    $filteredevents = array();
    // Check if the events are empty or none are selected.
    if ($events === 0) {
        return 0;
    }
    if ($events === null) {
        return null;
    }
    // Keep only events that are visible.
    foreach ($events as $key => $event) {
        // Determine the correct user info to check.
        if ($userid == $USER->id) {
            $coursemodule = $event['cm'];
        } else {
            $coursemodule = block_progress_get_coursemodule($event['type'], $event['id'], $course->id, $userid);
        }
        // Check visibility in course.
        if (!$coursemodule->visible && !has_capability('moodle/course:viewhiddenactivities', $coursecontext, $userid)) {
            continue;
        }
        // Check availability, allowing for visible, but not accessible items.
        if (!empty($CFG->enableavailability)) {
            if (isset($coursemodule->available) && !$coursemodule->available && empty($coursemodule->availableinfo) && !has_capability('moodle/course:viewhiddenactivities', $coursecontext, $userid)) {
                continue;
            }
        }
        // Check visibility by grouping constraints (includes capability check).
        if (!empty($CFG->enablegroupmembersonly)) {
            if (isset($coursemodule->uservisible)) {
                if ($coursemodule->uservisible != 1 && empty($coursemodule->availableinfo)) {
                    continue;
                }
            } else {
                if (!groups_course_module_visible($coursemodule, $userid)) {
                    continue;
                }
            }
        }
        // Save the visible event.
        $filteredevents[] = $event;
    }
    return $filteredevents;
}

function get_all_mods($courseid, &$mods, &$modnames, &$modnamesplural, &$modnamesused)
{
    // Returns a number of useful structures for course displays
    $mods = array();
    // course modules indexed by id
    $modnames = array();
    // all course module names (except resource!)
    $modnamesplural = array();
    // all course module names (plural form)
    $modnamesused = array();
    // course module names used
    if ($allmods = get_records("modules")) {
        foreach ($allmods as $mod) {
            if ($mod->visible) {
                $modnames[$mod->name] = get_string("modulename", "{$mod->name}");
                $modnamesplural[$mod->name] = get_string("modulenameplural", "{$mod->name}");
            }
        }
        asort($modnames, SORT_LOCALE_STRING);
    } else {
        error("No modules are installed!");
    }
    if ($rawmods = get_course_mods($courseid)) {
        foreach ($rawmods as $mod) {
            // Index the mods
            if (empty($modnames[$mod->modname])) {
                continue;
            }
            $mods[$mod->id] = $mod;
            $mods[$mod->id]->modfullname = $modnames[$mod->modname];
            if (!$mod->visible and !has_capability('moodle/course:viewhiddenactivities', get_context_instance(CONTEXT_COURSE, $courseid))) {
                continue;
            }
            // Check groupings
            if (!groups_course_module_visible($mod)) {
                continue;
            }
            $modnamesused[$mod->modname] = $modnames[$mod->modname];
        }
        if ($modnamesused) {
            asort($modnamesused, SORT_LOCALE_STRING);
        }
    }
}

function workshop_get_recent_mod_activity(&$activities, &$index, $sincetime, $courseid, $workshop = "0", $user = "", $groupid = "")
{
    // Returns all workshop posts since a given time.  If workshop is specified then
    // this restricts the results
    global $CFG;
    if ($workshop) {
        $workshopselect = " AND cm.id = '{$workshop}'";
    } else {
        $workshopselect = "";
    }
    if ($user) {
        $userselect = " AND u.id = '{$user}'";
    } else {
        $userselect = "";
    }
    $posts = get_records_sql("SELECT s.*, u.firstname, u.lastname,\n            u.picture, cm.instance, w.name, cm.section, cm.groupmode,\n            cm.course, cm.groupingid, cm.groupmembersonly, cm.id as cmid\n            FROM {$CFG->prefix}workshop_submissions s,\n            {$CFG->prefix}user u,\n            {$CFG->prefix}course_modules cm,\n            {$CFG->prefix}workshop w\n            WHERE s.timecreated  > '{$sincetime}' {$workshopselect}\n            AND s.userid = u.id {$userselect}\n            AND w.course = '{$courseid}'\n            AND cm.instance = w.id\n            AND cm.course = w.course\n            AND s.workshopid = w.id\n            ORDER BY s.id");
    if (empty($posts)) {
        return;
    }
    foreach ($posts as $post) {
        if ((empty($groupid) || groups_is_member($groupid, $post->userid)) && groups_course_module_visible($post)) {
            $tmpactivity = new Object();
            $tmpactivity->type = "workshop";
            $tmpactivity->defaultindex = $index;
            $tmpactivity->instance = $post->instance;
            $tmpactivity->name = $post->name;
            $tmpactivity->section = $post->section;
            $tmpactivity->content->id = $post->id;
            $tmpactivity->content->title = $post->title;
            $tmpactivity->user->userid = $post->userid;
            $tmpactivity->user->fullname = fullname($post);
            $tmpactivity->user->picture = $post->picture;
            $tmpactivity->cmid = $post->cmid;
            $tmpactivity->timestamp = $post->timecreated;
            $activities[] = $tmpactivity;
            $index++;
        }
    }
    return;
}

function calendar_get_mini($courses, $groups, $users, $cal_month = false, $cal_year = false)
{
    global $CFG, $USER;
    $display = new stdClass();
    $display->minwday = get_user_preferences('calendar_startwday', CALENDAR_STARTING_WEEKDAY);
    $display->maxwday = $display->minwday + 6;
    $content = '';
    if (!empty($cal_month) && !empty($cal_year)) {
        $thisdate = usergetdate(time());
        // Date and time the user sees at his location
        if ($cal_month == $thisdate['mon'] && $cal_year == $thisdate['year']) {
            // Navigated to this month
            $date = $thisdate;
            $display->thismonth = true;
        } else {
            // Navigated to other month, let's do a nice trick and save us a lot of work...
            if (!checkdate($cal_month, 1, $cal_year)) {
                $date = array('mday' => 1, 'mon' => $thisdate['mon'], 'year' => $thisdate['year']);
                $display->thismonth = true;
            } else {
                $date = array('mday' => 1, 'mon' => $cal_month, 'year' => $cal_year);
                $display->thismonth = false;
            }
        }
    } else {
        $date = usergetdate(time());
        // Date and time the user sees at his location
        $display->thismonth = true;
    }
    // Fill in the variables we 're going to use, nice and tidy
    list($d, $m, $y) = array($date['mday'], $date['mon'], $date['year']);
    // This is what we want to display
    $display->maxdays = calendar_days_in_month($m, $y);
    if (get_user_timezone_offset() < 99) {
        // We 'll keep these values as GMT here, and offset them when the time comes to query the db
        $display->tstart = gmmktime(0, 0, 0, $m, 1, $y);
        // This is GMT
        $display->tend = gmmktime(23, 59, 59, $m, $display->maxdays, $y);
        // GMT
    } else {
        // no timezone info specified
        $display->tstart = mktime(0, 0, 0, $m, 1, $y);
        $display->tend = mktime(23, 59, 59, $m, $display->maxdays, $y);
    }
    $startwday = dayofweek(1, $m, $y);
    // Align the starting weekday to fall in our display range
    // This is simple, not foolproof.
    if ($startwday < $display->minwday) {
        $startwday += 7;
    }
    // TODO: THIS IS TEMPORARY CODE!
    // [pj] I was just reading through this and realized that I when writing this code I was probably
    // asking for trouble, as all these time manipulations seem to be unnecessary and a simple
    // make_timestamp would accomplish the same thing. So here goes a test:
    //$test_start = make_timestamp($y, $m, 1);
    //$test_end   = make_timestamp($y, $m, $display->maxdays, 23, 59, 59);
    //if($test_start != usertime($display->tstart) - dst_offset_on($display->tstart)) {
    //notify('Failed assertion in calendar/lib.php line 126; display->tstart = '.$display->tstart.', dst_offset = '.dst_offset_on($display->tstart).', usertime = '.usertime($display->tstart).', make_t = '.$test_start);
    //}
    //if($test_end != usertime($display->tend) - dst_offset_on($display->tend)) {
    //notify('Failed assertion in calendar/lib.php line 130; display->tend = '.$display->tend.', dst_offset = '.dst_offset_on($display->tend).', usertime = '.usertime($display->tend).', make_t = '.$test_end);
    //}
    // Get the events matching our criteria. Don't forget to offset the timestamps for the user's TZ!
    $events = calendar_get_events(usertime($display->tstart) - dst_offset_on($display->tstart), usertime($display->tend) - dst_offset_on($display->tend), $users, $groups, $courses);
    // Set event course class for course events
    if (!empty($events)) {
        foreach ($events as $eventid => $event) {
            if (!empty($event->modulename)) {
                $cm = get_coursemodule_from_instance($event->modulename, $event->instance);
                if (!groups_course_module_visible($cm)) {
                    unset($events[$eventid]);
                }
            }
        }
    }
    // This is either a genius idea or an idiot idea: in order to not complicate things, we use this rule: if, after
    // possibly removing SITEID from $courses, there is only one course left, then clicking on a day in the month
    // will also set the $SESSION->cal_courses_shown variable to that one course. Otherwise, we 'd need to add extra
    // arguments to this function.
    $morehref = '';
    if (!empty($courses)) {
        $courses = array_diff($courses, array(SITEID));
        if (count($courses) == 1) {
            $morehref = '&amp;course=' . reset($courses);
        }
    }
    // We want to have easy access by day, since the display is on a per-day basis.
    // Arguments passed by reference.
    //calendar_events_by_day($events, $display->tstart, $eventsbyday, $durationbyday, $typesbyday);
    calendar_events_by_day($events, $m, $y, $eventsbyday, $durationbyday, $typesbyday, $courses);
    //Accessibility: added summary and <abbr> elements.
    ///global $CALENDARDAYS; appears to be broken.
    $days_title = array('sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday');
    $summary = get_string('calendarheading', 'calendar', userdate(make_timestamp($y, $m), get_string('strftimemonthyear')));
    $summary = get_string('tabledata', 'access', $summary);
    $content .= '<table class="minicalendar" summary="' . $summary . '">';
    // Begin table
    $content .= '<tr class="weekdays">';
    // Header row: day names
    // Print out the names of the weekdays
//.........这里部分代码省略.........

 /**
  * Get Calendar events
  *
  * @param array $events A list of events
  * @package array $options various options
  * @return array Array of event details
  * @since Moodle 2.5
  */
 public static function get_calendar_events($events = array(), $options = array())
 {
     global $SITE, $DB, $USER, $CFG;
     require_once $CFG->dirroot . "/calendar/lib.php";
     // Parameter validation.
     $params = self::validate_parameters(self::get_calendar_events_parameters(), array('events' => $events, 'options' => $options));
     $funcparam = array('courses' => array(), 'groups' => array());
     $hassystemcap = has_capability('moodle/calendar:manageentries', context_system::instance());
     $warnings = array();
     // Let us findout courses that we can return events from.
     if (!$hassystemcap) {
         foreach ($params['events']['courseids'] as $id) {
             try {
                 $context = context_course::instance($id);
                 self::validate_context($context);
                 $funcparam['courses'][] = $id;
             } catch (Exception $e) {
                 $warnings[] = array('item' => 'course', 'itemid' => $id, 'warningcode' => 'nopermissions', 'message' => 'No access rights in course context ' . $e->getMessage() . $e->getTraceAsString());
                 continue;
             }
         }
     } else {
         $courses = $params['events']['courseids'];
         $funcparam['courses'] = $courses;
     }
     // Let us findout groups that we can return events from.
     if (!$hassystemcap) {
         $groups = groups_get_my_groups();
         $groups = array_keys($groups);
         foreach ($params['events']['groupids'] as $id) {
             if (in_array($id, $groups)) {
                 $funcparam['groups'][] = $id;
             } else {
                 $warnings[] = array('item' => $id, 'warningcode' => 'nopermissions', 'message' => 'you do not have permissions to access this group');
             }
         }
     } else {
         $groups = $params['events']['groupids'];
         $funcparam['groups'] = $groups;
     }
     // Do we need user events?
     if (!empty($params['options']['userevents'])) {
         $funcparam['users'] = array($USER->id);
     } else {
         $funcparam['users'] = false;
     }
     // Do we need site events?
     if (!empty($params['options']['siteevents'])) {
         $funcparam['courses'][] = $SITE->id;
     }
     $eventlist = calendar_get_events($params['options']['timestart'], $params['options']['timeend'], $funcparam['users'], $funcparam['groups'], $funcparam['courses'], true, $params['options']['ignorehidden']);
     // WS expects arrays.
     $events = array();
     foreach ($eventlist as $id => $event) {
         $events[$id] = (array) $event;
     }
     // We need to get events asked for eventids.
     $eventsbyid = calendar_get_events_by_id($params['events']['eventids']);
     foreach ($eventsbyid as $eventid => $eventobj) {
         $event = (array) $eventobj;
         if (isset($events[$eventid])) {
             continue;
         }
         if ($hassystemcap) {
             // User can see everything, no further check is needed.
             $events[$eventid] = $event;
         } else {
             if (!empty($eventobj->modulename)) {
                 $cm = get_coursemodule_from_instance($eventobj->modulename, $eventobj->instance);
                 if (groups_course_module_visible($cm)) {
                     $events[$eventid] = $event;
                 }
             } else {
                 // Can the user actually see this event?
                 $eventobj = calendar_event::load($eventobj);
                 if ($eventobj->courseid == $SITE->id || !empty($eventobj->groupid) && in_array($eventobj->groupid, $groups) || !empty($eventobj->courseid) && in_array($eventobj->courseid, $courses) || $USER->id == $eventobj->userid || calendar_edit_event_allowed($eventid)) {
                     $events[$eventid] = $event;
                 } else {
                     $warnings[] = array('item' => $eventid, 'warningcode' => 'nopermissions', 'message' => 'you do not have permissions to view this event');
                 }
             }
         }
     }
     return array('events' => $events, 'warnings' => $warnings);
 }

function get_sessions($display, $groups, $users, $courses, $activefilters, &$events, &$sessionids) {
    global $cfgcalendarfilters;

    // Get events from database.
    $events = calendar_get_events(usertime($display->tstart), usertime($display->tend), $users, $groups, $courses);
    if (!empty($events)) {
        // Check if any filters has been selected.
        if ($cfgcalendarfilters) {
            $defaultfieldsessionids = get_matches_defaultfields($events);
            foreach ($defaultfieldsessionids as $defaultfield) {
                $sessiondata['sessionids'][] = $defaultfield->sessionid;
                $sessiondata['timestart'][] = (int)$defaultfield->timestart;
                $sessiondata['timefinish'][] = (int)$defaultfield->timefinish;
            }
        }
        foreach ($events as $eventid => $event) {
            if (empty($event->modulename)) {
                continue; // Nothing to check.
            }

            // Check that facetoface events match all filters.
            $sessionid = (int)$event->uuid;
            if ('facetoface' == $event->modulename and $sessionid > 0) {
                $matchesallfilters = true;

                // Check if there are active filters and they are not empty.
                if ($cfgcalendarfilters && count($activefilters['defaultfields'])) {
                    if (!count($defaultfieldsessionids) || !matches_defaultfield_filters($sessiondata, $event)) {
                        unset($events[$eventid]);
                        continue;
                    }
                }

                foreach ($activefilters['customfields'] as $fieldid => $fieldvalue) {
                    if (!matches_filter($fieldid, $fieldvalue, $sessionid)) {
                        // Different value => no match.
                        $matchesallfilters = false;
                        break;
                    }
                }

                if ($matchesallfilters) {
                    $sessionids[] = $sessionid;
                }
                else {
                    unset($events[$eventid]);
                    continue; // Move to next event.
                }
            }

            // Group checks.
            $cm = get_coursemodule_from_instance($event->modulename, $event->instance);
            if (!groups_course_module_visible($cm)) {
                unset($events[$eventid]);
            }
        }
    }
}

 /**
  * Displays a month in detail
  *
  * @param calendar_information $calendar
  * @param moodle_url $returnurl the url to return to
  * @return string
  */
 public function show_month_detailed(calendar_information $calendar, moodle_url $returnurl = null)
 {
     global $CFG;
     if (empty($returnurl)) {
         $returnurl = $this->page->url;
     }
     // Get the calendar type we are using.
     $calendartype = \core_calendar\type_factory::get_calendar_instance();
     // Store the display settings.
     $display = new stdClass();
     $display->thismonth = false;
     // Get the specified date in the calendar type being used.
     $date = $calendartype->timestamp_to_date_array($calendar->time);
     $thisdate = $calendartype->timestamp_to_date_array(time());
     if ($date['mon'] == $thisdate['mon'] && $date['year'] == $thisdate['year']) {
         $display->thismonth = true;
         $date = $thisdate;
         $calendar->time = time();
     }
     // Get Gregorian date for the start of the month.
     $gregoriandate = $calendartype->convert_to_gregorian($date['year'], $date['mon'], 1);
     // Store the gregorian date values to be used later.
     list($gy, $gm, $gd, $gh, $gmin) = array($gregoriandate['year'], $gregoriandate['month'], $gregoriandate['day'], $gregoriandate['hour'], $gregoriandate['minute']);
     // Get the starting week day for this month.
     $startwday = dayofweek(1, $date['mon'], $date['year']);
     // Get the days in a week.
     $daynames = calendar_get_days();
     // Store the number of days in a week.
     $numberofdaysinweek = $calendartype->get_num_weekdays();
     $display->minwday = calendar_get_starting_weekday();
     $display->maxwday = $display->minwday + ($numberofdaysinweek - 1);
     $display->maxdays = calendar_days_in_month($date['mon'], $date['year']);
     // These are used for DB queries, so we want unixtime, so we need to use Gregorian dates.
     $display->tstart = make_timestamp($gy, $gm, $gd, $gh, $gmin, 0);
     $display->tend = $display->tstart + $display->maxdays * DAYSECS - 1;
     // Align the starting weekday to fall in our display range
     // This is simple, not foolproof.
     if ($startwday < $display->minwday) {
         $startwday += $numberofdaysinweek;
     }
     // Get events from database
     $events = calendar_get_events($display->tstart, $display->tend, $calendar->users, $calendar->groups, $calendar->courses);
     if (!empty($events)) {
         foreach ($events as $eventid => $event) {
             $event = new calendar_event($event);
             if (!empty($event->modulename)) {
                 $cm = get_coursemodule_from_instance($event->modulename, $event->instance);
                 if (!groups_course_module_visible($cm)) {
                     unset($events[$eventid]);
                 }
             }
         }
     }
     // Extract information: events vs. time
     calendar_events_by_day($events, $date['mon'], $date['year'], $eventsbyday, $durationbyday, $typesbyday, $calendar->courses);
     $output = html_writer::start_tag('div', array('class' => 'header'));
     if (calendar_user_can_add_event($calendar->course)) {
         $output .= $this->add_event_button($calendar->course->id, 0, 0, 0, $calendar->time);
     }
     $output .= $this->course_filter_selector($returnurl, get_string('detailedmonthviewfor', 'calendar'));
     $output .= html_writer::end_tag('div', array('class' => 'header'));
     // Controls
     $output .= html_writer::tag('div', calendar_top_controls('month', array('id' => $calendar->courseid, 'time' => $calendar->time)), array('class' => 'controls'));
     $table = new html_table();
     $table->attributes = array('class' => 'calendarmonth calendartable');
     $table->summary = get_string('calendarheading', 'calendar', userdate($calendar->time, get_string('strftimemonthyear')));
     $table->data = array();
     // Get the day names as the header.
     $header = array();
     for ($i = $display->minwday; $i <= $display->maxwday; ++$i) {
         $header[] = $daynames[$i % $numberofdaysinweek]['shortname'];
     }
     $table->head = $header;
     // For the table display. $week is the row; $dayweek is the column.
     $week = 1;
     $dayweek = $startwday;
     $row = new html_table_row(array());
     // Paddding (the first week may have blank days in the beginning)
     for ($i = $display->minwday; $i < $startwday; ++$i) {
         $cell = new html_table_cell('&nbsp;');
         $cell->attributes = array('class' => 'nottoday dayblank');
         $row->cells[] = $cell;
     }
     // Now display all the calendar
     $weekend = CALENDAR_DEFAULT_WEEKEND;
     if (isset($CFG->calendar_weekend)) {
         $weekend = intval($CFG->calendar_weekend);
     }
     $daytime = strtotime('-1 day', $display->tstart);
     for ($day = 1; $day <= $display->maxdays; ++$day, ++$dayweek) {
         $daytime = strtotime('+1 day', $daytime);
         if ($dayweek > $display->maxwday) {
             // We need to change week (table row)
//.........这里部分代码省略.........

 /**
  * Checks if an activity is visible to the given user.
  *
  * Unlike other checks in the availability system, this check includes the
  * $cm->visible flag and also (if enabled) the groupmembersonly feature.
  * It is equivalent to $cm->uservisible.
  *
  * If you have already checked (or do not care whether) the user has access
  * to the course, you can set $checkcourse to false to save it checking
  * course access.
  *
  * When checking for the current user, you should generally not call
  * this function. Instead, use get_fast_modinfo to get a cm_info object,
  * then simply check the $cm->uservisible flag. This function is intended
  * to obtain that information for a separate course-module object that
  * wasn't loaded with get_fast_modinfo, or for a different user.
  *
  * This function has a performance cost unless the availability system is
  * disabled, and you supply a $cm object with necessary fields, and you
  * don't check course access.
  *
  * @param int|\stdClass|\cm_info $cmorid Object or id representing activity
  * @param int $userid User id (0 = current user)
  * @param bool $checkcourse If true, checks whether the user has course access
  * @return bool True if the activity is visible to the specified user
  * @throws \moodle_exception If the cmid doesn't exist
  */
 public static function is_user_visible($cmorid, $userid = 0, $checkcourse = true)
 {
     global $USER, $DB, $CFG;
     // Evaluate user id.
     if (!$userid) {
         $userid = $USER->id;
     }
     // If this happens to be already called with a cm_info for the right user
     // then just return uservisible.
     if ($cmorid instanceof \cm_info && $cmorid->get_modinfo()->userid == $userid) {
         return $cmorid->uservisible;
     }
     // If the $cmorid isn't an object or doesn't have required fields, load it.
     if (is_object($cmorid) && isset($cmorid->course) && isset($cmorid->visible)) {
         $cm = $cmorid;
     } else {
         if (is_object($cmorid)) {
             $cmorid = $cmorid->id;
         }
         $cm = $DB->get_record('course_modules', array('id' => $cmorid), '*', MUST_EXIST);
     }
     // Check the groupmembersonly feature.
     if (!groups_course_module_visible($cm, $userid)) {
         return false;
     }
     // If requested, check user can access the course.
     if ($checkcourse) {
         $coursecontext = \context_course::instance($cm->course);
         if (!is_enrolled($coursecontext, $userid, '', true) && !has_capability('moodle/course:view', $coursecontext, $userid)) {
             return false;
         }
     }
     // If availability is disabled, then all we need to do is check the visible flag.
     if (!$CFG->enableavailability && $cm->visible) {
         return true;
     }
     // When availability is enabled, access can depend on 3 things:
     // 1. $cm->visible
     // 2. $cm->availability
     // 3. $section->availability (for activity section and possibly for
     //    parent sections)
     // As a result we cannot take short cuts any longer and must get
     // standard modinfo.
     $modinfo = get_fast_modinfo($cm->course, $userid);
     return $modinfo->get_cm($cm->id)->uservisible;
 }

if ($course->id != SITEID) {
    // Only real courses have learning forums
    // Add extra field for section number, at the front
    if ($course->format == 'weeks' or $course->format == 'weekscss') {
        array_unshift($learningtable->head, $strweek);
    } else {
        array_unshift($learningtable->head, $strsection);
    }
    array_unshift($learningtable->align, "center");
    if ($learningforums) {
        $currentsection = "";
        foreach ($learningforums as $key => $forum) {
            $forum->visible = instance_is_visible("forum", $forum) || has_capability('moodle/course:view', $coursecontext);
            $cm = get_coursemodule_from_instance("forum", $forum->id, $course->id);
            $context = get_context_instance(CONTEXT_MODULE, $cm->id);
            if (!groups_course_module_visible($cm)) {
                continue;
            }
            $currentgroup = groups_get_activity_group($cm);
            $groupmode = groups_get_activity_groupmode($cm);
            $cantaccessagroup = $groupmode and !has_capability('moodle/site:accessallgroups', $context) and !mygroupid($course->id);
            if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
                $count = count_records("forum_discussions", "forum", "{$forum->id}", "groupid", $currentgroup);
            } else {
                $count = count_records("forum_discussions", "forum", "{$forum->id}");
            }
            if ($usetracking) {
                if ($forum->trackingtype == FORUM_TRACKING_ON || !isset($untracked[$forum->id])) {
                    $groupid = $groupmode == SEPARATEGROUPS && !has_capability('moodle/site:accessallgroups', $context) ? $currentgroup : false;
                    $unread = forum_tp_count_forum_unread_posts($USER->id, $forum->id, $groupid);
                    if ($unread > 0) {

/**
 * Determine whether a course module is visible within a course,
 * this is different from instance_is_visible() - faster and visibility for user
 *
 * @param object $cm object
 * @param int $userid empty means current user
 * @return bool
 */
function coursemodule_visible_for_user($cm, $userid = 0)
{
    global $USER;
    if (empty($cm->id)) {
        debugging("Incorrect course module parameter!", DEBUG_DEVELOPER);
        return false;
    }
    if (empty($userid)) {
        $userid = $USER->id;
    }
    if (!$cm->visible and !has_capability('moodle/course:viewhiddenactivities', get_context_instance(CONTEXT_MODULE, $cm->id), $userid)) {
        return false;
    }
    return groups_course_module_visible($cm, $userid);
}

/**
 * Returns a number of useful structures for course displays
 */
function get_all_mods($courseid, &$mods, &$modnames, &$modnamesplural, &$modnamesused)
{
    global $CFG, $DB, $COURSE;
    $mods = array();
    // course modules indexed by id
    $modnames = array();
    // all course module names (except resource!)
    $modnamesplural = array();
    // all course module names (plural form)
    $modnamesused = array();
    // course module names used
    if ($allmods = $DB->get_records("modules")) {
        foreach ($allmods as $mod) {
            if (!file_exists("{$CFG->dirroot}/mod/{$mod->name}/lib.php")) {
                continue;
            }
            if ($mod->visible) {
                $modnames[$mod->name] = get_string("modulename", "{$mod->name}");
                $modnamesplural[$mod->name] = get_string("modulenameplural", "{$mod->name}");
            }
        }
        collatorlib::asort($modnames);
    } else {
        print_error("nomodules", 'debug');
    }
    $course = $courseid == $COURSE->id ? $COURSE : $DB->get_record('course', array('id' => $courseid));
    $modinfo = get_fast_modinfo($course);
    if ($rawmods = $modinfo->cms) {
        foreach ($rawmods as $mod) {
            // Index the mods
            if (empty($modnames[$mod->modname])) {
                continue;
            }
            $mods[$mod->id] = $mod;
            $mods[$mod->id]->modfullname = $modnames[$mod->modname];
            if (!$mod->visible and !has_capability('moodle/course:viewhiddenactivities', get_context_instance(CONTEXT_COURSE, $courseid))) {
                continue;
            }
            // Check groupings
            if (!groups_course_module_visible($mod)) {
                continue;
            }
            $modnamesused[$mod->modname] = $modnames[$mod->modname];
        }
        if ($modnamesused) {
            collatorlib::asort($modnamesused);
        }
    }
}

 /**
  * Displays a month in detail
  *
  * @param calendar_information $calendar
  * @return string
  */
 public function show_month_detailed(calendar_information $calendar, moodle_url $returnurl = null)
 {
     global $CFG;
     if (empty($returnurl)) {
         $returnurl = $this->page->url;
     }
     $date = usergetdate(time());
     $display = new stdClass();
     $display->minwday = get_user_preferences('calendar_startwday', calendar_get_starting_weekday());
     $display->maxwday = $display->minwday + 6;
     $display->thismonth = $date['mon'] == $calendar->month;
     $display->maxdays = calendar_days_in_month($calendar->month, $calendar->year);
     $startwday = 0;
     if (get_user_timezone_offset() < 99) {
         // We 'll keep these values as GMT here, and offset them when the time comes to query the db
         $display->tstart = gmmktime(0, 0, 0, $calendar->month, 1, $calendar->year);
         // This is GMT
         $display->tend = gmmktime(23, 59, 59, $calendar->month, $display->maxdays, $calendar->year);
         // GMT
         $startwday = gmdate('w', $display->tstart);
         // $display->tstart is already GMT, so don't use date(): messes with server's TZ
     } else {
         // no timezone info specified
         $display->tstart = mktime(0, 0, 0, $calendar->month, 1, $calendar->year);
         $display->tend = mktime(23, 59, 59, $calendar->month, $display->maxdays, $calendar->year);
         $startwday = date('w', $display->tstart);
         // $display->tstart not necessarily GMT, so use date()
     }
     // Align the starting weekday to fall in our display range
     if ($startwday < $display->minwday) {
         $startwday += 7;
     }
     // Get events from database
     $events = calendar_get_events(usertime($display->tstart), usertime($display->tend), $calendar->users, $calendar->groups, $calendar->courses);
     if (!empty($events)) {
         foreach ($events as $eventid => $event) {
             $event = new calendar_event($event);
             if (!empty($event->modulename)) {
                 $cm = get_coursemodule_from_instance($event->modulename, $event->instance);
                 if (!groups_course_module_visible($cm)) {
                     unset($events[$eventid]);
                 }
             }
         }
     }
     // Extract information: events vs. time
     calendar_events_by_day($events, $calendar->month, $calendar->year, $eventsbyday, $durationbyday, $typesbyday, $calendar->courses);
     $output = html_writer::start_tag('div', array('class' => 'header'));
     if (calendar_user_can_add_event($calendar->course)) {
         $output .= $this->add_event_button($calendar->course->id, null, $calendar->month, $calendar->year);
     }
     $output .= get_string('detailedmonthview', 'calendar') . ': ' . $this->course_filter_selector($returnurl);
     $output .= html_writer::end_tag('div', array('class' => 'header'));
     // Controls
     $output .= html_writer::tag('div', calendar_top_controls('month', array('id' => $calendar->courseid, 'm' => $calendar->month, 'y' => $calendar->year)), array('class' => 'controls'));
     $days = calendar_get_days();
     $table = new html_table();
     $table->attributes = array('class' => 'calendarmonth calendartable');
     $table->data = array();
     $header = new html_table_row();
     $header->attributes = array('class' => 'weekdays');
     $header->cells = array();
     for ($i = $display->minwday; $i <= $display->maxwday; ++$i) {
         // This uses the % operator to get the correct weekday no matter what shift we have
         // applied to the $display->minwday : $display->maxwday range from the default 0 : 6
         $cell = new html_table_cell(get_string($days[$i % 7], 'calendar'));
         $cell->header = true;
         $header->cells[] = $cell;
     }
     // For the table display. $week is the row; $dayweek is the column.
     $week = 1;
     $dayweek = $startwday;
     // Create an array of all the week days.
     $wdays = array(0 => '<strong>' . get_string('sunday', 'calendar') . '</strong>', 1 => '<strong>' . get_string('monday', 'calendar') . '</strong>', 2 => '<strong>' . get_string('tuesday', 'calendar') . '</strong>', 3 => '<strong>' . get_string('wednesday', 'calendar') . '</strong>', 4 => '<strong>' . get_string('thursday', 'calendar') . '</strong>', 5 => '<strong>' . get_string('friday', 'calendar') . '</strong>', 6 => '<strong>' . get_string('saturday', 'calendar') . '</strong>');
     // Loop only if the day offset is greater than 0.
     // This loop involves shifting the days around until the desired start day
     // is at the start of the array.
     $daycount = 0;
     while ($display->minwday > $daycount++) {
         $wdays_end = array_shift($wdays);
         array_push($wdays, $wdays_end);
     }
     // Now we set the (modified) array to the table header to be displayed.
     $table->head = $wdays;
     $row = new html_table_row(array());
     // Paddding (the first week may have blank days in the beginning)
     for ($i = $display->minwday; $i < $startwday; ++$i) {
         $cell = new html_table_cell('&nbsp;');
         $cell->attributes = array('class' => 'nottoday');
         $row->cells[] = $cell;
     }
     // Now display all the calendar
     $weekend = CALENDAR_DEFAULT_WEEKEND;
     if (isset($CFG->calendar_weekend)) {
//.........这里部分代码省略.........

 /**
  * Load a list of users enrolled in the current course with the specified permission and group.
  * 0 for no group.
  *
  * @param int $currentgroup
  * @param bool $idsonly
  * @return array List of user records
  */
 public function list_participants($currentgroup, $idsonly)
 {
     if ($idsonly) {
         $users = get_enrolled_users($this->context, 'mod/assign:submit', $currentgroup, 'u.id', null, null, null, $this->show_only_active_users());
     } else {
         $users = get_enrolled_users($this->context, 'mod/assign:submit', $currentgroup, 'u.*', null, null, null, $this->show_only_active_users());
     }
     $cm = $this->get_course_module();
     foreach ($users as $userid => $user) {
         if (!groups_course_module_visible($cm, $userid)) {
             unset($users[$userid]);
         }
     }
     return $users;
 }