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 >
Text File  |  2004-03-08  |  52KB  |  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.     function update_reminder($user_id, $event_id, $remind_time)
  357.     {
  358.         return $this->query("UPDATE cal_reminders SET remind_time='$remind_time' WHERE user_id='$user_id' AND event_id='$event_id'");
  359.     }
  360.  
  361.     function delete_reminder($user_id, $event_id)
  362.     {
  363.         return $this->query("DELETE FROM cal_reminders WHERE user_id='$user_id' AND event_id='$event_id'");
  364.     }
  365.     /*
  366.     returns next starting time of an event in GMT timezone
  367.     */
  368.  
  369.     function get_next_recurrence_time($event_id, $gmt_time=0, $event='')
  370.     {
  371.         if ($event == '')
  372.         {
  373.             $event = $this->get_event($event_id);
  374.         }
  375.  
  376.         if ($gmt_time == 0)
  377.         {
  378.             $gmt_time = get_gmt_time();
  379.         }
  380.  
  381.         if ($event['repeat_forever'] == '0' && ($event['repeat_end_time'] < $gmt_time && $event['repeat_type'] != REPEAT_NONE))
  382.         {
  383.             return 0;
  384.         }
  385.  
  386.         if ($event['start_time'] > $gmt_time && $event['repeat_type'] != REPEAT_NONE)
  387.         {
  388.             $start_time = $event['start_time'];
  389.         }else
  390.         {
  391.             $start_time = $gmt_time;
  392.         }
  393.         $year = date('Y', $start_time);
  394.         $month = date('n', $start_time);
  395.         $day = date('j', $start_time);
  396.  
  397.         $event['start_year'] = date('Y', $event['start_time']);
  398.         $event['start_month'] = date('n', $event['start_time']);
  399.         $event['start_day'] = date('j', $event['start_time']);
  400.         $event['start_hour'] = date('G', $event['start_time']);
  401.         $event['start_min'] = date('i', $event['start_time']);
  402.  
  403.         $day_db_field[0] = 'sun';
  404.         $day_db_field[1] = 'mon';
  405.         $day_db_field[2] = 'tue';
  406.         $day_db_field[3] = 'wed';
  407.         $day_db_field[4] = 'thu';
  408.         $day_db_field[5] = 'fri';
  409.         $day_db_field[6] = 'sat';
  410.  
  411.         switch($event['repeat_type'])
  412.         {
  413.             case REPEAT_NONE:
  414.                 return $event['start_time'];
  415.             break;
  416.  
  417.             case REPEAT_WEEKLY:
  418.                 if ($event['repeat_every'] > 1)
  419.                 {
  420.                     $interval = $start_time - $event['start_time'];
  421.                     $interval_weeks = floor($interval/604800);
  422.                     $devided = $interval_weeks/$event['repeat_every'];
  423.                     $rounded = ceil($devided);
  424.                     $last_repeat_week = $event['repeat_every']*$rounded*604800;
  425.  
  426.                     $last_occurence_week = $event['start_time']+$last_repeat_week;
  427.                     $year = date('Y', $last_occurence_week);
  428.                     $month = date('n', $last_occurence_week);
  429.                     $day = date('j', $last_occurence_week);
  430.                 }else
  431.                 {
  432.                     $last_occurence_week= $start_time;
  433.                 }
  434.  
  435.                 $weekday = date("w", $last_occurence_week);
  436.                 //loop one day more then one week for occurence that happen exactly
  437.                 //one week later but earlier then this time
  438.                 $loops = $event['repeat_every'] > 1 ? 2 : 1;
  439.  
  440.                 for ($loop=0;$loop<$loops;$loop++)
  441.                 {
  442.                     $day_add=$loop*$event['repeat_every']*7;
  443.  
  444.                     for ($i=0;$i<7;$i++)
  445.                     {
  446.                         if ($weekday>6)
  447.                         {
  448.                             $weekday -= 7;
  449.                         }
  450.  
  451.                         if ($event[$day_db_field[$weekday]] == '1')
  452.                         {
  453.                             $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$i+$day_add, $year);
  454.  
  455.                             if ($event['repeat_forever'] == '0' && ($occurence_time > $event['repeat_end_time']))
  456.                             {
  457.                                 return 0;
  458.                             }elseif ($occurence_time > $start_time)
  459.                             {
  460.                                 return $occurence_time;
  461.                             }
  462.                         }
  463.                         $weekday++;
  464.                     }
  465.                 }
  466.  
  467.             break;
  468.  
  469.             case REPEAT_DAILY:
  470.  
  471.                 $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month, $day, $year);
  472.  
  473.                 if ($occurence_time <= $start_time)
  474.                 {
  475.                     $occurence_time =  mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$event['repeat_every'], $year);
  476.                 }
  477.  
  478.                 if ($event['repeat_forever'] == '0' && $occurence_time > $event['repeat_end_time'])
  479.                 {
  480.                     return 0;
  481.                 }else
  482.                 {
  483.                     return $occurence_time;
  484.                 }
  485.  
  486.  
  487.             break;
  488.  
  489.             case REPEAT_MONTH_DATE:
  490.                 $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month, $event['start_day'], $year);
  491.                 if ($occurence_time < $start_time)
  492.                 {
  493.                     $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month+$event['repeat_every'], $event['start_day'], $year);
  494.                 }
  495.  
  496.                 if ($event['repeat_forever'] == '0' && $occurence_time > $event['repeat_end_time'])
  497.                 {
  498.                     return 0;
  499.                 }else
  500.                 {
  501.                     return $occurence_time;
  502.                 }
  503.             break;
  504.  
  505.             case REPEAT_MONTH_DAY:
  506.  
  507.                 if ($event['repeat_every'] > 1)
  508.                 {
  509.                     $interval_years = $year-date('Y', $event['start_time']);
  510.                     $interval_months = $month - date('n', $event['start_time']);
  511.                     $interval_months = 12*$interval_years+$interval_months;
  512.                     $devided = $interval_months/$event['repeat_every'];
  513.                     $rounded = (int) $devided;
  514.                     $last_repeat_month = $event['repeat_every']*$rounded;
  515.  
  516.                     $repeat_year = date('Y', $event['start_time']);
  517.                     $repeat_month = date('n', $event['start_time']);
  518.                     $repeat_day = date('j', $event['start_time']);
  519.  
  520.                     $last_occurence_month = mktime(0,0,0, $repeat_month+$last_repeat_month, $repeat_day, $repeat_year);
  521.  
  522.                     //echo date(DB_DATE_FORMAT, $last_occurence_month).'<br /><br /><br />';
  523.                     $year = date('Y', $last_occurence_month);
  524.                     $month = date('n', $last_occurence_month);
  525.                     $day = date('j', $last_occurence_month);
  526.                 }else
  527.                 {
  528.                     $last_occurence_month = $start_time;
  529.                 }
  530.  
  531.                 $loops = $event['repeat_every'] > 1 ? 2 : 1;
  532.                 for ($loop=0;$loop<$loops;$loop++)
  533.                 {
  534.                     if ($loop > 0)
  535.                     {
  536.                         $month += ($loop*$event['repeat_every'])-1;
  537.                     }
  538.  
  539.                     //loop one day more then one week for occurence that happen exactly
  540.                     //one week later but earlier then this time
  541.                     for ($i=0;$i<32;$i++)
  542.                     {
  543.                         $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $month, $i+1, $year);
  544.                         $year = date('Y', $occurence_time);
  545.                         $month = date('n', $occurence_time);
  546.                         $day = date('j', $occurence_time);
  547.  
  548.                         //echo date(DB_DATE_FORMAT, $occurence_time).'<br />';
  549.                         $weekday = date("w", $occurence_time);
  550.  
  551.                         if ($event[$day_db_field[$weekday]] == '1')
  552.                         {
  553.                             if (ceil(date('j',$occurence_time)/7) == $event['month_time'])
  554.                             {
  555.                                 if ($event['repeat_forever'] == '0' && $occurence_time > $event['repeat_end_time'])
  556.                                 {
  557.                                     return 0;
  558.                                 }elseif ($occurence_time > $start_time)
  559.                                 {
  560.                                     //echo 'returns: '.date(DB_DATE_FORMAT, $occurence_time).'<br />';
  561.                                     return $occurence_time;
  562.                                 }
  563.                             }
  564.                         }
  565.                     }
  566.                 }
  567.  
  568.             break;
  569.  
  570.             case REPEAT_YEARLY;
  571.                 $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $event['start_month'], $event['start_day'], $year);
  572.                 if ($occurence_time < $start_time)
  573.                 {
  574.                     $occurence_time = mktime($event['start_hour'], $event['start_min'], 0, $event['start_month'], $event['start_day'], $year+$event['repeat_every']);
  575.                 }
  576.                 if ($event['repeat_forever'] == '0' &&$occurence_time > $event['repeat_end_time'])
  577.                 {
  578.                     return 0;
  579.                 }else
  580.                 {
  581.                     return $occurence_time;
  582.                 }
  583.             break;
  584.         }
  585.     }
  586.  
  587.     /*
  588.     Times in GMT!
  589.     */
  590.  
  591.     function get_events($calendar_id, $contact_id, $interval_start, $interval_end)
  592.     {
  593.         $sql  = "SELECT * FROM cal_events";
  594.  
  595.         if ($calendar_id > 0)
  596.         {
  597.              $sql .= " INNER JOIN cal_events_calendars ON (cal_events.id=cal_events_calendars.event_id)";
  598.         }
  599.  
  600.         $sql .= " WHERE";
  601.  
  602.         if ($calendar_id > 0)
  603.         {
  604.             $sql .= " cal_events_calendars.calendar_id='$calendar_id'";
  605.         }
  606.         if ($contact_id > 0)
  607.         {
  608.             $sql .= " cal_events.contact_id='$contact_id'";
  609.         }
  610.  
  611.         if ($interval_start > 0)
  612.         {
  613.             $sql .= " AND ((cal_events.repeat_type='".REPEAT_NONE."' AND ".
  614.                     "cal_events.start_time<='$interval_end' AND cal_events.end_time>='$interval_start') OR ".
  615.                     "(cal_events.repeat_type!='".REPEAT_NONE."' AND ".
  616.                     "cal_events.start_time<='$interval_end' AND ".
  617.                     "(cal_events.repeat_end_time>='$interval_start' OR cal_events.repeat_forever='1')))";
  618.         }
  619.         $sql .=    " ORDER BY start_time";
  620.  
  621.         $this->query($sql);
  622.  
  623.         return $this->num_rows();
  624.     }
  625.  
  626.     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)
  627.     {
  628.         global $GO_SECURITY;
  629.  
  630.         //build an array called $events with all events for the days to display
  631.         //$event[DAY_OF_MONTH][HOUR_OF_DAY]
  632.         $events = array();
  633.  
  634.         $show_days = ceil(($interval_end_time - $interval_start_time)/86400);
  635.  
  636.  
  637.         if($count = $this->get_events($calendar_id, $contact_id, $interval_start_time, $interval_end_time))
  638.         {
  639.             while($this->next_record())
  640.             {
  641.                 $event = $this->Record;
  642.                 if (!$event['write_permission'] = $GO_SECURITY->has_permission($GO_SECURITY->user_id, $event['acl_write']))
  643.                 {
  644.                     $event['read_permission'] = $GO_SECURITY->has_permission($GO_SECURITY->user_id, $event['acl_read']);
  645.                 }
  646.  
  647.                 if ($event['write_permission'] || $event['read_permission'])
  648.                 {
  649.                     //calculate stored GMT unix times to local timezone dates
  650.                     //don't calculate timezone offset for all day events
  651.                     $_timezone_offset = ($event['all_day_event'] == '0') ? $timezone_offset : 0;
  652.  
  653.                     //the start time of the first occurence localized
  654.                     $initial_start_time = $event['start_time']+($_timezone_offset*3600);
  655.  
  656.                     $event['repeat_start_time'] = $initial_start_time;
  657.                     $event['repeat_end_time'] += ($_timezone_offset*3600);
  658.  
  659.                     $event['start_hour'] = date('G', $initial_start_time);
  660.                     $event['start_min'] = date('i', $initial_start_time);
  661.  
  662.                     //the end time of the first occurence localized
  663.                     $initial_end_time = $event['end_time']+($_timezone_offset*3600);
  664.  
  665.                     $event['end_hour'] = date('G', $initial_end_time);
  666.                     $event['end_min'] = date('i', $initial_end_time);
  667.  
  668.                     $event['start_date'] = date('Y-m-d', $initial_start_time);
  669.  
  670.                     //how many hours does this event occur?
  671.                     $real_duration_hours = ($initial_end_time - $initial_start_time)/3600;
  672.                     $duration_hours = ceil($real_duration_hours+($event['start_min']/60));
  673.                     //zero hours should still be displayed in one hour
  674.                     if ($duration_hours == 0)
  675.                     {
  676.                         $duration_hours = 1;
  677.                     }
  678.  
  679.                     $duration_days = ceil(($initial_end_time - $initial_start_time)/86400)+1;
  680.  
  681.                     if ($event['reminder'] > 0)
  682.                     {
  683.                         $event['remind_time'] = $event['start_time'] - $event['reminder'];
  684.                     }
  685.                     $event['repeat_type'];
  686.  
  687.                     switch($event['repeat_type'])
  688.                     {
  689.                         case REPEAT_NONE:
  690.                             $event['start_time'] += ($_timezone_offset*3600);
  691.                             $event['end_time'] += ($_timezone_offset*3600);
  692.  
  693.                             $event['start_year'] = date('Y', $event['start_time']);
  694.                             $event['start_month'] = date('n', $event['start_time']);
  695.                             $event['start_day'] = date('j', $event['start_time']);
  696.  
  697.                             if ($index_date)
  698.                             {
  699.                                 if ($event['all_day_event'] == '1')
  700.                                 {
  701.                                     //if event starts before the time to display skip the
  702.                                     //time not displayed
  703.                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  704.                                     if($time_before > 0)
  705.                                     {
  706.                                         $event_start_day = floor($time_before/86400);
  707.                                     }else
  708.                                     {
  709.                                         $event_start_day = 0;
  710.                                     }
  711.                                     for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  712.                                     {
  713.                                         $process_time = mktime(0,0,0,$event['start_month'], $event['start_day']+$event_day, $event['start_year']);
  714.                                         $process_date = date($index_date, $process_time);
  715.                                         //echo $process_date;
  716.                                         $all_day_events[$process_date][] = $event;
  717.                                     }
  718.                                 }else
  719.                                 {
  720.                                     //if event starts before the time to display skip the
  721.                                     //time not displayed
  722.                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  723.                                     if($time_before > 0)
  724.                                     {
  725.                                         $event_start_hour = floor($time_before/3600);
  726.                                     }else
  727.                                     {
  728.                                         $event_start_hour = 0;
  729.                                     }
  730.                                     for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  731.                                     {
  732.                                         //the time we are now processing
  733.                                         $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$event['start_month'], $event['start_day'], $event['start_year']);
  734.                                         //if we are processing time that happens later then the end of the display time interval then exit the loop
  735.  
  736.                                         if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  737.                                         {
  738.                                             break;
  739.                                         }
  740.                                         $process_date = date($index_date, $process_time);
  741.                                         $process_hour = date('G', $process_time);
  742.  
  743.  
  744.                                         if ($event_hour == 0 || $process_hour == $display_start_hour)
  745.                                         {
  746.                                             //echo $process_date.': '.$process_hour.'<br />';
  747.                                             if ($index_hour)
  748.                                             {
  749.                                                 $events[$process_date][$process_hour][] = $event;
  750.                                             }else
  751.                                             {
  752.                                                 $events[$process_date][] = $event;
  753.                                                 if ($process_hour == $display_start_hour)
  754.                                                 {
  755.                                                     $event_hour += 23-$display_start_hour;
  756.                                                 }
  757.                                             }
  758.  
  759.                                         }else
  760.                                         {
  761.                                             $backgrounds[$process_date][$process_hour] = $event['background'];
  762.                                         }
  763.                                     }
  764.                                 }
  765.                             }else
  766.                             {
  767.                                 $events[] = $event;
  768.                             }
  769.  
  770.                         break;
  771.  
  772.                         case REPEAT_DAILY:
  773.                             //loop through all days that are displayed + the last day for occurences that started outside but end in the display interval
  774.                             for($show_day=-1;$show_day<$show_days;$show_day++)
  775.                             {
  776.                                 $day_start_time = mktime(0,0,0,$month, $day+$show_day, $year);
  777.                                 $day_end_time = mktime(0,0,0,$month, $day+$show_day+1, $year);
  778.  
  779.                                 //does the event occur at the current day to display?
  780.                                 if ($event['repeat_start_time'] < $day_end_time && ($event['repeat_end_time'] >= $day_start_time || $event['repeat_forever'] == '1'))
  781.                                 {
  782.                                     $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$show_day, $year);
  783.                                     $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  784.  
  785.                                     if ($event['repeat_every'] > 1)
  786.                                     {
  787.                                         $interval = $event['start_time'] - $event['repeat_start_time'];
  788.                                         $interval_days = ceil($interval/86400);
  789.                                         $devided = $interval_days/$event['repeat_every'];
  790.                                         $match = (int) $devided;
  791.  
  792.                                     }
  793.  
  794.                                     if ($event['repeat_every'] < 2 || $devided == $match)
  795.                                     {
  796.                                         if ($index_date)
  797.                                         {
  798.                                             if ($event['all_day_event'] == '1')
  799.                                             {
  800.                                                 //if event starts before the time to display skip the
  801.                                                 //time not displayed
  802.                                                 $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  803.                                                 if($time_before > 0)
  804.                                                 {
  805.                                                     $event_start_day = floor($time_before/86400);
  806.                                                 }else
  807.                                                 {
  808.                                                     $event_start_day = 0;
  809.                                                 }
  810.                                                 for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  811.                                                 {
  812.                                                     $process_time = mktime(0,0,0,$month, $day+$show_day+$event_day, $year);
  813.                                                     $process_date = date($index_date, $process_time);
  814.                                                     $all_day_events[$process_date][] = $event;
  815.                                                 }
  816.                                             }else
  817.                                             {
  818.  
  819.                                                 //if event starts before the time to display skip the
  820.                                                 //time not displayed
  821.                                                 $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  822.                                                 if($time_before > 0)
  823.                                                 {
  824.                                                     $event_start_hour = floor($time_before/3600);
  825.                                                 }else
  826.                                                 {
  827.                                                     $event_start_hour = 0;
  828.                                                 }
  829.                                                 for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  830.                                                 {
  831.                                                     //the time we are now processing
  832.  
  833.                                                     $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$month, $day+$show_day, $year);
  834.                                                     //if we are processing time that happens outside the display time interval then exit the loop
  835.                                                     if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  836.                                                     {
  837.                                                         break;
  838.                                                     }
  839.  
  840.                                                     $process_date = date($index_date, $process_time);
  841.                                                     $process_hour = date('G', $process_time);
  842.  
  843.                                                     if ($event_hour == 0 || $process_hour == $display_start_hour)
  844.                                                     {
  845.                                                         //echo $process_date.': '.$process_hour.'<br />';
  846.                                                         if ($index_hour)
  847.                                                         {
  848.                                                             $events[$process_date][$process_hour][] = $event;
  849.                                                         }else
  850.                                                         {
  851.                                                             $events[$process_date][] = $event;
  852.                                                             if ($process_hour == $display_start_hour)
  853.                                                             {
  854.                                                                 $event_hour += 23-$display_start_hour;
  855.                                                             }
  856.                                                         }
  857.                                                     }else
  858.                                                     {
  859.                                                         $backgrounds[$process_date][$process_hour] = $event['background'];
  860.                                                     }
  861.                                                 }
  862.                                             }
  863.                                         }else
  864.                                         {
  865.                                             $events[] = $event;
  866.                                         }
  867.                                     }
  868.                                 }
  869.                             }
  870.                         break;
  871.  
  872.                         case REPEAT_WEEKLY:
  873.                             //loop through all days that are displayed + the last day for occurences that started outside but end in the display interval
  874.                             for($show_day=-1;$show_day<$show_days;$show_day++)
  875.                             {
  876.                                 $day_start_time = mktime(0,0,0,$month, $day+$show_day, $year);
  877.                                 $day_end_time = mktime(0,0,0,$month, $day+$show_day+1, $year);
  878.  
  879.                                 //does the event occur at the current day to display?
  880.                                 if ($event['repeat_start_time'] < $day_end_time && ($event['repeat_end_time'] >= $day_start_time || $event['repeat_forever'] == '1'))
  881.                                 {
  882.                                     $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$show_day, $year);
  883.                                     $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  884.  
  885.                                     if ($event['repeat_every'] > 1)
  886.                                     {
  887.                                         $interval = $event['start_time'] - $event['repeat_start_time'];
  888.                                         $interval_weeks = floor($interval/604800);
  889.                                         $devided = $interval_weeks/$event['repeat_every'];
  890.                                         $match = (int) $devided;
  891.                                     }
  892.  
  893.                                     if ($event['repeat_every'] < 2 || $devided == $match)
  894.                                     {
  895.                                         $weekday = date('w', $day_start_time);
  896.  
  897.                                         //shift the weekdays to local time
  898.                                         $local_start_hour = date('H',$initial_start_time-($_timezone_offset*3600)) + $_timezone_offset;
  899.                                         if ($local_start_hour > 23)
  900.                                         {
  901.                                             $local_start_hour = $local_start_hour - 24;
  902.                                             $shift_day = 1;
  903.                                         }elseif($local_start_hour < 0)
  904.                                         {
  905.                                             $local_start_hour = 24 + $local_start_hour;
  906.                                             $shift_day = -1;
  907.                                         }else
  908.                                         {
  909.                                             $shift_day = 0;
  910.                                         }
  911.  
  912.                                         switch($shift_day)
  913.                                         {
  914.                                             case 0:
  915.                                                 $day_db_field[0] = 'sun';
  916.                                                 $day_db_field[1] = 'mon';
  917.                                                 $day_db_field[2] = 'tue';
  918.                                                 $day_db_field[3] = 'wed';
  919.                                                 $day_db_field[4] = 'thu';
  920.                                                 $day_db_field[5] = 'fri';
  921.                                                 $day_db_field[6] = 'sat';
  922.                                             break;
  923.  
  924.                                             case 1:
  925.                                                 $day_db_field[0] = 'sat';
  926.                                                 $day_db_field[1] = 'sun';
  927.                                                 $day_db_field[2] = 'mon';
  928.                                                 $day_db_field[3] = 'tue';
  929.                                                 $day_db_field[4] = 'wed';
  930.                                                 $day_db_field[5] = 'thu';
  931.                                                 $day_db_field[6] = 'fri';
  932.  
  933.                                             break;
  934.  
  935.                                             case -1:
  936.                                                 $day_db_field[0] = 'mon';
  937.                                                 $day_db_field[1] = 'tue';
  938.                                                 $day_db_field[2] = 'wed';
  939.                                                 $day_db_field[3] = 'thu';
  940.                                                 $day_db_field[4] = 'fri';
  941.                                                 $day_db_field[5] = 'sat';
  942.                                                 $day_db_field[6] = 'sun';
  943.                                             break;
  944.  
  945.                                         }
  946.  
  947.  
  948.                                         //does it repeat on this weekday?
  949.                                         if ($event[$day_db_field[$weekday]] == '1')
  950.                                         {
  951.                                             if ($index_date)
  952.                                             {
  953.                                                 if ($event['all_day_event'] == '1')
  954.                                                 {
  955.                                                     //if event starts before the time to display skip the
  956.                                                     //time not displayed
  957.                                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  958.                                                     if($time_before > 0)
  959.                                                     {
  960.                                                         $event_start_day = floor($time_before/86400);
  961.                                                     }else
  962.                                                     {
  963.                                                         $event_start_day = 0;
  964.                                                     }
  965.                                                     for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  966.                                                     {
  967.                                                         $process_time = mktime(0,0,0,$month, $day+$show_day+$event_day, $year);
  968.                                                         $process_date = date($index_date, $process_time);
  969.                                                         $all_day_events[$process_date][] = $event;
  970.                                                     }
  971.                                                 }else
  972.                                                 {
  973.                                                     //if event starts before the time to display skip the
  974.                                                     //time not displayed
  975.                                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  976.                                                     if($time_before > 0)
  977.                                                     {
  978.                                                         $event_start_hour = floor($time_before/3600);
  979.                                                     }else
  980.                                                     {
  981.                                                         $event_start_hour = 0;
  982.                                                     }
  983.                                                     for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  984.                                                     {
  985.                                                         //the time we are now processing
  986.                                                         $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$month, $day+$show_day, $year);
  987.  
  988.                                                         //if we are processing time that happens outside the display time interval then exit the loop
  989.                                                         if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  990.                                                         {
  991.                                                             break;
  992.                                                         }
  993.                                                         $process_date = date($index_date, $process_time);
  994.                                                         $process_hour = date('G', $process_time);
  995.  
  996.                                                         if ($event_hour == 0 || $process_hour == $display_start_hour)
  997.                                                         {
  998.                                                             //echo $process_date.': '.$process_hour.'<br />';
  999.                                                             if ($index_hour)
  1000.                                                             {
  1001.                                                                 $events[$process_date][$process_hour][] = $event;
  1002.                                                             }else
  1003.                                                             {
  1004.                                                                 $events[$process_date][] = $event;
  1005.                                                                 if ( $process_hour == $display_start_hour)
  1006.                                                                 {
  1007.                                                                     $event_hour += 23-$display_start_hour;
  1008.                                                                 }
  1009.  
  1010.                                                             }
  1011.                                                         }else
  1012.                                                         {
  1013.                                                             $backgrounds[$process_date][$process_hour] = $event['background'];
  1014.                                                         }
  1015.                                                     }
  1016.                                                 }
  1017.                                             }else
  1018.                                             {
  1019.                                                 $events[] = $event;
  1020.                                             }
  1021.                                         }
  1022.                                     }
  1023.                                 }
  1024.                             }
  1025.                         break;
  1026.  
  1027.                         case REPEAT_MONTH_DATE:
  1028.  
  1029.                             //how many months are to be displayed?
  1030.                             $first_month = date('m', $interval_start_time+($timezone_offset*3600));
  1031.                             $interval_years = date('Y', $interval_end_time)-date('Y', $interval_start_time+($timezone_offset*3600));
  1032.                             $interval_months = date('m', $interval_end_time) - date('m', $interval_start_time+($timezone_offset*3600));
  1033.                             $show_months = (12*$interval_years)+$interval_months+1;
  1034.  
  1035.                             //check for an occurence that started last year
  1036.                             $process_years = array($year);
  1037.                             if (date('Y', mktime(0,0,0,$month, $day, $year)) > date('Y', mktime(0,0,0,$first_month, $day, $year)-($duration_hours*3600)))
  1038.                             {
  1039.                                 $process_years[] = $year-1;
  1040.                             }
  1041.                             for ($process_year_index=0;$process_year_index<count($process_years);$process_year_index++)
  1042.                             {
  1043.                                 for ($show_month=0;$show_month<$show_months;$show_month++)
  1044.                                 {
  1045.                                     //does the event occur at this day?
  1046.                                     $event['start_day'] = date('j', $initial_start_time);
  1047.  
  1048.                                     $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $first_month+$show_month, $event['start_day'], $process_years[$process_year_index]);
  1049.                                     $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  1050.  
  1051.                                     if($event['start_time'] < $interval_end_time && $event['end_time'] > $interval_start_time)
  1052.                                     {
  1053.                                         if ($event['repeat_every'] > 1)
  1054.                                         {
  1055.                                             $interval_years = $year-date('Y', $event['repeat_start_time']);
  1056.                                             $interval_months = $first_month+$show_month - date('m', $event['repeat_start_time']);
  1057.  
  1058.                                             $interval_months = 12*$interval_years+$interval_months;
  1059.  
  1060.                                             $devided = $interval_months/$event['repeat_every'];
  1061.                                             $match = (int) $devided;
  1062.                                         }
  1063.  
  1064.                                         if ($event['repeat_every'] < 2 || $devided == $match)
  1065.                                         {
  1066.                                             if ($index_date)
  1067.                                             {
  1068.                                                 if ($event['all_day_event'] == '1')
  1069.                                                 {
  1070.                                                     //if event starts before the time to display skip the
  1071.                                                     //time not displayed
  1072.                                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1073.                                                     if($time_before > 0)
  1074.                                                     {
  1075.                                                         $event_start_day = floor($time_before/86400);
  1076.                                                     }else
  1077.                                                     {
  1078.                                                         $event_start_day = 0;
  1079.                                                     }
  1080.                                                     for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  1081.                                                     {
  1082.                                                         $process_time = mktime($event['start_hour'],$event['start_min'],0,$month, $event['start_day']+$event_day, $process_years[$process_year_index]);
  1083.                                                         $process_date = date($index_date, $process_time);
  1084.                                                         $all_day_events[$process_date][] = $event;
  1085.                                                     }
  1086.                                                 }else
  1087.                                                 {
  1088.                                                     //if event starts before the time to display skip the
  1089.                                                     //time not displayed
  1090.                                                     $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1091.                                                     if($time_before > 0)
  1092.                                                     {
  1093.                                                         $event_start_hour = floor($time_before/3600);
  1094.                                                     }else
  1095.                                                     {
  1096.                                                         $event_start_hour = 0;
  1097.                                                     }
  1098.                                                     for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  1099.                                                     {
  1100.                                                         //the time we are now processing
  1101.                                                         $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$first_month+$show_month, $event['start_day'], $process_years[$process_year_index]);
  1102.                                                         //if we are processing time that happens later then the end of the display time interval then exit the loop
  1103.  
  1104.                                                         if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  1105.                                                         {
  1106.                                                             break;
  1107.                                                         }
  1108.                                                         $process_date = date($index_date, $process_time);
  1109.                                                         $process_hour = date('G', $process_time);
  1110.  
  1111.                                                         if ($event_hour == 0 || $process_hour == $display_start_hour)
  1112.                                                         {
  1113.                                                             //echo $process_date.': '.$process_hour.'<br />';
  1114.                                                             if ($index_hour)
  1115.                                                             {
  1116.                                                                 $events[$process_date][$process_hour][] = $event;
  1117.                                                             }else
  1118.                                                             {
  1119.                                                                 $events[$process_date][] = $event;
  1120.                                                                 if ( $process_hour == $display_start_hour)
  1121.                                                                 {
  1122.                                                                     $event_hour += 23-$display_start_hour;
  1123.                                                                 }
  1124.  
  1125.                                                             }
  1126.                                                         }else
  1127.                                                         {
  1128.                                                             $backgrounds[$process_date][$process_hour] = $event['background'];
  1129.                                                         }
  1130.                                                     }
  1131.                                                 }
  1132.                                             }else
  1133.                                             {
  1134.                                                 $events[] = $event;
  1135.                                             }
  1136.                                         }
  1137.                                     }
  1138.                                 }
  1139.                             }
  1140.  
  1141.                         break;
  1142.  
  1143.                         case REPEAT_MONTH_DAY:
  1144.                             //loop through all days that are displayed + the last day for occurences that started outside but end in the display interval
  1145.  
  1146.                             for($show_day=-1;$show_day<$show_days;$show_day++)
  1147.                             {
  1148.                                 $day_start_time = mktime(0,0,0,$month, $day+$show_day, $year);
  1149.                                 $day_end_time = mktime(0,0,0,$month, $day+$show_day+1, $year);
  1150.  
  1151.                                 if ($event['repeat_every'] > 1)
  1152.                                 {
  1153.                                     $new_year = date('Y', $day_start_time);
  1154.                                     $new_month = date('n', $day_start_time);
  1155.  
  1156.                                     $interval_years = $new_year-date('Y', $event['repeat_start_time']);
  1157.                                     $interval_months = $new_month - date('m', $event['repeat_start_time']);
  1158.  
  1159.                                     $interval_months = 12*$interval_years+$interval_months;
  1160.  
  1161.                                     $devided = $interval_months/$event['repeat_every'];
  1162.                                     $match = (int) $devided;
  1163.  
  1164.                                     //echo $devided.' = '.$match.'<br />';
  1165.                                 }
  1166.  
  1167.                                 //echo date(DB_DATETIME_FORMAT, $event['start_time']).'<br />';
  1168.                                 if ($event['repeat_every'] < 2 || $devided == $match)
  1169.                                 {
  1170.                                     $new_day = date('j', $day_start_time);
  1171.  
  1172.                                     $month_time = ceil($new_day/7);
  1173.  
  1174.                                     if ($event['month_time'] == $month_time)
  1175.                                     {
  1176.                                         $day_start_time = mktime(0,0,0,$month, $day+$show_day, $year);
  1177.                                         $day_end_time = mktime(0,0,0,$month, $day+$show_day+1, $year);
  1178.  
  1179.                                         //does the event occur at the current day to display?
  1180.                                         if ($event['repeat_start_time'] < $day_end_time && ($event['repeat_end_time'] >= $day_start_time || $event['repeat_forever'] == '1'))
  1181.                                         {
  1182.                                             $weekday = date('w', $day_start_time);
  1183.                                             //shift the weekdays to local time
  1184.                                             $local_start_hour = date('H',$initial_start_time-($_timezone_offset*3600)) + $_timezone_offset;
  1185.                                             if ($local_start_hour > 23)
  1186.                                             {
  1187.                                                 $local_start_hour = $local_start_hour - 24;
  1188.                                                 $shift_day = 1;
  1189.                                             }elseif($local_start_hour < 0)
  1190.                                             {
  1191.                                                 $local_start_hour = 24 + $local_start_hour;
  1192.                                                 $shift_day = -1;
  1193.                                             }else
  1194.                                             {
  1195.                                                 $shift_day = 0;
  1196.                                             }
  1197.  
  1198.                                             switch($shift_day)
  1199.                                             {
  1200.                                                 case 0:
  1201.                                                     $day_db_field[0] = 'sun';
  1202.                                                     $day_db_field[1] = 'mon';
  1203.                                                     $day_db_field[2] = 'tue';
  1204.                                                     $day_db_field[3] = 'wed';
  1205.                                                     $day_db_field[4] = 'thu';
  1206.                                                     $day_db_field[5] = 'fri';
  1207.                                                     $day_db_field[6] = 'sat';
  1208.                                                 break;
  1209.  
  1210.                                                 case 1:
  1211.                                                     $day_db_field[0] = 'sat';
  1212.                                                     $day_db_field[1] = 'sun';
  1213.                                                     $day_db_field[2] = 'mon';
  1214.                                                     $day_db_field[3] = 'tue';
  1215.                                                     $day_db_field[4] = 'wed';
  1216.                                                     $day_db_field[5] = 'thu';
  1217.                                                     $day_db_field[6] = 'fri';
  1218.  
  1219.                                                 break;
  1220.  
  1221.                                                 case -1:
  1222.                                                     $day_db_field[0] = 'mon';
  1223.                                                     $day_db_field[1] = 'tue';
  1224.                                                     $day_db_field[2] = 'wed';
  1225.                                                     $day_db_field[3] = 'thu';
  1226.                                                     $day_db_field[4] = 'fri';
  1227.                                                     $day_db_field[5] = 'sat';
  1228.                                                     $day_db_field[6] = 'sun';
  1229.                                                 break;
  1230.  
  1231.                                             }
  1232.  
  1233.                                             $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $month, $day+$show_day, $year);
  1234.                                             $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  1235.  
  1236.                                             //does it repeat on this weekday?
  1237.                                             if ($event[$day_db_field[$weekday]] == '1')
  1238.                                             {
  1239.                                                 if($index_date)
  1240.                                                 {
  1241.                                                     if ($event['all_day_event'] == '1')
  1242.                                                     {
  1243.                                                         //if event starts before the time to display skip the
  1244.                                                         //time not displayed
  1245.                                                         $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1246.                                                         if($time_before > 0)
  1247.                                                         {
  1248.                                                             $event_start_day = floor($time_before/86400);
  1249.                                                         }else
  1250.                                                         {
  1251.                                                             $event_start_day = 0;
  1252.                                                         }
  1253.                                                         for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  1254.                                                         {
  1255.                                                             $process_time = mktime($event['start_hour'],$event['start_min'],0,$month, $day+$show_day+$event_day, $year);
  1256.                                                             $process_date = date($index_date, $process_time);
  1257.                                                             $all_day_events[$process_date][] = $event;
  1258.                                                         }
  1259.                                                     }else
  1260.                                                     {
  1261.  
  1262.                                                         //if event starts before the time to display skip the
  1263.                                                         //time not displayed
  1264.                                                         $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1265.                                                         if($time_before > 0)
  1266.                                                         {
  1267.                                                             $event_start_hour = floor($time_before/3600);
  1268.                                                         }else
  1269.                                                         {
  1270.                                                             $event_start_hour = 0;
  1271.                                                         }
  1272.                                                         for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  1273.                                                         {
  1274.                                                             //the time we are now processing
  1275.                                                             $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$month, $day+$show_day, $year);
  1276.  
  1277.                                                             //if we are processing time that happens outside the display time interval then exit the loop
  1278.                                                             if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  1279.                                                             {
  1280.                                                                 break;
  1281.                                                             }
  1282.                                                             $process_date = date($index_date, $process_time);
  1283.                                                             $process_hour = date('G', $process_time);
  1284.  
  1285.                                                             if ($event_hour == 0 || $process_hour == $display_start_hour)
  1286.                                                             {
  1287.                                                                 //echo $process_date.': '.$process_hour.'<br />';
  1288.                                                                 if ($index_hour)
  1289.                                                                 {
  1290.                                                                     $events[$process_date][$process_hour][] = $event;
  1291.                                                                 }else
  1292.                                                                 {
  1293.                                                                     $events[$process_date][] = $event;
  1294.                                                                     if ( $process_hour == $display_start_hour)
  1295.                                                                     {
  1296.                                                                         $event_hour += 23-$display_start_hour;
  1297.                                                                     }
  1298.  
  1299.                                                                 }
  1300.                                                             }else
  1301.                                                             {
  1302.                                                                 $backgrounds[$process_date][$process_hour] = $event['background'];
  1303.                                                             }
  1304.                                                         }
  1305.                                                     }
  1306.                                                 }else
  1307.                                                 {
  1308.                                                     $events[] = $event;
  1309.                                                 }
  1310.  
  1311.                                             }
  1312.                                         }
  1313.                                     }
  1314.                                 }
  1315.                             }
  1316.  
  1317.                         break;
  1318.  
  1319.                         case REPEAT_YEARLY:
  1320.                             //check for an occurence that started last year
  1321.                             $process_years = array($year);
  1322.                             if (date('Y', mktime(0,0,0,$month, $day, $year)) > date('Y', mktime(0,0,0,$month, $day, $year)-($duration_hours*3600)))
  1323.                             {
  1324.                                 $process_years[] = $year-1;
  1325.                             }
  1326.                             for ($process_year_index=0;$process_year_index<count($process_years);$process_year_index++)
  1327.                             {
  1328.                                 if ($event['repeat_every'] > 1)
  1329.                                 {
  1330.                                     $interval_years = $process_years[$process_year_index]-date('Y', $event['repeat_start_time']);
  1331.  
  1332.                                     $devided = $interval_years/$event['repeat_every'];
  1333.                                     $match = (int) $devided;
  1334.                                 }
  1335.  
  1336.                                 if ($event['repeat_every'] < 2 || $devided == $match)
  1337.                                 {
  1338.                                     //does the event occur at this day?
  1339.                                     $event['start_month'] = date('n', $event['start_time']);
  1340.                                     $event['start_day'] = date('j', $event['start_time']);
  1341.  
  1342.                                     $event['start_time'] = mktime($event['start_hour'], $event['start_min'], 0, $event['start_month'], $event['start_day'], $process_years[$process_year_index]);
  1343.                                     $event['end_time'] = $event['start_time'] + $initial_end_time - $initial_start_time;
  1344.  
  1345.                                     if($event['start_time'] < $interval_end_time && $event['end_time'] > $interval_start_time)
  1346.                                     {
  1347.                                         if ($index_date)
  1348.                                         {
  1349.                                             if ($event['all_day_event'] == '1')
  1350.                                             {
  1351.                                                 //if event starts before the time to display skip the
  1352.                                                 //time not displayed
  1353.                                                 $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1354.                                                 if($time_before > 0)
  1355.                                                 {
  1356.                                                     $event_start_day = floor($time_before/86400);
  1357.                                                 }else
  1358.                                                 {
  1359.                                                     $event_start_day = 0;
  1360.                                                 }
  1361.                                                 for ($event_day=$event_start_day;$event_day<$duration_days;$event_day++)
  1362.                                                 {
  1363.                                                     $process_time = mktime($event['start_hour'],$event['start_min'],0,$event['start_month'], $event['start_day'], $process_years[$process_year_index]);
  1364.                                                     $process_date = date($index_date, $process_time);
  1365.                                                     $all_day_events[$process_date][] = $event;
  1366.                                                 }
  1367.                                             }else
  1368.                                             {
  1369.                                                 //if event starts before the time to display skip the
  1370.                                                 //time not displayed
  1371.                                                 $time_before = $interval_start_time+($_timezone_offset*3600) - $event['start_time'];
  1372.                                                 if($time_before > 0)
  1373.                                                 {
  1374.                                                     $event_start_hour = floor($time_before/3600);
  1375.                                                 }else
  1376.                                                 {
  1377.                                                     $event_start_hour = 0;
  1378.                                                 }
  1379.                                                 for($event_hour=$event_start_hour;$event_hour<$duration_hours;$event_hour++)
  1380.                                                 {
  1381.                                                     //the time we are now processing
  1382.                                                     $process_time = mktime($event['start_hour']+$event_hour,$event['start_min'],0,$event['start_month'], $event['start_day'], $process_years[$process_year_index]);
  1383.                                                     //if we are processing time that happens later then the end of the display time interval then exit the loop
  1384.  
  1385.                                                     //TODO don't process time before
  1386.  
  1387.                                                     if (($process_time-($_SESSION['GO_SESSION']['timezone']*3600)) > $interval_end_time)
  1388.                                                     {
  1389.                                                         break;
  1390.                                                     }
  1391.                                                     $process_date = date($index_date, $process_time);
  1392.                                                     $process_hour = date('G', $process_time);
  1393.  
  1394.                                                     if ($event_hour == 0 || $process_hour == 0)
  1395.                                                     {
  1396.                                                         //echo $process_date.': '.$process_hour.'<br />';
  1397.                                                         if ($index_hour)
  1398.                                                         {
  1399.                                                             $events[$process_date][$process_hour][] = $event;
  1400.                                                         }else
  1401.                                                         {
  1402.                                                             $events[$process_date][] = $event;
  1403.                                                             if ( $process_hour == $display_start_hour)
  1404.                                                             {
  1405.                                                                 $event_hour += 23-$display_start_hour;
  1406.                                                             }
  1407.  
  1408.                                                         }
  1409.                                                     }else
  1410.                                                     {
  1411.                                                         $backgrounds[$process_date][$process_hour] = $event['background'];
  1412.                                                     }
  1413.                                                 }
  1414.                                             }
  1415.  
  1416.                                         }else
  1417.                                         {
  1418.                                             $events[] = $event;
  1419.                                         }
  1420.                                     }
  1421.                                 }
  1422.                             }
  1423.                         break;
  1424.                     }
  1425.                 }
  1426.             }
  1427.         }
  1428.         if ($index_date)
  1429.         {
  1430.             $all_events['timed'] = isset($events) ? $events : array();
  1431.             $all_events['all_day'] = isset($all_day_events) ? $all_day_events : array();
  1432.             $all_events['backgrounds'] = isset($backgrounds) ? $backgrounds : array();
  1433.             return $all_events;
  1434.         }else
  1435.         {
  1436.             return $events;
  1437.         }
  1438.     }
  1439.  
  1440.     function get_events_to_remind($user_id)
  1441.     {
  1442.         $gmt_time = get_gmt_time();
  1443.  
  1444.         $sql = "SELECT * FROM cal_reminders WHERE user_id='$user_id' AND remind_time<='$gmt_time'";
  1445.         $this->query($sql);
  1446.         return $this->num_rows();
  1447.     }
  1448.     /*
  1449.     function get_all_events($calendar_id)
  1450.     {
  1451.         $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'";
  1452.         $this->query($sql);
  1453.         return $this->num_rows();
  1454.     }
  1455.     */
  1456.  
  1457.     function get_event($event_id)
  1458.     {
  1459.         $sql = "SELECT * FROM cal_events WHERE id='$event_id'";
  1460.         $this->query($sql);
  1461.         if($this->next_record())
  1462.         {
  1463.             return $this->Record;
  1464.         }else
  1465.         {
  1466.             return false;
  1467.         }
  1468.     }
  1469.  
  1470.     function delete_event($event_id)
  1471.     {
  1472.         $event = $this->get_event($event_id);
  1473.  
  1474.         $sql = "DELETE FROM cal_events WHERE id='$event_id'";
  1475.         $this->query($sql);
  1476.         $sql = "DELETE FROM cal_events_calendars WHERE event_id='$event_id'";
  1477.         $this->query($sql);
  1478.         $sql = "DELETE FROM cal_reminders WHERE event_id='$event_id'";
  1479.         $this->query($sql);
  1480.         $sql = "DELETE FROM cal_participants WHERE event_id='$event_id'";
  1481.         return $this->query($sql);
  1482.     }
  1483.  
  1484.     function delete_user($user_id)
  1485.     {
  1486.         $this->unsubscribe_all($user_id);
  1487.  
  1488.         $delete = new calendar();
  1489.         $sql = "SELECT * FROM cal_calendars WHERE user_id='$user_id'";
  1490.         $this->query($sql);
  1491.         while($this->next_record())
  1492.         {
  1493.             $delete->delete_calendar($this->f('id'));
  1494.         }
  1495.  
  1496.         $sql = "SELECT * FROM cal_events WHERE user_id='$user_id'";
  1497.         $this->query($sql);
  1498.  
  1499.         while($this->next_record())
  1500.         {
  1501.             $delete->delete_event($this->f('id'));
  1502.         }
  1503.  
  1504.     }
  1505. }
  1506. ?>