egroupware_official/calendar/inc/class.socal.inc.php

<?php
/**************************************************************************\
* eGroupWare - Calendar's storage-object                                   *
* http://www.egroupware.org                                                *
* Written and (c) 2005 by Ralf Becker <RalfBecker@outdoor-training.de>     *
* --------------------------------------------                             *
*  This program is free software; you can redistribute it and/or modify it *
*  under the terms of the GNU General Public License as published by the   *
*  Free Software Foundation; either version 2 of the License, or (at your  *
*  option) any later version.                                              *
\**************************************************************************/

/* $Id$ */

/**
 * some necessary defines used by the calendar
 */
if(extension_loaded('mcal') == False)
{
	define('MCAL_RECUR_NONE',0);
	define('MCAL_RECUR_DAILY',1);
	define('MCAL_RECUR_WEEKLY',2);
	define('MCAL_RECUR_MONTHLY_MDAY',3);
	define('MCAL_RECUR_MONTHLY_WDAY',4);
	define('MCAL_RECUR_YEARLY',5);
	define('MCAL_RECUR_SECONDLY',6);
	define('MCAL_RECUR_MINUTELY',7);
	define('MCAL_RECUR_HOURLY',8);
	
	define('MCAL_M_SUNDAY',1);
	define('MCAL_M_MONDAY',2);
	define('MCAL_M_TUESDAY',4);
	define('MCAL_M_WEDNESDAY',8);
	define('MCAL_M_THURSDAY',16);
	define('MCAL_M_FRIDAY',32);
	define('MCAL_M_SATURDAY',64);
	
	define('MCAL_M_WEEKDAYS',62);
	define('MCAL_M_WEEKEND',65);
	define('MCAL_M_ALLDAYS',127);
}

define('REJECTED',0);
define('NO_RESPONSE',1);
define('TENTATIVE',2);
define('ACCEPTED',3);

/**
 * Class to store all calendar data (storage object)
 *
 * Tables used by socal:
 *	- egw_cal: general calendar data: cal_id, title, describtion, locations, ...
 *	- egw_cal_dates: start- and enddates (multiple entry per cal_id for recuring events!)
 *	- egw_cal_users: participant info including status (multiple entries per cal_id AND startdate for recuring events)
 * 	- egw_cal_repeats: recur-data: type, optional enddate, etc.
 *  - egw_cal_extra: custom fields (multiple entries per cal_id possible)
 * 
 * The new UI, BO and SO classes have a strikt definition, in which time-zone they operate:
 *  UI only operates in user-time, so there have to be no conversation at all !!!
 *  BO's functions take and return user-time only (!), they convert internaly everything to servertime, because
 *  SO operates only on server-time
 *
 * @package calendar
 * @author Ralf Becker <RalfBecker-AT-outdoor-training.de>
 * @copyright (c) 2005 by RalfBecker-At-outdoor-training.de
 * @license http://opensource.org/licenses/gpl-license.php GPL - GNU General Public License
 */
class socal
{
	/**
	 * name of the main calendar table and prefix for all other calendar tables
	 */
	var $cal_table = 'egw_cal';
	var $extra_table,$repeats_table,$user_table,$dates_table,$all_tables;
	
	/**
	 * internal copy of the global db-object
	 */
	var $db;

	/**
	 * Constructor of the socal class
	 */
	function socal()
	{
		foreach(array(
			'async' => 'phpgwapi.asyncservice',
		) as $my => $app_class)
		{
			list(,$class) = explode('.',$app_class);

			if (!is_object($GLOBALS['egw']->$class))
			{
				//echo "<p>calling CreateObject($app_class)</p>\n".str_repeat(' ',4096);
				$GLOBALS['egw']->$class =& CreateObject($app_class);
			}
			$this->$my =& $GLOBALS['egw']->$class;
		}
		$this->db = clone($GLOBALS['egw']->db);
		$this->db->set_app('calendar');
		
		$this->all_tables = array($this->cal_table);
		foreach(array('extra','repeats','user','dates') as $name)
		{
			$vname = $name.'_table';
			$this->all_tables[] = $this->$vname = $this->cal_table.'_'.$name;
		}
	}
	
	/**
	 * reads one or more calendar entries
	 *
	 * All times (start, end and modified) are returned as timesstamps in servertime!
	 *
	 * @param int/array/string $ids id or array of id's of the entries to read, or string with a single uid
	 * @param int $recur_date=0 if set read the next recurrance at or after the timestamp, default 0 = read the initital one
	 * @return array/boolean array with id => data pairs or false if entry not found
	 */
	function read($ids,$recur_date=0)
	{
		//echo "<p>socal::read(".print_r($ids,true).",$recur_date)<br />\n".function_backtrace()."<p>\n";

		$table_def = $this->db->get_table_definitions('calendar',$this->cal_table);
		$group_by_cols = $this->cal_table.'.'.implode(','.$this->cal_table.'.',array_keys($table_def['fd']));
		$table_def = $this->db->get_table_definitions('calendar',$this->repeats_table);
		$group_by_cols .= ','.$this->repeats_table.'.'.implode(','.$this->repeats_table.'.',array_keys($table_def['fd']));

		$where = array();
		if (is_array($ids))
		{
			array_walk($ids,create_function('&$val,$key','$val = (int) $val;'));

			$where[] = $this->cal_table.'.cal_id IN ('.implode(',',$ids).')';
		}
		elseif (is_numeric($ids))
		{
			$where[] = $this->cal_table.'.cal_id = '.(int) $ids;
		}
		else
		{
			$where['cal_uid'] = $ids;
		}
		if ((int) $recur_date)
		{
			$where[] = 'cal_start >= '.(int)$recur_date;
		}
		$this->db->select($this->cal_table,"$this->repeats_table.*,$this->cal_table.*,MIN(cal_start) AS cal_start,MIN(cal_end) AS cal_end",
			$where,__LINE__,__FILE__,false,'GROUP BY '.$group_by_cols,false,0,
			",$this->dates_table LEFT JOIN $this->repeats_table ON $this->dates_table.cal_id=$this->repeats_table.cal_id".
			" WHERE $this->cal_table.cal_id=$this->dates_table.cal_id");
		
		$events = false;
		while (($row = $this->db->row(true,'cal_')))
		{
			$row['recur_exception'] = $row['recur_exception'] ? explode(',',$row['recur_exception']) : array();
			if (!$row['recur_type']) $row['recur_type'] = MCAL_RECUR_NONE;
			$row['alarm'] = array();
			$events[$row['id']] = $row;

			// if a uid was supplied, convert it for the further code to an id
			if (!is_array($ids) && !is_numeric($ids)) $ids = $row['id'];
		}
		if (!$events) return false;
		
		// check if we have a real recurance, if not set $recur_date=0
		if (is_array($ids) || $events[(int)$ids]['recur_type'] == MCAL_RECUR_NONE)
		{
			$recur_date = 0;
		}
		else	// adjust the given recurance to the real time, it can be a date without time(!)
		{
			// check if the start read is the the first (default) entry of the recuring events, then it's recur_date is 0!!!
			$this->db->select($this->dates_table,'MIN(cal_start) AS cal_start',array('cal_id' => $ids),__LINE__,__FILE__);
			$first = $this->db->row(true);
			$recur_date = $first['cal_start'] == $events[$ids]['start'] ? 0 : $events[$ids]['start'];
			
			if ($recur_date) $events[$ids]['recur_date'] = $recur_date;	// remember it, maybe we need it later, duno now
		}
		// participants, if a recur_date give, we read that recurance, else the one users from the default entry with recur_date=0
		$this->db->select($this->user_table,'*',array(
			'cal_id'      => $ids,
			'cal_recur_date' => $recur_date,
		),__LINE__,__FILE__,false,'ORDER BY cal_user_type DESC');	// DESC puts users before resources and contacts
		while (($row = $this->db->row(true)))
		{
			// if the type is not an ordinary user (eg. contact or resource)...
			if ($row['cal_user_type'] && $row['cal_user_type'] != 'u')
			{
				// prefix the id with the type
				$user_id = $row['cal_user_type'].$row['cal_user_id'];
				// and append quantity
				$row['cal_status'] .= $row['cal_quantity'] == 1 ? '' : $row['cal_quantity'];
			}
			else
			{
				$user_id = (int) $row['cal_user_id'];
			}
			$events[$row['cal_id']]['participants'][$user_id] = $row['cal_status'];
			$events[$row['cal_id']]['participant_types'][$row['cal_user_type']][$row['cal_user_id']] = $row['cal_status'];
		}

		// custom fields
		$this->db->select($this->extra_table,'*',array('cal_id'=>$ids),__LINE__,__FILE__);
		while (($row = $this->db->row(true)))
		{
			$events[$row['cal_id']]['#'.$row['cal_extra_name']] = $row['cal_extra_value'];
		}
		
		// alarms, atm. we read all alarms in the system, as this can be done in a single query
		foreach((array)$this->async->read('cal'.(is_array($ids) ? '' : ':'.(int)$ids).':%') as $id => $job)
		{
			list(,$cal_id) = explode(':',$id);
			if (!isset($events[$cal_id])) continue;	// not needed
			
			$alarm         = $job['data'];	// text, enabled
			$alarm['id']   = $id;
			$alarm['time'] = $job['next'];

			$events[$cal_id]['alarm'][$id] = $alarm;
		}
		//echo "<p>socal::read(".print_r($ids,true).")=<pre>".print_r($events,true)."</pre>\n";
		return $events;
	}

	/**
	 * generate SQL to filter after a given category (evtl. incl. subcategories)
	 * 
	 * @param array/int $cat_id cat-id or array of cat-ids, or !$cat_id for none
	 * @return string SQL to include in the query
	 */
	function cat_filter($cat_id)
	{
		$sql = '';
		if ($cat_id)
		{
			if (!is_array($cat_ids) && !@$GLOBALS['egw_info']['user']['preferences']['common']['cats_no_subs'])
			{
				if (!is_object($GLOBALS['egw']->categories))
				{
					$GLOBALS['egw']->categories =& CreateObject('phpgwapi.categories');
				}
				$cats = $GLOBALS['egw']->categories->return_all_children($cat_id);
			}
			else
			{
				$cats = is_array($cat_id) ? $cat_id : array($cat_id);
			}
			array_walk($cats,create_function('&$val,$key','$val = (int) $val;'));

			$sql = '(cal_category'.(count($cats) > 1 ? ' IN ('.implode(',',$cats).')' : '='.$this->db->quote((int)$cat_id));
			foreach($cats as $cat)
			{
				$sql .= ' OR '.$this->db->concat("','",'cal_category',"','").' LIKE '.$this->db->quote('%,'.$cat.',%');
			}
			$sql .= ') ';
		}
		return $sql;
	}

	/**
	 * Searches / lists calendar entries, including repeating ones
	 *
	 * @param int $start startdate of the search/list (servertime)
	 * @param int $end enddate of the search/list (servertime)
	 * @param int/array $users user-id or array of user-id's, !$users means all entries regardless of users
	 * @param int $cat_id=0 mixed category-id or array of cat-id's, default 0 = all
	 *		Please note: only a single cat-id, will include all sub-cats (if the common-pref 'cats_no_subs' is False)
	 * @param string $filter='' string space delimited filter-names, NOT used atm.
	 * @param string $query='' pattern so search for, if unset or empty all matching entries are returned (no search)
	 *		Please Note: a search never returns repeating events more then once AND does not honor start+end date !!!
	 * @param int/bool $offset=False offset for a limited query or False (default)
	 * @param int $num_rows=0 number of rows to return if offset set, default 0 = use default in user prefs
	 * @param string $order='cal_start' column-names plus optional DESC|ASC separted by comma
	 * @param boolean $show_rejected=true should the search return rejected invitations
	 * @return array of cal_ids, or false if error in the parameters
	 *
	 * ToDo: search custom-fields too
	 */
	function &search($start,$end,$users,$cat_id=0,$filter='',$query='',$offset=False,$num_rows=0,$order = 'cal_start',$show_rejected=true)
	{
		//echo '<p>socal::search('.($start ? date('Y-m-d H:i',$start) : '').','.($end ? date('Y-m-d H:i',$end) : '').','.print_r($users,true).','.print_r($cat_id,true).",'$filter',".print_r($query,true).",$offset,$num_rows)</p>\n";

		$where = array();
		if (is_array($query))
		{
			$where = $query;
		}
		elseif ($query)
		{
			foreach(array('cal_title','cal_description','cal_location') as $col)
			{
				$to_or[] = $col . ' LIKE ' . $this->db->quote('%'.$query.'%');
			}
			$where[] = '('.implode(' OR ',$to_or).')';
		}
		if ($users)
		{
			$users_by_type = array();
			foreach(is_array($users) ? $users : array($users) as $user)
			{
				if (is_numeric($user))
				{
					$users_by_type['u'][] = (int) $user;
				}
				elseif (is_numeric(substr($user,1)))
				{
					$users_by_type[$user{0}] = (int) substr($user,1);
				}
			}
			$to_or = array();
			foreach($users_by_type as $type => $ids)
			{
				$to_or[] = $this->db->expression($this->user_table,array(
					'cal_user_type' => $type,
					'cal_user_id'   => $ids,
				));
			}
			$where[] = '('.implode(' OR ',$to_or).')';
			
			if (!$show_rejected) $where[] = "cal_status != 'R'";
		}
		if ($cat_id)
		{
			$where[] = $this->cat_filter($cat_id);
		}
		if ($start) $where[] = (int)$start.' < cal_end';
		if ($end)   $where[] = 'cal_start < '.(int)$end;
		
		if (!preg_match('/^[a-z_ ,]+$/i',$order)) $order = 'cal_start';		// gard against SQL injunktion
		
		// changed the original OR in the query into a union, to speed up the query execution under MySQL 5
		$select = array(
			'table' => $this->cal_table,
			'join'  => "JOIN $this->dates_table USING(cal_id) JOIN $this->user_table USING(cal_id) LEFT JOIN $this->repeats_table USING(cal_id)",
			'cols'  => "$this->repeats_table.*,$this->cal_table.*,cal_start,cal_end,cal_recur_date",
			'where' => $where,
		);
		$selects = array($select,$select);
		$selects[0]['where'][] = 'recur_type IS NULL AND cal_recur_date=0';
		$selects[1]['where'][] = 'cal_recur_date=cal_start';
		
		if (is_numeric($offset))	// get the total too
		{
			// we only select cal_table.cal_id (and not cal_table.*) to be able to use DISTINCT (eg. MsSQL does not allow it for text-columns)
			$selects[0]['cols'] = $selects[1]['cols'] = "DISTINCT $this->repeats_table.*,$this->cal_table.cal_id,cal_start,cal_end,cal_recur_date";
			
			$this->db->union($selects,__LINE__,__FILE__);
			$this->total = $this->db->num_rows();

			$selects[0]['cols'] = $selects[1]['cols'] = $select['cols'];	// restore the original cols
		}
		$this->db->union($selects,__LINE__,__FILE__,$order,$offset,$num_rows);

/*		original query	
		$where[] = '(recur_type IS NULL AND cal_recur_date=0 OR cal_recur_date=cal_start)';

		//_debug_array($where);
		if (is_numeric($offset))	// get the total too
		{
			// we only select cal_table.cal_id (and not cal_table.*) to be able to use DISTINCT (eg. MsSQL does not allow it for text-columns)
			$this->db->select($this->cal_table,"DISTINCT $this->repeats_table.*,$this->cal_table.cal_id,cal_start,cal_end,cal_recur_date",
				$where,__LINE__,__FILE__,false,'',false,0,
				"JOIN $this->dates_table USING(cal_id) JOIN $this->user_table USING(cal_id) LEFT JOIN $this->repeats_table USING(cal_id)");

			$this->total = $this->db->num_rows();
		}
		$this->db->select($this->cal_table,($this->db->capabilities['distinct_on_text'] ? 'DISTINCT ' : '').
			"$this->repeats_table.*,$this->cal_table.*,cal_start,cal_end,cal_recur_date",
			$where,__LINE__,__FILE__,$offset,'ORDER BY '.$order,false,$num_rows,
			"JOIN $this->dates_table USING(cal_id) JOIN $this->user_table USING(cal_id) LEFT JOIN $this->repeats_table USING(cal_id)");
*/
		$events = $ids = $recur_dates = $recur_ids = array();	
		while (($row =& $this->db->row(true,'cal_')))
		{
			$ids[] = $id = $row['id'];
			if ($row['recur_date'])
			{
				$id .= '-'.$row['recur_date'];
				$recur_dates[] = $row['recur_date'];
			}
			$row['alarm'] = array();
			$row['recur_exception'] = $row['recur_exception'] ? explode(',',$row['recur_exception']) : array();

			$events[$id] = $row;
		}
		
		if (count($events))
		{
			// now ready all users with the given cal_id AND (cal_recur_date=0 or the fitting recur-date)
			// This will always read the first entry of each recuring event too, we eliminate it later
			$recur_dates[] = 0;
			$this->db->select($this->user_table,'*',array(
				'cal_id' => array_unique($ids),
				'cal_recur_date' => $recur_dates, 
			),__LINE__,__FILE__,false,'ORDER BY cal_id,cal_user_type DESC');	// DESC puts users before resources and contacts
	
			while (($row = $this->db->row(true)))
			{
				$id = $row['cal_id'];
				if ($row['cal_recur_date']) $id .= '-'.$row['cal_recur_date'];
				
				if (!isset($events[$id])) continue;		// not needed first entry of recuring event
	
				$events[$id]['participants'][$this->combine_user($row['cal_user_type'],$row['cal_user_id'])] = $row['cal_status'];
			}
/*			custom fields are not shown in the regular views, so we can ignore them here for the moment
			$this->db->select($this->extra_table,'*',array('cal_id'=>$ids),__LINE__,__FILE__);
			while (($row = $this->db->row(true)))
			{
				$set_ids = array($row['cal_id']);
				if (isset($recur_ids[$row['cal_id']])) $set_ids += $recur_ids[$row['cal_id']];
				
				foreach($set_ids as $id)
				{
					if (isset($events[$cal_id]))
					{
						$events[$id]['#'.$row['cal_extra_name']] = $row['cal_extra_value'];
					}
				}
			}
*/		
			// alarms, atm. we read all alarms in the system, as this can be done in a single query
			foreach((array)$this->async->read('cal'.(is_array($ids) ? '' : ':'.(int)$ids).':%') as $id => $job)
			{
				list(,$cal_id) = explode(':',$cal_id);
				if (!isset($events[$cal_id])) continue;	// not needed
				
				$alarm         = $job['data'];	// text, enabled
				$alarm['id']   = $id;
				$alarm['time'] = $job['next'];
	
				$events[$cal_id]['alarm'][$id] = $alarm;
			}
		}
		//echo "<p>socal::search\n"; _debug_array($events);
		return $events;
	}
	
	/**
	 * Checks for conflicts
	 */

/* folowing SQL checks for conflicts completly on DB level
	 
SELECT cal_user_type, cal_user_id, SUM( cal_quantity )
FROM egw_cal, egw_cal_dates, egw_cal_user
LEFT JOIN egw_cal_repeats ON egw_cal.cal_id = egw_cal_repeats.cal_id
WHERE egw_cal.cal_id = egw_cal_dates.cal_id
AND egw_cal.cal_id = egw_cal_user.cal_id
AND (
recur_type IS NULL
AND cal_recur_date =0
OR cal_recur_date = cal_start
)
AND (
(
cal_user_type = 'u'			# user of the checked event
AND cal_user_id
IN ( 7, 5 )
)
AND 1118822400 < cal_end	# start- and end-time of the checked event
AND cal_start <1118833200
)
AND egw_cal.cal_id !=26		# id of the checked event
AND cal_non_blocking !=1
AND cal_status != 'R'
GROUP BY cal_user_type, cal_user_id
ORDER BY cal_user_type, cal_usre_id

*/ 
	
	/**
	 * Saves or creates an event
	 *
	 * We always set cal_modified and cal_modifier and for new events cal_uid.
	 * All other column are only written if they are set in the $event parameter!
	 *
	 * @param array $event
	 * @param boolean &$set_recurrences on return: true if the recurrences need to be written, false otherwise
	 * @param int $change_since=0 time from which on the repetitions should be changed, default 0=all
	 * @return boolean/int false on error, cal_id otherwise
	 */
	function save($event,&$set_recurrences,$change_since=0)
	{
		//echo "<p>socal::save(,$change_since) event="; _debug_array($event);

		$cal_id = (int) $event['id'];
		unset($event['id']);
		
		$set_recurrences = !$cal_id && $event['recur_type'] != MCAL_RECUR_NONE;
		
		// add colum prefix 'cal_' if there's not already a 'recur_' prefix
		foreach($event as $col => $val)
		{
			if ($col{0} != '#' && substr($col,0,6) != 'recur_' && $col != 'alarm')
			{
				$event['cal_'.$col] = $val;
				unset($event[$col]);
			}
		}
		if (is_array($event['cal_category'])) $event['cal_category'] = implode(',',$event['cal_category']);

		if ($cal_id)
		{
			$this->db->update($this->cal_table,$event,array('cal_id' => $cal_id),__LINE__,__FILE__);
		}
		else
		{
			if (!$event['cal_owner']) $event['cal_owner'] = $GLOBALS['egw_info']['user']['account_id'];

			if (!$event['cal_id'] && !isset($event['cal_uid'])) $event['cal_uid'] = '';	// uid is NOT NULL!

			$this->db->insert($this->cal_table,$event,false,__LINE__,__FILE__);
			if (!($cal_id = $this->db->get_last_insert_id($this->cal_table,'cal_id')))
			{
				return false;
			}
			// new event (without uid) or new created referencing event => create new uid
			if (!$event['cal_uid'] || $event['cal_reference'] && strstr($event['cal_uid'],'cal-'.$event['calreference'].'-'))
			{
				$event['cal_uid'] = $GLOBALS['egw']->common->generate_uid('calendar',$cal_id);
				$this->db->update($this->cal_table,array('cal_uid' => $event['cal_uid']),array('cal_id' => $cal_id),__LINE__,__FILE__);
			}
			// new events need to have at least one participant, default to the owner
			if (!isset($event['cal_participants']))
			{
				$event['cal_participants'] = array($event['cal_owner'] => 'A');
			}
		}
		// write information about recuring event, if recur_type is present in the array
		if (isset($event['recur_type']))
		{
			if (isset($event['recur_exception']) && is_array($event['recur_exception']) && count($event['recur_exception']))
			{
				// delete execeptions from the user and dates table, it could be the first time
				$this->db->delete($this->user_table,array('cal_id' => $cal_id,'cal_recur_date' => $event['recur_exception']),__LINE__,__FILE__);
				$this->db->delete($this->dates_table,array('cal_id' => $cal_id,'cal_start' => $event['recur_exception']),__LINE__,__FILE__);

				$event['recur_exception'] = implode(',',$event['recur_exception']);
			}
			else
			{
				$event['recur_exception'] = null;
			}
			if (!$set_recurrences)
			{
				// check if the recure-information changed
				$this->db->select($this->repeats_table,'*',array('cal_id' => $cal_id),__LINE__,__FILE__);
				$old_recur = $this->db->row(true);
				$old_exceptions = $old_recur['recur_exception'] ? explode(',',$old_recur['recur_exception']) : array();
				$exceptions = $event['recur_exception'] ? explode(',',$event['recur_exception']) : array();
				$set_recurrences = $event['recur_type'] != $old_recur['recur_type'] || $event['recur_data'] != $old_recur['recur_data'] ||
					$event['recur_interval'] != $old_recur['recur_interval'] || $event['recur_enddate'] != $old_recur['recur_enddate'] ||
					count(array_diff($old_exceptions,$exceptions));	// exception deleted
			}
			if($event['recur_type'] != MCAL_RECUR_NONE)
			{
				$this->db->insert($this->repeats_table,$event,array('cal_id' => $cal_id),__LINE__,__FILE__);
			}
			else
			{
				$this->db->delete($this->repeats_table,array('cal_id' => $cal_id),__LINE__,__FILE__);
			}
			if ($set_recurrences)
			{
				// delete all, but the lowest dates record
				$this->db->select($this->dates_table,'MIN(cal_start)',array('cal_id'=>$cal_id),__LINE__,__FILE__);
				$min = $this->db->next_record() ? $this->db->f(0) : 0;

				$this->db->delete($this->dates_table,array(
					'cal_id' => $cal_id,
					'cal_start > '.(int)$min,
				),__LINE__,__FILE__);
				// delete all user-records, with recur-date != 0
				$this->db->delete($this->user_table,array(
					'cal_id' => $cal_id,
					'cal_recur_date != 0',
				),__LINE__,__FILE__);
			}
		}
		// update start- and endtime if present in the event-array, evtl. we need to move all recurrences
		if (isset($event['cal_start']) && isset($event['cal_end']))
		{
			$this->move($cal_id,$event['cal_start'],$event['cal_end'],!$cal_id ? false : $change_since);
		}
		// update participants if present in the event-array
		if (isset($event['cal_participants']))
		{
			$this->participants($cal_id,$event['cal_participants'],!$cal_id ? false : $change_since);
		}
		// Custom fields
		foreach($event as $name => $value)
		{
			if ($name[0] == '#')
			{
				if (strlen($value))
				{
					$this->db->insert($this->extra_table,array(
						'cal_extra_value'	=> $value,
					),array(
						'cal_id'			=> $cal_id,
						'cal_extra_name'	=> substr($name,1),
					),__LINE__,__FILE__);
				}
				else
				{
					$this->db->delete($this->extra_table,array(
						'cal_id'			=> $cal_id,
						'cal_extra_name'	=> substr($name,1),
					),__LINE__,__FILE__);
				}	
			}
		}
		// updating or saving the alarms, new alarms have a temporary numeric id!
		// ToDo: recuring events !!!
		if (is_array($event['alarm']))
		{
			foreach ($event['alarm'] as $id => $alarm)
			{
				if (is_numeric($id)) unset($alarm['id']);	// unset the temporary id, to add the alarm

				$alarm['time'] = $event['cal_start'] - $alarm['offset'];	// recalculate the offset, as the start-time might have changed
				
				$this->save_alarm($cal_id,$alarm);
			}
		}
		return $cal_id;
	}
	
	/**
	 * moves an event to an other start- and end-time taken into account the evtl. recurrences of the event(!)
	 *
	 * @param int $cal_id
	 * @param int $start new starttime
	 * @param int $end new endtime
	 * @param int/boolean $change_since=0 false=new entry, > 0 time from which on the repetitions should be changed, default 0=all
	 * @param int $old_start=0 old starttime or (default) 0, to query it from the db
	 * @param int $old_end=0 old starttime or (default) 0
	 * @return int/boolean number of moved recurrences or false on error
	 */
	function move($cal_id,$start,$end,$change_since=0,$old_start=0,$old_end=0)
	{
		//echo "<p>socal::move($cal_id,$start,$end,$change_since,$old_start,$old_end)</p>\n";
		
		if (!(int) $cal_id) return false;

		if (!$old_start)
		{
			if ($change_since !== false) $this->db->select($this->dates_table,'MIN(cal_start) AS cal_start,MIN(cal_end) AS cal_end',
				array('cal_id'=>$cal_id),__LINE__,__FILE__);
			// if no recurrence found, create one with the new dates
			if ($change_since === false || !($row = $this->db->row(true)) || !$row['cal_start'] || !$row['cal_end'])
			{
				$this->db->insert($this->dates_table,array(
					'cal_id'    => $cal_id,
					'cal_start' => $start,
					'cal_end'   => $end,
				),false,__LINE__,__FILE__);

				return 1;
			}
			$move_start = (int) ($start-$row['cal_start']);
			$move_end   = (int) ($end-$row['cal_end']);
		}
		else
		{
			$move_start = (int) ($start-$old_start);
			$move_end   = (int) ($end-$old_end);
		}
		$where = $this->db->expression($this->cal_table,array('cal_id' => $cal_id));

		if ($move_start)
		{
			// move the recur-date of the participants
			$this->db->query("UPDATE $this->user_table SET cal_recur_date=cal_recur_date+$move_start WHERE $where AND cal_recur_date ".
				((int)$change_since ? '>= '.(int)$change_since : '!= 0'));
		}
		if ($move_start || $move_end)
		{
			// move the event and it's recurrences
			$this->db->query("UPDATE $this->dates_table SET cal_start=cal_start+$move_start,cal_end=cal_end+$move_end WHERE $where".
				((int) $change_since ? ' AND cal_start >= '.(int) $change_since : ''));
		}
		return $this->db->affected_rows();
	}
	
	/**
	 * combines user_type and user_id into a single string or integer (for users)
	 *
	 * @param string $user_type 1-char type: 'u' = user, ...
	 * @param int $user_id id
	 * @return string/int combined id
	 */
	function combine_user($user_type,$user_id)
	{
		if (!$user_type || $user_type == 'u')
		{
			return (int) $user_id;
		}
		return $user_type.$user_id;
	}
	
	/**
	 * splits the combined user_type and user_id into a single values
	 *
	 * @param string $user_type 1-char type: 'u' = user, ...
	 * @param int $user_id id
	 * @return string/int
	 */
	function split_user($uid,&$user_type,&$user_id)
	{
		if (is_numeric($uid))
		{
			$user_type = 'u';
			$user_id = (int) $uid;
		}
		else
		{
			$user_type = $uid[0];
			$user_id = (int) substr($uid,1);
		}
	}
	
	/**
	 * updates the participants of an event, taken into account the evtl. recurrences of the event(!)
	 * 
	 * @param int $cal_id
	 * @param array $participants id => status pairs
	 * @param int/boolean $change_since=0 false=new entry, > 0 time from which on the repetitions should be changed, default 0=all
	 * @param int $recur_date=0 time of which repetitions should be updated, default 0=all
	 * @return int/boolean number of updated recurrences or false on error
	 */
	function participants($cal_id,$participants,$change_since=0)
	{
		//echo "<p>socal::participants($cal_id,".print_r($participants,true).",$change_since)</p>\n";

		// remove group-invitations, they are NOT stored in the db
		foreach($participants as $uid => $status)
		{
			if ($status == 'G')
			{
				unset($participants[$uid]);
			}
		}
		$where = array('cal_id' => $cal_id);

		if ((int) $change_since)
		{
			$where[] = '(cal_recur_date=0 OR cal_recur_date >= '.(int)$change_since.')';
		}
		if ($change_since !== false)	// existing entries only
		{
			// delete not longer set participants
			$deleted = array();
			$this->db->select($this->user_table,'DISTINCT cal_user_type,cal_user_id,cal_quantity',$where,__LINE__,__FILE__);
			while (($row = $this->db->row(true)))
			{
				$uid = $this->combine_user($row['cal_user_type'],$row['cal_user_id']);
				if (!isset($participants[$uid]))	// delete group-invitations
				{
					$deleted[$row['cal_user_type']][] = $row['cal_user_id'];
				}
				elseif($row['cal_quantity'] == (substr($participants[$uid],1) ? substr($participants[$uid],1) : 1))
				{
					unset($participants[$uid]);	// we dont touch them
				}
			}

			if (count($deleted))
			{
				$to_or = array();
				foreach($deleted as $type => $ids)
				{
					$to_or[] = $this->db->expression($this->user_table,array(
						'cal_user_type' => $type,
						'cal_user_id'   => $ids,
					));
				}
				$this->db->delete($this->user_table,$where + array('('.implode(' OR ',$to_or).')'),__LINE__,__FILE__);
			}
		}
		if (count($participants))	// these are NEW participants now
		{
			// find all recurrences, as they all need the new parts to be added
			$recurrences = array();
			if ($change_since !== false)	// existing entries only
			{
				$this->db->select($this->user_table,'DISTINCT cal_recur_date',$where,__LINE__,__FILE__);
				while(($row = $this->db->row(true)))
				{
					$recurrences[] = $row['cal_recur_date'];
				}
			}
			if (!count($recurrences)) $recurrences[] = 0;	// insert the default one

			foreach($participants as $uid => $status)
			{
				$this->split_user($uid,$type,$id);
				foreach($recurrences as $recur_date)
				{
					$this->db->insert($this->user_table,array(
						'cal_status'	  => $status !== true ? $status{0} : 'U',
						'cal_quantity'	=> substr($status,1) ? substr($status,1) : 1,
						'cal_recur_date' => $recur_date,
						),array(
						'cal_id'	=> $cal_id,
						'cal_user_type'   => $type,
						'cal_user_id' 	  => $id,
						
					),__LINE__,__FILE__);
				}
			}
		}
		return true;				
	}

	/**
	 * set the status of one participant for a given recurrence or for all recurrences since now (includes recur_date=0)
	 *
	 * @param int $cal_id
	 * @param char $user_type 'u' regular user
	 * @param int $user_id
	 * @param int/char $status numeric status (defines) or 1-char code: 'R', 'U', 'T' or 'A'
	 * @param int $recur_date=0 date to change, or 0 = all since now
	 * @return int number of changed recurrences
	 */
	function set_status($cal_id,$user_type,$user_id,$status,$recur_date=0)
	{
		static $status_code_short = array(
			REJECTED 	=> 'R',
			NO_RESPONSE	=> 'U',
			TENTATIVE	=> 'T',
			ACCEPTED	=> 'A'
		);
		if (!(int)$cal_id || !(int)$user_id) return false;
		
		if (is_numeric($status)) $status = $status_code_short[$status];
		
		$where = array(
			'cal_id'		=> $cal_id,
			'cal_user_type'	=> $user_type ? $user_type : 'u',
			'cal_user_id'   => $user_id,
		);
		if ((int) $recur_date)
		{
			$where['cal_recur_date'] = $recur_date;
		}
		else
		{
			$where[] = '(cal_recur_date=0 OR cal_recur_date >= '.time().')';
		}
		if ($status == 'G')		// remove group invitations, as we dont store them in the db
		{
			$this->db->delete($this->user_table,$where,__LINE__,__FILE__);
		}
		else
		{
			$this->db->insert($this->user_table,array(
				'cal_status'     => $status,
			),$where,__LINE__,__FILE__);
		}
		return $this->db->affected_rows();
	}
	
	/**
	 * creates or update a recurrence in the dates and users table
	 *
	 * @param int $cal_id 
	 * @param int $start
	 * @param int $end
	 * @param array $participants uid => status pairs
	 */
	function recurrence($cal_id,$start,$end,$participants)
	{
		//echo "<p>socal::recurrence($cal_id,$start,$end,".print_r($participants,true).")</p>\n";
		$this->db->insert($this->dates_table,array(
			'cal_end' => $end,
		),array(
			'cal_id' => $cal_id,
			'cal_start'  => $start,
		),__LINE__,__FILE__);
		
		foreach($participants as $uid => $status)
		{
			if ($status == 'G') continue;	// dont save group-invitations

			$this->split_user($uid,$type,$id);
			$this->db->insert($this->user_table,array(
				'cal_status'	 => $status !== true ? $status{0} : 'U',
				'cal_quantity'	=> substr($status,1) ? substr($status,1) : 1,
			),array(
				'cal_id'		 => $cal_id,
				'cal_recur_date' => $start,
				'cal_user_type'  => $type,
				'cal_user_id' 	 => $id,
			),__LINE__,__FILE__);
		}
	}

	/**
	 * Get all unfinished recuring events (or all users) after a given time
	 *
	 * @param int $time 
	 * @return array with cal_id => max(cal_start) pairs
	 */
	function unfinished_recuring($time)
	{
		$this->db->select($this->repeats_table,"$this->repeats_table.cal_id,MAX(cal_start) AS cal_start",array(
			"$this->repeats_table.cal_id = $this->dates_table.cal_id",
			'(recur_enddate = 0 OR recur_enddate IS NULL OR recur_enddate > '.(int)$time.')',
		),__LINE__,__FILE__,false,"GROUP BY $this->repeats_table.cal_id",false,0,','.$this->dates_table);
		$ids = array();
		while (($row = $this->db->Row(true)))
		{
			$ids[$row['cal_id']] = $row['cal_start'];
		}
		return $ids;
	}

	/**
	 * deletes an event incl. all recurrences, participants and alarms
	 *
	 * @param int $cal_id
	 */
	function delete($cal_id)
	{
		//echo "<p>socal::delete($cal_id)</p>\n";

		$this->delete_alarms($cal_id);

		foreach($this->all_tables as $table)
		{
			$this->db->delete($table,array('cal_id'=>$cal_id),__LINE__,__FILE__);
		}
	}

	/**
	 * read the alarms of a calendar-event specified by $cal_id
	 *
	 * alarm-id is a string of 'cal:'.$cal_id.':'.$alarm_nr, it is used as the job-id too
	 *
	 * @param int $cal_id
	 * @return array of alarms with alarm-id as key
	 */
	function read_alarms($cal_id)
	{
		$alarms = array();

		if ($jobs = $this->async->read('cal:'.(int)$cal_id.':%'))
		{
			foreach($jobs as $id => $job)
			{
				$alarm         = $job['data'];	// text, enabled
				$alarm['id']   = $id;
				$alarm['time'] = $job['next'];

				$alarms[$id] = $alarm;
			}
		}
		return $alarms;
	}

	/**
	 * read a single alarm specified by it's $id
	 *
	 * @param string $id alarm-id is a string of 'cal:'.$cal_id.':'.$alarm_nr, it is used as the job-id too
	 * @return array with data of the alarm
	 */
	function read_alarm($id)
	{
		if (!($jobs = $this->async->read($id)))
		{
			return False;
		}
		list($id,$job) = each($jobs);
		$alarm         = $job['data'];	// text, enabled
		$alarm['id']   = $id;
		$alarm['time'] = $job['next'];

		//echo "<p>read_alarm('$id')="; print_r($alarm); echo "</p>\n";
		return $alarm;
	}

	/**
	 * saves a new or updated alarm
	 *
	 * @param int $cal_id Id of the calendar-entry
	 * @param array $alarm array with fields: text, owner, enabled, ..
	 * @return string id of the alarm
	 */
	function save_alarm($cal_id,$alarm)
	{
		//echo "<p>save_alarm(cal_id=$cal_id, alarm="; print_r($alarm); echo ")</p>\n";
		if (!($id = $alarm['id']))
		{
			$alarms = $this->read_alarms($cal_id);	// find a free alarm#
			$n = count($alarms);
			do
			{
				$id = 'cal:'.(int)$cal_id.':'.$n;
				++$n;
			}
			while (@isset($alarms[$id]));
		}
		else
		{
			$this->async->cancel_timer($id);
		}
		$alarm['cal_id'] = $cal_id;		// we need the back-reference

		if (!$this->async->set_timer($alarm['time'],$id,'calendar.bocalupdate.send_alarm',$alarm))
		{
			return False;
		}
		return $id;
	}

	/**
	 * delete all alarms of a calendar-entry
	 *
	 * @param int $cal_id Id of the calendar-entry
	 * @return int number of alarms deleted
	 */
	function delete_alarms($cal_id)
	{
		$alarms = $this->read_alarms($cal_id);

		foreach($alarms as $id => $alarm)
		{
			$this->async->cancel_timer($id);
		}
		return count($alarms);
	}

	/**
	 * delete one alarms identified by its id
	 *
	 * @param string $id alarm-id is a string of 'cal:'.$cal_id.':'.$alarm_nr, it is used as the job-id too
	 * @return int number of alarms deleted
	 */
	function delete_alarm($id)
	{
		return $this->async->cancel_timer($id);
	}
	
	function change_delete_user($old_user,$new_user=false)
	{
		if (!(int)$new_user)
		{
			$this->split_user($old_user,$user_type,$user_id);
			
			if ($user_type == 'u')	// only accounts can be owners of events
			{
				$ids = array();
				$this->db->select($this->cal_table,'cal_id',array('cal_owner' => $old_user),__LINE__,__FILE__);
				while(($row = $this->db->row(true)))
				{
					$ids[] = $row['cal_id'];
				}
				foreach($ids as $cal_id)
				{
					$this->delete($cal_id);
				}
			}
			$this->db->delete($this->user_table,array(
				'cal_user_type' => $user_type,
				'cal_user_id'   => $user_id,
			),__LINE__,__FILE__);
		}
		else
		{
			$this->db->update($this->cal_table,array('cal_owner' => $new_user),array('cal_owner' => $old_user),__LINE__,__FILE__);
			$this->db->update($this->user_table,array('cal_user_id' => $new_user),array('cal_user_type' => 'u','cal_user_id' => $old_user),__LINE__,__FILE__);
		}
	}
}