calendar/lib.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Calendar extension
  19  *
  20  * @package    core_calendar
  21  * @copyright  2004 Greek School Network (http://www.sch.gr), Jon Papaioannou,
  22  *             Avgoustos Tsinakos
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  */
  25
  26 if (!defined('MOODLE_INTERNAL')) {
  27     die('Direct access to this script is forbidden.');    ///  It must be included from a Moodle page
  28 }
  29
  30 /**
  31  *  These are read by the administration component to provide default values
  32  */
  33
  34 /**
  35  * CALENDAR_DEFAULT_UPCOMING_LOOKAHEAD - default value of upcoming event preference
  36  */
  37 define('CALENDAR_DEFAULT_UPCOMING_LOOKAHEAD', 21);
  38
  39 /**
  40  * CALENDAR_DEFAULT_UPCOMING_MAXEVENTS - default value to display the maximum number of upcoming event
  41  */
  42 define('CALENDAR_DEFAULT_UPCOMING_MAXEVENTS', 10);
  43
  44 /**
  45  * CALENDAR_DEFAULT_STARTING_WEEKDAY - default value to display the starting weekday
  46  */
  47 define('CALENDAR_DEFAULT_STARTING_WEEKDAY', 1);
  48
  49 // This is a packed bitfield: day X is "weekend" if $field & (1 << X) is true
  50 // Default value = 65 = 64 + 1 = 2^6 + 2^0 = Saturday & Sunday
  51
  52 /**
  53  * CALENDAR_DEFAULT_WEEKEND - default value for weekend (Saturday & Sunday)
  54  */
  55 define('CALENDAR_DEFAULT_WEEKEND', 65);
  56
  57 /**
  58  * CALENDAR_URL - path to calendar's folder
  59  */
  60 define('CALENDAR_URL', $CFG->wwwroot.'/calendar/');
  61
  62 /**
  63  * CALENDAR_TF_24 - Calendar time in 24 hours format
  64  */
  65 define('CALENDAR_TF_24', '%H:%M');
  66
  67 /**
  68  * CALENDAR_TF_12 - Calendar time in 12 hours format
  69  */
  70 define('CALENDAR_TF_12', '%I:%M %p');
  71
  72 /**
  73  * CALENDAR_EVENT_GLOBAL - Global calendar event types
  74  */
  75 define('CALENDAR_EVENT_GLOBAL', 1);
  76
  77 /**
  78  * CALENDAR_EVENT_COURSE - Course calendar event types
  79  */
  80 define('CALENDAR_EVENT_COURSE', 2);
  81
  82 /**
  83  * CALENDAR_EVENT_GROUP - group calendar event types
  84  */
  85 define('CALENDAR_EVENT_GROUP', 4);
  86
  87 /**
  88  * CALENDAR_EVENT_USER - user calendar event types
  89  */
  90 define('CALENDAR_EVENT_USER', 8);
  91
  92
  93 /**
  94  * CALENDAR_IMPORT_FROM_FILE - import the calendar from a file
  95  */
  96 define('CALENDAR_IMPORT_FROM_FILE', 0);
  97
  98 /**
  99  * CALENDAR_IMPORT_FROM_URL - import the calendar from a URL
 100  */
 101 define('CALENDAR_IMPORT_FROM_URL',  1);
 102
 103 /**
 104  * CALENDAR_IMPORT_EVENT_UPDATED - imported event was updated
 105  */
 106 define('CALENDAR_IMPORT_EVENT_UPDATED',  1);
 107
 108 /**
 109  * CALENDAR_IMPORT_EVENT_INSERTED - imported event was added by insert
 110  */
 111 define('CALENDAR_IMPORT_EVENT_INSERTED', 2);
 112
 113 /**
 114  * Return the days of the week
 115  *
 116  * @return array array of days
 117  */
 118 function calendar_get_days() {
 119     return array('sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday');
 120 }
 121
 122 /**
 123  * Get the subscription from a given id
 124  *
 125  * @since Moodle 2.5
 126  * @param int $id id of the subscription
 127  * @return stdClass Subscription record from DB
 128  * @throws moodle_exception for an invalid id
 129  */
 130 function calendar_get_subscription($id) {
 131     global $DB;
 132
 133     $cache = cache::make('core', 'calendar_subscriptions');
 134     $subscription = $cache->get($id);
 135     if (empty($subscription)) {
 136         $subscription = $DB->get_record('event_subscriptions', array('id' => $id), '*', MUST_EXIST);
 137         // cache the data.
 138         $cache->set($id, $subscription);
 139     }
 140     return $subscription;
 141 }
 142
 143 /**
 144  * Gets the first day of the week
 145  *
 146  * Used to be define('CALENDAR_STARTING_WEEKDAY', blah);
 147  *
 148  * @return int
 149  */
 150 function calendar_get_starting_weekday() {
 151     global $CFG;
 152
 153     if (isset($CFG->calendar_startwday)) {
 154         $firstday = $CFG->calendar_startwday;
 155     } else {
 156         $firstday = get_string('firstdayofweek', 'langconfig');
 157     }
 158
 159     if(!is_numeric($firstday)) {
 160         return CALENDAR_DEFAULT_STARTING_WEEKDAY;
 161     } else {
 162         return intval($firstday) % 7;
 163     }
 164 }
 165
 166 /**
 167  * Generates the HTML for a miniature calendar
 168  *
 169  * @param array $courses list of course to list events from
 170  * @param array $groups list of group
 171  * @param array $users user's info
 172  * @param int $cal_month calendar month in numeric, default is set to false
 173  * @param int $cal_year calendar month in numeric, default is set to false
 174  * @param string $placement the place/page the calendar is set to appear - passed on the the controls function
 175  * @param int $courseid id of the course the calendar is displayed on - passed on the the controls function
 176  * @return string $content return html table for mini calendar
 177  */
 178 function calendar_get_mini($courses, $groups, $users, $cal_month = false, $cal_year = false, $placement = false, $courseid = false ) {
 179     global $CFG, $USER, $OUTPUT;
 180
 181     $display = new stdClass;
 182     $display->minwday = get_user_preferences('calendar_startwday', calendar_get_starting_weekday());
 183     $display->maxwday = $display->minwday + 6;
 184
 185     $content = '';
 186
 187     if(!empty($cal_month) && !empty($cal_year)) {
 188         $thisdate = usergetdate(time()); // Date and time the user sees at his location
 189         if($cal_month == $thisdate['mon'] && $cal_year == $thisdate['year']) {
 190             // Navigated to this month
 191             $date = $thisdate;
 192             $display->thismonth = true;
 193         } else {
 194             // Navigated to other month, let's do a nice trick and save us a lot of work...
 195             if(!checkdate($cal_month, 1, $cal_year)) {
 196                 $date = array('mday' => 1, 'mon' => $thisdate['mon'], 'year' => $thisdate['year']);
 197                 $display->thismonth = true;
 198             } else {
 199                 $date = array('mday' => 1, 'mon' => $cal_month, 'year' => $cal_year);
 200                 $display->thismonth = false;
 201             }
 202         }
 203     } else {
 204         $date = usergetdate(time()); // Date and time the user sees at his location
 205         $display->thismonth = true;
 206     }
 207
 208     // Fill in the variables we 're going to use, nice and tidy
 209     list($d, $m, $y) = array($date['mday'], $date['mon'], $date['year']); // This is what we want to display
 210     $display->maxdays = calendar_days_in_month($m, $y);
 211
 212     if (get_user_timezone_offset() < 99) {
 213         // We 'll keep these values as GMT here, and offset them when the time comes to query the db
 214         $display->tstart = gmmktime(0, 0, 0, $m, 1, $y); // This is GMT
 215         $display->tend = gmmktime(23, 59, 59, $m, $display->maxdays, $y); // GMT
 216     } else {
 217         // no timezone info specified
 218         $display->tstart = mktime(0, 0, 0, $m, 1, $y);
 219         $display->tend = mktime(23, 59, 59, $m, $display->maxdays, $y);
 220     }
 221
 222     $startwday = dayofweek(1, $m, $y);
 223
 224     // Align the starting weekday to fall in our display range
 225     // This is simple, not foolproof.
 226     if($startwday < $display->minwday) {
 227         $startwday += 7;
 228     }
 229
 230     // TODO: THIS IS TEMPORARY CODE!
 231     // [pj] I was just reading through this and realized that I when writing this code I was probably
 232     // asking for trouble, as all these time manipulations seem to be unnecessary and a simple
 233     // make_timestamp would accomplish the same thing. So here goes a test:
 234     //$test_start = make_timestamp($y, $m, 1);
 235     //$test_end   = make_timestamp($y, $m, $display->maxdays, 23, 59, 59);
 236     //if($test_start != usertime($display->tstart) - dst_offset_on($display->tstart)) {
 237         //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);
 238     //}
 239     //if($test_end != usertime($display->tend) - dst_offset_on($display->tend)) {
 240         //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);
 241     //}
 242
 243
 244     // Get the events matching our criteria. Don't forget to offset the timestamps for the user's TZ!
 245     $events = calendar_get_events(
 246         usertime($display->tstart) - dst_offset_on($display->tstart),
 247         usertime($display->tend) - dst_offset_on($display->tend),
 248         $users, $groups, $courses);
 249
 250     // Set event course class for course events
 251     if (!empty($events)) {
 252         foreach ($events as $eventid => $event) {
 253             if (!empty($event->modulename)) {
 254                 $cm = get_coursemodule_from_instance($event->modulename, $event->instance);
 255                 if (!groups_course_module_visible($cm)) {
 256                     unset($events[$eventid]);
 257                 }
 258             }
 259         }
 260     }
 261
 262     // This is either a genius idea or an idiot idea: in order to not complicate things, we use this rule: if, after
 263     // possibly removing SITEID from $courses, there is only one course left, then clicking on a day in the month
 264     // will also set the $SESSION->cal_courses_shown variable to that one course. Otherwise, we 'd need to add extra
 265     // arguments to this function.
 266
 267     $hrefparams = array();
 268     if(!empty($courses)) {
 269         $courses = array_diff($courses, array(SITEID));
 270         if(count($courses) == 1) {
 271             $hrefparams['course'] = reset($courses);
 272         }
 273     }
 274
 275     // We want to have easy access by day, since the display is on a per-day basis.
 276     // Arguments passed by reference.
 277     //calendar_events_by_day($events, $display->tstart, $eventsbyday, $durationbyday, $typesbyday);
 278     calendar_events_by_day($events, $m, $y, $eventsbyday, $durationbyday, $typesbyday, $courses);
 279
 280     //Accessibility: added summary and <abbr> elements.
 281     $days_title = calendar_get_days();
 282
 283     $summary = get_string('calendarheading', 'calendar', userdate(make_timestamp($y, $m), get_string('strftimemonthyear')));
 284     $content .= '<table class="minicalendar calendartable" summary="'.$summary.'">'; // Begin table
 285     if (($placement !== false) && ($courseid  !== false)) {
 286         $content .= '<caption>'. calendar_top_controls($placement, array('id' => $courseid, 'm' => $m, 'y' => $y)) .'</caption>';
 287     }
 288     $content .= '<tr class="weekdays">'; // Header row: day names
 289
 290     // Print out the names of the weekdays
 291     $days = array('sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat');
 292     for($i = $display->minwday; $i <= $display->maxwday; ++$i) {
 293         // This uses the % operator to get the correct weekday no matter what shift we have
 294         // applied to the $display->minwday : $display->maxwday range from the default 0 : 6
 295         $content .= '<th scope="col"><abbr title="'. get_string($days_title[$i % 7], 'calendar') .'">'.
 296             get_string($days[$i % 7], 'calendar') ."</abbr></th>\n";
 297     }
 298
 299     $content .= '</tr><tr>'; // End of day names; prepare for day numbers
 300
 301     // For the table display. $week is the row; $dayweek is the column.
 302     $dayweek = $startwday;
 303
 304     // Paddding (the first week may have blank days in the beginning)
 305     for($i = $display->minwday; $i < $startwday; ++$i) {
 306         $content .= '<td class="dayblank">&nbsp;</td>'."\n";
 307     }
 308
 309     $weekend = CALENDAR_DEFAULT_WEEKEND;
 310     if (isset($CFG->calendar_weekend)) {
 311         $weekend = intval($CFG->calendar_weekend);
 312     }
 313
 314     // Now display all the calendar
 315     for($day = 1; $day <= $display->maxdays; ++$day, ++$dayweek) {
 316         if($dayweek > $display->maxwday) {
 317             // We need to change week (table row)
 318             $content .= '</tr><tr>';
 319             $dayweek = $display->minwday;
 320         }
 321
 322         // Reset vars
 323         $cell = '';
 324         if ($weekend & (1 << ($dayweek % 7))) {
 325             // Weekend. This is true no matter what the exact range is.
 326             $class = 'weekend day';
 327         } else {
 328             // Normal working day.
 329             $class = 'day';
 330         }
 331
 332         // Special visual fx if an event is defined
 333         if(isset($eventsbyday[$day])) {
 334             $class .= ' hasevent';
 335             $hrefparams['view'] = 'day';
 336             $dayhref = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', $hrefparams), $day, $m, $y);
 337
 338             $popupcontent = '';
 339             foreach($eventsbyday[$day] as $eventid) {
 340                 if (!isset($events[$eventid])) {
 341                     continue;
 342                 }
 343                 $event = new calendar_event($events[$eventid]);
 344                 $popupalt  = '';
 345                 $component = 'moodle';
 346                 if(!empty($event->modulename)) {
 347                     $popupicon = 'icon';
 348                     $popupalt  = $event->modulename;
 349                     $component = $event->modulename;
 350                 } else if ($event->courseid == SITEID) {                                // Site event
 351                     $popupicon = 'i/siteevent';
 352                 } else if ($event->courseid != 0 && $event->courseid != SITEID && $event->groupid == 0) {      // Course event
 353                     $popupicon = 'i/courseevent';
 354                 } else if ($event->groupid) {                                      // Group event
 355                     $popupicon = 'i/groupevent';
 356                 } else if ($event->userid) {                                       // User event
 357                     $popupicon = 'i/userevent';
 358                 }
 359
 360                 $dayhref->set_anchor('event_'.$event->id);
 361
 362                 $popupcontent .= html_writer::start_tag('div');
 363                 $popupcontent .= $OUTPUT->pix_icon($popupicon, $popupalt, $component);
 364                 $name = format_string($event->name, true);
 365                 // Show ical source if needed.
 366                 if (!empty($event->subscription) && $CFG->calendar_showicalsource) {
 367                     $a = new stdClass();
 368                     $a->name = $name;
 369                     $a->source = $event->subscription->name;
 370                     $name = get_string('namewithsource', 'calendar', $a);
 371                 }
 372                 $popupcontent .= html_writer::link($dayhref, $name);
 373                 $popupcontent .= html_writer::end_tag('div');
 374             }
 375
 376             //Accessibility: functionality moved to calendar_get_popup.
 377             if($display->thismonth && $day == $d) {
 378                 $popupid = calendar_get_popup(true, $events[$eventid]->timestart, $popupcontent);
 379             } else {
 380                 $popupid = calendar_get_popup(false, $events[$eventid]->timestart, $popupcontent);
 381             }
 382
 383             // Class and cell content
 384             if(isset($typesbyday[$day]['startglobal'])) {
 385                 $class .= ' calendar_event_global';
 386             } else if(isset($typesbyday[$day]['startcourse'])) {
 387                 $class .= ' calendar_event_course';
 388             } else if(isset($typesbyday[$day]['startgroup'])) {
 389                 $class .= ' calendar_event_group';
 390             } else if(isset($typesbyday[$day]['startuser'])) {
 391                 $class .= ' calendar_event_user';
 392             }
 393             $cell = html_writer::link($dayhref, $day, array('aria-controls' => $popupid.'_panel', 'id' => $popupid));
 394         } else {
 395             $cell = $day;
 396         }
 397
 398         $durationclass = false;
 399         if (isset($typesbyday[$day]['durationglobal'])) {
 400             $durationclass = ' duration_global';
 401         } else if(isset($typesbyday[$day]['durationcourse'])) {
 402             $durationclass = ' duration_course';
 403         } else if(isset($typesbyday[$day]['durationgroup'])) {
 404             $durationclass = ' duration_group';
 405         } else if(isset($typesbyday[$day]['durationuser'])) {
 406             $durationclass = ' duration_user';
 407         }
 408         if ($durationclass) {
 409             $class .= ' duration '.$durationclass;
 410         }
 411
 412         // If event has a class set then add it to the table day <td> tag
 413         // Note: only one colour for minicalendar
 414         if(isset($eventsbyday[$day])) {
 415             foreach($eventsbyday[$day] as $eventid) {
 416                 if (!isset($events[$eventid])) {
 417                     continue;
 418                 }
 419                 $event = $events[$eventid];
 420                 if (!empty($event->class)) {
 421                     $class .= ' '.$event->class;
 422                 }
 423                 break;
 424             }
 425         }
 426
 427         // Special visual fx for today
 428         //Accessibility: hidden text for today, and popup.
 429         if($display->thismonth && $day == $d) {
 430             $class .= ' today';
 431             $today = get_string('today', 'calendar').' '.userdate(time(), get_string('strftimedayshort'));
 432
 433             if(! isset($eventsbyday[$day])) {
 434                 $class .= ' eventnone';
 435                 $popupid = calendar_get_popup(true, false);
 436                 $cell = html_writer::link('#', $day, array('aria-controls' => $popupid.'_panel', 'id' => $popupid));
 437             }
 438             $cell = get_accesshide($today.' ').$cell;
 439         }
 440
 441         // Just display it
 442         if(!empty($class)) {
 443             $class = ' class="'.$class.'"';
 444         }
 445         $content .= '<td'.$class.'>'.$cell."</td>\n";
 446     }
 447
 448     // Paddding (the last week may have blank days at the end)
 449     for($i = $dayweek; $i <= $display->maxwday; ++$i) {
 450         $content .= '<td class="dayblank">&nbsp;</td>';
 451     }
 452     $content .= '</tr>'; // Last row ends
 453
 454     $content .= '</table>'; // Tabular display of days ends
 455
 456     return $content;
 457 }
 458
 459 /**
 460  * Gets the calendar popup
 461  *
 462  * It called at multiple points in from calendar_get_mini.
 463  * Copied and modified from calendar_get_mini.
 464  *
 465  * @param bool $is_today false except when called on the current day.
 466  * @param mixed $event_timestart $events[$eventid]->timestart, OR false if there are no events.
 467  * @param string $popupcontent content for the popup window/layout.
 468  * @return string eventid for the calendar_tooltip popup window/layout.
 469  */
 470 function calendar_get_popup($is_today, $event_timestart, $popupcontent='') {
 471     global $PAGE;
 472     static $popupcount;
 473     if ($popupcount === null) {
 474         $popupcount = 1;
 475     }
 476     $popupcaption = '';
 477     if($is_today) {
 478         $popupcaption = get_string('today', 'calendar').' ';
 479     }
 480     if (false === $event_timestart) {
 481         $popupcaption .= userdate(time(), get_string('strftimedayshort'));
 482         $popupcontent = get_string('eventnone', 'calendar');
 483
 484     } else {
 485         $popupcaption .= get_string('eventsfor', 'calendar', userdate($event_timestart, get_string('strftimedayshort')));
 486     }
 487     $id = 'calendar_tooltip_'.$popupcount;
 488     $PAGE->requires->yui_module('moodle-calendar-eventmanager', 'M.core_calendar.add_event', array(array('eventId'=>$id,'title'=>$popupcaption, 'content'=>$popupcontent)));
 489
 490     $popupcount++;
 491     return $id;
 492 }
 493
 494 /**
 495  * Gets the calendar upcoming event
 496  *
 497  * @param array $courses array of courses
 498  * @param array|int|bool $groups array of groups, group id or boolean for all/no group events
 499  * @param array|int|bool $users array of users, user id or boolean for all/no user events
 500  * @param int $daysinfuture number of days in the future we 'll look
 501  * @param int $maxevents maximum number of events
 502  * @param int $fromtime start time
 503  * @return array $output array of upcoming events
 504  */
 505 function calendar_get_upcoming($courses, $groups, $users, $daysinfuture, $maxevents, $fromtime=0) {
 506     global $CFG, $COURSE, $DB;
 507
 508     $display = new stdClass;
 509     $display->range = $daysinfuture; // How many days in the future we 'll look
 510     $display->maxevents = $maxevents;
 511
 512     $output = array();
 513
 514     // Prepare "course caching", since it may save us a lot of queries
 515     $coursecache = array();
 516
 517     $processed = 0;
 518     $now = time(); // We 'll need this later
 519     $usermidnighttoday = usergetmidnight($now);
 520
 521     if ($fromtime) {
 522         $display->tstart = $fromtime;
 523     } else {
 524         $display->tstart = $usermidnighttoday;
 525     }
 526
 527     // This works correctly with respect to the user's DST, but it is accurate
 528     // only because $fromtime is always the exact midnight of some day!
 529     $display->tend = usergetmidnight($display->tstart + DAYSECS * $display->range + 3 * HOURSECS) - 1;
 530
 531     // Get the events matching our criteria
 532     $events = calendar_get_events($display->tstart, $display->tend, $users, $groups, $courses);
 533
 534     // This is either a genius idea or an idiot idea: in order to not complicate things, we use this rule: if, after
 535     // possibly removing SITEID from $courses, there is only one course left, then clicking on a day in the month
 536     // will also set the $SESSION->cal_courses_shown variable to that one course. Otherwise, we 'd need to add extra
 537     // arguments to this function.
 538
 539     $hrefparams = array();
 540     if(!empty($courses)) {
 541         $courses = array_diff($courses, array(SITEID));
 542         if(count($courses) == 1) {
 543             $hrefparams['course'] = reset($courses);
 544         }
 545     }
 546
 547     if ($events !== false) {
 548
 549         $modinfo = get_fast_modinfo($COURSE);
 550
 551         foreach($events as $event) {
 552
 553
 554             if (!empty($event->modulename)) {
 555                 if ($event->courseid == $COURSE->id) {
 556                     if (isset($modinfo->instances[$event->modulename][$event->instance])) {
 557                         $cm = $modinfo->instances[$event->modulename][$event->instance];
 558                         if (!$cm->uservisible) {
 559                             continue;
 560                         }
 561                     }
 562                 } else {
 563                     if (!$cm = get_coursemodule_from_instance($event->modulename, $event->instance)) {
 564                         continue;
 565                     }
 566                     if (!coursemodule_visible_for_user($cm)) {
 567                         continue;
 568                     }
 569                 }
 570                 if ($event->modulename == 'assignment'){
 571                     // create calendar_event to test edit_event capability
 572                     // this new event will also prevent double creation of calendar_event object
 573                     $checkevent = new calendar_event($event);
 574                     // TODO: rewrite this hack somehow
 575                     if (!calendar_edit_event_allowed($checkevent)){ // cannot manage entries, eg. student
 576                         if (!$assignment = $DB->get_record('assignment', array('id'=>$event->instance))) {
 577                             // print_error("invalidid", 'assignment');
 578                             continue;
 579                         }
 580                         // assign assignment to assignment object to use hidden_is_hidden method
 581                         require_once($CFG->dirroot.'/mod/assignment/lib.php');
 582
 583                         if (!file_exists($CFG->dirroot.'/mod/assignment/type/'.$assignment->assignmenttype.'/assignment.class.php')) {
 584                             continue;
 585                         }
 586                         require_once ($CFG->dirroot.'/mod/assignment/type/'.$assignment->assignmenttype.'/assignment.class.php');
 587
 588                         $assignmentclass = 'assignment_'.$assignment->assignmenttype;
 589                         $assignmentinstance = new $assignmentclass($cm->id, $assignment, $cm);
 590
 591                         if ($assignmentinstance->description_is_hidden()){//force not to show description before availability
 592                             $event->description = get_string('notavailableyet', 'assignment');
 593                         }
 594                     }
 595                 }
 596             }
 597
 598             if ($processed >= $display->maxevents) {
 599                 break;
 600             }
 601
 602             $event->time = calendar_format_event_time($event, $now, $hrefparams);
 603             $output[] = $event;
 604             ++$processed;
 605         }
 606     }
 607     return $output;
 608 }
 609
 610 /**
 611  * Add calendar event metadata
 612  *
 613  * @param stdClass $event event info
 614  * @return stdClass $event metadata
 615  */
 616 function calendar_add_event_metadata($event) {
 617     global $CFG, $OUTPUT;
 618
 619     //Support multilang in event->name
 620     $event->name = format_string($event->name,true);
 621
 622     if(!empty($event->modulename)) {                                // Activity event
 623         // The module name is set. I will assume that it has to be displayed, and
 624         // also that it is an automatically-generated event. And of course that the
 625         // fields for get_coursemodule_from_instance are set correctly.
 626         $module = calendar_get_module_cached($coursecache, $event->modulename, $event->instance);
 627
 628         if ($module === false) {
 629             return;
 630         }
 631
 632         $modulename = get_string('modulename', $event->modulename);
 633         if (get_string_manager()->string_exists($event->eventtype, $event->modulename)) {
 634             // will be used as alt text if the event icon
 635             $eventtype = get_string($event->eventtype, $event->modulename);
 636         } else {
 637             $eventtype = '';
 638         }
 639         $icon = $OUTPUT->pix_url('icon', $event->modulename) . '';
 640
 641         $context = context_course::instance($module->course);
 642         $fullname = format_string($coursecache[$module->course]->fullname, true, array('context' => $context));
 643
 644         $event->icon = '<img src="'.$icon.'" alt="'.$eventtype.'" title="'.$modulename.'" class="icon" />';
 645         $event->referer = '<a href="'.$CFG->wwwroot.'/mod/'.$event->modulename.'/view.php?id='.$module->id.'">'.$event->name.'</a>';
 646         $event->courselink = '<a href="'.$CFG->wwwroot.'/course/view.php?id='.$module->course.'">'.$fullname.'</a>';
 647         $event->cmid = $module->id;
 648
 649
 650     } else if($event->courseid == SITEID) {                              // Site event
 651         $event->icon = '<img src="'.$OUTPUT->pix_url('i/siteevent') . '" alt="'.get_string('globalevent', 'calendar').'" class="icon" />';
 652         $event->cssclass = 'calendar_event_global';
 653     } else if($event->courseid != 0 && $event->courseid != SITEID && $event->groupid == 0) {          // Course event
 654         calendar_get_course_cached($coursecache, $event->courseid);
 655
 656         $context = context_course::instance($event->courseid);
 657         $fullname = format_string($coursecache[$event->courseid]->fullname, true, array('context' => $context));
 658
 659         $event->icon = '<img src="'.$OUTPUT->pix_url('i/courseevent') . '" alt="'.get_string('courseevent', 'calendar').'" class="icon" />';
 660         $event->courselink = '<a href="'.$CFG->wwwroot.'/course/view.php?id='.$event->courseid.'">'.$fullname.'</a>';
 661         $event->cssclass = 'calendar_event_course';
 662     } else if ($event->groupid) {                                    // Group event
 663         $event->icon = '<img src="'.$OUTPUT->pix_url('i/groupevent') . '" alt="'.get_string('groupevent', 'calendar').'" class="icon" />';
 664         $event->cssclass = 'calendar_event_group';
 665     } else if($event->userid) {                                      // User event
 666         $event->icon = '<img src="'.$OUTPUT->pix_url('i/userevent') . '" alt="'.get_string('userevent', 'calendar').'" class="icon" />';
 667         $event->cssclass = 'calendar_event_user';
 668     }
 669     return $event;
 670 }
 671
 672 /**
 673  * Get calendar events
 674  *
 675  * @param int $tstart Start time of time range for events
 676  * @param int $tend End time of time range for events
 677  * @param array|int|boolean $users array of users, user id or boolean for all/no user events
 678  * @param array|int|boolean $groups array of groups, group id or boolean for all/no group events
 679  * @param array|int|boolean $courses array of courses, course id or boolean for all/no course events
 680  * @param boolean $withduration whether only events starting within time range selected
 681  *                              or events in progress/already started selected as well
 682  * @param boolean $ignorehidden whether to select only visible events or all events
 683  * @return array $events of selected events or an empty array if there aren't any (or there was an error)
 684  */
 685 function calendar_get_events($tstart, $tend, $users, $groups, $courses, $withduration=true, $ignorehidden=true) {
 686     global $DB;
 687
 688     $whereclause = '';
 689     // Quick test
 690     if(is_bool($users) && is_bool($groups) && is_bool($courses)) {
 691         return array();
 692     }
 693
 694     if(is_array($users) && !empty($users)) {
 695         // Events from a number of users
 696         if(!empty($whereclause)) $whereclause .= ' OR';
 697         $whereclause .= ' (userid IN ('.implode(',', $users).') AND courseid = 0 AND groupid = 0)';
 698     } else if(is_numeric($users)) {
 699         // Events from one user
 700         if(!empty($whereclause)) $whereclause .= ' OR';
 701         $whereclause .= ' (userid = '.$users.' AND courseid = 0 AND groupid = 0)';
 702     } else if($users === true) {
 703         // Events from ALL users
 704         if(!empty($whereclause)) $whereclause .= ' OR';
 705         $whereclause .= ' (userid != 0 AND courseid = 0 AND groupid = 0)';
 706     } else if($users === false) {
 707         // No user at all, do nothing
 708     }
 709
 710     if(is_array($groups) && !empty($groups)) {
 711         // Events from a number of groups
 712         if(!empty($whereclause)) $whereclause .= ' OR';
 713         $whereclause .= ' groupid IN ('.implode(',', $groups).')';
 714     } else if(is_numeric($groups)) {
 715         // Events from one group
 716         if(!empty($whereclause)) $whereclause .= ' OR ';
 717         $whereclause .= ' groupid = '.$groups;
 718     } else if($groups === true) {
 719         // Events from ALL groups
 720         if(!empty($whereclause)) $whereclause .= ' OR ';
 721         $whereclause .= ' groupid != 0';
 722     }
 723     // boolean false (no groups at all): we don't need to do anything
 724
 725     if(is_array($courses) && !empty($courses)) {
 726         if(!empty($whereclause)) {
 727             $whereclause .= ' OR';
 728         }
 729         $whereclause .= ' (groupid = 0 AND courseid IN ('.implode(',', $courses).'))';
 730     } else if(is_numeric($courses)) {
 731         // One course
 732         if(!empty($whereclause)) $whereclause .= ' OR';
 733         $whereclause .= ' (groupid = 0 AND courseid = '.$courses.')';
 734     } else if ($courses === true) {
 735         // Events from ALL courses
 736         if(!empty($whereclause)) $whereclause .= ' OR';
 737         $whereclause .= ' (groupid = 0 AND courseid != 0)';
 738     }
 739
 740     // Security check: if, by now, we have NOTHING in $whereclause, then it means
 741     // that NO event-selecting clauses were defined. Thus, we won't be returning ANY
 742     // events no matter what. Allowing the code to proceed might return a completely
 743     // valid query with only time constraints, thus selecting ALL events in that time frame!
 744     if(empty($whereclause)) {
 745         return array();
 746     }
 747
 748     if($withduration) {
 749         $timeclause = '(timestart >= '.$tstart.' OR timestart + timeduration > '.$tstart.') AND timestart <= '.$tend;
 750     }
 751     else {
 752         $timeclause = 'timestart >= '.$tstart.' AND timestart <= '.$tend;
 753     }
 754     if(!empty($whereclause)) {
 755         // We have additional constraints
 756         $whereclause = $timeclause.' AND ('.$whereclause.')';
 757     }
 758     else {
 759         // Just basic time filtering
 760         $whereclause = $timeclause;
 761     }
 762
 763     if ($ignorehidden) {
 764         $whereclause .= ' AND visible = 1';
 765     }
 766
 767     $events = $DB->get_records_select('event', $whereclause, null, 'timestart');
 768     if ($events === false) {
 769         $events = array();
 770     }
 771     return $events;
 772 }
 773
 774 /** Get calendar events by id
 775  *
 776  * @since Moodle 2.5
 777  * @param array $eventids list of event ids
 778  * @return array Array of event entries, empty array if nothing found
 779  */
 780
 781 function calendar_get_events_by_id($eventids) {
 782     global $DB;
 783
 784     if (!is_array($eventids) || empty($eventids)) {
 785         return array();
 786     }
 787     list($wheresql, $params) = $DB->get_in_or_equal($eventids);
 788     $wheresql = "id $wheresql";
 789
 790     return $DB->get_records_select('event', $wheresql, $params);
 791 }
 792
 793 /**
 794  * Get control options for Calendar
 795  *
 796  * @param string $type of calendar
 797  * @param array $data calendar information
 798  * @return string $content return available control for the calender in html
 799  */
 800 function calendar_top_controls($type, $data) {
 801     global $CFG, $PAGE;
 802     $content = '';
 803     if(!isset($data['d'])) {
 804         $data['d'] = 1;
 805     }
 806
 807     // Ensure course id passed if relevant
 808     // Required due to changes in view/lib.php mainly (calendar_session_vars())
 809     $courseid = '';
 810     if (!empty($data['id'])) {
 811         $courseid = '&amp;course='.$data['id'];
 812     }
 813
 814     if(!checkdate($data['m'], $data['d'], $data['y'])) {
 815         $time = time();
 816     }
 817     else {
 818         $time = make_timestamp($data['y'], $data['m'], $data['d']);
 819     }
 820     $date = usergetdate($time);
 821
 822     $data['m'] = $date['mon'];
 823     $data['y'] = $date['year'];
 824     $urlbase = $PAGE->url;
 825
 826     //Accessibility: calendar block controls, replaced <table> with <div>.
 827     //$nexttext = link_arrow_right(get_string('monthnext', 'access'), $url='', $accesshide=true);
 828     //$prevtext = link_arrow_left(get_string('monthprev', 'access'), $url='', $accesshide=true);
 829
 830     switch($type) {
 831         case 'frontpage':
 832             list($prevmonth, $prevyear) = calendar_sub_month($data['m'], $data['y']);
 833             list($nextmonth, $nextyear) = calendar_add_month($data['m'], $data['y']);
 834             $nextlink = calendar_get_link_next(get_string('monthnext', 'access'), $urlbase, 0, $nextmonth, $nextyear, true);
 835             $prevlink = calendar_get_link_previous(get_string('monthprev', 'access'), $urlbase, 0, $prevmonth, $prevyear, true);
 836
 837             $calendarlink = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', array('view'=>'month')), 1, $data['m'], $data['y']);
 838             if (!empty($data['id'])) {
 839                 $calendarlink->param('course', $data['id']);
 840             }
 841
 842             if (right_to_left()) {
 843                 $left = $nextlink;
 844                 $right = $prevlink;
 845             } else {
 846                 $left = $prevlink;
 847                 $right = $nextlink;
 848             }
 849
 850             $content .= html_writer::start_tag('div', array('class'=>'calendar-controls'));
 851             $content .= $left.'<span class="hide"> | </span>';
 852             $content .= html_writer::tag('span', html_writer::link($calendarlink, userdate($time, get_string('strftimemonthyear')), array('title'=>get_string('monththis','calendar'))), array('class'=>'current'));
 853             $content .= '<span class="hide"> | </span>'. $right;
 854             $content .= "<span class=\"clearer\"><!-- --></span>\n";
 855             $content .= html_writer::end_tag('div');
 856
 857             break;
 858         case 'course':
 859             list($prevmonth, $prevyear) = calendar_sub_month($data['m'], $data['y']);
 860             list($nextmonth, $nextyear) = calendar_add_month($data['m'], $data['y']);
 861             $nextlink = calendar_get_link_next(get_string('monthnext', 'access'), $urlbase, 0, $nextmonth, $nextyear, true);
 862             $prevlink = calendar_get_link_previous(get_string('monthprev', 'access'), $urlbase, 0, $prevmonth, $prevyear, true);
 863
 864             $calendarlink = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', array('view'=>'month')), 1, $data['m'], $data['y']);
 865             if (!empty($data['id'])) {
 866                 $calendarlink->param('course', $data['id']);
 867             }
 868
 869             if (right_to_left()) {
 870                 $left = $nextlink;
 871                 $right = $prevlink;
 872             } else {
 873                 $left = $prevlink;
 874                 $right = $nextlink;
 875             }
 876
 877             $content .= html_writer::start_tag('div', array('class'=>'calendar-controls'));
 878             $content .= $left.'<span class="hide"> | </span>';
 879             $content .= html_writer::tag('span', html_writer::link($calendarlink, userdate($time, get_string('strftimemonthyear')), array('title'=>get_string('monththis','calendar'))), array('class'=>'current'));
 880             $content .= '<span class="hide"> | </span>'. $right;
 881             $content .= "<span class=\"clearer\"><!-- --></span>";
 882             $content .= html_writer::end_tag('div');
 883             break;
 884         case 'upcoming':
 885             $calendarlink = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', array('view'=>'upcoming')), 1, $data['m'], $data['y']);
 886             if (!empty($data['id'])) {
 887                 $calendarlink->param('course', $data['id']);
 888             }
 889             $calendarlink = html_writer::link($calendarlink, userdate($time, get_string('strftimemonthyear')));
 890             $content .= html_writer::tag('div', $calendarlink, array('class'=>'centered'));
 891             break;
 892         case 'display':
 893             $calendarlink = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', array('view'=>'month')), 1, $data['m'], $data['y']);
 894             if (!empty($data['id'])) {
 895                 $calendarlink->param('course', $data['id']);
 896             }
 897             $calendarlink = html_writer::link($calendarlink, userdate($time, get_string('strftimemonthyear')));
 898             $content .= html_writer::tag('h3', $calendarlink);
 899             break;
 900         case 'month':
 901             list($prevmonth, $prevyear) = calendar_sub_month($data['m'], $data['y']);
 902             list($nextmonth, $nextyear) = calendar_add_month($data['m'], $data['y']);
 903             $prevdate = make_timestamp($prevyear, $prevmonth, 1);
 904             $nextdate = make_timestamp($nextyear, $nextmonth, 1);
 905             $prevlink = calendar_get_link_previous(userdate($prevdate, get_string('strftimemonthyear')), 'view.php?view=month'.$courseid.'&amp;', 1, $prevmonth, $prevyear);
 906             $nextlink = calendar_get_link_next(userdate($nextdate, get_string('strftimemonthyear')), 'view.php?view=month'.$courseid.'&amp;', 1, $nextmonth, $nextyear);
 907
 908             if (right_to_left()) {
 909                 $left = $nextlink;
 910                 $right = $prevlink;
 911             } else {
 912                 $left = $prevlink;
 913                 $right = $nextlink;
 914             }
 915
 916             $content .= html_writer::start_tag('div', array('class'=>'calendar-controls'));
 917             $content .= $left . '<span class="hide"> | </span><h1 class="current">'.userdate($time, get_string('strftimemonthyear'))."</h1>";
 918             $content .= '<span class="hide"> | </span>' . $right;
 919             $content .= '<span class="clearer"><!-- --></span>';
 920             $content .= html_writer::end_tag('div')."\n";
 921             break;
 922         case 'day':
 923             $days = calendar_get_days();
 924             $data['d'] = $date['mday']; // Just for convenience
 925             $prevdate = usergetdate(make_timestamp($data['y'], $data['m'], $data['d'] - 1));
 926             $nextdate = usergetdate(make_timestamp($data['y'], $data['m'], $data['d'] + 1));
 927             $prevname = calendar_wday_name($days[$prevdate['wday']]);
 928             $nextname = calendar_wday_name($days[$nextdate['wday']]);
 929             $prevlink = calendar_get_link_previous($prevname, 'view.php?view=day'.$courseid.'&amp;', $prevdate['mday'], $prevdate['mon'], $prevdate['year']);
 930             $nextlink = calendar_get_link_next($nextname, 'view.php?view=day'.$courseid.'&amp;', $nextdate['mday'], $nextdate['mon'], $nextdate['year']);
 931
 932             if (right_to_left()) {
 933                 $left = $nextlink;
 934                 $right = $prevlink;
 935             } else {
 936                 $left = $prevlink;
 937                 $right = $nextlink;
 938             }
 939
 940             $content .= html_writer::start_tag('div', array('class'=>'calendar-controls'));
 941             $content .= $left;
 942             $content .= '<span class="hide"> | </span><span class="current">'.userdate($time, get_string('strftimedaydate')).'</span>';
 943             $content .= '<span class="hide"> | </span>'. $right;
 944             $content .= "<span class=\"clearer\"><!-- --></span>";
 945             $content .= html_writer::end_tag('div')."\n";
 946
 947             break;
 948     }
 949     return $content;
 950 }
 951
 952 /**
 953  * Formats a filter control element.
 954  *
 955  * @param moodle_url $url of the filter
 956  * @param int $type constant defining the type filter
 957  * @return string html content of the element
 958  */
 959 function calendar_filter_controls_element(moodle_url $url, $type) {
 960     global $OUTPUT;
 961     switch ($type) {
 962         case CALENDAR_EVENT_GLOBAL:
 963             $typeforhumans = 'global';
 964             $class = 'calendar_event_global';
 965             break;
 966         case CALENDAR_EVENT_COURSE:
 967             $typeforhumans = 'course';
 968             $class = 'calendar_event_course';
 969             break;
 970         case CALENDAR_EVENT_GROUP:
 971             $typeforhumans = 'groups';
 972             $class = 'calendar_event_group';
 973             break;
 974         case CALENDAR_EVENT_USER:
 975             $typeforhumans = 'user';
 976             $class = 'calendar_event_user';
 977             break;
 978     }
 979     if (calendar_show_event_type($type)) {
 980         $icon = $OUTPUT->pix_icon('t/hide', get_string('hide'));
 981         $str = get_string('hide'.$typeforhumans.'events', 'calendar');
 982     } else {
 983         $icon = $OUTPUT->pix_icon('t/show', get_string('show'));
 984         $str = get_string('show'.$typeforhumans.'events', 'calendar');
 985     }
 986     $content = html_writer::start_tag('li', array('class' => 'calendar_event'));
 987     $content .= html_writer::start_tag('a', array('href' => $url));
 988     $content .= html_writer::tag('span', $icon, array('class' => $class));
 989     $content .= html_writer::tag('span', $str, array('class' => 'eventname'));
 990     $content .= html_writer::end_tag('a');
 991     $content .= html_writer::end_tag('li');
 992     return $content;
 993 }
 994
 995 /**
 996  * Get the controls filter for calendar.
 997  *
 998  * Filter is used to hide calendar info from the display page
 999  *
1000  * @param moodle_url $returnurl return-url for filter controls
1001  * @return string $content return filter controls in html
1002  */
1003 function calendar_filter_controls(moodle_url $returnurl) {
1004     global $CFG, $USER, $OUTPUT;
1005
1006     $groupevents = true;
1007     $id = optional_param( 'id',0,PARAM_INT );
1008     $seturl = new moodle_url('/calendar/set.php', array('return' => base64_encode($returnurl->out(false)), 'sesskey'=>sesskey()));
1009     $content = html_writer::start_tag('ul');
1010
1011     $seturl->param('var', 'showglobal');
1012     $content .= calendar_filter_controls_element($seturl, CALENDAR_EVENT_GLOBAL);
1013
1014     $seturl->param('var', 'showcourses');
1015     $content .= calendar_filter_controls_element($seturl, CALENDAR_EVENT_COURSE);
1016
1017     if (isloggedin() && !isguestuser()) {
1018         if ($groupevents) {
1019             // This course MIGHT have group events defined, so show the filter
1020             $seturl->param('var', 'showgroups');
1021             $content .= calendar_filter_controls_element($seturl, CALENDAR_EVENT_GROUP);
1022         } else {
1023             // This course CANNOT have group events, so lose the filter
1024         }
1025         $seturl->param('var', 'showuser');
1026         $content .= calendar_filter_controls_element($seturl, CALENDAR_EVENT_USER);
1027     }
1028     $content .= html_writer::end_tag('ul');
1029
1030     return $content;
1031 }
1032
1033 /**
1034  * Return the representation day
1035  *
1036  * @param int $tstamp Timestamp in GMT
1037  * @param int $now current Unix timestamp
1038  * @param bool $usecommonwords
1039  * @return string the formatted date/time
1040  */
1041 function calendar_day_representation($tstamp, $now = false, $usecommonwords = true) {
1042
1043     static $shortformat;
1044     if(empty($shortformat)) {
1045         $shortformat = get_string('strftimedayshort');
1046     }
1047
1048     if($now === false) {
1049         $now = time();
1050     }
1051
1052     // To have it in one place, if a change is needed
1053     $formal = userdate($tstamp, $shortformat);
1054
1055     $datestamp = usergetdate($tstamp);
1056     $datenow   = usergetdate($now);
1057
1058     if($usecommonwords == false) {
1059         // We don't want words, just a date
1060         return $formal;
1061     }
1062     else if($datestamp['year'] == $datenow['year'] && $datestamp['yday'] == $datenow['yday']) {
1063         // Today
1064         return get_string('today', 'calendar');
1065     }
1066     else if(
1067         ($datestamp['year'] == $datenow['year'] && $datestamp['yday'] == $datenow['yday'] - 1 ) ||
1068         ($datestamp['year'] == $datenow['year'] - 1 && $datestamp['mday'] == 31 && $datestamp['mon'] == 12 && $datenow['yday'] == 1)
1069         ) {
1070         // Yesterday
1071         return get_string('yesterday', 'calendar');
1072     }
1073     else if(
1074         ($datestamp['year'] == $datenow['year'] && $datestamp['yday'] == $datenow['yday'] + 1 ) ||
1075         ($datestamp['year'] == $datenow['year'] + 1 && $datenow['mday'] == 31 && $datenow['mon'] == 12 && $datestamp['yday'] == 1)
1076         ) {
1077         // Tomorrow
1078         return get_string('tomorrow', 'calendar');
1079     }
1080     else {
1081         return $formal;
1082     }
1083 }
1084
1085 /**
1086  * return the formatted representation time
1087  *
1088  * @param int $time the timestamp in UTC, as obtained from the database
1089  * @return string the formatted date/time
1090  */
1091 function calendar_time_representation($time) {
1092     static $langtimeformat = NULL;
1093     if($langtimeformat === NULL) {
1094         $langtimeformat = get_string('strftimetime');
1095     }
1096     $timeformat = get_user_preferences('calendar_timeformat');
1097     if(empty($timeformat)){
1098         $timeformat = get_config(NULL,'calendar_site_timeformat');
1099     }
1100     // The ? is needed because the preference might be present, but empty
1101     return userdate($time, empty($timeformat) ? $langtimeformat : $timeformat);
1102 }
1103
1104 /**
1105  * Adds day, month, year arguments to a URL and returns a moodle_url object.
1106  *
1107  * @param string|moodle_url $linkbase
1108  * @param int $d The number of the day.
1109  * @param int $m The number of the month.
1110  * @param int $y The number of the year.
1111  * @return moodle_url|null $linkbase
1112  */
1113 function calendar_get_link_href($linkbase, $d, $m, $y) {
1114     if (empty($linkbase)) {
1115         return '';
1116     }
1117     if (!($linkbase instanceof moodle_url)) {
1118         $linkbase = new moodle_url($linkbase);
1119     }
1120     if (!empty($d)) {
1121         $linkbase->param('cal_d', $d);
1122     }
1123     if (!empty($m)) {
1124         $linkbase->param('cal_m', $m);
1125     }
1126     if (!empty($y)) {
1127         $linkbase->param('cal_y', $y);
1128     }
1129     return $linkbase;
1130 }
1131
1132 /**
1133  * Build and return a previous month HTML link, with an arrow.
1134  *
1135  * @param string $text The text label.
1136  * @param string|moodle_url $linkbase The URL stub.
1137  * @param int $d The number of the date.
1138  * @param int $m The number of the month.
1139  * @param int $y year The number of the year.
1140  * @param bool $accesshide Default visible, or hide from all except screenreaders.
1141  * @return string HTML string.
1142  */
1143 function calendar_get_link_previous($text, $linkbase, $d, $m, $y, $accesshide=false) {
1144     $href = calendar_get_link_href(new moodle_url($linkbase), $d, $m, $y);
1145     if (empty($href)) {
1146         return $text;
1147     }
1148     return link_arrow_left($text, (string)$href, $accesshide, 'previous');
1149 }
1150
1151 /**
1152  * Build and return a next month HTML link, with an arrow.
1153  *
1154  * @param string $text The text label.
1155  * @param string|moodle_url $linkbase The URL stub.
1156  * @param int $d the number of the Day
1157  * @param int $m The number of the month.
1158  * @param int $y The number of the year.
1159  * @param bool $accesshide Default visible, or hide from all except screenreaders.
1160  * @return string HTML string.
1161  */
1162 function calendar_get_link_next($text, $linkbase, $d, $m, $y, $accesshide=false) {
1163     $href = calendar_get_link_href(new moodle_url($linkbase), $d, $m, $y);
1164     if (empty($href)) {
1165         return $text;
1166     }
1167     return link_arrow_right($text, (string)$href, $accesshide, 'next');
1168 }
1169
1170 /**
1171  * Return the name of the weekday
1172  *
1173  * @param string $englishname
1174  * @return string of the weekeday
1175  */
1176 function calendar_wday_name($englishname) {
1177     return get_string(strtolower($englishname), 'calendar');
1178 }
1179
1180 /**
1181  * Return the number of days in month
1182  *
1183  * @param int $month the number of the month.
1184  * @param int $year the number of the year
1185  * @return int
1186  */
1187 function calendar_days_in_month($month, $year) {
1188    return intval(date('t', mktime(0, 0, 0, $month, 1, $year)));
1189 }
1190
1191 /**
1192  * Get the upcoming event block
1193  *
1194  * @param array $events list of events
1195  * @param moodle_url|string $linkhref link to event referer
1196  * @return string|null $content html block content
1197  */
1198 function calendar_get_block_upcoming($events, $linkhref = NULL) {
1199     $content = '';
1200     $lines = count($events);
1201     if (!$lines) {
1202         return $content;
1203     }
1204
1205     for ($i = 0; $i < $lines; ++$i) {
1206         if (!isset($events[$i]->time)) {   // Just for robustness
1207             continue;
1208         }
1209         $events[$i] = calendar_add_event_metadata($events[$i]);
1210         $content .= '<div class="event"><span class="icon c0">'.$events[$i]->icon.'</span>';
1211         if (!empty($events[$i]->referer)) {
1212             // That's an activity event, so let's provide the hyperlink
1213             $content .= $events[$i]->referer;
1214         } else {
1215             if(!empty($linkhref)) {
1216                 $ed = usergetdate($events[$i]->timestart);
1217                 $href = calendar_get_link_href(new moodle_url(CALENDAR_URL.$linkhref), $ed['mday'], $ed['mon'], $ed['year']);
1218                 $href->set_anchor('event_'.$events[$i]->id);
1219                 $content .= html_writer::link($href, $events[$i]->name);
1220             }
1221             else {
1222                 $content .= $events[$i]->name;
1223             }
1224         }
1225         $events[$i]->time = str_replace('&raquo;', '<br />&raquo;', $events[$i]->time);
1226         $content .= '<div class="date">'.$events[$i]->time.'</div></div>';
1227         if ($i < $lines - 1) $content .= '<hr />';
1228     }
1229
1230     return $content;
1231 }
1232
1233 /**
1234  * Get the next following month
1235  *
1236  * If the current month is December, it will get the first month of the following year.
1237  *
1238  *
1239  * @param int $month the number of the month.
1240  * @param int $year the number of the year.
1241  * @return array the following month
1242  */
1243 function calendar_add_month($month, $year) {
1244     if($month == 12) {
1245         return array(1, $year + 1);
1246     }
1247     else {
1248         return array($month + 1, $year);
1249     }
1250 }
1251
1252 /**
1253  * Get the previous month
1254  *
1255  * If the current month is January, it will get the last month of the previous year.
1256  *
1257  * @param int $month the number of the month.
1258  * @param int $year the number of the year.
1259  * @return array previous month
1260  */
1261 function calendar_sub_month($month, $year) {
1262     if($month == 1) {
1263         return array(12, $year - 1);
1264     }
1265     else {
1266         return array($month - 1, $year);
1267     }
1268 }
1269
1270 /**
1271  * Get per-day basis events
1272  *
1273  * @param array $events list of events
1274  * @param int $month the number of the month
1275  * @param int $year the number of the year
1276  * @param array $eventsbyday event on specific day
1277  * @param array $durationbyday duration of the event in days
1278  * @param array $typesbyday event type (eg: global, course, user, or group)
1279  * @param array $courses list of courses
1280  * @return void
1281  */
1282 function calendar_events_by_day($events, $month, $year, &$eventsbyday, &$durationbyday, &$typesbyday, &$courses) {
1283     $eventsbyday = array();
1284     $typesbyday = array();
1285     $durationbyday = array();
1286
1287     if($events === false) {
1288         return;
1289     }
1290
1291     foreach($events as $event) {
1292
1293         $startdate = usergetdate($event->timestart);
1294         // Set end date = start date if no duration
1295         if ($event->timeduration) {
1296             $enddate   = usergetdate($event->timestart + $event->timeduration - 1);
1297         } else {
1298             $enddate = $startdate;
1299         }
1300
1301         // Simple arithmetic: $year * 13 + $month is a distinct integer for each distinct ($year, $month) pair
1302         if(!($startdate['year'] * 13 + $startdate['mon'] <= $year * 13 + $month) && ($enddate['year'] * 13 + $enddate['mon'] >= $year * 13 + $month)) {
1303             // Out of bounds
1304             continue;
1305         }
1306
1307         $eventdaystart = intval($startdate['mday']);
1308
1309         if($startdate['mon'] == $month && $startdate['year'] == $year) {
1310             // Give the event to its day
1311             $eventsbyday[$eventdaystart][] = $event->id;
1312
1313             // Mark the day as having such an event
1314             if($event->courseid == SITEID && $event->groupid == 0) {
1315                 $typesbyday[$eventdaystart]['startglobal'] = true;
1316                 // Set event class for global event
1317                 $events[$event->id]->class = 'calendar_event_global';
1318             }
1319             else if($event->courseid != 0 && $event->courseid != SITEID && $event->groupid == 0) {
1320                 $typesbyday[$eventdaystart]['startcourse'] = true;
1321                 // Set event class for course event
1322                 $events[$event->id]->class = 'calendar_event_course';
1323             }
1324             else if($event->groupid) {
1325                 $typesbyday[$eventdaystart]['startgroup'] = true;
1326                 // Set event class for group event
1327                 $events[$event->id]->class = 'calendar_event_group';
1328             }
1329             else if($event->userid) {
1330                 $typesbyday[$eventdaystart]['startuser'] = true;
1331                 // Set event class for user event
1332                 $events[$event->id]->class = 'calendar_event_user';
1333             }
1334         }
1335
1336         if($event->timeduration == 0) {
1337             // Proceed with the next
1338             continue;
1339         }
1340
1341         // The event starts on $month $year or before. So...
1342         $lowerbound = $startdate['mon'] == $month && $startdate['year'] == $year ? intval($startdate['mday']) : 0;
1343
1344         // Also, it ends on $month $year or later...
1345         $upperbound = $enddate['mon'] == $month && $enddate['year'] == $year ? intval($enddate['mday']) : calendar_days_in_month($month, $year);
1346
1347         // Mark all days between $lowerbound and $upperbound (inclusive) as duration
1348         for($i = $lowerbound + 1; $i <= $upperbound; ++$i) {
1349             $durationbyday[$i][] = $event->id;
1350             if($event->courseid == SITEID && $event->groupid == 0) {
1351                 $typesbyday[$i]['durationglobal'] = true;
1352             }
1353             else if($event->courseid != 0 && $event->courseid != SITEID && $event->groupid == 0) {
1354                 $typesbyday[$i]['durationcourse'] = true;
1355             }
1356             else if($event->groupid) {
1357                 $typesbyday[$i]['durationgroup'] = true;
1358             }
1359             else if($event->userid) {
1360                 $typesbyday[$i]['durationuser'] = true;
1361             }
1362         }
1363
1364     }
1365     return;
1366 }
1367
1368 /**
1369  * Get current module cache
1370  *
1371  * @param array $coursecache list of course cache
1372  * @param string $modulename name of the module
1373  * @param int $instance module instance number
1374  * @return stdClass|bool $module information
1375  */
1376 function calendar_get_module_cached(&$coursecache, $modulename, $instance) {
1377     $module = get_coursemodule_from_instance($modulename, $instance);
1378
1379     if($module === false) return false;
1380     if(!calendar_get_course_cached($coursecache, $module->course)) {
1381         return false;
1382     }
1383     return $module;
1384 }
1385
1386 /**
1387  * Get current course cache
1388  *
1389  * @param array $coursecache list of course cache
1390  * @param int $courseid id of the course
1391  * @return stdClass $coursecache[$courseid] return the specific course cache
1392  */
1393 function calendar_get_course_cached(&$coursecache, $courseid) {
1394     global $COURSE, $DB;
1395
1396     if (!isset($coursecache[$courseid])) {
1397         if ($courseid == $COURSE->id) {
1398             $coursecache[$courseid] = $COURSE;
1399         } else {
1400             $coursecache[$courseid] = $DB->get_record('course', array('id'=>$courseid));
1401         }
1402     }
1403     return $coursecache[$courseid];
1404 }
1405
1406 /**
1407  * Returns the courses to load events for, the
1408  *
1409  * @param array $courseeventsfrom An array of courses to load calendar events for
1410  * @param bool $ignorefilters specify the use of filters, false is set as default
1411  * @return array An array of courses, groups, and user to load calendar events for based upon filters
1412  */
1413 function calendar_set_filters(array $courseeventsfrom, $ignorefilters = false) {
1414     global $USER, $CFG, $DB;
1415
1416     // For backwards compatability we have to check whether the courses array contains
1417     // just id's in which case we need to load course objects.
1418     $coursestoload = array();
1419     foreach ($courseeventsfrom as $id => $something) {
1420         if (!is_object($something)) {
1421             $coursestoload[] = $id;
1422             unset($courseeventsfrom[$id]);
1423         }
1424     }
1425     if (!empty($coursestoload)) {
1426         // TODO remove this in 2.2
1427         debugging('calendar_set_filters now preferes an array of course objects with preloaded contexts', DEBUG_DEVELOPER);
1428         $courseeventsfrom = array_merge($courseeventsfrom, $DB->get_records_list('course', 'id', $coursestoload));
1429     }
1430
1431     $courses = array();
1432     $user = false;
1433     $group = false;
1434
1435     // capabilities that allow seeing group events from all groups
1436     // TODO: rewrite so that moodle/calendar:manageentries is not necessary here
1437     $allgroupscaps = array('moodle/site:accessallgroups', 'moodle/calendar:manageentries');
1438
1439     $isloggedin = isloggedin();
1440
1441     if ($ignorefilters || calendar_show_event_type(CALENDAR_EVENT_COURSE)) {
1442         $courses = array_keys($courseeventsfrom);
1443     }
1444     if ($ignorefilters || calendar_show_event_type(CALENDAR_EVENT_GLOBAL)) {
1445         $courses[] = SITEID;
1446     }
1447     $courses = array_unique($courses);
1448     sort($courses);
1449
1450     if (!empty($courses) && in_array(SITEID, $courses)) {
1451         // Sort courses for consistent colour highlighting
1452         // Effectively ignoring SITEID as setting as last course id
1453         $key = array_search(SITEID, $courses);
1454         unset($courses[$key]);
1455         $courses[] = SITEID;
1456     }
1457
1458     if ($ignorefilters || ($isloggedin && calendar_show_event_type(CALENDAR_EVENT_USER))) {
1459         $user = $USER->id;
1460     }
1461
1462     if (!empty($courseeventsfrom) && (calendar_show_event_type(CALENDAR_EVENT_GROUP) || $ignorefilters)) {
1463
1464         if (count($courseeventsfrom)==1) {
1465             $course = reset($courseeventsfrom);
1466             if (has_any_capability($allgroupscaps, context_course::instance($course->id))) {
1467                 $coursegroups = groups_get_all_groups($course->id, 0, 0, 'g.id');
1468                 $group = array_keys($coursegroups);
1469             }
1470         }
1471         if ($group === false) {
1472             if (!empty($CFG->calendar_adminseesall) && has_any_capability($allgroupscaps, get_system_context())) {
1473                 $group = true;
1474             } else if ($isloggedin) {
1475                 $groupids = array();
1476
1477                 // We already have the courses to examine in $courses
1478                 // For each course...
1479                 foreach ($courseeventsfrom as $courseid => $course) {
1480                     // If the user is an editing teacher in there,
1481                     if (!empty($USER->groupmember[$course->id])) {
1482                         // We've already cached the users groups for this course so we can just use that
1483                         $groupids = array_merge($groupids, $USER->groupmember[$course->id]);
1484                     } else if ($course->groupmode != NOGROUPS || !$course->groupmodeforce) {
1485                         // If this course has groups, show events from all of those related to the current user
1486                         $coursegroups = groups_get_user_groups($course->id, $USER->id);
1487                         $groupids = array_merge($groupids, $coursegroups['0']);
1488                     }
1489                 }
1490                 if (!empty($groupids)) {
1491                     $group = $groupids;
1492                 }
1493             }
1494         }
1495     }
1496     if (empty($courses)) {
1497         $courses = false;
1498     }
1499
1500     return array($courses, $group, $user);
1501 }
1502
1503 /**
1504  * Return the capability for editing calendar event
1505  *
1506  * @param calendar_event $event event object
1507  * @return bool capability to edit event
1508  */
1509 function calendar_edit_event_allowed($event) {
1510     global $USER, $DB;
1511
1512     // Must be logged in
1513     if (!isloggedin()) {
1514         return false;
1515     }
1516
1517     // can not be using guest account
1518     if (isguestuser()) {
1519         return false;
1520     }
1521
1522     // You cannot edit calendar subscription events presently.
1523     if (!empty($event->subscriptionid)) {
1524         return false;
1525     }
1526
1527     $sitecontext = context_system::instance();
1528     // if user has manageentries at site level, return true
1529     if (has_capability('moodle/calendar:manageentries', $sitecontext)) {
1530         return true;
1531     }
1532
1533     // if groupid is set, it's definitely a group event
1534     if (!empty($event->groupid)) {
1535         // Allow users to add/edit group events if:
1536         // 1) They have manageentries (= entries for whole course)
1537         // 2) They have managegroupentries AND are in the group
1538         $group = $DB->get_record('groups', array('id'=>$event->groupid));
1539         return $group && (
1540             has_capability('moodle/calendar:manageentries', $event->context) ||
1541             (has_capability('moodle/calendar:managegroupentries', $event->context)
1542                 && groups_is_member($event->groupid)));
1543     } else if (!empty($event->courseid)) {
1544     // if groupid is not set, but course is set,
1545     // it's definiely a course event
1546         return has_capability('moodle/calendar:manageentries', $event->context);
1547     } else if (!empty($event->userid) && $event->userid == $USER->id) {
1548     // if course is not set, but userid id set, it's a user event
1549         return (has_capability('moodle/calendar:manageownentries', $event->context));
1550     } else if (!empty($event->userid)) {
1551         return (has_capability('moodle/calendar:manageentries', $event->context));
1552     }
1553     return false;
1554 }
1555
1556 /**
1557  * Returns the default courses to display on the calendar when there isn't a specific
1558  * course to display.
1559  *
1560  * @return array $courses Array of courses to display
1561  */
1562 function calendar_get_default_courses() {
1563     global $CFG, $DB;
1564
1565     if (!isloggedin()) {
1566         return array();
1567     }
1568
1569     $courses = array();
1570     if (!empty($CFG->calendar_adminseesall) && has_capability('moodle/calendar:manageentries', context_system::instance())) {
1571         list ($select, $join) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
1572         $sql = "SELECT c.* $select
1573                   FROM {course} c
1574                   $join
1575                   WHERE EXISTS (SELECT 1 FROM {event} e WHERE e.courseid = c.id)
1576                   ";
1577         $courses = $DB->get_records_sql($sql, null, 0, 20);
1578         foreach ($courses as $course) {
1579             context_helper::preload_from_record($course);
1580         }
1581         return $courses;
1582     }
1583
1584     $courses = enrol_get_my_courses();
1585
1586     return $courses;
1587 }
1588
1589 /**
1590  * Display calendar preference button
1591  *
1592  * @param stdClass $course course object
1593  * @return string return preference button in html
1594  */
1595 function calendar_preferences_button(stdClass $course) {
1596     global $OUTPUT;
1597
1598     // Guests have no preferences
1599     if (!isloggedin() || isguestuser()) {
1600         return '';
1601     }
1602
1603     return $OUTPUT->single_button(new moodle_url('/calendar/preferences.php', array('course' => $course->id)), get_string("preferences", "calendar"));
1604 }
1605
1606 /**
1607  * Get event format time
1608  *
1609  * @param calendar_event $event event object
1610  * @param int $now current time in gmt
1611  * @param array $linkparams list of params for event link
1612  * @param bool $usecommonwords the words as formatted date/time.
1613  * @param int $showtime determine the show time GMT timestamp
1614  * @return string $eventtime link/string for event time
1615  */
1616 function calendar_format_event_time($event, $now, $linkparams = null, $usecommonwords = true, $showtime=0) {
1617     $startdate = usergetdate($event->timestart);
1618     $enddate = usergetdate($event->timestart + $event->timeduration);
1619     $usermidnightstart = usergetmidnight($event->timestart);
1620
1621     if($event->timeduration) {
1622         // To avoid doing the math if one IF is enough :)
1623         $usermidnightend = usergetmidnight($event->timestart + $event->timeduration);
1624     }
1625     else {
1626         $usermidnightend = $usermidnightstart;
1627     }
1628
1629     if (empty($linkparams) || !is_array($linkparams)) {
1630         $linkparams = array();
1631     }
1632     $linkparams['view'] = 'day';
1633
1634     // OK, now to get a meaningful display...
1635     // First of all we have to construct a human-readable date/time representation
1636
1637     if($event->timeduration) {
1638         // It has a duration
1639         if($usermidnightstart == $usermidnightend ||
1640            ($event->timestart == $usermidnightstart) && ($event->timeduration == 86400 || $event->timeduration == 86399) ||
1641            ($event->timestart + $event->timeduration <= $usermidnightstart + 86400)) {
1642             // But it's all on the same day
1643             $timestart = calendar_time_representation($event->timestart);
1644             $timeend = calendar_time_representation($event->timestart + $event->timeduration);
1645             $time = $timestart.' <strong>&raquo;</strong> '.$timeend;
1646
1647             if ($event->timestart == $usermidnightstart && ($event->timeduration == 86400 || $event->timeduration == 86399)) {
1648                 $time = get_string('allday', 'calendar');
1649             }
1650
1651             // Set printable representation
1652             if (!$showtime) {
1653                 $day = calendar_day_representation($event->timestart, $now, $usecommonwords);
1654                 $url = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', $linkparams), $enddate['mday'], $enddate['mon'], $enddate['year']);
1655                 $eventtime = html_writer::link($url, $day).', '.$time;
1656             } else {
1657                 $eventtime = $time;
1658             }
1659         } else {
1660             // It spans two or more days
1661             $daystart = calendar_day_representation($event->timestart, $now, $usecommonwords).', ';
1662             if ($showtime == $usermidnightstart) {
1663                 $daystart = '';
1664             }
1665             $timestart = calendar_time_representation($event->timestart);
1666             $dayend = calendar_day_representation($event->timestart + $event->timeduration, $now, $usecommonwords).', ';
1667             if ($showtime == $usermidnightend) {
1668                 $dayend = '';
1669             }
1670             $timeend = calendar_time_representation($event->timestart + $event->timeduration);
1671
1672             // Set printable representation
1673             if ($now >= $usermidnightstart && $now < ($usermidnightstart + 86400)) {
1674                 $url = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', $linkparams), $enddate['mday'], $enddate['mon'], $enddate['year']);
1675                 $eventtime = $timestart.' <strong>&raquo;</strong> '.html_writer::link($url, $dayend).$timeend;
1676             } else {
1677                 $url = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', $linkparams), $enddate['mday'], $enddate['mon'], $enddate['year']);
1678                 $eventtime  = html_writer::link($url, $daystart).$timestart.' <strong>&raquo;</strong> ';
1679
1680                 $url = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', $linkparams), $startdate['mday'], $startdate['mon'], $startdate['year']);
1681                 $eventtime .= html_writer::link($url, $dayend).$timeend;
1682             }
1683         }
1684     } else {
1685         $time = calendar_time_representation($event->timestart);
1686
1687         // Set printable representation
1688         if (!$showtime) {
1689             $day = calendar_day_representation($event->timestart, $now, $usecommonwords);
1690             $url = calendar_get_link_href(new moodle_url(CALENDAR_URL.'view.php', $linkparams), $startdate['mday'], $startdate['mon'], $startdate['year']);
1691             $eventtime = html_writer::link($url, $day).', '.trim($time);
1692         } else {
1693             $eventtime = $time;
1694         }
1695     }
1696
1697     if($event->timestart + $event->timeduration < $now) {
1698         // It has expired
1699         $eventtime = '<span class="dimmed_text">'.str_replace(' href=', ' class="dimmed" href=', $eventtime).'</span>';
1700     }
1701
1702     return $eventtime;
1703 }
1704
1705 /**
1706  * Display month selector options
1707  *
1708  * @param string $name for the select element
1709  * @param string|array $selected options for select elements
1710  */
1711 function calendar_print_month_selector($name, $selected) {
1712     $months = array();
1713     for ($i=1; $i<=12; $i++) {
1714         $months[$i] = userdate(gmmktime(12, 0, 0, $i, 15, 2000), '%B');
1715     }
1716     echo html_writer::label(get_string('months'), 'menu'. $name, false, array('class' => 'accesshide'));
1717     echo html_writer::select($months, $name, $selected, false);
1718 }
1719
1720 /**
1721  * Checks to see if the requested type of event should be shown for the given user.
1722  *
1723  * @param CALENDAR_EVENT_GLOBAL|CALENDAR_EVENT_COURSE|CALENDAR_EVENT_GROUP|CALENDAR_EVENT_USER $type
1724  *          The type to check the display for (default is to display all)
1725  * @param stdClass|int|null $user The user to check for - by default the current user
1726  * @return bool True if the tyep should be displayed false otherwise
1727  */
1728 function calendar_show_event_type($type, $user = null) {
1729     $default = CALENDAR_EVENT_GLOBAL + CALENDAR_EVENT_COURSE + CALENDAR_EVENT_GROUP + CALENDAR_EVENT_USER;
1730     if (get_user_preferences('calendar_persistflt', 0, $user) === 0) {
1731         global $SESSION;
1732         if (!isset($SESSION->calendarshoweventtype)) {
1733             $SESSION->calendarshoweventtype = $default;
1734         }
1735         return $SESSION->calendarshoweventtype & $type;
1736     } else {
1737         return get_user_preferences('calendar_savedflt', $default, $user) & $type;
1738     }
1739 }
1740
1741 /**
1742  * Sets the display of the event type given $display.
1743  *
1744  * If $display = true the event type will be shown.
1745  * If $display = false the event type will NOT be shown.
1746  * If $display = null the current value will be toggled and saved.
1747  *
1748  * @param CALENDAR_EVENT_GLOBAL|CALENDAR_EVENT_COURSE|CALENDAR_EVENT_GROUP|CALENDAR_EVENT_USER $type object of CALENDAR_EVENT_XXX
1749  * @param bool $display option to display event type
1750  * @param stdClass|int $user moodle user object or id, null means current user
1751  */
1752 function calendar_set_event_type_display($type, $display = null, $user = null) {
1753     $persist = get_user_preferences('calendar_persistflt', 0, $user);
1754     $default = CALENDAR_EVENT_GLOBAL + CALENDAR_EVENT_COURSE + CALENDAR_EVENT_GROUP + CALENDAR_EVENT_USER;
1755     if ($persist === 0) {
1756         global $SESSION;
1757         if (!isset($SESSION->calendarshoweventtype)) {
1758             $SESSION->calendarshoweventtype = $default;
1759         }
1760         $preference = $SESSION->calendarshoweventtype;
1761     } else {
1762         $preference = get_user_preferences('calendar_savedflt', $default, $user);
1763     }
1764     $current = $preference & $type;
1765     if ($display === null) {
1766         $display = !$current;
1767     }
1768     if ($display && !$current) {
1769         $preference += $type;
1770     } else if (!$display && $current) {
1771         $preference -= $type;
1772     }
1773     if ($persist === 0) {
1774         $SESSION->calendarshoweventtype = $preference;
1775     } else {
1776         if ($preference == $default) {
1777             unset_user_preference('calendar_savedflt', $user);
1778         } else {
1779             set_user_preference('calendar_savedflt', $preference, $user);
1780         }
1781     }
1782 }
1783
1784 /**
1785  * Get calendar's allowed types
1786  *
1787  * @param stdClass $allowed list of allowed edit for event  type
1788  * @param stdClass|int $course object of a course or course id
1789  */
1790 function calendar_get_allowed_types(&$allowed, $course = null) {
1791     global $USER, $CFG, $DB;
1792     $allowed = new stdClass();
1793     $allowed->user = has_capability('moodle/calendar:manageownentries', get_system_context());
1794     $allowed->groups = false; // This may change just below
1795     $allowed->courses = false; // This may change just below
1796     $allowed->site = has_capability('moodle/calendar:manageentries', context_course::instance(SITEID));
1797
1798     if (!empty($course)) {
1799         if (!is_object($course)) {
1800             $course = $DB->get_record('course', array('id' => $course), '*', MUST_EXIST);
1801         }
1802         if ($course->id != SITEID) {
1803             $coursecontext = context_course::instance($course->id);
1804             $allowed->user = has_capability('moodle/calendar:manageownentries', $coursecontext);
1805
1806             if (has_capability('moodle/calendar:manageentries', $coursecontext)) {
1807                 $allowed->courses = array($course->id => 1);
1808
1809                 if ($course->groupmode != NOGROUPS || !$course->groupmodeforce) {
1810                     if (has_capability('moodle/site:accessallgroups', $coursecontext)) {
1811                         $allowed->groups = groups_get_all_groups($course->id);
1812                     } else {
1813                         $allowed->groups = groups_get_all_groups($course->id, $USER->id);
1814                     }
1815                 }
1816             } else if (has_capability('moodle/calendar:managegroupentries', $coursecontext)) {
1817                 if($course->groupmode != NOGROUPS || !$course->groupmodeforce) {
1818                     if (has_capability('moodle/site:accessallgroups', $coursecontext)) {
1819                         $allowed->groups = groups_get_all_groups($course->id);
1820                     } else {
1821                         $allowed->groups = groups_get_all_groups($course->id, $USER->id);
1822                     }
1823                 }
1824             }
1825         }
1826     }
1827 }
1828
1829 /**
1830  * See if user can add calendar entries at all
1831  * used to print the "New Event" button
1832  *
1833  * @param stdClass $course object of a course or course id
1834  * @return bool has the capability to add at least one event type
1835  */
1836 function calendar_user_can_add_event($course) {
1837     if (!isloggedin() || isguestuser()) {
1838         return false;
1839     }
1840     calendar_get_allowed_types($allowed, $course);
1841     return (bool)($allowed->user || $allowed->groups || $allowed->courses || $allowed->site);
1842 }
1843
1844 /**
1845  * Check wether the current user is permitted to add events
1846  *
1847  * @param stdClass $event object of event
1848  * @return bool has the capability to add event
1849  */
1850 function calendar_add_event_allowed($event) {
1851     global $USER, $DB;
1852
1853     // can not be using guest account
1854     if (!isloggedin() or isguestuser()) {
1855         return false;
1856     }
1857
1858     $sitecontext = context_system::instance();
1859     // if user has manageentries at site level, always return true
1860     if (has_capability('moodle/calendar:manageentries', $sitecontext)) {
1861         return true;
1862     }
1863
1864     switch ($event->eventtype) {
1865         case 'course':
1866             return has_capability('moodle/calendar:manageentries', $event->context);
1867
1868         case 'group':
1869             // Allow users to add/edit group events if:
1870             // 1) They have manageentries (= entries for whole course)
1871             // 2) They have managegroupentries AND are in the group
1872             $group = $DB->get_record('groups', array('id'=>$event->groupid));
1873             return $group && (
1874                 has_capability('moodle/calendar:manageentries', $event->context) ||
1875                 (has_capability('moodle/calendar:managegroupentries', $event->context)
1876                     && groups_is_member($event->groupid)));
1877
1878         case 'user':
1879             if ($event->userid == $USER->id) {
1880                 return (has_capability('moodle/calendar:manageownentries', $event->context));
1881             }
1882             //there is no 'break;' intentionally
1883
1884         case 'site':
1885             return has_capability('moodle/calendar:manageentries', $event->context);
1886
1887         default:
1888             return has_capability('moodle/calendar:manageentries', $event->context);
1889     }
1890 }
1891
1892 /**
1893  * Manage calendar events
1894  *
1895  * This class provides the required functionality in order to manage calendar events.
1896  * It was introduced as part of Moodle 2.0 and was created in order to provide a
1897  * better framework for dealing with calendar events in particular regard to file
1898  * handling through the new file API
1899  *
1900  * @package    core_calendar
1901  * @category   calendar
1902  * @copyright  2009 Sam Hemelryk
1903  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1904  *
1905  * @property int $id The id within the event table
1906  * @property string $name The name of the event
1907  * @property string $description The description of the event
1908  * @property int $format The format of the description FORMAT_?
1909  * @property int $courseid The course the event is associated with (0 if none)
1910  * @property int $groupid The group the event is associated with (0 if none)
1911  * @property int $userid The user the event is associated with (0 if none)
1912  * @property int $repeatid If this is a repeated event this will be set to the
1913  *                          id of the original
1914  * @property string $modulename If added by a module this will be the module name
1915  * @property int $instance If added by a module this will be the module instance
1916  * @property string $eventtype The event type
1917  * @property int $timestart The start time as a timestamp
1918  * @property int $timeduration The duration of the event in seconds
1919  * @property int $visible 1 if the event is visible
1920  * @property int $uuid ?
1921  * @property int $sequence ?
1922  * @property int $timemodified The time last modified as a timestamp
1923  */
1924 class calendar_event {
1925
1926     /** @var array An object containing the event properties can be accessed via the magic __get/set methods */
1927     protected $properties = null;
1928
1929     /**
1930      * @var string The converted event discription with file paths resolved. This gets populated when someone requests description for the first time */
1931     protected $_description = null;
1932
1933     /** @var array The options to use with this description editor */
1934     protected $editoroptions = array(
1935             'subdirs'=>false,
1936             'forcehttps'=>false,
1937             'maxfiles'=>-1,
1938             'maxbytes'=>null,
1939             'trusttext'=>false);
1940
1941     /** @var object The context to use with the description editor */
1942     protected $editorcontext = null;
1943
1944     /**
1945      * Instantiates a new event and optionally populates its properties with the
1946      * data provided
1947      *
1948      * @param stdClass $data Optional. An object containing the properties to for
1949      *                  an event
1950      */
1951     public function __construct($data=null) {
1952         global $CFG, $USER;
1953
1954         // First convert to object if it is not already (should either be object or assoc array)
1955         if (!is_object($data)) {
1956             $data = (object)$data;
1957         }
1958
1959         $this->editoroptions['maxbytes'] = $CFG->maxbytes;
1960
1961         $data->eventrepeats = 0;
1962
1963         if (empty($data->id)) {
1964             $data->id = null;
1965         }
1966
1967         if (!empty($data->subscriptionid)) {
1968             $data->subscription = calendar_get_subscription($data->subscriptionid);
1969         }
1970
1971         // Default to a user event
1972         if (empty($data->eventtype)) {
1973             $data->eventtype = 'user';
1974         }
1975
1976         // Default to the current user
1977         if (empty($data->userid)) {
1978             $data->userid = $USER->id;
1979         }
1980
1981         if (!empty($data->timeduration) && is_array($data->timeduration)) {
1982             $data->timeduration = make_timestamp($data->timeduration['year'], $data->timeduration['month'], $data->timeduration['day'], $data->timeduration['hour'], $data->timeduration['minute']) - $data->timestart;
1983         }
1984         if (!empty($data->description) && is_array($data->description)) {
1985             $data->format = $data->description['format'];
1986             $data->description = $data->description['text'];
1987         } else if (empty($data->description)) {
1988             $data->description = '';
1989             $data->format = editors_get_preferred_format();
1990         }
1991         // Ensure form is defaulted correctly
1992         if (empty($data->format)) {
1993             $data->format = editors_get_preferred_format();
1994         }
1995
1996         if (empty($data->context)) {
1997             $data->context = $this->calculate_context($data);
1998         }
1999         $this->properties = $data;
2000     }
2001
2002     /**
2003      * Magic property method
2004      *
2005      * Attempts to call a set_$key method if one exists otherwise falls back
2006      * to simply set the property
2007      *
2008      * @param string $key property name
2009      * @param mixed $value value of the property
2010      */
2011     public function __set($key, $value) {
2012         if (method_exists($this, 'set_'.$key)) {
2013             $this->{'set_'.$key}($value);
2014         }
2015         $this->properties->{$key} = $value;
2016     }
2017
2018     /**
2019      * Magic get method
2020      *
2021      * Attempts to call a get_$key method to return the property and ralls over
2022      * to return the raw property
2023      *
2024      * @param string $key property name
2025      * @return mixed property value
2026      */
2027     public function __get($key) {
2028         if (method_exists($this, 'get_'.$key)) {
2029             return $this->{'get_'.$key}();
2030         }
2031         if (!isset($this->properties->{$key})) {
2032             throw new coding_exception('Undefined property requested');
2033         }
2034         return $this->properties->{$key};
2035     }
2036
2037     /**
2038      * Stupid PHP needs an isset magic method if you use the get magic method and
2039      * still want empty calls to work.... blah ~!
2040      *
2041      * @param string $key $key property name
2042      * @return bool|mixed property value, false if property is not exist
2043      */
2044     public function __isset($key) {
2045         return !empty($this->properties->{$key});
2046     }
2047
2048     /**
2049      * Calculate the context value needed for calendar_event.
2050      * Event's type can be determine by the available value store in $data
2051      * It is important to check for the existence of course/courseid to determine
2052      * the course event.
2053      * Default value is set to CONTEXT_USER
2054      *
2055      * @param stdClass $data information about event
2056      * @return stdClass The context object.
2057      */
2058     protected function calculate_context(stdClass $data) {
2059         global $USER, $DB;
2060
2061         $context = null;
2062         if (isset($data->courseid) && $data->courseid > 0) {
2063             $context =  context_course::instance($data->courseid);
2064         } else if (isset($data->course) && $data->course > 0) {
2065             $context =  context_course::instance($data->course);
2066         } else if (isset($data->groupid) && $data->groupid > 0) {
2067             $group = $DB->get_record('groups', array('id'=>$data->groupid));
2068             $context = context_course::instance($group->courseid);
2069         } else if (isset($data->userid) && $data->userid > 0 && $data->userid == $USER->id) {
2070             $context =  context_user::instance($data->userid);
2071         } else if (isset($data->userid) && $data->userid > 0 && $data->userid != $USER->id &&
2072                    isset($data->instance) && $data->instance > 0) {
2073             $cm = get_coursemodule_from_instance($data->modulename, $data->instance, 0, false, MUST_EXIST);
2074             $context =  context_course::instance($cm->course);
2075         } else {
2076             $context =  context_user::instance($data->userid);
2077         }
2078
2079         return $context;
2080     }
2081
2082     /**
2083      * Returns an array of editoroptions for this event: Called by __get
2084      * Please use $blah = $event->editoroptions;
2085      *
2086      * @return array event editor options
2087      */
2088     protected function get_editoroptions() {
2089         return $this->editoroptions;
2090     }
2091
2092     /**
2093      * Returns an event description: Called by __get
2094      * Please use $blah = $event->description;
2095      *
2096      * @return string event description
2097      */
2098     protected function get_description() {
2099         global $CFG;
2100
2101         require_once($CFG->libdir . '/filelib.php');
2102
2103         if ($this->_description === null) {
2104             // Check if we have already resolved the context for this event
2105             if ($this->editorcontext === null) {
2106                 // Switch on the event type to decide upon the appropriate context
2107                 // to use for this event
2108                 $this->editorcontext = $this->properties->context;
2109                 if ($this->properties->eventtype != 'user' && $this->properties->eventtype != 'course'
2110                         && $this->properties->eventtype != 'site' && $this->properties->eventtype != 'group') {
2111                     return clean_text($this->properties->description, $this->properties->format);
2112                 }
2113             }
2114
2115             // Work out the item id for the editor, if this is a repeated event then the files will
2116             // be associated with the original
2117             if (!empty($this->properties->repeatid) && $this->properties->repeatid > 0) {
2118                 $itemid = $this->properties->repeatid;
2119             } else {
2120                 $itemid = $this->properties->id;
2121             }
2122
2123             // Convert file paths in the description so that things display correctly
2124             $this->_description = file_rewrite_pluginfile_urls($this->properties->description, 'pluginfile.php', $this->editorcontext->id, 'calendar', 'event_description', $itemid);
2125             // Clean the text so no nasties get through
2126             $this->_description = clean_text($this->_description, $this->properties->format);
2127         }
2128         // Finally return the description
2129         return $this->_description;
2130     }
2131
2132     /**
2133      * Return the number of repeat events there are in this events series
2134      *
2135      * @return int number of event repeated
2136      */
2137     public function count_repeats() {
2138         global $DB;
2139         if (!empty($this->properties->repeatid)) {
2140             $this->properties->eventrepeats = $DB->count_records('event', array('repeatid'=>$this->properties->repeatid));
2141             // We don't want to count ourselves
2142             $this->properties->eventrepeats--;
2143         }
2144         return $this->properties->eventrepeats;
2145     }
2146
2147     /**
2148      * Update or create an event within the database
2149      *
2150      * Pass in a object containing the event properties and this function will
2151      * insert it into the database and deal with any associated files
2152      *
2153      * @see add_event()
2154      * @see update_event()
2155      *
2156      * @param stdClass $data object of event
2157      * @param bool $checkcapability if moodle should check calendar managing capability or not
2158      * @return bool event updated
2159      */
2160     public function update($data, $checkcapability=true) {
2161         global $CFG, $DB, $USER;
2162
2163         foreach ($data as $key=>$value) {
2164             $this->properties->$key = $value;
2165         }
2166
2167         $this->properties->timemodified = time();
2168         $usingeditor = (!empty($this->properties->description) && is_array($this->properties->description));
2169
2170         if (empty($this->properties->id) || $this->properties->id < 1) {
2171
2172             if ($checkcapability) {
2173                 if (!calendar_add_event_allowed($this->properties)) {
2174                     print_error('nopermissiontoupdatecalendar');
2175                 }
2176             }
2177
2178             if ($usingeditor) {
2179                 switch ($this->properties->eventtype) {
2180                     case 'user':
2181                         $this->properties->courseid = 0;
2182                         $this->properties->course = 0;
2183                         $this->properties->groupid = 0;
2184                         $this->properties->userid = $USER->id;
2185                         break;
2186                     case 'site':
2187                         $this->properties->courseid = SITEID;
2188                         $this->properties->course = SITEID;
2189                         $this->properties->groupid = 0;
2190                         $this->properties->userid = $USER->id;
2191                         break;
2192                     case 'course':
2193                         $this->properties->groupid = 0;
2194                         $this->properties->userid = $USER->id;
2195                         break;
2196                     case 'group':
2197                         $this->properties->userid = $USER->id;
2198                         break;
2199                     default:
2200                         // Ewww we should NEVER get here, but just incase we do lets
2201                         // fail gracefully
2202                         $usingeditor = false;
2203                         break;
2204                 }
2205
2206                 // If we are actually using the editor, we recalculate the context because some default values
2207                 // were set when calculate_context() was called from the constructor.
2208                 if ($usingeditor) {
2209                     $this->properties->context = $this->calculate_context($this->properties);
2210                     $this->editorcontext = $this->properties->context;
2211                 }
2212
2213                 $editor = $this->properties->description;
2214                 $this->properties->format = $this->properties->description['format'];
2215                 $this->properties->description = $this->properties->description['text'];
2216             }
2217
2218             // Insert the event into the database
2219             $this->properties->id = $DB->insert_record('event', $this->properties);
2220
2221             if ($usingeditor) {
2222                 $this->properties->description = file_save_draft_area_files(
2223                                                 $editor['itemid'],
2224                                                 $this->editorcontext->id,
2225                                                 'calendar',
2226                                                 'event_description',
2227                                                 $this->properties->id,
2228                                                 $this->editoroptions,
2229                                                 $editor['text'],
2230                                                 $this->editoroptions['forcehttps']);
2231                 $DB->set_field('event', 'description', $this->properties->description, array('id'=>$this->properties->id));
2232             }
2233
2234             // Log the event entry.
2235             add_to_log($this->properties->courseid, 'calendar', 'add', 'event.php?action=edit&amp;id='.$this->properties->id, $this->properties->name);
2236
2237             $repeatedids = array();
2238
2239             if (!empty($this->properties->repeat)) {
2240                 $this->properties->repeatid = $this->properties->id;
2241                 $DB->set_field('event', 'repeatid', $this->properties->repeatid, array('id'=>$this->properties->id));
2242
2243                 $eventcopy = clone($this->properties);
2244                 unset($eventcopy->id);
2245
2246                 for($i = 1; $i < $eventcopy->repeats; $i++) {
2247
2248                     $eventcopy->timestart = ($eventcopy->timestart+WEEKSECS) + dst_offset_on($eventcopy->timestart) - dst_offset_on($eventcopy->timestart+WEEKSECS);
2249
2250                     // Get the event id for the log record.
2251                     $eventcopyid = $DB->insert_record('event', $eventcopy);
2252
2253                     // If the context has been set delete all associated files
2254                     if ($usingeditor) {
2255                         $fs = get_file_storage();
2256                         $files = $fs->get_area_files($this->editorcontext->id, 'calendar', 'event_description', $this->properties->id);
2257                         foreach ($files as $file) {
2258                             $fs->create_file_from_storedfile(array('itemid'=>$eventcopyid), $file);
2259                         }
2260                     }
2261
2262                     $repeatedids[] = $eventcopyid;
2263                     // Log the event entry.
2264                     add_to_log($eventcopy->courseid, 'calendar', 'add', 'event.php?action=edit&amp;id='.$eventcopyid, $eventcopy->name);
2265                 }
2266             }
2267
2268             // Hook for tracking added events
2269             self::calendar_event_hook('add_event', array($this->properties, $repeatedids));
2270             return true;
2271         } else {
2272
2273             if ($checkcapability) {
2274                 if(!calendar_edit_event_allowed($this->properties)) {
2275                     print_error('nopermissiontoupdatecalendar');
2276                 }
2277             }
2278
2279             if ($usingeditor) {
2280                 if ($this->editorcontext !== null) {
2281                     $this->properties->description = file_save_draft_area_files(
2282                                                     $this->properties->description['itemid'],
2283                                                     $this->editorcontext->id,
2284                                                     'calendar',
2285                                                     'event_description',
2286                                                     $this->properties->id,
2287                                                     $this->editoroptions,
2288                                                     $this->properties->description['text'],
2289                                                     $this->editoroptions['forcehttps']);
2290                 } else {
2291                     $this->properties->format = $this->properties->description['format'];
2292                     $this->properties->description = $this->properties->description['text'];
2293                 }
2294             }
2295
2296             $event = $DB->get_record('event', array('id'=>$this->properties->id));
2297
2298             $updaterepeated = (!empty($this->properties->repeatid) && !empty($this->properties->repeateditall));
2299
2300             if ($updaterepeated) {
2301                 // Update all
2302                 if ($this->properties->timestart != $event->timestart) {
2303                     $timestartoffset = $this->properties->timestart - $event->timestart;
2304                     $sql = "UPDATE {event}
2305                                SET name = ?,
2306                                    description = ?,
2307                                    timestart = timestart + ?,
2308                                    timeduration = ?,
2309                                    timemodified = ?
2310                              WHERE repeatid = ?";
2311                     $params = array($this->properties->name, $this->properties->description, $timestartoffset, $this->properties->timeduration, time(), $event->repeatid);
2312                 } else {
2313                     $sql = "UPDATE {event} SET name = ?, description = ?, timeduration = ?, timemodified = ? WHERE repeatid = ?";
2314                     $params = array($this->properties->name, $this->properties->description, $this->properties->timeduration, time(), $event->repeatid);
2315                 }
2316                 $DB->execute($sql, $params);
2317
2318                 // Log the event update.
2319                 add_to_log($this->properties->courseid, 'calendar', 'edit all', 'event.php?action=edit&amp;id='.$this->properties->id, $this->properties->name);
2320             } else {
2321                 $DB->update_record('event', $this->properties);
2322                 $event = calendar_event::load($this->properties->id);
2323                 $this->properties = $event->properties();
2324                 add_to_log($this->properties->courseid, 'calendar', 'edit', 'event.php?action=edit&amp;id='.$this->properties->id, $this->properties->name);
2325             }
2326
2327             // Hook for tracking event updates
2328             self::calendar_event_hook('update_event', array($this->properties, $updaterepeated));
2329             return true;
2330         }
2331     }
2332
2333     /**
2334      * Deletes an event and if selected an repeated events in the same series
2335      *
2336      * This function deletes an event, any associated events if $deleterepeated=true,
2337      * and cleans up any files associated with the events.
2338      *
2339      * @see delete_event()
2340      *
2341      * @param bool $deleterepeated  delete event repeatedly
2342      * @return bool succession of deleting event
2343      */
2344     public function delete($deleterepeated=false) {
2345         global $DB;
2346
2347         // If $this->properties->id is not set then something is wrong
2348         if (empty($this->properties->id)) {
2349             debugging('Attempting to delete an event before it has been loaded', DEBUG_DEVELOPER);
2350             return false;
2351         }
2352
2353         // Delete the event
2354         $DB->delete_records('event', array('id'=>$this->properties->id));
2355
2356         // If we are deleting parent of a repeated event series, promote the next event in the series as parent
2357         if (($this->properties->id == $this->properties->repeatid) && !$deleterepeated) {
2358             $newparent = $DB->get_field_sql("SELECT id from {event} where repeatid = ? order by id ASC", array($this->properties->id), IGNORE_MULTIPLE);
2359             if (!empty($newparent)) {
2360                 $DB->execute("UPDATE {event} SET repeatid = ? WHERE repeatid = ?", array($newparent, $this->properties->id));
2361                 // Get all records where the repeatid is the same as the event being removed
2362                 $events = $DB->get_records('event', array('repeatid' => $newparent));
2363                 // For each of the returned events trigger the event_update hook.
2364                 foreach ($events as $event) {
2365                     self::calendar_event_hook('update_event', array($event, false));
2366                 }
2367             }
2368         }
2369
2370         // If the editor context hasn't already been set then set it now
2371         if ($this->editorcontext === null) {
2372             $this->editorcontext = $this->properties->context;
2373         }
2374
2375         // If the context has been set delete all associated files
2376         if ($this->editorcontext !== null) {
2377             $fs = get_file_storage();
2378             $files = $fs->get_area_files($this->editorcontext->id, 'calendar', 'event_description', $this->properties->id);
2379             foreach ($files as $file) {
2380                 $file->delete();
2381             }
2382         }
2383
2384         // Fire the event deleted hook
2385         self::calendar_event_hook('delete_event', array($this->properties->id, $deleterepeated));
2386
2387         // If we need to delete repeated events then we will fetch them all and delete one by one
2388         if ($deleterepeated && !empty($this->properties->repeatid) && $this->properties->repeatid > 0) {
2389             // Get all records where the repeatid is the same as the event being removed
2390             $events = $DB->get_records('event', array('repeatid'=>$this->properties->repeatid));
2391             // For each of the returned events populate a calendar_event object and call delete
2392             // make sure the arg passed is false as we are already deleting all repeats
2393             foreach ($events as $event) {
2394                 $event = new calendar_event($event);
2395                 $event->delete(false);
2396             }
2397         }
2398
2399         return true;
2400     }
2401
2402     /**
2403      * Fetch all event properties
2404      *
2405      * This function returns all of the events properties as an object and optionally
2406      * can prepare an editor for the description field at the same time. This is
2407      * designed to work when the properties are going to be used to set the default
2408      * values of a moodle forms form.
2409      *
2410      * @param bool $prepareeditor If set to true a editor is prepared for use with
2411      *              the mforms editor element. (for description)
2412      * @return stdClass Object containing event properties
2413      */
2414     public function properties($prepareeditor=false) {
2415         global $USER, $CFG, $DB;
2416
2417         // First take a copy of the properties. We don't want to actually change the
2418         // properties or we'd forever be converting back and forwards between an
2419         // editor formatted description and not
2420         $properties = clone($this->properties);
2421         // Clean the description here
2422         $properties->description = clean_text($properties->description, $properties->format);
2423
2424         // If set to true we need to prepare the properties for use with an editor
2425         // and prepare the file area
2426         if ($prepareeditor) {
2427
2428             // We may or may not have a property id. If we do then we need to work
2429             // out the context so we can copy the existing files to the draft area
2430             if (!empty($properties->id)) {
2431
2432                 if ($properties->eventtype === 'site') {
2433                     // Site context
2434                     $this->editorcontext = $this->properties->context;
2435                 } else if ($properties->eventtype === 'user') {
2436                     // User context
2437                     $this->editorcontext = $this->properties->context;
2438                 } else if ($properties->eventtype === 'group' || $properties->eventtype === 'course') {
2439                     // First check the course is valid
2440                     $course = $DB->get_record('course', array('id'=>$properties->courseid));
2441                     if (!$course) {
2442                         print_error('invalidcourse');
2443                     }
2444                     // Course context
2445                     $this->editorcontext = $this->properties->context;
2446                     // We have a course and are within the course context so we had
2447                     // better use the courses max bytes value
2448                     $this->editoroptions['maxbytes'] = $course->maxbytes;
2449                 } else {
2450                     // If we get here we have a custom event type as used by some
2451                     // modules. In this case the event will have been added by
2452                     // code and we won't need the editor
2453                     $this->editoroptions['maxbytes'] = 0;
2454                     $this->editoroptions['maxfiles'] = 0;
2455                 }
2456
2457                 if (empty($this->editorcontext) || empty($this->editorcontext->id)) {
2458                     $contextid = false;
2459                 } else {
2460                     // Get the context id that is what we really want
2461                     $contextid = $this->editorcontext->id;
2462                 }
2463             } else {
2464
2465                 // If we get here then this is a new event in which case we don't need a
2466                 // context as there is no existing files to copy to the draft area.
2467                 $contextid = null;
2468             }
2469
2470             // If the contextid === false we don't support files so no preparing
2471             // a draft area
2472             if ($contextid !== false) {
2473                 // Just encase it has already been submitted
2474                 $draftiddescription = file_get_submitted_draft_itemid('description');
2475                 // Prepare the draft area, this copies existing files to the draft area as well
2476                 $properties->description = file_prepare_draft_area($draftiddescription, $contextid, 'calendar', 'event_description', $properties->id, $this->editoroptions, $properties->description);
2477             } else {
2478                 $draftiddescription = 0;
2479             }
2480
2481             // Structure the description field as the editor requires
2482             $properties->description = array('text'=>$properties->description, 'format'=>$properties->format, 'itemid'=>$draftiddescription);
2483         }
2484
2485         // Finally return the properties
2486         return $properties;
2487     }
2488
2489     /**
2490      * Toggles the visibility of an event
2491      *
2492      * @param null|bool $force If it is left null the events visibility is flipped,
2493      *                   If it is false the event is made hidden, if it is true it
2494      *                   is made visible.
2495      * @return bool if event is successfully updated, toggle will be visible
2496      */
2497     public function toggle_visibility($force=null) {
2498         global $CFG, $DB;
2499
2500         // Set visible to the default if it is not already set
2501         if (empty($this->properties->visible)) {
2502             $this->properties->visible = 1;
2503         }
2504
2505         if ($force === true || ($force !== false && $this->properties->visible == 0)) {
2506             // Make this event visible
2507             $this->properties->visible = 1;
2508             // Fire the hook
2509             self::calendar_event_hook('show_event', array($this->properties));
2510         } else {
2511             // Make this event hidden
2512             $this->properties->visible = 0;
2513             // Fire the hook
2514             self::calendar_event_hook('hide_event', array($this->properties));
2515         }
2516
2517         // Update the database to reflect this change
2518         return $DB->set_field('event', 'visible', $this->properties->visible, array('id'=>$this->properties->id));
2519     }
2520
2521     /**
2522      * Attempts to call the hook for the specified action should a calendar type
2523      * by set $CFG->calendar, and the appopriate function defined
2524      *
2525      * @param string $action One of `update_event`, `add_event`, `delete_event`, `show_event`, `hide_event`
2526      * @param array $args The args to pass to the hook, usually the event is the first element
2527      * @return bool attempts to call event hook
2528      */
2529     public static function calendar_event_hook($action, array $args) {
2530         global $CFG;
2531         static $extcalendarinc;
2532         if ($extcalendarinc === null) {
2533             if (!empty($CFG->calendar)) {
2534                 if (is_readable($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php')) {
2535                     include_once($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php');
2536                     $extcalendarinc = true;
2537                 } else {
2538                     debugging("Calendar lib file missing or not readable at /calendar/{$CFG->calendar}/lib.php.",
2539                         DEBUG_DEVELOPER);
2540                     $extcalendarinc = false;
2541                 }
2542             } else {
2543                 $extcalendarinc = false;
2544             }
2545         }
2546         if($extcalendarinc === false) {
2547             return false;
2548         }
2549         $hook = $CFG->calendar .'_'.$action;
2550         if (function_exists($hook)) {
2551             call_user_func_array($hook, $args);
2552             return true;
2553         }
2554         return false;
2555     }
2556
2557     /**
2558      * Returns a calendar_event object when provided with an event id
2559      *
2560      * This function makes use of MUST_EXIST, if the event id passed in is invalid
2561      * it will result in an exception being thrown
2562      *
2563      * @param int|object $param event object or event id
2564      * @return calendar_event|false status for loading calendar_event
2565      */
2566     public static function load($param) {
2567         global $DB;
2568         if (is_object($param)) {
2569             $event = new calendar_event($param);
2570         } else {
2571             $event = $DB->get_record('event', array('id'=>(int)$param), '*', MUST_EXIST);
2572             $event = new calendar_event($event);
2573         }
2574         return $event;
2575     }
2576
2577     /**
2578      * Creates a new event and returns a calendar_event object
2579      *
2580      * @param object|array $properties An object containing event properties
2581      * @return calendar_event|false The event object or false if it failed
2582      */
2583     public static function create($properties) {
2584         if (is_array($properties)) {
2585             $properties = (object)$properties;
2586         }
2587         if (!is_object($properties)) {
2588             throw new coding_exception('When creating an event properties should be either an object or an assoc array');
2589         }
2590         $event = new calendar_event($properties);
2591         if ($event->update($properties)) {
2592             return $event;
2593         } else {
2594             return false;
2595         }
2596     }
2597 }
2598
2599 /**
2600  * Calendar information class
2601  *
2602  * This class is used simply to organise the information pertaining to a calendar
2603  * and is used primarily to make information easily available.
2604  *
2605  * @package core_calendar
2606  * @category calendar
2607  * @copyright 2010 Sam Hemelryk
2608  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
2609  */
2610 class calendar_information {
2611     /** @var int The day */
2612     public $day;
2613
2614     /** @var int The month */
2615     public $month;
2616
2617     /** @var int The year */
2618     public $year;
2619
2620     /** @var int A course id */
2621     public $courseid = null;
2622
2623     /** @var array An array of courses */
2624     public $courses = array();
2625
2626     /** @var array An array of groups */
2627     public $groups = array();
2628
2629     /** @var array An array of users */
2630     public $users = array();
2631
2632     /**
2633      * Creates a new instance
2634      *
2635      * @param int $day the number of the day
2636      * @param int $month the number of the month
2637      * @param int $year the number of the year
2638      */
2639     public function __construct($day=0, $month=0, $year=0) {
2640
2641         $date = usergetdate(time());
2642
2643         if (empty($day)) {
2644             $day = $date['mday'];
2645         }
2646
2647         if (empty($month)) {
2648             $month = $date['mon'];
2649         }
2650
2651         if (empty($year)) {
2652             $year =  $date['year'];
2653         }
2654
2655         $this->day = $day;
2656         $this->month = $month;
2657         $this->year = $year;
2658     }
2659
2660     /**
2661      * Initialize calendar information
2662      *
2663      * @param stdClass $course object
2664      * @param array $coursestoload An array of courses [$course->id => $course]
2665      * @param bool $ignorefilters options to use filter
2666      */
2667     public function prepare_for_view(stdClass $course, array $coursestoload, $ignorefilters = false) {
2668         $this->courseid = $course->id;
2669         $this->course = $course;
2670         list($courses, $group, $user) = calendar_set_filters($coursestoload, $ignorefilters);
2671         $this->courses = $courses;
2672         $this->groups = $group;
2673         $this->users = $user;
2674     }
2675
2676     /**
2677      * Ensures the date for the calendar is correct and either sets it to now
2678      * or throws a moodle_exception if not
2679      *
2680      * @param bool $defaultonow use current time
2681      * @throws moodle_exception
2682      * @return bool validation of checkdate
2683      */
2684     public function checkdate($defaultonow = true) {
2685         if (!checkdate($this->month, $this->day, $this->year)) {
2686             if ($defaultonow) {
2687                 $now = usergetdate(time());
2688                 $this->day = intval($now['mday']);
2689                 $this->month = intval($now['mon']);
2690                 $this->year = intval($now['year']);
2691                 return true;
2692             } else {
2693                 throw new moodle_exception('invaliddate');
2694             }
2695         }
2696         return true;
2697     }
2698     /**
2699      * Gets todays timestamp for the calendar
2700      *
2701      * @return int today timestamp
2702      */
2703     public function timestamp_today() {
2704         return make_timestamp($this->year, $this->month, $this->day);
2705     }
2706     /**
2707      * Gets tomorrows timestamp for the calendar
2708      *
2709      * @return int tomorrow timestamp
2710      */
2711     public function timestamp_tomorrow() {
2712         return make_timestamp($this->year, $this->month, $this->day+1);
2713     }
2714     /**
2715      * Adds the pretend blocks for the calendar
2716      *
2717      * @param core_calendar_renderer $renderer
2718      * @param bool $showfilters display filters, false is set as default
2719      * @param string|null $view preference view options (eg: day, month, upcoming)
2720      */
2721     public function add_sidecalendar_blocks(core_calendar_renderer $renderer, $showfilters=false, $view=null) {
2722         if ($showfilters) {
2723             $filters = new block_contents();
2724             $filters->content = $renderer->fake_block_filters($this->courseid, $this->day, $this->month, $this->year, $view, $this->courses);
2725             $filters->footer = '';
2726             $filters->title = get_string('eventskey', 'calendar');
2727             $renderer->add_pretend_calendar_block($filters, BLOCK_POS_RIGHT);
2728         }
2729         $block = new block_contents;
2730         $block->content = $renderer->fake_block_threemonths($this);
2731         $block->footer = '';
2732         $block->title = get_string('monthlyview', 'calendar');
2733         $renderer->add_pretend_calendar_block($block, BLOCK_POS_RIGHT);
2734     }
2735 }
2736
2737 /**
2738  * Returns option list for the poll interval setting.
2739  *
2740  * @return array An array of poll interval options. Interval => description.
2741  */
2742 function calendar_get_pollinterval_choices() {
2743     return array(
2744         '0' => new lang_string('never', 'calendar'),
2745         '3600' => new lang_string('hourly', 'calendar'),
2746         '86400' => new lang_string('daily', 'calendar'),
2747         '604800' => new lang_string('weekly', 'calendar'),
2748         '2628000' => new lang_string('monthly', 'calendar'),
2749         '31536000' => new lang_string('annually', 'calendar')
2750     );
2751 }
2752
2753 /**
2754  * Returns option list of available options for the calendar event type, given the current user and course.
2755  *
2756  * @param int $courseid The id of the course
2757  * @return array An array containing the event types the user can create.
2758  */
2759 function calendar_get_eventtype_choices($courseid) {
2760     $choices = array();
2761     $allowed = new stdClass;
2762     calendar_get_allowed_types($allowed, $courseid);
2763
2764     if ($allowed->user) {
2765         $choices['user'] = get_string('userevents', 'calendar');
2766     }
2767     if ($allowed->site) {
2768         $choices['site'] = get_string('siteevents', 'calendar');
2769     }
2770     if (!empty($allowed->courses)) {
2771         $choices['course'] = get_string('courseevents', 'calendar');
2772     }
2773     if (!empty($allowed->groups) and is_array($allowed->groups)) {
2774         $choices['group'] = get_string('group');
2775     }
2776
2777     return array($choices, $allowed->groups);
2778 }
2779
2780 /**
2781  * Add an iCalendar subscription to the database.
2782  *
2783  * @param stdClass $sub The subscription object (e.g. from the form)
2784  * @return int The insert ID, if any.
2785  */
2786 function calendar_add_subscription($sub) {
2787     global $DB, $USER, $SITE;
2788
2789     if ($sub->eventtype === 'site') {
2790         $sub->courseid = $SITE->id;
2791     } else if ($sub->eventtype === 'group' || $sub->eventtype === 'course') {
2792         $sub->courseid = $sub->course;
2793     } else {
2794         // User events.
2795         $sub->courseid = 0;
2796     }
2797     $sub->userid = $USER->id;
2798
2799     // File subscriptions never update.
2800     if (empty($sub->url)) {
2801         $sub->pollinterval = 0;
2802     }
2803
2804     if (!empty($sub->name)) {
2805         if (empty($sub->id)) {
2806             $id = $DB->insert_record('event_subscriptions', $sub);
2807             // we cannot cache the data here because $sub is not complete.
2808             return $id;
2809         } else {
2810             // Why are we doing an update here?
2811             calendar_update_subscription($sub);
2812             return $sub->id;
2813         }
2814     } else {
2815         print_error('errorbadsubscription', 'importcalendar');
2816     }
2817 }
2818
2819 /**
2820  * Add an iCalendar event to the Moodle calendar.
2821  *
2822  * @param object $event The RFC-2445 iCalendar event
2823  * @param int $courseid The course ID
2824  * @param int $subscriptionid The iCalendar subscription ID
2825  * @throws dml_exception A DML specific exception is thrown for invalid subscriptionids.
2826  * @return int Code: 1=updated, 2=inserted, 0=error
2827  */
2828 function calendar_add_icalendar_event($event, $courseid, $subscriptionid) {
2829     global $DB, $USER;
2830
2831     // Probably an unsupported X-MICROSOFT-CDO-BUSYSTATUS event.
2832     if (empty($event->properties['SUMMARY'])) {
2833         return 0;
2834     }
2835
2836     $name = $event->properties['SUMMARY'][0]->value;
2837     $name = str_replace('\n', '<br />', $name);
2838     $name = str_replace('\\', '', $name);
2839     $name = preg_replace('/\s+/', ' ', $name);
2840
2841     $eventrecord = new stdClass;
2842     $eventrecord->name = clean_param($name, PARAM_NOTAGS);
2843
2844     if (empty($event->properties['DESCRIPTION'][0]->value)) {
2845         $description = '';
2846     } else {
2847         $description = $event->properties['DESCRIPTION'][0]->value;
2848         $description = str_replace('\n', '<br />', $description);
2849         $description = str_replace('\\', '', $description);
2850         $description = preg_replace('/\s+/', ' ', $description);
2851     }
2852     $eventrecord->description = clean_param($description, PARAM_NOTAGS);
2853
2854     // Probably a repeating event with RRULE etc. TODO: skip for now.
2855     if (empty($event->properties['DTSTART'][0]->value)) {
2856         return 0;
2857     }
2858
2859     $eventrecord->timestart = strtotime($event->properties['DTSTART'][0]->value);
2860     if (empty($event->properties['DTEND'])) {
2861         $eventrecord->timeduration = 3600; // one hour if no end time specified
2862     } else {
2863         $eventrecord->timeduration = strtotime($event->properties['DTEND'][0]->value) - $eventrecord->timestart;
2864     }
2865     $eventrecord->uuid = $event->properties['UID'][0]->value;
2866     $eventrecord->timemodified = time();
2867
2868     // Add the iCal subscription details if required.
2869     // We should never do anything with an event without a subscription reference.
2870     $sub = calendar_get_subscription($subscriptionid);
2871     $eventrecord->subscriptionid = $subscriptionid;
2872     $eventrecord->userid = $sub->userid;
2873     $eventrecord->groupid = $sub->groupid;
2874     $eventrecord->courseid = $sub->courseid;
2875     $eventrecord->eventtype = $sub->eventtype;
2876
2877     if ($updaterecord = $DB->get_record('event', array('uuid' => $eventrecord->uuid))) {
2878         $eventrecord->id = $updaterecord->id;
2879         if ($DB->update_record('event', $eventrecord)) {
2880             return CALENDAR_IMPORT_EVENT_UPDATED;
2881         } else {
2882             return 0;
2883         }
2884     } else {
2885         if ($DB->insert_record('event', $eventrecord)) {
2886             return CALENDAR_IMPORT_EVENT_INSERTED;
2887         } else {
2888             return 0;
2889         }
2890     }
2891 }
2892
2893 /**
2894  * Update a subscription from the form data in one of the rows in the existing subscriptions table.
2895  *
2896  * @param int $subscriptionid The ID of the subscription we are acting upon.
2897  * @param int $pollinterval The poll interval to use.
2898  * @param int $action The action to be performed. One of update or remove.
2899  * @throws dml_exception if invalid subscriptionid is provided
2900  * @return string A log of the import progress, including errors
2901  */
2902 function calendar_process_subscription_row($subscriptionid, $pollinterval, $action) {
2903     global $DB;
2904
2905     // Fetch the subscription from the database making sure it exists.
2906     $sub = calendar_get_subscription($subscriptionid);
2907
2908     $strupdate = get_string('update');
2909     $strremove = get_string('remove');
2910
2911     // Update or remove the subscription, based on action.
2912     switch ($action) {
2913         case $strupdate:
2914             // Skip updating file subscriptions.
2915             if (empty($sub->url)) {
2916                 break;
2917             }
2918             $sub->pollinterval = $pollinterval;
2919             calendar_update_subscription($sub);
2920
2921             // Update the events.
2922             return "<p>".get_string('subscriptionupdated', 'calendar', $sub->name)."</p>" . calendar_update_subscription_events($subscriptionid);
2923
2924         case $strremove:
2925             calendar_delete_subscription($subscriptionid);
2926             return get_string('subscriptionremoved', 'calendar', $sub->name);
2927             break;
2928
2929         default:
2930             break;
2931     }
2932     return '';
2933 }
2934
2935 /**
2936  * Delete subscription and all related events.
2937  *
2938  * @param int|stdClass $subscription subscription or it's id, which needs to be deleted.
2939  */
2940 function calendar_delete_subscription($subscription) {
2941     global $DB;
2942
2943     if (is_object($subscription)) {
2944         $subscription = $subscription->id;
2945     }
2946     // Delete subscription and related events.
2947     $DB->delete_records('event', array('subscriptionid' => $subscription));
2948     $DB->delete_records('event_subscriptions', array('id' => $subscription));
2949     cache_helper::invalidate_by_definition('core', 'calendar_subscriptions', array(), array($subscription));
2950 }
2951 /**
2952  * From a URL, fetch the calendar and return an iCalendar object.
2953  *
2954  * @param string $url The iCalendar URL
2955  * @return stdClass The iCalendar object
2956  */
2957 function calendar_get_icalendar($url) {
2958     global $CFG;
2959
2960     require_once($CFG->libdir.'/filelib.php');
2961
2962     $curl = new curl();
2963     $curl->setopt(array('CURLOPT_FOLLOWLOCATION' => 1, 'CURLOPT_MAXREDIRS' => 5));
2964     $calendar = $curl->get($url);
2965     // Http code validation should actually be the job of curl class.
2966     if (!$calendar || $curl->info['http_code'] != 200 || !empty($curl->errorno)) {
2967         throw new moodle_exception('errorinvalidicalurl', 'calendar');
2968     }
2969
2970     $ical = new iCalendar();
2971     $ical->unserialize($calendar);
2972     return $ical;
2973 }
2974
2975 /**
2976  * Import events from an iCalendar object into a course calendar.
2977  *
2978  * @param stdClass $ical The iCalendar object.
2979  * @param int $courseid The course ID for the calendar.
2980  * @param int $subscriptionid The subscription ID.
2981  * @return string A log of the import progress, including errors.
2982  */
2983 function calendar_import_icalendar_events($ical, $courseid, $subscriptionid = null) {
2984     global $DB;
2985     $return = '';
2986     $eventcount = 0;
2987     $updatecount = 0;
2988
2989     // Large calendars take a while...
2990     set_time_limit(300);
2991
2992     // Mark all events in a subscription with a zero timestamp.
2993     if (!empty($subscriptionid)) {
2994         $sql = "UPDATE {event} SET timemodified = :time WHERE subscriptionid = :id";
2995         $DB->execute($sql, array('time' => 0, 'id' => $subscriptionid));
2996     }
2997     foreach ($ical->components['VEVENT'] as $event) {
2998         $res = calendar_add_icalendar_event($event, $courseid, $subscriptionid);
2999         switch ($res) {
3000           case CALENDAR_IMPORT_EVENT_UPDATED:
3001             $updatecount++;
3002             break;
3003           case CALENDAR_IMPORT_EVENT_INSERTED:
3004             $eventcount++;
3005             break;
3006           case 0:
3007             $return .= '<p>'.get_string('erroraddingevent', 'calendar').': '.(empty($event->properties['SUMMARY'])?'('.get_string('notitle', 'calendar').')':$event->properties['SUMMARY'][0]->value)." </p>\n";
3008             break;
3009         }
3010     }
3011     $return .= "<p> ".get_string('eventsimported', 'calendar', $eventcount)."</p>";
3012     $return .= "<p> ".get_string('eventsupdated', 'calendar', $updatecount)."</p>";
3013
3014     // Delete remaining zero-marked events since they're not in remote calendar.
3015     if (!empty($subscriptionid)) {
3016         $deletecount = $DB->count_records('event', array('timemodified' => 0, 'subscriptionid' => $subscriptionid));
3017         if (!empty($deletecount)) {
3018             $sql = "DELETE FROM {event} WHERE timemodified = :time AND subscriptionid = :id";
3019             $DB->execute($sql, array('time' => 0, 'id' => $subscriptionid));
3020             $return .= "<p> ".get_string('eventsdeleted', 'calendar').": {$deletecount} </p>\n";
3021         }
3022     }
3023
3024     return $return;
3025 }
3026
3027 /**
3028  * Fetch a calendar subscription and update the events in the calendar.
3029  *
3030  * @param int $subscriptionid The course ID for the calendar.
3031  * @return string A log of the import progress, including errors.
3032  */
3033 function calendar_update_subscription_events($subscriptionid) {
3034     global $DB;
3035
3036     $sub = calendar_get_subscription($subscriptionid);
3037     // Don't update a file subscription. TODO: Update from a new uploaded file.
3038     if (empty($sub->url)) {
3039         return 'File subscription not updated.';
3040     }
3041     $ical = calendar_get_icalendar($sub->url);
3042     $return = calendar_import_icalendar_events($ical, $sub->courseid, $subscriptionid);
3043     $sub->lastupdated = time();
3044     calendar_update_subscription($sub);
3045     return $return;
3046 }
3047
3048 /**
3049  * Update a calendar subscription. Also updates the associated cache.
3050  *
3051  * @param stdClass|array $subscription Subscription record.
3052  * @throws coding_exception If something goes wrong
3053  * @since Moodle 2.5
3054  */
3055 function calendar_update_subscription($subscription) {
3056     global $DB;
3057
3058     if (is_array($subscription)) {
3059         $subscription = (object)$subscription;
3060     }
3061     if (empty($subscription->id) || !$DB->record_exists('event_subscriptions', array('id' => $subscription->id))) {
3062         throw new coding_exception('Cannot update a subscription without a valid id');
3063     }
3064
3065     $DB->update_record('event_subscriptions', $subscription);
3066     // Update cache.
3067     $cache = cache::make('core', 'calendar_subscriptions');
3068     $cache->set($subscription->id, $subscription);
3069 }
3070
3071 /**
3072  * Checks to see if the user can edit a given subscription feed.
3073  *
3074  * @param mixed $subscriptionorid Subscription object or id
3075  * @return bool true if current user can edit the subscription else false
3076  */
3077 function calendar_can_edit_subscription($subscriptionorid) {
3078     global $DB;
3079
3080     if (is_array($subscriptionorid)) {
3081         $subscription = (object)$subscriptionorid;
3082     } else if (is_object($subscriptionorid)) {
3083         $subscription = $subscriptionorid;
3084     } else {
3085         $subscription = calendar_get_subscription($subscriptionorid);
3086     }
3087     $allowed = new stdClass;
3088     $courseid = $subscription->courseid;
3089     $groupid = $subscription->groupid;
3090     calendar_get_allowed_types($allowed, $courseid);
3091     switch ($subscription->eventtype) {
3092         case 'user':
3093             return $allowed->user;
3094         case 'course':
3095             if (isset($allowed->courses[$courseid])) {
3096                 return $allowed->courses[$courseid];
3097             } else {
3098                 return false;
3099             }
3100         case 'site':
3101             return $allowed->site;
3102         case 'group':
3103             if (isset($allowed->groups[$groupid])) {
3104                 return $allowed->groups[$groupid];
3105             } else {
3106                 return false;
3107             }
3108         default:
3109             return false;
3110     }
3111 }
3112
3113 /**
3114  * Update calendar subscriptions.
3115  *
3116  * @return bool
3117  */
3118 function calendar_cron() {
3119     global $CFG, $DB;
3120
3121     // In order to execute this we need bennu.
3122     require_once($CFG->libdir.'/bennu/bennu.inc.php');
3123
3124     mtrace('Updating calendar subscriptions:');
3125     cron_trace_time_and_memory();
3126
3127     $time = time();
3128     $subscriptions = $DB->get_records_sql('SELECT * FROM {event_subscriptions} WHERE pollinterval > 0 AND lastupdated + pollinterval < ?', array($time));
3129     foreach ($subscriptions as $sub) {
3130         mtrace("Updating calendar subscription {$sub->name} in course {$sub->courseid}");
3131         try {
3132             $log = calendar_update_subscription_events($sub->id);
3133         } catch (moodle_exception $ex) {
3134
3135         }
3136         mtrace(trim(strip_tags($log)));
3137     }
3138
3139     mtrace('Finished updating calendar subscriptions.');
3140
3141     return true;
3142 }