home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 April / CMCD0404.ISO / Software / Freeware / Programare / groupoffice-com-2.01 / classes / calendar.class.inc < prev    next >
Encoding:
Text File  |  2004-03-08  |  50.6 KB  |  1,506 lines
  1. <?php
  2. /*
  3. Copyright Intermesh 2003
  4. Author: Merijn Schering <mschering@intermesh.nl>
  5. Version: 1.0 Release date: 08 July 2003
  6.  
  7. This program is free software; you can redistribute it and/or modify it
  8. under the terms of the GNU General Public License as published by the
  9. Free Software Foundation; either version 2 of the License, or (at your
  10. option) any later version.
  11. */
  12.  
  13. define('REPEAT_NONE', 0);
  14. define('REPEAT_DAILY', 1);
  15. define('REPEAT_WEEKLY', 2);
  16. define('REPEAT_MONTH_DATE', 3);
  17. define('REPEAT_MONTH_DAY', 4);
  18. define('REPEAT_YEARLY', 5);
  19.  
  20. define('DB_DATETIME_FORMAT', 'Y-m-d H:i:00');
  21. define('DB_DATE_FORMAT', 'Y-m-d');
  22. define('DB_TIME_FORMAT', 'H:i:00');
  23.  
  24. class calendar extends db
  25. {
  26.     function calendar()
  27.     {
  28.         $this->db();
  29.     }
  30.     /*
  31.     takes a sting YYYY-MM-DD HH:MM in GMT time and converts it to an array with hour, min etc. with
  32.     a timezone offset. If 0000 or 00 is sed in a date (not time) then it will be replaced with current locale
  33.     date.
  34.     */
  35.     function explode_datetime($datetime_stamp, $timezone_offset)
  36.     {
  37.         $local_time = get_time();
  38.  
  39.         $datetime_array = explode(' ', $datetime_stamp);
  40.         $date_stamp = $datetime_array[0];
  41.         $time_stamp = isset($datetime_array[1]) ? $datetime_array[1] : '00:00:00';
  42.  
  43.         $date_array = explode('-',$date_stamp);
  44.  
  45.         $year = $date_array[0] == '0000' ? date('Y', $local_time) : $date_array[0];
  46.         $month = $date_array[1] == '00' ? date('n', $local_time) : $date_array[1];
  47.         $day = $date_array[2] == '00' ? date('j', $local_time) : $date_array[2];;
  48.  
  49.         $time_array = explode(':',$time_stamp);
  50.         $hour = $time_array[0];
  51.         $min = $time_array[1];
  52.  
  53.         $unix_time = mktime($hour, $min, 0, $month, $day, $year);
  54.  
  55.         $unix_time = $unix_time+($timezone_offset*3600);
  56.  
  57.         $result['year'] = date('Y', $unix_time);
  58.         $result['month'] = date('n', $unix_time);
  59.         $result['day'] = date('j', $unix_time);
  60.         $result['hour'] = date('G', $unix_time);
  61.         $result['min'] = date('i', $unix_time);
  62.  
  63.         return $result;
  64.     }
  65.  
  66.     function get_default_calendar($user_id)
  67.     {
  68.         $sql = "SELECT calendar_id FROM cal_subscribed WHERE user_id='$user_id' AND standard='1'";
  69.         $this->query($sql);
  70.         if($this->next_record())
  71.         {
  72.             return $this->f('calendar_id');
  73.         }
  74.         return false;
  75.     }
  76.  
  77.     function set_default_calendar($user_id, $calendar_id)
  78.     {
  79.         $sql = "UPDATE cal_subscribed SET standard='0' WHERE user_id='$user_id' AND standard='1'";
  80.         if ($this->query($sql))
  81.         {
  82.             return $this->query("UPDATE cal_subscribed SET standard='1' WHERE user_id='$user_id' AND calendar_id='$calendar_id'");
  83.         }
  84.         return false;
  85.     }
  86.  
  87.     function add_participant($event_id, $name, $email, $user_id = 0)
  88.     {
  89.         $id = $this->nextid("cal_participants");
  90.  
  91.         if ($id > 0)
  92.         {
  93.             $sql = "INSERT INTO cal_participants (id, event_id, user_id, name, email) VALUES ('$id', '$event_id', '$user_id', '".smart_addslashes($name)."', '".smart_addslashes($email)."')";
  94.             if ($this->query($sql))
  95.             {
  96.                 return $id;
  97.             }else
  98.             {
  99.                 return -1;
  100.             }
  101.         }else
  102.         {
  103.             return -1;
  104.         }
  105.     }
  106.  
  107.     function remove_participants($event_id)
  108.     {
  109.         $sql = "DELETE FROM cal_participants WHERE event_id='$event_id'";
  110.         return $this->query($sql);
  111.     }
  112.  
  113.     function is_participant($event_id, $email)
  114.     {
  115.         $sql = "SELECT id FROM cal_participants WHERE event_id='$event_id' AND email='".smart_addslashes($email)."'";
  116.         $this->query($sql);
  117.         return $this->next_record();
  118.     }
  119.  
  120.     function get_participants($event_id, $sort="name", $direction="ASC")
  121.     {
  122.         $sql = "SELECT * FROM cal_participants WHERE event_id='$event_id' ORDER BY ".$sort." ".$direction;
  123.         $this->query($sql);
  124.         return $this->num_rows();
  125.     }
  126.  
  127.     function subscribe($user_id, $calendar_id)
  128.     {
  129.         $sql = "INSERT INTO cal_subscribed (user_id, calendar_id) VALUES ('$user_id','$calendar_id')";
  130.         return $this->query($sql);
  131.     }
  132.  
  133.     function unsubscribe($user_id, $calendar_id)
  134.     {
  135.         $sql = "DELETE FROM cal_subscribed WHERE user_id='$user_id' AND calendar_id='$calendar_id'";
  136.         return $this->query($sql);
  137.     }
  138.  
  139.     function unsubscribe_all($user_id)
  140.     {
  141.         $sql = "DELETE FROM cal_subscribed WHERE user_id='$user_id'";
  142.         return $this->query($sql);
  143.     }
  144.  
  145.     function is_subscribed($user_id, $calendar_id)
  146.     {
  147.         $sql = "SELECT * FROM cal_subscribed WHERE user_id='$user_id' AND calendar_id='$calendar_id'";
  148.         $this->query($sql);
  149.         return $this->next_record();
  150.     }
  151.  
  152.     function add_calendar($user_id, $name, $start_hour, $end_hour)
  153.     {
  154.         $name = htmlentities($name);
  155.  
  156.         global $GO_SECURITY;
  157.         $acl_read = $GO_SECURITY->get_new_acl('calendar read: '.$name);
  158.         $acl_write = $GO_SECURITY->get_new_acl('calendar write: '.$name);
  159.         if ($acl_read > 0 && $acl_write > 0)
  160.         {
  161.             $calendar_id = $this->nextid("cal_calendars");
  162.             if ($calendar_id > 0)
  163.             {
  164.                 $sql  = "INSERT INTO cal_calendars (id, user_id, name, acl_read, acl_write, start_hour, end_hour) ";
  165.                 $sql .= "VALUES ('$calendar_id', '$user_id', '".smart_addslashes($name)."', '$acl_read', '$acl_write', '$start_hour', '$end_hour')";
  166.                 if ($this->query($sql))
  167.                 {
  168.                     $this->subscribe($user_id, $calendar_id);
  169.                     $GO_SECURITY->add_user_to_acl($user_id,$acl_write);
  170.                     if (!$this->get_default_calendar($user_id))
  171.                     {
  172.                         $this->set_default_calendar($user_id, $calendar_id);
  173.                     }
  174.                     return $calendar_id;
  175.                 }
  176.             }else
  177.             {
  178.                 $GO_SECURITY->delete_acl($acl_read);
  179.                 $GO_SECURITY->delete_acl($acl_write);
  180.             }
  181.  
  182.         }
  183.         return false;
  184.  
  185.     }
  186.  
  187.  
  188.     function delete_calendar($calendar_id)
  189.     {
  190.         global $GO_SECURITY;
  191.         $delete = new calendar;
  192.  
  193.         $sql = "SELECT * FROM cal_events_calendars WHERE calendar_id='$calendar_id'";
  194.         $this->query($sql);
  195.  
  196.         while ($this->next_record())
  197.         {
  198.             $sql = "SELECT * FROM cal_events_calendars WHERE event_id='".$this->f("event_id")." '";
  199.             $delete->query($sql);
  200.             if ($delete->num_rows() < 2)
  201.             {
  202.                 $event = $delete->get_event($this->f("event_id"));
  203.                 $GO_SECURITY->delete_acl($event["acl_read"]);
  204.                 $GO_SECURITY->delete_acl($event["acl_write"]);
  205.                 $sql = "DELETE FROM cal_events WHERE id='".$this->f("event_id")."'";
  206.                 $delete->query($sql);
  207.                 $sql = "DELETE FROM cal_participants WHERE event_id='".$this->f("event_id")."'";
  208.                 $delete->query($sql);
  209.                 $sql = "DELETE FROM cal_reminders WHERE event_id='".$this->f("event_id")."'";
  210.                 $delete->query($sql);
  211.             }
  212.         }
  213.         $sql = "DELETE FROM cal_events_calendars WHERE calendar_id='$calendar_id'";
  214.         $this->query($sql);
  215.  
  216.         $sql= "DELETE FROM cal_calendars WHERE id='$calendar_id'";
  217.         $this->query($sql);
  218.         $sql = "DELETE FROM cal_subscribed WHERE calendar_id='$calendar_id'";
  219.         $this->query($sql);
  220.     }
  221.  
  222.     function update_calendar($calendar_id, $name, $start_hour, $end_hour)
  223.     {
  224.         $name = htmlentities($name);
  225.         $sql = "UPDATE cal_calendars SET name='".smart_addslashes($name)."', start_hour='$start_hour', end_hour='$end_hour' WHERE id='$calendar_id'";
  226.         return $this->query($sql);
  227.     }
  228.  
  229.  
  230.     function get_calendar($calendar_id)
  231.     {
  232.         $sql = "SELECT * FROM cal_calendars WHERE id='$calendar_id'";
  233.         $this->query($sql);
  234.         if ($this->next_record())
  235.         {
  236.             return $this->Record;
  237.         }else
  238.         {
  239.             return false;
  240.         }
  241.     }
  242.  
  243.     function get_calendar_by_name($name)
  244.     {
  245.         $sql = "SELECT * FROM cal_calendars WHERE name='".smart_addslashes($name)."'";
  246.         $this->query($sql);
  247.         if ($this->next_record())
  248.         {
  249.             return $this->Record;
  250.         }else
  251.         {
  252.             return false;
  253.         }
  254.     }
  255.  
  256.     function get_subscribed($user_id)
  257.     {
  258.         $sql = "SELECT cal_calendars.* FROM cal_calendars LEFT JOIN cal_subscribed ON (cal_subscribed.calendar_id=cal_calendars.id) WHERE cal_subscribed.user_id='$user_id' ORDER BY name ASC";
  259.         $this->query($sql);
  260.         return $this->num_rows();
  261.     }
  262.  
  263.     function get_calendars()
  264.     {
  265.         $sql = "SELECT * FROM cal_calendars ORDER BY name ASC";
  266.         $this->query($sql);
  267.         return $this->num_rows();
  268.     }
  269.  
  270.     function get_authorized_calendars($user_id)
  271.     {
  272.         $sql = "SELECT DISTINCT cal_calendars.* FROM cal_calendars, acl, users_groups WHERE (".
  273.                 "cal_calendars.acl_read = acl.acl_id OR cal_calendars.acl_write = acl.acl_id".
  274.                 ") AND ( ( acl.group_id = users_groups.group_id AND users_groups.user_id = ".$user_id." AND acl.user_id = 0 ) OR (".
  275.                 "acl.group_id = 0 AND acl.user_id = ".$user_id." ) ) ORDER BY cal_calendars.name ASC";
  276.         $this->query($sql);
  277.         return $this->num_rows();
  278.     }
  279.  
  280.     function set_event_status($event_id, $status, $email)
  281.     {
  282.         $sql = "UPDATE cal_participants SET status='$status' WHERE email='".smart_addslashes($email)."' AND event_id='$event_id'";
  283.         return $this->query($sql);
  284.     }
  285.  
  286.     function get_event_status($event_id, $email)
  287.     {
  288.         $sql = "SELECT status FROM cal_participants WHERE email='".smart_addslashes($email)."' AND event_id='$event_id'";
  289.         if($this->query($sql))
  290.         {
  291.             if($this->next_record())
  292.             {
  293.                 return $this->f('status');
  294.             }
  295.         }
  296.         return false;
  297.     }
  298.  
  299.  
  300.     /*
  301.     Times in GMT!
  302.     */
  303.     function add_event($user_id, $start_time, $end_time, $all_day_event, $name, $description, $contact_id, $reminder, $location, $background, $repeat_type, $repeat_end_time, $month_time, $repeat_forever, $repeat_every, $mon, $tue, $wed, $thu, $fri, $sat, $sun, $acl_read, $acl_write)
  304.     {
  305.         $event_id = $this->nextid("cal_events");
  306.         if ($event_id > 0)
  307.         {
  308.             $sql = "INSERT INTO cal_events (id, user_id, start_time, end_time, all_day_event, acl_read, acl_write, name, description, contact_id, reminder, location, background, repeat_type, repeat_end_time, month_time, repeat_forever, repeat_every, mon, tue, wed, thu, fri, sat, sun) VALUES ".
  309.                     "('$event_id', '$user_id', '$start_time', '$end_time', '$all_day_event', '$acl_read', '$acl_write', '".smart_addslashes($name)."', '".smart_addslashes($description)."', '$contact_id', '$reminder', '".smart_addslashes($location)."', '$background', '$repeat_type', '$repeat_end_time', '$month_time', '$repeat_forever', '$repeat_every',  '$mon', '$tue', '$wed', '$thu', '$fri', '$sat', '$sun')";
  310.             if ($this->query($sql))
  311.             {
  312.                 return $event_id;
  313.             }
  314.         }
  315.         return false;
  316.     }
  317.  
  318.     function update_event($event_id, $user_id, $start_time, $end_time, $all_day_event, $name, $description, $contact_id, $reminder, $location, $background, $repeat_type, $repeat_end_time, $month_time, $repeat_forever, $repeat_every, $mon, $tue, $wed, $thu, $fri, $sat, $sun)
  319.     {
  320.         $sql = "UPDATE cal_events SET start_time='$start_time', end_time='$end_time', all_day_event='$all_day_event', name='".smart_addslashes($name)."', description='".smart_addslashes($description)."', reminder='$reminder', location='".smart_addslashes($location)."', background='$background', repeat_type='$repeat_type', repeat_end_time='$repeat_end_time', month_time='$month_time', repeat_forever='$repeat_forever', repeat_every='$repeat_every', mon='$mon', tue='$tue', wed='$wed', thu='$thu', fri='$fri', sat='$sat', sun='$sun' WHERE id='$event_id'";
  321.         return $this->query($sql);
  322.     }
  323.  
  324.     function subscribe_event($event_id, $calendar_id)
  325.     {
  326.         $sql = "INSERT INTO cal_events_calendars (calendar_id, event_id) VALUES ('$calendar_id','$event_id')";
  327.         return $this->query($sql);
  328.     }
  329.  
  330.     function unsubscribe_event($event_id, $calendar_id)
  331.     {
  332.         $sql = "DELETE FROM cal_events_calendars WHERE calendar_id='$calendar_id' AND event_id='$event_id'";
  333.         return $this->query($sql);
  334.     }
  335.  
  336.     function event_is_subscribed($event_id, $calendar_id)
  337.     {
  338.         $sql = "SELECT * FROM cal_events_calendars WHERE event_id='$event_id' AND calendar_id='$calendar_id'";
  339.         $this->query($sql);
  340.         return $this->next_record();
  341.     }
  342.  
  343.     function get_event_subscribtions($event_id)
  344.     {
  345.         $sql = "SELECT * FROM cal_events_calendars WHERE event_id='$event_id'";
  346.         $this->query($sql);
  347.         return $this->num_rows();
  348.     }
  349.  
  350.  
  351.     function insert_reminder($user_id, $event_id, $remind_time)
  352.     {
  353.         return $this->query("INSERT INTO cal_reminders (user_id, event_id, remind_time) VALUES ('$user_id', '$event_id', '$remind_time')");
  354.     }
  355.  
  356.  
  357.     function update_reminder($user_id, $event_id, $remind_time)
  358.     {
  359.         return $this->query("UPDATE cal_reminders SET remind_time='$remind_time' WHERE user_id='$user_id' AND event_id='$event_id'");
  360.     }
  361.  
  362.     function delete_reminder($user_id, $event_id)
  363.     {
  364.         return $this->query("DELETE FROM cal_reminders WHERE user_id='$user_id' AND event_id='$event_id'");
  365.     }
  366.     /*
  367.     returns next starting time of an event in GMT timezone
  368.     */
  369.  
  370.     function get_next_recurrence_time($event_id, $gmt_time=0, $event='')
  371.     {
  372.         if ($event == '')
  373.         {
  374.             $event = $this->get_event($event_id);
  375.         }
  376.  
  377.         if ($gmt_time == 0)
  378.         {
  379.             $gmt_time = get_gmt_time();
  380.         }
  381.  
  382.         if ($event['repeat_forever'] == '0' && ($event['repeat_end_time'] < $gmt_time && $event['repeat_type'] != REPEAT_NONE))
  383.         {
  384.             return 0;
  385.         }
  386.  
  387.         if ($event['start_time'] > $gmt_time && $event['repeat_type'] != REPEAT_NONE)
  388.         {
  389.             $start_time = $event['start_time'];
  390.         }else
  391.         {
  392.             $start_time = $gmt_time;
  393.         }
  394.         $year = date('Y', $start_time);
  395.         $month = date('n', $start_time);
  396.         $day = date('j', $start_time);
  397.  
  398.         $event['start_year'] = date('Y', $event['start_time']);
  399.         $event['start_month'] = date('n', $event['start_time']);
  400.         $event['start_day'] = date('j', $event['start_time']);
  401.         $event['start_hour'] = date('G', $event['start_time']);
  402.         $event['start_min'] = date('i', $event['start_time']);
  403.  
  404.         $day_db_field[0] = 'sun';
  405.         $day_db_field[1] = 'mon';
  406.         $day_db_field[2] = 'tue';
  407.         $day_db_field[3] = 'wed';
  408.         $day_db_field[4] = 'thu';
  409.         $day_db_field[5] = 'fri';
  410.         $day_db_field[6] = 'sat';
  411.  
  412.         switch($event['repeat_type'])
  413.         {
  414.             case REPEAT_NONE:
  415.                 return $event['start_time'];
  416.             break;
  417.  
  418.             case REPEAT_WEEKLY:
  419.                 if ($event['repeat_every'] > 1)
  420.                 {
  421.                     $interval = $start_time - $event['start_time'];
  422.                     $interval_weeks = floor($interval/604800);
  423.                     $devided = $interval_weeks/$event['repeat_every'];
  424.                     $rounded = ceil($devided);
  425.                     $last_repeat_week = $event['repeat_every']*$rounded*604800;
  426.  
  427.                     $last_occurence_week = $event['start_time']+$last_repeat_week;
  428.                     $year = date('Y', $last_occurence_week);
  429.                     $month = date('n', $last_occurence_week);
  430.                     $day = date('j', $last_occurence_week);
  431.                 }else
  432.                 {
  433.                     $last_occurence_week= $start_time;
  434.                 }
  435.  
  436.                 $weekday = date("w", $last_occurence_week);
  437.                 //loop one day more then one week for occurence that happen exactly
  438.                 //one week later but earlier then this time
  439.                 $loops = $event['repeat_every'] > 1 ? 2 : 1;
  440.  
  441.                 for ($loop=0;$loop<$loops;$loop++)
  442.                 {
  443.                     $day_add=$loop*$event['repeat_every']*7;
  444.  
  445.                     for ($i=0;$i<7;$i++)
  446.                     {
  447.                         if ($weekday>6)
  448.                         {
  449.                             $weekday -= 7;
  450.                         }
  451.  
  452.                         if ($event[$day_db_field[$weekday]] == '1')
  453.                         {
  454.                             $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$i+$day_add, $year);
  455.  
  456.                             if ($event['repeat_forever'] == '0' && ($occurence_time > $event['repeat_end_time']))
  457.                             {
  458.                                 return 0;
  459.                             }elseif ($occurence_time > $start_time)
  460.                             {
  461.                                 return $occurence_time;
  462.                             }
  463.                         }
  464.                         $weekday++;
  465.                     }
  466.                 }
  467.  
  468.             break;
  469.  
  470.             case REPEAT_DAILY:
  471.  
  472.                 $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month, $day, $year);
  473.  
  474.                 if ($occurence_time <= $start_time)
  475.                 {
  476.                     $occurence_time =  mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$event['repeat_every'], $year);
  477.                 }
  478.  
  479.                 if ($event['repeat_forever'] == '0' && $occurence_time > $event['repeat_end_time'])
  480.                 {
  481.                     return 0;
  482.                 }else
  483.                 {
  484.                     return $occurence_time;
  485.                 }
  486.  
  487.  
  488.             break;
  489.  
  490.             case REPEAT_MONTH_DATE:
  491.                 $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month, $event['start_day'], $year);
  492.                 if ($occurence_time < $start_time)
  493.                 {
  494.                     $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month+$event['repeat_every'], $event['start_day'], $year);
  495.                 }
  496.  
  497.                 if ($event['repeat_forever'] == '0' && $occurence_time > $event['repeat_end_time'])
  498.                 {
  499.                     return 0;
  500.                 }else
  501.                 {
  502.                     return $occurence_time;
  503.                 }
  504.             break;
  505.  
  506.             case REPEAT_MONTH_DAY:
  507.  
  508.                 if ($event['repeat_every'] > 1)
  509.                 {
  510.                     $interval_years = $year-date('Y', $event['start_time']);
  511.                     $interval_months = $month - date('n', $event['start_time']);
  512.                     $interval_months = 12*$interval_years+$interval_months;
  513.                     $devided = $interval_months/$event['repeat_every'];
  514.                     $rounded = (int) $devided;
  515.                     $last_repeat_month = $event['repeat_every']*$rounded;
  516.  
  517.                     $repeat_year = date('Y', $event['start_time']);
  518.                     $repeat_month = date('n', $event['start_time']);
  519.                     $repeat_day = date('j', $event['start_time']);
  520.  
  521.                     $last_occurence_month = mktime(0,0,0, $repeat_month+$last_repeat_month, $repeat_day, $repeat_year);
  522.  
  523.                     //echo date(DB_DATE_FORMAT, $last_occurence_month).'<br /><br /><br />';
  524.                     $year = date('Y', $last_occurence_month);
  525.                     $month = date('n', $last_occurence_month);
  526.                     $day = date('j', $last_occurence_month);
  527.                 }else
  528.                 {
  529.                     $last_occurence_month = $start_time;
  530.                 }
  531.  
  532.                 $loops = $event['repeat_every'] > 1 ? 2 : 1;
  533.                 for ($loop=0;$loop<$loops;$loop++)
  534.                 {
  535.                     if ($loop > 0)
  536.                     {
  537.                         $month += ($loop*$event['repeat_every'])-1;
  538.                     }
  539.  
  540.                     //loop one day more then one week for occurence that happen exactly
  541.                     //one week later but earlier then this time
  542.                     for ($i=0;$i<32;$i++)
  543.                     {
  544.                         $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month, $i+1, $year);
  545.                         $year = date('Y', $occurence_time);
  546.                         $month = date('n', $occurence_time);
  547.                         $day = date('j', $occurence_time);
  548.  
  549.                         //echo date(DB_DATE_FORMAT, $occurence_time).'<br />';
  550.                         $weekday = date("w", $occurence_time);
  551.  
  552.                         if ($event[$day_db_field[$weekday]] == '1')
  553.                         {
  554.                             if (ceil(date('j',$occurence_time)/7) == $event['month_time'])
  555.                             {
  556.                                 if ($event['repeat_forever'] == '0' && $occurence_time > $event['repeat_end_time'])
  557.                                 {
  558.                                     return 0;
  559.                                 }elseif ($occurence_time > $start_time)
  560.                                 {
  561.                                     //echo 'returns: '.date(DB_DATE_FORMAT, $occurence_time).'<br />';
  562.                                     return $occurence_time;
  563.                                 }
  564.                             }
  565.                         }
  566.                     }
  567.                 }
  568.  
  569.             break;
  570.  
  571.             case REPEAT_YEARLY;
  572.                 $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $event['start_month'], $event['start_day'], $year);
  573.                 if ($occurence_time < $start_time)
  574.                 {
  575.                     $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $event['start_month'], $event['start_day'], $year+$event['repeat_every']);
  576.                 }
  577.                 if ($event['repeat_forever'] == '0' &&$occurence_time > $event['repeat_end_time'])
  578.                 {
  579.                     return 0;
  580.                 }else
  581.                 {
  582.                     return $occurence_time;
  583.                 }
  584.             break;
  585.         }
  586.     }
  587.  
  588.     /*
  589.     Times in GMT!
  590.     */
  591.  
  592.     function get_events($calendar_id, $contact_id, $interval_start, $interval_end)
  593.     {
  594.         $sql  = "SELECT * FROM cal_events";
  595.  
  596.         if ($calendar_id > 0)
  597.         {
  598.              $sql .= " INNER JOIN cal_events_calendars ON (cal_events.id=cal_events_calendars.event_id)";
  599.         }
  600.  
  601.         $sql .= " WHERE";
  602.  
  603.         if ($calendar_id > 0)
  604.         {
  605.             $sql .= " cal_events_calendars.calendar_id='$calendar_id'";
  606.         }
  607.         if ($contact_id > 0)
  608.         {
  609.             $sql .= " cal_events.contact_id='$contact_id'";
  610.         }
  611.  
  612.         if ($interval_start > 0)
  613.         {
  614.             $sql .= " AND ((cal_events.repeat_type='".REPEAT_NONE."' AND ".
  615.                     "cal_events.start_time<='$interval_end' AND cal_events.end_time>='$interval_start') OR ".
  616.                     "(cal_events.repeat_type!='".REPEAT_NONE."' AND ".
  617.                     "cal_events.start_time<='$interval_end' AND ".
  618.                     "(cal_events.repeat_end_time>='$interval_start' OR cal_events.repeat_forever='1')))";
  619.         }
  620.         $sql .=    " ORDER BY start_time";
  621.  
  622.         $this->query($sql);
  623.  
  624.         return $this->num_rows();
  625.     }
  626.  
  627.     function get_events_in_array($calendar_id, $contact_id, $interval_start_time, $interval_end_time, $day, $month, $year, $timezone_offset, $display_start_hour=0, $index_date='Ymd', $index_hour=true)
  628.     {
  629.         global $GO_SECURITY;
  630.  
  631.         //build an array called $events with all events for the days to display
  632.         //$event[DAY_OF_MONTH][HOUR_OF_DAY]
  633.         $events = array();
  634.  
  635.         $show_days = ceil(($interval_end_time - $interval_start_time)/86400);
  636.  
  637.  
  638.         if($count = $this->get_events($calendar_id, $contact_id, $interval_start_time, $interval_end_time))
  639.         {
  640.             while($this->next_record())
  641.             {
  642.                 $event = $this->Record;
  643.                 if (!$event['write_permission'] = $GO_SECURITY->has_permission($GO_SECURITY->user_id, $event['acl_write']))
  644.                 {
  645.                     $event['read_permission'] = $GO_SECURITY->has_permission($GO_SECURITY->user_id, $event['acl_read']);
  646.                 }
  647.  
  648.                 if ($event['write_permission'] || $event['read_permission'])
  649.                 {
  650.                     //calculate stored GMT unix times to local timezone dates
  651.                     //don't calculate timezone offset for all day events
  652.                     $_timezone_offset = ($event['all_day_event'] == '0') ? $timezone_offset : 0;
  653.  
  654.                     //the start time of the first occurence localized
  655.                     $initial_start_time = $event['start_time']+($_timezone_offset*3600);
  656.  
  657.                     $event['repeat_start_time'] = $initial_start_time;
  658.                     $event['repeat_end_time'] += ($_timezone_offset*3600);
  659.  
  660.                     $event['start_hour'] = date('G', $initial_start_time);
  661.                     $event['start_min'] = date('i', $initial_start_time);
  662.  
  663.                     //the end time of the first occurence localized
  664.                     $initial_end_time = $event['end_time']+($_timezone_offset*3600);
  665.  
  666.                     $event['end_hour'] = date('G', $initial_end_time);
  667.                     $event['end_min'] = date('i', $initial_end_time);
  668.  
  669.                     $event['start_date'] = date('Y-m-d', $initial_start_time);
  670.  
  671.                     //how many hours does this event occur?
  672.                     $real_duration_hours = ($initial_end_time - $initial_start_time)/3600;
  673.                     $duration_hours = ceil($real_duration_hours+($event['start_min']/60));
  674.                     //zero hours should still be displayed in one hour
  675.                     if ($duration_hours == 0)
  676.                     {
  677.                         $duration_hours = 1;
  678.                     }
  679.  
  680.                     $duration_days = ceil(($initial_end_time - $initial_start_time)/86400)+1;
  681.  
  682.                     if ($event['reminder'] > 0)
  683.                     {
  684.                         $event['remind_time'] = $event['start_time'] - $event['reminder'];
  685.                     }
  686.                     $event['repeat_type'];
  687.  
  688.                     switch($event['repeat_type'])
  689.                     {
  690.                         case REPEAT_NONE:
  691.                             $event['start_time'] += ($_timezone_offset*3600);
  692.                             $event['end_time'] += ($_timezone_offset*3600);
  693.  
  694.                             $event['start_year'] = date('Y', $event['start_time']);
  695.                             $event['start_month'] = date('n', $event['start_time']);
  696.                             $event['start_day'] = date('j', $event['start_time']);
  697.  
  698.                             if ($index_date)
  699.                             {
  700.                                 if ($event['all_day_event'] == '1')
  701.                                 {
  702.                                     //if event starts before the time to display skip the
  703.                                     //time not displayed
  704.                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  705.                                     if($time_before > 0)
  706.                                     {
  707.                                         $event_start_day = floor($time_before/86400);
  708.                                     }else
  709.                                     {
  710.                                         $event_start_day = 0;
  711.                                     }
  712.                                     for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  713.                                     {
  714.                                         $process_time = mktime(0,0,0,$event['start_month'], $event['start_day']+$event_day, $event['start_year']);
  715.                                         $process_date = date($index_date, $process_time);
  716.                                         //echo $process_date;
  717.                                         $all_day_events[$process_date][] = $event;
  718.                                     }
  719.                                 }else
  720.                                 {
  721.                                     //if event starts before the time to display skip the
  722.                                     //time not displayed
  723.                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  724.                                     if($time_before > 0)
  725.                                     {
  726.                                         $event_start_hour = floor($time_before/3600);
  727.                                     }else
  728.                                     {
  729.                                         $event_start_hour = 0;
  730.                                     }
  731.                                     for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  732.                                     {
  733.                                         //the time we are now processing
  734.                                         $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$event['start_month'], $event['start_day'], $event['start_year']);
  735.                                         //if we are processing time that happens later then the end of the display time interval then exit the loop
  736.  
  737.                                         if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  738.                                         {
  739.                                             break;
  740.                                         }
  741.                                         $process_date = date($index_date, $process_time);
  742.                                         $process_hour = date('G', $process_time);
  743.  
  744.  
  745.                                         if ($event_hour == 0 || $process_hour == $display_start_hour)
  746.                                         {
  747.                                             //echo $process_date.': '.$process_hour.'<br />';
  748.                                             if ($index_hour)
  749.                                             {
  750.                                                 $events[$process_date][$process_hour][] = $event;
  751.                                             }else
  752.                                             {
  753.                                                 $events[$process_date][] = $event;
  754.                                                 if ($process_hour == $display_start_hour)
  755.                                                 {
  756.                                                     $event_hour += 23-$display_start_hour;
  757.                                                 }
  758.                                             }
  759.  
  760.                                         }else
  761.                                         {
  762.                                             $backgrounds[$process_date][$process_hour] = $event['background'];
  763.                                         }
  764.                                     }
  765.                                 }
  766.                             }else
  767.                             {
  768.                                 $events[] = $event;
  769.                             }
  770.  
  771.                         break;
  772.  
  773.                         case REPEAT_DAILY:
  774.                             //loop through all days that are displayed + the last day for occurences that started outside but end in the display interval
  775.                             for($show_day=-1;$show_day<$show_days;$show_day++)
  776.                             {
  777.                                 $day_start_time = mktime(0,0,0,$month, $day+$show_day, $year);
  778.                                 $day_end_time = mktime(0,0,0,$month, $day+$show_day+1, $year);
  779.  
  780.                                 //does the event occur at the current day to display?
  781.                                 if ($event['repeat_start_time'] < $day_end_time && ($event['repeat_end_time'] >= $day_start_time || $event['repeat_forever'] == '1'))
  782.                                 {
  783.                                     $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$show_day, $year);
  784.                                     $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  785.  
  786.                                     if ($event['repeat_every'] > 1)
  787.                                     {
  788.                                         $interval = $event['start_time'] - $event['repeat_start_time'];
  789.                                         $interval_days = ceil($interval/86400);
  790.                                         $devided = $interval_days/$event['repeat_every'];
  791.                                         $match = (int) $devided;
  792.  
  793.                                     }
  794.  
  795.                                     if ($event['repeat_every'] < 2 || $devided == $match)
  796.                                     {
  797.                                         if ($index_date)
  798.                                         {
  799.                                             if ($event['all_day_event'] == '1')
  800.                                             {
  801.                                                 //if event starts before the time to display skip the
  802.                                                 //time not displayed
  803.                                                 $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  804.                                                 if($time_before > 0)
  805.                                                 {
  806.                                                     $event_start_day = floor($time_before/86400);
  807.                                                 }else
  808.                                                 {
  809.                                                     $event_start_day = 0;
  810.                                                 }
  811.                                                 for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  812.                                                 {
  813.                                                     $process_time = mktime(0,0,0,$month, $day+$show_day+$event_day, $year);
  814.                                                     $process_date = date($index_date, $process_time);
  815.                                                     $all_day_events[$process_date][] = $event;
  816.                                                 }
  817.                                             }else
  818.                                             {
  819.  
  820.                                                 //if event starts before the time to display skip the
  821.                                                 //time not displayed
  822.                                                 $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  823.                                                 if($time_before > 0)
  824.                                                 {
  825.                                                     $event_start_hour = floor($time_before/3600);
  826.                                                 }else
  827.                                                 {
  828.                                                     $event_start_hour = 0;
  829.                                                 }
  830.                                                 for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  831.                                                 {
  832.                                                     //the time we are now processing
  833.  
  834.                                                     $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$month, $day+$show_day, $year);
  835.                                                     //if we are processing time that happens outside the display time interval then exit the loop
  836.                                                     if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  837.                                                     {
  838.                                                         break;
  839.                                                     }
  840.  
  841.                                                     $process_date = date($index_date, $process_time);
  842.                                                     $process_hour = date('G', $process_time);
  843.  
  844.                                                     if ($event_hour == 0 || $process_hour == $display_start_hour)
  845.                                                     {
  846.                                                         //echo $process_date.': '.$process_hour.'<br />';
  847.                                                         if ($index_hour)
  848.                                                         {
  849.                                                             $events[$process_date][$process_hour][] = $event;
  850.                                                         }else
  851.                                                         {
  852.                                                             $events[$process_date][] = $event;
  853.                                                             if ($process_hour == $display_start_hour)
  854.                                                             {
  855.                                                                 $event_hour += 23-$display_start_hour;
  856.                                                             }
  857.                                                         }
  858.                                                     }else
  859.                                                     {
  860.                                                         $backgrounds[$process_date][$process_hour] = $event['background'];
  861.                                                     }
  862.                                                 }
  863.                                             }
  864.                                         }else
  865.                                         {
  866.                                             $events[] = $event;
  867.                                         }
  868.                                     }
  869.                                 }
  870.                             }
  871.                         break;
  872.  
  873.                         case REPEAT_WEEKLY:
  874.                             //loop through all days that are displayed + the last day for occurences that started outside but end in the display interval
  875.                             for($show_day=-1;$show_day<$show_days;$show_day++)
  876.                             {
  877.                                 $day_start_time = mktime(0,0,0,$month, $day+$show_day, $year);
  878.                                 $day_end_time = mktime(0,0,0,$month, $day+$show_day+1, $year);
  879.  
  880.                                 //does the event occur at the current day to display?
  881.                                 if ($event['repeat_start_time'] < $day_end_time && ($event['repeat_end_time'] >= $day_start_time || $event['repeat_forever'] == '1'))
  882.                                 {
  883.                                     $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$show_day, $year);
  884.                                     $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  885.  
  886.                                     if ($event['repeat_every'] > 1)
  887.                                     {
  888.                                         $interval = $event['start_time'] - $event['repeat_start_time'];
  889.                                         $interval_weeks = floor($interval/604800);
  890.                                         $devided = $interval_weeks/$event['repeat_every'];
  891.                                         $match = (int) $devided;
  892.                                     }
  893.  
  894.                                     if ($event['repeat_every'] < 2 || $devided == $match)
  895.                                     {
  896.                                         $weekday = date('w', $day_start_time);
  897.  
  898.                                         //shift the weekdays to local time
  899.                                         $local_start_hour = date('H',$initial_start_time-($_timezone_offset*3600)) + $_timezone_offset;
  900.                                         if ($local_start_hour > 23)
  901.                                         {
  902.                                             $local_start_hour = $local_start_hour - 24;
  903.                                             $shift_day = 1;
  904.                                         }elseif($local_start_hour < 0)
  905.                                         {
  906.                                             $local_start_hour = 24 + $local_start_hour;
  907.                                             $shift_day = -1;
  908.                                         }else
  909.                                         {
  910.                                             $shift_day = 0;
  911.                                         }
  912.  
  913.                                         switch($shift_day)
  914.                                         {
  915.                                             case 0:
  916.                                                 $day_db_field[0] = 'sun';
  917.                                                 $day_db_field[1] = 'mon';
  918.                                                 $day_db_field[2] = 'tue';
  919.                                                 $day_db_field[3] = 'wed';
  920.                                                 $day_db_field[4] = 'thu';
  921.                                                 $day_db_field[5] = 'fri';
  922.                                                 $day_db_field[6] = 'sat';
  923.                                             break;
  924.  
  925.                                             case 1:
  926.                                                 $day_db_field[0] = 'sat';
  927.                                                 $day_db_field[1] = 'sun';
  928.                                                 $day_db_field[2] = 'mon';
  929.                                                 $day_db_field[3] = 'tue';
  930.                                                 $day_db_field[4] = 'wed';
  931.                                                 $day_db_field[5] = 'thu';
  932.                                                 $day_db_field[6] = 'fri';
  933.  
  934.                                             break;
  935.  
  936.                                             case -1:
  937.                                                 $day_db_field[0] = 'mon';
  938.                                                 $day_db_field[1] = 'tue';
  939.                                                 $day_db_field[2] = 'wed';
  940.                                                 $day_db_field[3] = 'thu';
  941.                                                 $day_db_field[4] = 'fri';
  942.                                                 $day_db_field[5] = 'sat';
  943.                                                 $day_db_field[6] = 'sun';
  944.                                             break;
  945.  
  946.                                         }
  947.  
  948.  
  949.                                         //does it repeat on this weekday?
  950.                                         if ($event[$day_db_field[$weekday]] == '1')
  951.                                         {
  952.                                             if ($index_date)
  953.                                             {
  954.                                                 if ($event['all_day_event'] == '1')
  955.                                                 {
  956.                                                     //if event starts before the time to display skip the
  957.                                                     //time not displayed
  958.                                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  959.                                                     if($time_before > 0)
  960.                                                     {
  961.                                                         $event_start_day = floor($time_before/86400);
  962.                                                     }else
  963.                                                     {
  964.                                                         $event_start_day = 0;
  965.                                                     }
  966.                                                     for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  967.                                                     {
  968.                                                         $process_time = mktime(0,0,0,$month, $day+$show_day+$event_day, $year);
  969.                                                         $process_date = date($index_date, $process_time);
  970.                                                         $all_day_events[$process_date][] = $event;
  971.                                                     }
  972.                                                 }else
  973.                                                 {
  974.                                                     //if event starts before the time to display skip the
  975.                                                     //time not displayed
  976.                                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  977.                                                     if($time_before > 0)
  978.                                                     {
  979.                                                         $event_start_hour = floor($time_before/3600);
  980.                                                     }else
  981.                                                     {
  982.                                                         $event_start_hour = 0;
  983.                                                     }
  984.                                                     for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  985.                                                     {
  986.                                                         //the time we are now processing
  987.                                                         $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$month, $day+$show_day, $year);
  988.  
  989.                                                         //if we are processing time that happens outside the display time interval then exit the loop
  990.                                                         if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  991.                                                         {
  992.                                                             break;
  993.                                                         }
  994.                                                         $process_date = date($index_date, $process_time);
  995.                                                         $process_hour = date('G', $process_time);
  996.  
  997.                                                         if ($event_hour == 0 || $process_hour == $display_start_hour)
  998.                                                         {
  999.                                                             //echo $process_date.': '.$process_hour.'<br />';
  1000.                                                             if ($index_hour)
  1001.                                                             {
  1002.                                                                 $events[$process_date][$process_hour][] = $event;
  1003.                                                             }else
  1004.                                                             {
  1005.                                                                 $events[$process_date][] = $event;
  1006.                                                                 if ( $process_hour == $display_start_hour)
  1007.                                                                 {
  1008.                                                                     $event_hour += 23-$display_start_hour;
  1009.                                                                 }
  1010.  
  1011.                                                             }
  1012.                                                         }else
  1013.                                                         {
  1014.                                                             $backgrounds[$process_date][$process_hour] = $event['background'];
  1015.                                                         }
  1016.                                                     }
  1017.                                                 }
  1018.                                             }else
  1019.                                             {
  1020.                                                 $events[] = $event;
  1021.                                             }
  1022.                                         }
  1023.                                     }
  1024.                                 }
  1025.                             }
  1026.                         break;
  1027.  
  1028.                         case REPEAT_MONTH_DATE:
  1029.  
  1030.                             //how many months are to be displayed?
  1031.                             $first_month = date('m', $interval_start_time+($timezone_offset*3600));
  1032.                             $interval_years = date('Y', $interval_end_time)-date('Y', $interval_start_time+($timezone_offset*3600));
  1033.                             $interval_months = date('m', $interval_end_time) - date('m', $interval_start_time+($timezone_offset*3600));
  1034.                             $show_months = (12*$interval_years)+$interval_months+1;
  1035.  
  1036.                             //check for an occurence that started last year
  1037.                             $process_years = array($year);
  1038.                             if (date('Y', mktime(0,0,0,$month, $day, $year)) > date('Y', mktime(0,0,0,$first_month, $day, $year)-($duration_hours*3600)))
  1039.                             {
  1040.                                 $process_years[] = $year-1;
  1041.                             }
  1042.                             for ($process_year_index=0;$process_year_index<count($process_years);$process_year_index++)
  1043.                             {
  1044.                                 for ($show_month=0;$show_month<$show_months;$show_month++)
  1045.                                 {
  1046.                                     //does the event occur at this day?
  1047.                                     $event['start_day'] = date('j', $initial_start_time);
  1048.  
  1049.                                     $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $first_month+$show_month, $event['start_day'], $process_years[$process_year_index]);
  1050.                                     $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  1051.  
  1052.                                     if($event['start_time'] < $interval_end_time && $event['end_time'] > $interval_start_time)
  1053.                                     {
  1054.                                         if ($event['repeat_every'] > 1)
  1055.                                         {
  1056.                                             $interval_years = $year-date('Y', $event['repeat_start_time']);
  1057.                                             $interval_months = $first_month+$show_month - date('m', $event['repeat_start_time']);
  1058.  
  1059.                                             $interval_months = 12*$interval_years+$interval_months;
  1060.  
  1061.                                             $devided = $interval_months/$event['repeat_every'];
  1062.                                             $match = (int) $devided;
  1063.                                         }
  1064.  
  1065.                                         if ($event['repeat_every'] < 2 || $devided == $match)
  1066.                                         {
  1067.                                             if ($index_date)
  1068.                                             {
  1069.                                                 if ($event['all_day_event'] == '1')
  1070.                                                 {
  1071.                                                     //if event starts before the time to display skip the
  1072.                                                     //time not displayed
  1073.                                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1074.                                                     if($time_before > 0)
  1075.                                                     {
  1076.                                                         $event_start_day = floor($time_before/86400);
  1077.                                                     }else
  1078.                                                     {
  1079.                                                         $event_start_day = 0;
  1080.                                                     }
  1081.                                                     for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  1082.                                                     {
  1083.                                                         $process_time = mktime($event['start_hour'],$event['start_min'],0,$month, $event['start_day']+$event_day, $process_years[$process_year_index]);
  1084.                                                         $process_date = date($index_date, $process_time);
  1085.                                                         $all_day_events[$process_date][] = $event;
  1086.                                                     }
  1087.                                                 }else
  1088.                                                 {
  1089.                                                     //if event starts before the time to display skip the
  1090.                                                     //time not displayed
  1091.                                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1092.                                                     if($time_before > 0)
  1093.                                                     {
  1094.                                                         $event_start_hour = floor($time_before/3600);
  1095.                                                     }else
  1096.                                                     {
  1097.                                                         $event_start_hour = 0;
  1098.                                                     }
  1099.                                                     for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  1100.                                                     {
  1101.                                                         //the time we are now processing
  1102.                                                         $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$first_month+$show_month, $event['start_day'], $process_years[$process_year_index]);
  1103.                                                         //if we are processing time that happens later then the end of the display time interval then exit the loop
  1104.  
  1105.                                                         if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  1106.                                                         {
  1107.                                                             break;
  1108.                                                         }
  1109.                                                         $process_date = date($index_date, $process_time);
  1110.                                                         $process_hour = date('G', $process_time);
  1111.  
  1112.                                                         if ($event_hour == 0 || $process_hour == $display_start_hour)
  1113.                                                         {
  1114.                                                             //echo $process_date.': '.$process_hour.'<br />';
  1115.                                                             if ($index_hour)
  1116.                                                             {
  1117.                                                                 $events[$process_date][$process_hour][] = $event;
  1118.                                                             }else
  1119.                                                             {
  1120.                                                                 $events[$process_date][] = $event;
  1121.                                                                 if ( $process_hour == $display_start_hour)
  1122.                                                                 {
  1123.                                                                     $event_hour += 23-$display_start_hour;
  1124.                                                                 }
  1125.  
  1126.                                                             }
  1127.                                                         }else
  1128.                                                         {
  1129.                                                             $backgrounds[$process_date][$process_hour] = $event['background'];
  1130.                                                         }
  1131.                                                     }
  1132.                                                 }
  1133.                                             }else
  1134.                                             {
  1135.                                                 $events[] = $event;
  1136.                                             }
  1137.                                         }
  1138.                                     }
  1139.                                 }
  1140.                             }
  1141.  
  1142.                         break;
  1143.  
  1144.                         case REPEAT_MONTH_DAY:
  1145.                             //loop through all days that are displayed + the last day for occurences that started outside but end in the display interval
  1146.  
  1147.                             for($show_day=-1;$show_day<$show_days;$show_day++)
  1148.                             {
  1149.                                 $day_start_time = mktime(0,0,0,$month, $day+$show_day, $year);
  1150.                                 $day_end_time = mktime(0,0,0,$month, $day+$show_day+1, $year);
  1151.  
  1152.                                 if ($event['repeat_every'] > 1)
  1153.                                 {
  1154.                                     $new_year = date('Y', $day_start_time);
  1155.                                     $new_month = date('n', $day_start_time);
  1156.  
  1157.                                     $interval_years = $new_year-date('Y', $event['repeat_start_time']);
  1158.                                     $interval_months = $new_month - date('m', $event['repeat_start_time']);
  1159.  
  1160.                                     $interval_months = 12*$interval_years+$interval_months;
  1161.  
  1162.                                     $devided = $interval_months/$event['repeat_every'];
  1163.                                     $match = (int) $devided;
  1164.  
  1165.                                     //echo $devided.' = '.$match.'<br />';
  1166.                                 }
  1167.  
  1168.                                 //echo date(DB_DATETIME_FORMAT, $event['start_time']).'<br />';
  1169.                                 if ($event['repeat_every'] < 2 || $devided == $match)
  1170.                                 {
  1171.                                     $new_day = date('j', $day_start_time);
  1172.  
  1173.                                     $month_time = ceil($new_day/7);
  1174.  
  1175.                                     if ($event['month_time'] == $month_time)
  1176.                                     {
  1177.                                         $day_start_time = mktime(0,0,0,$month, $day+$show_day, $year);
  1178.                                         $day_end_time = mktime(0,0,0,$month, $day+$show_day+1, $year);
  1179.  
  1180.                                         //does the event occur at the current day to display?
  1181.                                         if ($event['repeat_start_time'] < $day_end_time && ($event['repeat_end_time'] >= $day_start_time || $event['repeat_forever'] == '1'))
  1182.                                         {
  1183.                                             $weekday = date('w', $day_start_time);
  1184.                                             //shift the weekdays to local time
  1185.                                             $local_start_hour = date('H',$initial_start_time-($_timezone_offset*3600)) + $_timezone_offset;
  1186.                                             if ($local_start_hour > 23)
  1187.                                             {
  1188.                                                 $local_start_hour = $local_start_hour - 24;
  1189.                                                 $shift_day = 1;
  1190.                                             }elseif($local_start_hour < 0)
  1191.                                             {
  1192.                                                 $local_start_hour = 24 + $local_start_hour;
  1193.                                                 $shift_day = -1;
  1194.                                             }else
  1195.                                             {
  1196.                                                 $shift_day = 0;
  1197.                                             }
  1198.  
  1199.                                             switch($shift_day)
  1200.                                             {
  1201.                                                 case 0:
  1202.                                                     $day_db_field[0] = 'sun';
  1203.                                                     $day_db_field[1] = 'mon';
  1204.                                                     $day_db_field[2] = 'tue';
  1205.                                                     $day_db_field[3] = 'wed';
  1206.                                                     $day_db_field[4] = 'thu';
  1207.                                                     $day_db_field[5] = 'fri';
  1208.                                                     $day_db_field[6] = 'sat';
  1209.                                                 break;
  1210.  
  1211.                                                 case 1:
  1212.                                                     $day_db_field[0] = 'sat';
  1213.                                                     $day_db_field[1] = 'sun';
  1214.                                                     $day_db_field[2] = 'mon';
  1215.                                                     $day_db_field[3] = 'tue';
  1216.                                                     $day_db_field[4] = 'wed';
  1217.                                                     $day_db_field[5] = 'thu';
  1218.                                                     $day_db_field[6] = 'fri';
  1219.  
  1220.                                                 break;
  1221.  
  1222.                                                 case -1:
  1223.                                                     $day_db_field[0] = 'mon';
  1224.                                                     $day_db_field[1] = 'tue';
  1225.                                                     $day_db_field[2] = 'wed';
  1226.                                                     $day_db_field[3] = 'thu';
  1227.                                                     $day_db_field[4] = 'fri';
  1228.                                                     $day_db_field[5] = 'sat';
  1229.                                                     $day_db_field[6] = 'sun';
  1230.                                                 break;
  1231.  
  1232.                                             }
  1233.  
  1234.                                             $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$show_day, $year);
  1235.                                             $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  1236.  
  1237.                                             //does it repeat on this weekday?
  1238.                                             if ($event[$day_db_field[$weekday]] == '1')
  1239.                                             {
  1240.                                                 if($index_date)
  1241.                                                 {
  1242.                                                     if ($event['all_day_event'] == '1')
  1243.                                                     {
  1244.                                                         //if event starts before the time to display skip the
  1245.                                                         //time not displayed
  1246.                                                         $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1247.                                                         if($time_before > 0)
  1248.                                                         {
  1249.                                                             $event_start_day = floor($time_before/86400);
  1250.                                                         }else
  1251.                                                         {
  1252.                                                             $event_start_day = 0;
  1253.                                                         }
  1254.                                                         for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  1255.                                                         {
  1256.                                                             $process_time = mktime($event['start_hour'],$event['start_min'],0,$month, $day+$show_day+$event_day, $year);
  1257.                                                             $process_date = date($index_date, $process_time);
  1258.                                                             $all_day_events[$process_date][] = $event;
  1259.                                                         }
  1260.                                                     }else
  1261.                                                     {
  1262.  
  1263.                                                         //if event starts before the time to display skip the
  1264.                                                         //time not displayed
  1265.                                                         $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1266.                                                         if($time_before > 0)
  1267.                                                         {
  1268.                                                             $event_start_hour = floor($time_before/3600);
  1269.                                                         }else
  1270.                                                         {
  1271.                                                             $event_start_hour = 0;
  1272.                                                         }
  1273.                                                         for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  1274.                                                         {
  1275.                                                             //the time we are now processing
  1276.                                                             $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$month, $day+$show_day, $year);
  1277.  
  1278.                                                             //if we are processing time that happens outside the display time interval then exit the loop
  1279.                                                             if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  1280.                                                             {
  1281.                                                                 break;
  1282.                                                             }
  1283.                                                             $process_date = date($index_date, $process_time);
  1284.                                                             $process_hour = date('G', $process_time);
  1285.  
  1286.                                                             if ($event_hour == 0 || $process_hour == $display_start_hour)
  1287.                                                             {
  1288.                                                                 //echo $process_date.': '.$process_hour.'<br />';
  1289.                                                                 if ($index_hour)
  1290.                                                                 {
  1291.                                                                     $events[$process_date][$process_hour][] = $event;
  1292.                                                                 }else
  1293.                                                                 {
  1294.                                                                     $events[$process_date][] = $event;
  1295.                                                                     if ( $process_hour == $display_start_hour)
  1296.                                                                     {
  1297.                                                                         $event_hour += 23-$display_start_hour;
  1298.                                                                     }
  1299.  
  1300.                                                                 }
  1301.                                                             }else
  1302.                                                             {
  1303.                                                                 $backgrounds[$process_date][$process_hour] = $event['background'];
  1304.                                                             }
  1305.                                                         }
  1306.                                                     }
  1307.                                                 }else
  1308.                                                 {
  1309.                                                     $events[] = $event;
  1310.                                                 }
  1311.  
  1312.                                             }
  1313.                                         }
  1314.                                     }
  1315.                                 }
  1316.                             }
  1317.  
  1318.                         break;
  1319.  
  1320.                         case REPEAT_YEARLY:
  1321.                             //check for an occurence that started last year
  1322.                             $process_years = array($year);
  1323.                             if (date('Y', mktime(0,0,0,$month, $day, $year)) > date('Y', mktime(0,0,0,$month, $day, $year)-($duration_hours*3600)))
  1324.                             {
  1325.                                 $process_years[] = $year-1;
  1326.                             }
  1327.                             for ($process_year_index=0;$process_year_index<count($process_years);$process_year_index++)
  1328.                             {
  1329.                                 if ($event['repeat_every'] > 1)
  1330.                                 {
  1331.                                     $interval_years = $process_years[$process_year_index]-date('Y', $event['repeat_start_time']);
  1332.  
  1333.                                     $devided = $interval_years/$event['repeat_every'];
  1334.                                     $match = (int) $devided;
  1335.                                 }
  1336.  
  1337.                                 if ($event['repeat_every'] < 2 || $devided == $match)
  1338.                                 {
  1339.                                     //does the event occur at this day?
  1340.                                     $event['start_month'] = date('n', $event['start_time']);
  1341.                                     $event['start_day'] = date('j', $event['start_time']);
  1342.  
  1343.                                     $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $event['start_month'], $event['start_day'], $process_years[$process_year_index]);
  1344.                                     $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  1345.  
  1346.                                     if($event['start_time'] < $interval_end_time && $event['end_time'] > $interval_start_time)
  1347.                                     {
  1348.                                         if ($index_date)
  1349.                                         {
  1350.                                             if ($event['all_day_event'] == '1')
  1351.                                             {
  1352.                                                 //if event starts before the time to display skip the
  1353.                                                 //time not displayed
  1354.                                                 $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1355.                                                 if($time_before > 0)
  1356.                                                 {
  1357.                                                     $event_start_day = floor($time_before/86400);
  1358.                                                 }else
  1359.                                                 {
  1360.                                                     $event_start_day = 0;
  1361.                                                 }
  1362.                                                 for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  1363.                                                 {
  1364.                                                     $process_time = mktime($event['start_hour'],$event['start_min'],0,$event['start_month'], $event['start_day'], $process_years[$process_year_index]);
  1365.                                                     $process_date = date($index_date, $process_time);
  1366.                                                     $all_day_events[$process_date][] = $event;
  1367.                                                 }
  1368.                                             }else
  1369.                                             {
  1370.                                                 //if event starts before the time to display skip the
  1371.                                                 //time not displayed
  1372.                                                 $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1373.                                                 if($time_before > 0)
  1374.                                                 {
  1375.                                                     $event_start_hour = floor($time_before/3600);
  1376.                                                 }else
  1377.                                                 {
  1378.                                                     $event_start_hour = 0;
  1379.                                                 }
  1380.                                                 for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  1381.                                                 {
  1382.                                                     //the time we are now processing
  1383.                                                     $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$event['start_month'], $event['start_day'], $process_years[$process_year_index]);
  1384.                                                     //if we are processing time that happens later then the end of the display time interval then exit the loop
  1385.  
  1386.                                                     //TODO don't process time before
  1387.  
  1388.                                                     if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  1389.                                                     {
  1390.                                                         break;
  1391.                                                     }
  1392.                                                     $process_date = date($index_date, $process_time);
  1393.                                                     $process_hour = date('G', $process_time);
  1394.  
  1395.                                                     if ($event_hour == 0 || $process_hour == 0)
  1396.                                                     {
  1397.                                                         //echo $process_date.': '.$process_hour.'<br />';
  1398.                                                         if ($index_hour)
  1399.                                                         {
  1400.                                                             $events[$process_date][$process_hour][] = $event;
  1401.                                                         }else
  1402.                                                         {
  1403.                                                             $events[$process_date][] = $event;
  1404.                                                             if ( $process_hour == $display_start_hour)
  1405.                                                             {
  1406.                                                                 $event_hour += 23-$display_start_hour;
  1407.                                                             }
  1408.  
  1409.                                                         }
  1410.                                                     }else
  1411.                                                     {
  1412.                                                         $backgrounds[$process_date][$process_hour] = $event['background'];
  1413.                                                     }
  1414.                                                 }
  1415.                                             }
  1416.  
  1417.                                         }else
  1418.                                         {
  1419.                                             $events[] = $event;
  1420.                                         }
  1421.                                     }
  1422.                                 }
  1423.                             }
  1424.                         break;
  1425.                     }
  1426.                 }
  1427.             }
  1428.         }
  1429.         if ($index_date)
  1430.         {
  1431.             $all_events['timed'] = isset($events) ? $events : array();
  1432.             $all_events['all_day'] = isset($all_day_events) ? $all_day_events : array();
  1433.             $all_events['backgrounds'] = isset($backgrounds) ? $backgrounds : array();
  1434.             return $all_events;
  1435.         }else
  1436.         {
  1437.             return $events;
  1438.         }
  1439.     }
  1440.  
  1441.     function get_events_to_remind($user_id)
  1442.     {
  1443.         $gmt_time = get_gmt_time();
  1444.  
  1445.         $sql = "SELECT * FROM cal_reminders WHERE user_id='$user_id' AND remind_time<='$gmt_time'";
  1446.         $this->query($sql);
  1447.         return $this->num_rows();
  1448.     }
  1449.     /*
  1450.     function get_all_events($calendar_id)
  1451.     {
  1452.         $sql = "SELECT cal_events.* FROM cal_events LEFT JOIN cal_events_calendars ON (cal_events.id=cal_events_calendars.event_id) WHERE cal_events_calendars.calendar_id='$calendar_id'";
  1453.         $this->query($sql);
  1454.         return $this->num_rows();
  1455.     }
  1456.     */
  1457.  
  1458.     function get_event($event_id)
  1459.     {
  1460.         $sql = "SELECT * FROM cal_events WHERE id='$event_id'";
  1461.         $this->query($sql);
  1462.         if($this->next_record())
  1463.         {
  1464.             return $this->Record;
  1465.         }else
  1466.         {
  1467.             return false;
  1468.         }
  1469.     }
  1470.  
  1471.     function delete_event($event_id)
  1472.     {
  1473.         $event = $this->get_event($event_id);
  1474.  
  1475.         $sql = "DELETE FROM cal_events WHERE id='$event_id'";
  1476.         $this->query($sql);
  1477.         $sql = "DELETE FROM cal_events_calendars WHERE event_id='$event_id'";
  1478.         $this->query($sql);
  1479.         $sql = "DELETE FROM cal_reminders WHERE event_id='$event_id'";
  1480.         $this->query($sql);
  1481.         $sql = "DELETE FROM cal_participants WHERE event_id='$event_id'";
  1482.         return $this->query($sql);
  1483.     }
  1484.  
  1485.     function delete_user($user_id)
  1486.     {
  1487.         $this->unsubscribe_all($user_id);
  1488.  
  1489.         $delete = new calendar();
  1490.         $sql = "SELECT * FROM cal_calendars WHERE user_id='$user_id'";
  1491.         $this->query($sql);
  1492.         while($this->next_record())
  1493.         {
  1494.             $delete->delete_calendar($this->f('id'));
  1495.         }
  1496.  
  1497.         $sql = "SELECT * FROM cal_events WHERE user_id='$user_id'";
  1498.         $this->query($sql);
  1499.  
  1500.         while($this->next_record())
  1501.         {
  1502.             $delete->delete_event($this->f('id'));
  1503.         }
  1504.  
  1505.     }
  1506. }
  1507. ?>