No OneTemporary
Actions

Size

90 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/plugins/calendar/drivers/database/database_driver.php b/plugins/calendar/drivers/database/database_driver.php
	index 8c22bb0a..0038218c 100644
	--- a/plugins/calendar/drivers/database/database_driver.php
	+++ b/plugins/calendar/drivers/database/database_driver.php
	@@ -1,1027 +1,1027 @@
	<?php

	/**
	* Database driver for the Calendar plugin
	*
	* @version @package_version@
	* @author Lazlo Westerhof <hello@lazlo.me>
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2010, Lazlo Westerhof <hello@lazlo.me>
	* Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/


	class database_driver extends calendar_driver
	{
	const DB_DATE_FORMAT = 'Y-m-d H:i:s';

	// features this backend supports
	public $alarms = true;
	public $attendees = true;
	public $freebusy = false;
	public $attachments = true;
	public $alarm_types = array('DISPLAY');

	private $rc;
	private $cal;
	private $cache = array();
	private $calendars = array();
	private $calendar_ids = '';
	private $free_busy_map = array('free' => 0, 'busy' => 1, 'out-of-office' => 2, 'outofoffice' => 2, 'tentative' => 3);
	private $sensitivity_map = array('public' => 0, 'private' => 1, 'confidential' => 2);
	private $server_timezone;

	private $db_events = 'events';
	private $db_calendars = 'calendars';
	private $db_attachments = 'attachments';


	/**
	* Default constructor
	*/
	public function __construct($cal)
	{
	$this->cal = $cal;
	$this->rc = $cal->rc;
	$this->server_timezone = new DateTimeZone(date_default_timezone_get());

	// load library classes
	require_once($this->cal->home . '/lib/Horde_Date_Recurrence.php');

	// read database config
	$db = $this->rc->get_dbh();
	$this->db_events = $this->rc->config->get('db_table_events', $db->table_name($this->db_events));
	$this->db_calendars = $this->rc->config->get('db_table_calendars', $db->table_name($this->db_calendars));
	$this->db_attachments = $this->rc->config->get('db_table_attachments', $db->table_name($this->db_attachments));

	$this->_read_calendars();
	}

	/**
	* Read available calendars for the current user and store them internally
	*/
	private function _read_calendars()
	{
	$hidden = array_filter(explode(',', $this->rc->config->get('hidden_calendars', '')));

	if (!empty($this->rc->user->ID)) {
	$calendar_ids = array();
	$result = $this->rc->db->query(
	"SELECT *, calendar_id AS id FROM " . $this->db_calendars . "
	WHERE user_id=?
	ORDER BY name",
	$this->rc->user->ID
	);
	while ($result && ($arr = $this->rc->db->fetch_assoc($result))) {
	$arr['showalarms'] = intval($arr['showalarms']);
	$arr['active'] = !in_array($arr['id'], $hidden);
	$arr['name'] = html::quote($arr['name']);
	$this->calendars[$arr['calendar_id']] = $arr;
	$calendar_ids[] = $this->rc->db->quote($arr['calendar_id']);
	}
	$this->calendar_ids = join(',', $calendar_ids);
	}
	}

	/**
	* Get a list of available calendars from this source
	*
	* @param bool $active Return only active calendars
	* @param bool $personal Return only personal calendars
	*
	* @return array List of calendars
	*/
	public function list_calendars($active = false, $personal = false)
	{
	// attempt to create a default calendar for this user
	if (empty($this->calendars)) {
	if ($this->create_calendar(array('name' => 'Default', 'color' => 'cc0000')))
	$this->_read_calendars();
	}

	$calendars = $this->calendars;

	// filter active calendars
	if ($active) {
	foreach ($calendars as $idx => $cal) {
	if (!$cal['active']) {
	unset($calendars[$idx]);
	}
	}
	}

	// 'personal' is unsupported in this driver

	return $calendars;
	}

	/**
	* Create a new calendar assigned to the current user
	*
	* @param array Hash array with calendar properties
	* name: Calendar name
	* color: The color of the calendar
	* @return mixed ID of the calendar on success, False on error
	*/
	public function create_calendar($prop)
	{
	$result = $this->rc->db->query(
	"INSERT INTO " . $this->db_calendars . "
	(user_id, name, color, showalarms)
	VALUES (?, ?, ?, ?)",
	$this->rc->user->ID,
	$prop['name'],
	$prop['color'],
	$prop['showalarms']?1:0
	);

	if ($result)
	return $this->rc->db->insert_id($this->db_calendars);

	return false;
	}

	/**
	* Update properties of an existing calendar
	*
	* @see calendar_driver::edit_calendar()
	*/
	public function edit_calendar($prop)
	{
	$query = $this->rc->db->query(
	"UPDATE " . $this->db_calendars . "
	SET name=?, color=?, showalarms=?
	WHERE calendar_id=?
	AND user_id=?",
	$prop['name'],
	$prop['color'],
	$prop['showalarms']?1:0,
	$prop['id'],
	$this->rc->user->ID
	);

	return $this->rc->db->affected_rows($query);
	}

	/**
	* Set active/subscribed state of a calendar
	* Save a list of hidden calendars in user prefs
	*
	* @see calendar_driver::subscribe_calendar()
	*/
	public function subscribe_calendar($prop)
	{
	$hidden = array_flip(explode(',', $this->rc->config->get('hidden_calendars', '')));

	if ($prop['active'])
	unset($hidden[$prop['id']]);
	else
	$hidden[$prop['id']] = 1;

	return $this->rc->user->save_prefs(array('hidden_calendars' => join(',', array_keys($hidden))));
	}

	/**
	* Delete the given calendar with all its contents
	*
	* @see calendar_driver::remove_calendar()
	*/
	public function remove_calendar($prop)
	{
	if (!$this->calendars[$prop['id']])
	return false;

	// events and attachments will be deleted by foreign key cascade

	$query = $this->rc->db->query(
	"DELETE FROM " . $this->db_calendars . "
	WHERE calendar_id=?",
	$prop['id']
	);

	return $this->rc->db->affected_rows($query);
	}

	/**
	* Add a single event to the database
	*
	* @param array Hash array with event properties
	* @see calendar_driver::new_event()
	*/
	public function new_event($event)
	{
	if (!$this->validate($event))
	return false;

	if (!empty($this->calendars)) {
	if ($event['calendar'] && !$this->calendars[$event['calendar']])
	return false;
	if (!$event['calendar'])
	$event['calendar'] = reset(array_keys($this->calendars));

	$event = $this->_save_preprocess($event);

	$this->rc->db->query(sprintf(
	"INSERT INTO " . $this->db_events . "
	(calendar_id, created, changed, uid, %s, %s, all_day, recurrence, title, description, location, categories, url, free_busy, priority, sensitivity, attendees, alarms, notifyat)
	VALUES (?, %s, %s, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
	$this->rc->db->quote_identifier('start'),
	$this->rc->db->quote_identifier('end'),
	$this->rc->db->now(),
	$this->rc->db->now()
	),
	$event['calendar'],
	strval($event['uid']),
	$event['start']->format(self::DB_DATE_FORMAT),
	$event['end']->format(self::DB_DATE_FORMAT),
	intval($event['all_day']),
	$event['_recurrence'],
	strval($event['title']),
	strval($event['description']),
	strval($event['location']),
	strval($event['categories']),
	strval($event['url']),
	intval($event['free_busy']),
	intval($event['priority']),
	intval($event['sensitivity']),
	$event['attendees'],
	$event['alarms'],
	$event['notifyat']
	);

	$event_id = $this->rc->db->insert_id($this->db_events);

	if ($event_id) {
	$event['id'] = $event_id;

	// add attachments
	if (!empty($event['attachments'])) {
	foreach ($event['attachments'] as $attachment) {
	$this->add_attachment($attachment, $event_id);
	unset($attachment);
	}
	}

	$this->_update_recurring($event);
	}

	return $event_id;
	}

	return false;
	}

	/**
	* Update an event entry with the given data
	*
	* @param array Hash array with event properties
	* @see calendar_driver::edit_event()
	*/
	public function edit_event($event)
	{
	if (!empty($this->calendars)) {
	$update_master = false;
	$update_recurring = true;
	$old = $this->get_event($event);

	// increment sequence number
	- if ($old['sequence'])
	+ if ($old['sequence'] && empty($event['sequence']))
	$event['sequence'] = max($event['sequence'], $old['sequence']+1);

	// modify a recurring event, check submitted savemode to do the right things
	if ($old['recurrence'] \|\| $old['recurrence_id']) {
	$master = $old['recurrence_id'] ? $this->get_event(array('id' => $old['recurrence_id'])) : $old;

	// keep saved exceptions (not submitted by the client)
	if ($old['recurrence']['EXDATE'])
	$event['recurrence']['EXDATE'] = $old['recurrence']['EXDATE'];

	switch ($event['_savemode']) {
	case 'new':
	$event['uid'] = $this->cal->generate_uid();
	return $this->new_event($event);

	case 'current':
	// add exception to master event
	$master['recurrence']['EXDATE'][] = $old['start'];
	$update_master = true;

	// just update this occurence (decouple from master)
	$update_recurring = false;
	$event['recurrence_id'] = 0;
	$event['recurrence'] = array();
	break;

	case 'future':
	if ($master['id'] != $event['id']) {
	// set until-date on master event, then save this instance as new recurring event
	$master['recurrence']['UNTIL'] = clone $event['start'];
	$master['recurrence']['UNTIL']->sub(new DateInterval('P1D'));
	unset($master['recurrence']['COUNT']);
	$update_master = true;

	// if recurrence COUNT, update value to the correct number of future occurences
	if ($event['recurrence']['COUNT']) {
	$fromdate = clone $event['start'];
	$fromdate->setTimezone($this->server_timezone);
	$sqlresult = $this->rc->db->query(sprintf(
	"SELECT event_id FROM " . $this->db_events . "
	WHERE calendar_id IN (%s)
	AND %s >= ?
	AND recurrence_id=?",
	$this->calendar_ids,
	$this->rc->db->quote_identifier('start')
	),
	$fromdate->format(self::DB_DATE_FORMAT),
	$master['id']);
	if ($count = $this->rc->db->num_rows($sqlresult))
	$event['recurrence']['COUNT'] = $count;
	}

	$update_recurring = true;
	$event['recurrence_id'] = 0;
	break;
	}
	// else: 'future' == 'all' if modifying the master event

	default: // 'all' is default
	$event['id'] = $master['id'];
	$event['recurrence_id'] = 0;

	// use start date from master but try to be smart on time or duration changes
	$old_start_date = $old['start']->format('Y-m-d');
	$old_start_time = $old['allday'] ? '' : $old['start']->format('H:i');
	$old_duration = $old['end']->format('U') - $old['start']->format('U');

	$new_start_date = $event['start']->format('Y-m-d');
	$new_start_time = $event['allday'] ? '' : $event['start']->format('H:i');
	$new_duration = $event['end']->format('U') - $event['start']->format('U');

	$diff = $old_start_date != $new_start_date \|\| $old_start_time != $new_start_time \|\| $old_duration != $new_duration;

	// shifted or resized
	if ($diff && ($old_start_date == $new_start_date \|\| $old_duration == $new_duration)) {
	$event['start'] = $master['start']->add($old['start']->diff($event['start']));
	$event['end'] = clone $event['start'];
	$event['end']->add(new DateInterval('PT'.$new_duration.'S'));
	}
	break;
	}
	}

	$success = $this->_update_event($event, $update_recurring);
	if ($success && $update_master)
	$this->_update_event($master, true);

	return $success;
	}

	return false;
	}

	/**
	* Convert save data to be used in SQL statements
	*/
	private function _save_preprocess($event)
	{
	// shift dates to server's timezone
	$event['start'] = clone $event['start'];
	$event['start']->setTimezone($this->server_timezone);
	$event['end'] = clone $event['end'];
	$event['end']->setTimezone($this->server_timezone);

	// compose vcalendar-style recurrencue rule from structured data
	$rrule = $event['recurrence'] ? libcalendaring::to_rrule($event['recurrence']) : '';
	$event['_recurrence'] = rtrim($rrule, ';');
	$event['free_busy'] = intval($this->free_busy_map[strtolower($event['free_busy'])]);
	$event['sensitivity'] = intval($this->sensitivity_map[strtolower($event['sensitivity'])]);

	if (isset($event['allday'])) {
	$event['all_day'] = $event['allday'] ? 1 : 0;
	}

	// compute absolute time to notify the user
	$event['notifyat'] = $this->_get_notification($event);

	// process event attendees
	$_attendees = '';
	foreach ((array)$event['attendees'] as $attendee) {
	if (!$attendee['name'] && !$attendee['email'])
	continue;
	$_attendees .= 'NAME="'.addcslashes($attendee['name'], '"') . '"' .
	';STATUS=' . $attendee['status'].
	';ROLE=' . $attendee['role'] .
	';EMAIL=' . $attendee['email'] .
	"\n";
	}
	$event['attendees'] = rtrim($_attendees);

	return $event;
	}

	/**
	* Compute absolute time to notify the user
	*/
	private function _get_notification($event)
	{
	if ($event['alarms'] && $event['start'] > new DateTime()) {
	$alarm = libcalendaring::get_next_alarm($event);

	if ($alarm['time'] && $alarm['action'] == 'DISPLAY')
	return date('Y-m-d H:i:s', $alarm['time']);
	}

	return null;
	}

	/**
	* Save the given event record to database
	*
	* @param array Event data, already passed through self::_save_preprocess()
	* @param boolean True if recurring events instances should be updated, too
	*/
	private function _update_event($event, $update_recurring = true)
	{
	$event = $this->_save_preprocess($event);
	$sql_set = array();
	$set_cols = array('start', 'end', 'all_day', 'recurrence_id', 'sequence', 'title', 'description', 'location', 'categories', 'url', 'free_busy', 'priority', 'sensitivity', 'attendees', 'alarms', 'notifyat');
	foreach ($set_cols as $col) {
	if (is_object($event[$col]) && is_a($event[$col], 'DateTime'))
	$sql_set[] = $this->rc->db->quote_identifier($col) . '=' . $this->rc->db->quote($event[$col]->format(self::DB_DATE_FORMAT));
	else if (isset($event[$col]))
	$sql_set[] = $this->rc->db->quote_identifier($col) . '=' . $this->rc->db->quote($event[$col]);
	}

	if ($event['_recurrence'])
	$sql_set[] = $this->rc->db->quote_identifier('recurrence') . '=' . $this->rc->db->quote($event['_recurrence']);

	if ($event['_fromcalendar'] && $event['_fromcalendar'] != $event['calendar'])
	$sql_set[] = 'calendar_id=' . $this->rc->db->quote($event['calendar']);

	$query = $this->rc->db->query(sprintf(
	"UPDATE " . $this->db_events . "
	SET changed=%s %s
	WHERE event_id=?
	AND calendar_id IN (" . $this->calendar_ids . ")",
	$this->rc->db->now(),
	($sql_set ? ', ' . join(', ', $sql_set) : '')
	),
	$event['id']
	);

	$success = $this->rc->db->affected_rows($query);

	// add attachments
	if ($success && !empty($event['attachments'])) {
	foreach ($event['attachments'] as $attachment) {
	$this->add_attachment($attachment, $event['id']);
	unset($attachment);
	}
	}

	// remove attachments
	if ($success && !empty($event['deleted_attachments'])) {
	foreach ($event['deleted_attachments'] as $attachment) {
	$this->remove_attachment($attachment, $event['id']);
	}
	}

	if ($success) {
	unset($this->cache[$event['id']]);
	if ($update_recurring)
	$this->_update_recurring($event);
	}

	return $success;
	}

	/**
	* Insert "fake" entries for recurring occurences of this event
	*/
	private function _update_recurring($event)
	{
	if (empty($this->calendars))
	return;

	// clear existing recurrence copies
	$this->rc->db->query(
	"DELETE FROM " . $this->db_events . "
	WHERE recurrence_id=?
	AND calendar_id IN (" . $this->calendar_ids . ")",
	$event['id']
	);

	// create new fake entries
	if ($event['recurrence']) {
	// include library class
	require_once($this->cal->home . '/lib/calendar_recurrence.php');

	$recurrence = new calendar_recurrence($this->cal, $event);

	$count = 0;
	$duration = $event['start']->diff($event['end']);
	while ($next_start = $recurrence->next_start()) {
	$next_start->setTimezone($this->server_timezone);
	$next_end = clone $next_start;
	$next_end->add($duration);
	$notify_at = $this->_get_notification(array('alarms' => $event['alarms'], 'start' => $next_start, 'end' => $next_end));
	$query = $this->rc->db->query(sprintf(
	"INSERT INTO " . $this->db_events . "
	(calendar_id, recurrence_id, created, changed, uid, %s, %s, all_day, recurrence, title, description, location, categories, url, free_busy, priority, sensitivity, alarms, notifyat)
	SELECT calendar_id, ?, %s, %s, uid, ?, ?, all_day, recurrence, title, description, location, categories, url, free_busy, priority, sensitivity, alarms, ?
	FROM " . $this->db_events . " WHERE event_id=? AND calendar_id IN (" . $this->calendar_ids . ")",
	$this->rc->db->quote_identifier('start'),
	$this->rc->db->quote_identifier('end'),
	$this->rc->db->now(),
	$this->rc->db->now()
	),
	$event['id'],
	$next_start->format(self::DB_DATE_FORMAT),
	$next_end->format(self::DB_DATE_FORMAT),
	$notify_at,
	$event['id']
	);

	if (!$this->rc->db->affected_rows($query))
	break;

	// stop adding events for inifinite recurrence after 20 years
	if (++$count > 999 \|\| (!$recurrence->recurEnd && !$recurrence->recurCount && $next_start->format('Y') > date('Y') + 20))
	break;
	}
	}
	}

	/**
	* Move a single event
	*
	* @param array Hash array with event properties
	* @see calendar_driver::move_event()
	*/
	public function move_event($event)
	{
	// let edit_event() do all the magic
	return $this->edit_event($event + (array)$this->get_event($event));
	}

	/**
	* Resize a single event
	*
	* @param array Hash array with event properties
	* @see calendar_driver::resize_event()
	*/
	public function resize_event($event)
	{
	// let edit_event() do all the magic
	return $this->edit_event($event + (array)$this->get_event($event));
	}

	/**
	* Remove a single event from the database
	*
	* @param array Hash array with event properties
	* @param boolean Remove record irreversible (@TODO)
	*
	* @see calendar_driver::remove_event()
	*/
	public function remove_event($event, $force = true)
	{
	if (!empty($this->calendars)) {
	$event += (array)$this->get_event($event);
	$master = $event;
	$update_master = false;
	$savemode = 'all';

	// read master if deleting a recurring event
	if ($event['recurrence'] \|\| $event['recurrence_id']) {
	$master = $event['recurrence_id'] ? $this->get_event(array('id' => $event['recurrence_id'])) : $event;
	$savemode = $event['_savemode'];
	}

	switch ($savemode) {
	case 'current':
	// add exception to master event
	$master['recurrence']['EXDATE'][] = $event['start'];
	$update_master = true;

	// just delete this single occurence
	$query = $this->rc->db->query(
	"DELETE FROM " . $this->db_events . "
	WHERE calendar_id IN (" . $this->calendar_ids . ")
	AND event_id=?",
	$event['id']
	);
	break;

	case 'future':
	if ($master['id'] != $event['id']) {
	// set until-date on master event
	$master['recurrence']['UNTIL'] = clone $event['start'];
	$master['recurrence']['UNTIL']->sub(new DateInterval('P1D'));
	unset($master['recurrence']['COUNT']);
	$update_master = true;

	// delete this and all future instances
	$fromdate = clone $event['start'];
	$fromdate->setTimezone($this->server_timezone);
	$query = $this->rc->db->query(
	"DELETE FROM " . $this->db_events . "
	WHERE calendar_id IN (" . $this->calendar_ids . ")
	AND " . $this->rc->db->quote_identifier('start') . " >= ?
	AND recurrence_id=?",
	$fromdate->format(self::DB_DATE_FORMAT),
	$master['id']
	);
	break;
	}
	// else: future == all if modifying the master event

	default: // 'all' is default
	$query = $this->rc->db->query(
	"DELETE FROM " . $this->db_events . "
	WHERE (event_id=? OR recurrence_id=?)
	AND calendar_id IN (" . $this->calendar_ids . ")",
	$master['id'],
	$master['id']
	);
	break;
	}

	$success = $this->rc->db->affected_rows($query);
	if ($success && $update_master)
	$this->_update_event($master, true);

	return $success;
	}

	return false;
	}

	/**
	* Return data of a specific event
	* @param mixed Hash array with event properties or event UID
	* @param boolean Only search in writeable calendars (ignored)
	* @param boolean Only search in active calendars
	* @param boolean Only search in personal calendars (ignored)
	* @return array Hash array with event properties
	*/
	public function get_event($event, $writeable = false, $active = false, $personal = false)
	{
	$id = is_array($event) ? ($event['id'] ? $event['id'] : $event['uid']) : $event;
	$col = is_array($event) && is_numeric($id) ? 'event_id' : 'uid';

	if ($this->cache[$id])
	return $this->cache[$id];

	if ($active) {
	$calendars = $this->calendars;
	foreach ($calendars as $idx => $cal) {
	if (!$cal['active']) {
	unset($calendars[$idx]);
	}
	}
	$cals = join(',', $calendars);
	}
	else {
	$cals = $this->calendar_ids;
	}

	$result = $this->rc->db->query(sprintf(
	"SELECT e.*, (SELECT COUNT(attachment_id) FROM " . $this->db_attachments . "
	WHERE event_id = e.event_id OR event_id = e.recurrence_id) AS _attachments
	FROM " . $this->db_events . " AS e
	WHERE e.calendar_id IN (%s)
	AND e.$col=?",
	$cals
	),
	$id);

	if ($result && ($event = $this->rc->db->fetch_assoc($result)) && $event['event_id']) {
	$this->cache[$id] = $this->_read_postprocess($event);
	return $this->cache[$id];
	}

	return false;
	}

	/**
	* Get event data
	*
	* @see calendar_driver::load_events()
	*/
	public function load_events($start, $end, $query = null, $calendars = null)
	{
	if (empty($calendars))
	$calendars = array_keys($this->calendars);
	else if (is_string($calendars))
	$calendars = explode(',', $calendars);

	// only allow to select from calendars of this use
	$calendar_ids = array_map(array($this->rc->db, 'quote'), array_intersect($calendars, array_keys($this->calendars)));

	// compose (slow) SQL query for searching
	// FIXME: improve searching using a dedicated col and normalized values
	if ($query) {
	foreach (array('title','location','description','categories','attendees') as $col)
	$sql_query[] = $this->rc->db->ilike($col, '%'.$query.'%');
	$sql_add = 'AND (' . join(' OR ', $sql_query) . ')';
	}

	$events = array();
	if (!empty($calendar_ids)) {
	$result = $this->rc->db->query(sprintf(
	"SELECT e.*, (SELECT COUNT(attachment_id) FROM " . $this->db_attachments . "
	WHERE event_id = e.event_id OR event_id = e.recurrence_id) AS _attachments
	FROM " . $this->db_events . " AS e
	WHERE e.calendar_id IN (%s)
	AND e.start <= %s AND e.end >= %s
	%s
	GROUP BY e.event_id",
	join(',', $calendar_ids),
	$this->rc->db->fromunixtime($end),
	$this->rc->db->fromunixtime($start),
	$sql_add
	));

	while ($result && ($event = $this->rc->db->fetch_assoc($result))) {
	$events[] = $this->_read_postprocess($event);
	}
	}

	return $events;
	}

	/**
	* Convert sql record into a rcube style event object
	*/
	private function _read_postprocess($event)
	{
	$free_busy_map = array_flip($this->free_busy_map);
	$sensitivity_map = array_flip($this->sensitivity_map);

	$event['id'] = $event['event_id'];
	$event['start'] = new DateTime($event['start']);
	$event['end'] = new DateTime($event['end']);
	$event['allday'] = intval($event['all_day']);
	$event['changed'] = new DateTime($event['changed']);
	$event['free_busy'] = $free_busy_map[$event['free_busy']];
	$event['sensitivity'] = $sensitivity_map[$event['sensitivity']];
	$event['calendar'] = $event['calendar_id'];
	$event['recurrence_id'] = intval($event['recurrence_id']);

	// parse recurrence rule
	if ($event['recurrence'] && preg_match_all('/([A-Z]+)=([^;]+);?/', $event['recurrence'], $m, PREG_SET_ORDER)) {
	$event['recurrence'] = array();
	foreach ($m as $rr) {
	if (is_numeric($rr[2]))
	$rr[2] = intval($rr[2]);
	else if ($rr[1] == 'UNTIL')
	$rr[2] = date_create($rr[2]);
	else if ($rr[1] == 'EXDATE')
	$rr[2] = array_map('date_create', explode(',', $rr[2]));
	$event['recurrence'][$rr[1]] = $rr[2];
	}
	}

	if ($event['_attachments'] > 0)
	$event['attachments'] = (array)$this->list_attachments($event);

	// decode serialized event attendees
	if ($event['attendees']) {
	$attendees = array();
	foreach (explode("\n", $event['attendees']) as $line) {
	$att = array();
	foreach (rcube_utils::explode_quoted_string(';', $line) as $prop) {
	list($key, $value) = explode("=", $prop);
	$att[strtolower($key)] = stripslashes(trim($value, '""'));
	}
	$attendees[] = $att;
	}
	$event['attendees'] = $attendees;
	}

	unset($event['event_id'], $event['calendar_id'], $event['notifyat'], $event['all_day'], $event['_attachments']);
	return $event;
	}

	/**
	* Get a list of pending alarms to be displayed to the user
	*
	* @see calendar_driver::pending_alarms()
	*/
	public function pending_alarms($time, $calendars = null)
	{
	if (empty($calendars))
	$calendars = array_keys($this->calendars);
	else if (is_string($calendars))
	$calendars = explode(',', $calendars);

	// only allow to select from calendars with activated alarms
	$calendar_ids = array();
	foreach ($calendars as $cid) {
	if ($this->calendars[$cid] && $this->calendars[$cid]['showalarms'])
	$calendar_ids[] = $cid;
	}
	$calendar_ids = array_map(array($this->rc->db, 'quote'), $calendar_ids);

	$alarms = array();
	if (!empty($calendar_ids)) {
	$result = $this->rc->db->query(sprintf(
	"SELECT * FROM " . $this->db_events . "
	WHERE calendar_id IN (%s)
	AND notifyat <= %s AND %s > %s",
	join(',', $calendar_ids),
	$this->rc->db->fromunixtime($time),
	$this->rc->db->quote_identifier('end'),
	$this->rc->db->fromunixtime($time)
	));

	while ($result && ($event = $this->rc->db->fetch_assoc($result)))
	$alarms[] = $this->_read_postprocess($event);
	}

	return $alarms;
	}

	/**
	* Feedback after showing/sending an alarm notification
	*
	* @see calendar_driver::dismiss_alarm()
	*/
	public function dismiss_alarm($event_id, $snooze = 0)
	{
	// set new notifyat time or unset if not snoozed
	$notify_at = $snooze > 0 ? date(self::DB_DATE_FORMAT, time() + $snooze) : null;

	$query = $this->rc->db->query(sprintf(
	"UPDATE " . $this->db_events . "
	SET changed=%s, notifyat=?
	WHERE event_id=?
	AND calendar_id IN (" . $this->calendar_ids . ")",
	$this->rc->db->now()),
	$notify_at,
	$event_id
	);

	return $this->rc->db->affected_rows($query);
	}

	/**
	* Save an attachment related to the given event
	*/
	private function add_attachment($attachment, $event_id)
	{
	$data = $attachment['data'] ? $attachment['data'] : file_get_contents($attachment['path']);

	$query = $this->rc->db->query(
	"INSERT INTO " . $this->db_attachments .
	" (event_id, filename, mimetype, size, data)" .
	" VALUES (?, ?, ?, ?, ?)",
	$event_id,
	$attachment['name'],
	$attachment['mimetype'],
	strlen($data),
	base64_encode($data)
	);

	return $this->rc->db->affected_rows($query);
	}

	/**
	* Remove a specific attachment from the given event
	*/
	private function remove_attachment($attachment_id, $event_id)
	{
	$query = $this->rc->db->query(
	"DELETE FROM " . $this->db_attachments .
	" WHERE attachment_id = ?" .
	" AND event_id IN (SELECT event_id FROM " . $this->db_events .
	" WHERE event_id = ?" .
	" AND calendar_id IN (" . $this->calendar_ids . "))",
	$attachment_id,
	$event_id
	);

	return $this->rc->db->affected_rows($query);
	}

	/**
	* List attachments of specified event
	*/
	public function list_attachments($event)
	{
	$attachments = array();

	if (!empty($this->calendar_ids)) {
	$result = $this->rc->db->query(
	"SELECT attachment_id AS id, filename AS name, mimetype, size " .
	" FROM " . $this->db_attachments .
	" WHERE event_id IN (SELECT event_id FROM " . $this->db_events .
	" WHERE event_id=?" .
	" AND calendar_id IN (" . $this->calendar_ids . "))".
	" ORDER BY filename",
	$event['recurrence_id'] ? $event['recurrence_id'] : $event['event_id']
	);

	while ($result && ($arr = $this->rc->db->fetch_assoc($result))) {
	$attachments[] = $arr;
	}
	}

	return $attachments;
	}

	/**
	* Get attachment properties
	*/
	public function get_attachment($id, $event)
	{
	if (!empty($this->calendar_ids)) {
	$result = $this->rc->db->query(
	"SELECT attachment_id AS id, filename AS name, mimetype, size " .
	" FROM " . $this->db_attachments .
	" WHERE attachment_id=?".
	" AND event_id=?",
	$id,
	$event['recurrence_id'] ? $event['recurrence_id'] : $event['id']
	);

	if ($result && ($arr = $this->rc->db->fetch_assoc($result))) {
	return $arr;
	}
	}

	return null;
	}

	/**
	* Get attachment body
	*/
	public function get_attachment_body($id, $event)
	{
	if (!empty($this->calendar_ids)) {
	$result = $this->rc->db->query(
	"SELECT data " .
	" FROM " . $this->db_attachments .
	" WHERE attachment_id=?".
	" AND event_id=?",
	$id,
	$event['id']
	);

	if ($result && ($arr = $this->rc->db->fetch_assoc($result))) {
	return base64_decode($arr['data']);
	}
	}

	return null;
	}

	/**
	* Remove the given category
	*/
	public function remove_category($name)
	{
	$query = $this->rc->db->query(
	"UPDATE " . $this->db_events . "
	SET categories=''
	WHERE categories=?
	AND calendar_id IN (" . $this->calendar_ids . ")",
	$name
	);

	return $this->rc->db->affected_rows($query);
	}

	/**
	* Update/replace a category
	*/
	public function replace_category($oldname, $name, $color)
	{
	$query = $this->rc->db->query(
	"UPDATE " . $this->db_events . "
	SET categories=?
	WHERE categories=?
	AND calendar_id IN (" . $this->calendar_ids . ")",
	$name,
	$oldname
	);

	return $this->rc->db->affected_rows($query);
	}

	}
	diff --git a/plugins/calendar/drivers/kolab/kolab_driver.php b/plugins/calendar/drivers/kolab/kolab_driver.php
	index 3e0b8b0b..516452fb 100644
	--- a/plugins/calendar/drivers/kolab/kolab_driver.php
	+++ b/plugins/calendar/drivers/kolab/kolab_driver.php
	@@ -1,1225 +1,1229 @@
	<?php

	/**
	* Kolab driver for the Calendar plugin
	*
	* @version @package_version@
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	* @author Aleksander Machniak <machniak@kolabsys.com>
	*
	* Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	require_once(dirname(__FILE__) . '/kolab_calendar.php');

	class kolab_driver extends calendar_driver
	{
	// features this backend supports
	public $alarms = true;
	public $attendees = true;
	public $freebusy = true;
	public $attachments = true;
	public $undelete = true;
	public $alarm_types = array('DISPLAY');
	public $categoriesimmutable = true;

	private $rc;
	private $cal;
	private $calendars;
	private $has_writeable = false;
	private $freebusy_trigger = false;

	/**
	* Default constructor
	*/
	public function __construct($cal)
	{
	$this->cal = $cal;
	$this->rc = $cal->rc;
	$this->_read_calendars();

	$this->cal->register_action('push-freebusy', array($this, 'push_freebusy'));
	$this->cal->register_action('calendar-acl', array($this, 'calendar_acl'));

	$this->freebusy_trigger = $this->rc->config->get('calendar_freebusy_trigger', false);

	if (kolab_storage::$version == '2.0') {
	$this->alarm_types = array('DISPLAY');
	$this->alarm_absolute = false;
	}
	}


	/**
	* Read available calendars from server
	*/
	private function _read_calendars()
	{
	// already read sources
	if (isset($this->calendars))
	return $this->calendars;

	// get all folders that have "event" type, sorted by namespace/name
	$folders = kolab_storage::sort_folders(kolab_storage::get_folders('event'));
	$this->calendars = array();

	foreach ($folders as $folder) {
	$calendar = new kolab_calendar($folder->name, $this->cal);
	$this->calendars[$calendar->id] = $calendar;
	if (!$calendar->readonly)
	$this->has_writeable = true;
	}

	return $this->calendars;
	}


	/**
	* Get a list of available calendars from this source
	*
	* @param bool $active Return only active calendars
	* @param bool $personal Return only personal calendars
	*
	* @return array List of calendars
	*/
	public function list_calendars($active = false, $personal = false)
	{
	// attempt to create a default calendar for this user
	if (!$this->has_writeable) {
	if ($this->create_calendar(array('name' => 'Calendar', 'color' => 'cc0000'))) {
	unset($this->calendars);
	$this->_read_calendars();
	}
	}

	$calendars = $this->filter_calendars(false, $active, $personal);
	$names = array();

	foreach ($calendars as $id => $cal) {
	$name = kolab_storage::folder_displayname($cal->get_name(), $names);

	$calendars[$id] = array(
	'id' => $cal->id,
	'name' => $name,
	'editname' => $cal->get_foldername(),
	'color' => $cal->get_color(),
	'readonly' => $cal->readonly,
	'showalarms' => $cal->alarms,
	'class_name' => $cal->get_namespace(),
	'default' => $cal->storage->default,
	'active' => $cal->storage->is_active(),
	'owner' => $cal->get_owner(),
	);
	}

	return $calendars;
	}


	/**
	* Get list of calendars according to specified filters
	*
	* @param bool $writeable Return only writeable calendars
	* @param bool $active Return only active calendars
	* @param bool $personal Return only personal calendars
	*
	* @return array List of calendars
	*/
	protected function filter_calendars($writeable = false, $active = false, $personal = false)
	{
	$calendars = array();

	$plugin = $this->rc->plugins->exec_hook('calendar_list_filter', array(
	'list' => $this->calendars, 'calendars' => $calendars,
	'writeable' => $writeable, 'active' => $active, 'personal' => $personal,
	));

	if ($plugin['abort']) {
	return $plugin['calendars'];
	}

	foreach ($this->calendars as $cal) {
	if (!$cal->ready) {
	continue;
	}
	if ($writeable && $cal->readonly) {
	continue;
	}
	if ($active && !$cal->storage->is_active()) {
	continue;
	}
	if ($personal && $cal->get_namespace() != 'personal') {
	continue;
	}
	$calendars[$cal->id] = $cal;
	}

	return $calendars;
	}

	/**
	* Create a new calendar assigned to the current user
	*
	* @param array Hash array with calendar properties
	* name: Calendar name
	* color: The color of the calendar
	* @return mixed ID of the calendar on success, False on error
	*/
	public function create_calendar($prop)
	{
	$prop['type'] = 'event';
	$prop['active'] = true;
	$prop['subscribed'] = true;
	$folder = kolab_storage::folder_update($prop);

	if ($folder === false) {
	$this->last_error = $this->cal->gettext(kolab_storage::$last_error);
	return false;
	}

	// create ID
	$id = kolab_storage::folder_id($folder);

	// save color in user prefs (temp. solution)
	$prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());

	if (isset($prop['color']))
	$prefs['kolab_calendars'][$id]['color'] = $prop['color'];
	if (isset($prop['showalarms']))
	$prefs['kolab_calendars'][$id]['showalarms'] = $prop['showalarms'] ? true : false;

	if ($prefs['kolab_calendars'][$id])
	$this->rc->user->save_prefs($prefs);

	return $id;
	}


	/**
	* Update properties of an existing calendar
	*
	* @see calendar_driver::edit_calendar()
	*/
	public function edit_calendar($prop)
	{
	if ($prop['id'] && ($cal = $this->calendars[$prop['id']])) {
	$prop['oldname'] = $cal->get_realname();
	$newfolder = kolab_storage::folder_update($prop);

	if ($newfolder === false) {
	$this->last_error = $this->cal->gettext(kolab_storage::$last_error);
	return false;
	}

	// create ID
	$id = kolab_storage::folder_id($newfolder);

	// fallback to local prefs
	$prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());
	unset($prefs['kolab_calendars'][$prop['id']]);

	if (isset($prop['color']))
	$prefs['kolab_calendars'][$id]['color'] = $prop['color'];
	if (isset($prop['showalarms']))
	$prefs['kolab_calendars'][$id]['showalarms'] = $prop['showalarms'] ? true : false;

	if ($prefs['kolab_calendars'][$id])
	$this->rc->user->save_prefs($prefs);

	return true;
	}

	return false;
	}


	/**
	* Set active/subscribed state of a calendar
	*
	* @see calendar_driver::subscribe_calendar()
	*/
	public function subscribe_calendar($prop)
	{
	if ($prop['id'] && ($cal = $this->calendars[$prop['id']])) {
	return $cal->storage->activate($prop['active']);
	}

	return false;
	}


	/**
	* Delete the given calendar with all its contents
	*
	* @see calendar_driver::remove_calendar()
	*/
	public function remove_calendar($prop)
	{
	if ($prop['id'] && ($cal = $this->calendars[$prop['id']])) {
	$folder = $cal->get_realname();
	if (kolab_storage::folder_delete($folder)) {
	// remove color in user prefs (temp. solution)
	$prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());
	unset($prefs['kolab_calendars'][$prop['id']]);

	$this->rc->user->save_prefs($prefs);
	return true;
	}
	else
	$this->last_error = kolab_storage::$last_error;
	}

	return false;
	}


	/**
	* Fetch a single event
	*
	* @see calendar_driver::get_event()
	* @return array Hash array with event properties, false if not found
	*/
	public function get_event($event, $writeable = false, $active = false, $personal = false)
	{
	if (is_array($event)) {
	$id = $event['id'] ? $event['id'] : $event['uid'];
	$cal = $event['calendar'];
	}
	else {
	$id = $event;
	}

	if ($cal) {
	if ($storage = $this->calendars[$cal]) {
	return $storage->get_event($id);
	}
	}
	// iterate over all calendar folders and search for the event ID
	else {
	foreach ($this->filter_calendars($writeable, $active, $personal) as $calendar) {
	if ($result = $calendar->get_event($id)) {
	return $result;
	}
	}
	}

	return false;
	}

	/**
	* Add a single event to the database
	*
	* @see calendar_driver::new_event()
	*/
	public function new_event($event)
	{
	if (!$this->validate($event))
	return false;

	$cid = $event['calendar'] ? $event['calendar'] : reset(array_keys($this->calendars));
	if ($storage = $this->calendars[$cid]) {
	// handle attachments to add
	if (!empty($event['attachments'])) {
	foreach ($event['attachments'] as $idx => $attachment) {
	// we'll read file contacts into memory, Horde/Kolab classes does the same
	// So we cannot save memory, rcube_imap class can do this better
	$event['attachments'][$idx]['content'] = $attachment['data'] ? $attachment['data'] : file_get_contents($attachment['path']);
	}
	}

	$success = $storage->insert_event($event);

	if ($success && $this->freebusy_trigger)
	$this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));

	return $success;
	}

	return false;
	}

	/**
	* Update an event entry with the given data
	*
	* @see calendar_driver::new_event()
	* @return boolean True on success, False on error
	*/
	public function edit_event($event)
	{
	return $this->update_event($event);
	}

	/**
	* Move a single event
	*
	* @see calendar_driver::move_event()
	* @return boolean True on success, False on error
	*/
	public function move_event($event)
	{
	- if (($storage = $this->calendars[$event['calendar']]) && ($ev = $storage->get_event($event['id'])))
	+ if (($storage = $this->calendars[$event['calendar']]) && ($ev = $storage->get_event($event['id']))) {
	+ unset($ev['sequence']);
	return $this->update_event($event + $ev);
	+ }

	return false;
	}

	/**
	* Resize a single event
	*
	* @see calendar_driver::resize_event()
	* @return boolean True on success, False on error
	*/
	public function resize_event($event)
	{
	- if (($storage = $this->calendars[$event['calendar']]) && ($ev = $storage->get_event($event['id'])))
	+ if (($storage = $this->calendars[$event['calendar']]) && ($ev = $storage->get_event($event['id']))) {
	+ unset($ev['sequence']);
	return $this->update_event($event + $ev);
	+ }

	return false;
	}

	/**
	* Remove a single event
	*
	* @param array Hash array with event properties:
	* id: Event identifier
	* @param boolean Remove record(s) irreversible (mark as deleted otherwise)
	*
	* @return boolean True on success, False on error
	*/
	public function remove_event($event, $force = true)
	{
	$success = false;
	$savemode = $event['_savemode'];

	if (($storage = $this->calendars[$event['calendar']]) && ($event = $storage->get_event($event['id']))) {
	$event['_savemode'] = $savemode;
	$savemode = 'all';
	$master = $event;

	$this->rc->session->remove('calendar_restore_event_data');

	// read master if deleting a recurring event
	if ($event['recurrence'] \|\| $event['recurrence_id']) {
	$master = $event['recurrence_id'] ? $storage->get_event($event['recurrence_id']) : $event;
	$savemode = $event['_savemode'];
	}

	// removing an exception instance
	if ($event['recurrence_id']) {
	$i = $event['_instance'] - 1;
	if (!empty($master['recurrence']['EXCEPTIONS'][$i])) {
	unset($master['recurrence']['EXCEPTIONS'][$i]);
	}
	}

	switch ($savemode) {
	case 'current':
	$_SESSION['calendar_restore_event_data'] = $master;

	// removing the first instance => just move to next occurence
	if ($master['id'] == $event['id']) {
	$recurring = reset($storage->_get_recurring_events($event, $event['start'], null, $event['id'].'-1'));

	// no future instances found: delete the master event (bug #1677)
	if (!$recurring['start']) {
	$success = $storage->delete_event($master, $force);
	break;
	}

	$master['start'] = $recurring['start'];
	$master['end'] = $recurring['end'];
	if ($master['recurrence']['COUNT'])
	$master['recurrence']['COUNT']--;
	}
	else { // add exception to master event
	$master['recurrence']['EXDATE'][] = $event['start'];
	}
	$success = $storage->update_event($master);
	break;

	case 'future':
	if ($master['id'] != $event['id']) {
	$_SESSION['calendar_restore_event_data'] = $master;

	// set until-date on master event
	$master['recurrence']['UNTIL'] = clone $event['start'];
	$master['recurrence']['UNTIL']->sub(new DateInterval('P1D'));
	unset($master['recurrence']['COUNT']);

	// if all future instances are deleted, remove recurrence rule entirely (bug #1677)
	if ($master['recurrence']['UNTIL']->format('Ymd') == $master['start']->format('Ymd'))
	$master['recurrence'] = array();

	$success = $storage->update_event($master);
	break;
	}

	default: // 'all' is default
	$success = $storage->delete_event($master, $force);
	break;
	}
	}

	if ($success && $this->freebusy_trigger)
	$this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));

	return $success;
	}

	/**
	* Restore a single deleted event
	*
	* @param array Hash array with event properties:
	* id: Event identifier
	* @return boolean True on success, False on error
	*/
	public function restore_event($event)
	{
	if ($storage = $this->calendars[$event['calendar']]) {
	if (!empty($_SESSION['calendar_restore_event_data']))
	$success = $storage->update_event($_SESSION['calendar_restore_event_data']);
	else
	$success = $storage->restore_event($event);

	if ($success && $this->freebusy_trigger)
	$this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));

	return $success;
	}

	return false;
	}

	/**
	* Wrapper to update an event object depending on the given savemode
	*/
	private function update_event($event)
	{
	if (!($storage = $this->calendars[$event['calendar']]))
	return false;

	// move event to another folder/calendar
	if ($event['_fromcalendar'] && $event['_fromcalendar'] != $event['calendar']) {
	if (!($fromcalendar = $this->calendars[$event['_fromcalendar']]))
	return false;

	if ($event['_savemode'] != 'new') {
	if (!$fromcalendar->storage->move($event['id'], $storage->get_realname()))
	return false;

	$fromcalendar = $storage;
	}
	}
	else
	$fromcalendar = $storage;

	$success = false;
	$savemode = 'all';
	$attachments = array();
	$old = $master = $fromcalendar->get_event($event['id']);

	if (!$old \|\| !$old['start']) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Failed to load event object to update: id=" . $event['id']),
	true, false);
	return false;
	}

	// delete existing attachment(s)
	if (!empty($event['deleted_attachments'])) {
	foreach ($event['deleted_attachments'] as $attachment) {
	if (!empty($old['attachments'])) {
	foreach ($old['attachments'] as $idx => $att) {
	if ($att['id'] == $attachment) {
	$old['attachments'][$idx]['_deleted'] = true;
	}
	}
	}
	}
	unset($event['deleted_attachments']);
	}

	// handle attachments to add
	if (!empty($event['attachments'])) {
	foreach ($event['attachments'] as $attachment) {
	// skip entries without content (could be existing ones)
	if (!$attachment['data'] && !$attachment['path'])
	continue;

	$attachments[] = array(
	'name' => $attachment['name'],
	'mimetype' => $attachment['mimetype'],
	'content' => $attachment['data'],
	'path' => $attachment['path'],
	);
	}
	}

	$event['attachments'] = array_merge((array)$old['attachments'], $attachments);

	// modify a recurring event, check submitted savemode to do the right things
	if ($old['recurrence'] \|\| $old['recurrence_id']) {
	$master = $old['recurrence_id'] ? $fromcalendar->get_event($old['recurrence_id']) : $old;
	$savemode = $event['_savemode'];
	}

	// keep saved exceptions (not submitted by the client)
	if ($old['recurrence']['EXDATE'])
	$event['recurrence']['EXDATE'] = $old['recurrence']['EXDATE'];
	if ($old['recurrence']['EXCEPTIONS'])
	$event['recurrence']['EXCEPTIONS'] = $old['recurrence']['EXCEPTIONS'];

	switch ($savemode) {
	case 'new':
	// save submitted data as new (non-recurring) event
	$event['recurrence'] = array();
	$event['uid'] = $this->cal->generate_uid();

	// copy attachment data to new event
	foreach ((array)$event['attachments'] as $idx => $attachment) {
	if (!$attachment['data'])
	$attachment['data'] = $fromcalendar->get_attachment_body($attachment['id'], $event);
	}

	$success = $storage->insert_event($event);
	break;

	case 'future':
	case 'current':
	// recurring instances shall not store recurrence rules
	$event['recurrence'] = array();
	$event['thisandfuture'] = $savemode == 'future';

	// remove some internal properties which should not be saved
	unset($event['_savemode'], $event['_fromcalendar'], $event['_identity']);

	// save properties to a recurrence exception instance
	if ($old['recurrence_id']) {
	$i = $old['_instance'] - 1;
	if (!empty($master['recurrence']['EXCEPTIONS'][$i])) {
	$master['recurrence']['EXCEPTIONS'][$i] = $event;
	$success = $storage->update_event($master, $old['id']);
	break;
	}
	}

	// save as new exception to master event
	$master['recurrence']['EXCEPTIONS'][] = $event;
	$success = $storage->update_event($master);
	break;

	default: // 'all' is default
	$event['id'] = $master['id'];
	$event['uid'] = $master['uid'];

	// use start date from master but try to be smart on time or duration changes
	$old_start_date = $old['start']->format('Y-m-d');
	$old_start_time = $old['allday'] ? '' : $old['start']->format('H:i');
	$old_duration = $old['end']->format('U') - $old['start']->format('U');

	$new_start_date = $event['start']->format('Y-m-d');
	$new_start_time = $event['allday'] ? '' : $event['start']->format('H:i');
	$new_duration = $event['end']->format('U') - $event['start']->format('U');

	$diff = $old_start_date != $new_start_date \|\| $old_start_time != $new_start_time \|\| $old_duration != $new_duration;

	// shifted or resized
	if ($diff && ($old_start_date == $new_start_date \|\| $old_duration == $new_duration)) {
	$event['start'] = $master['start']->add($old['start']->diff($event['start']));
	$event['end'] = clone $event['start'];
	$event['end']->add(new DateInterval('PT'.$new_duration.'S'));

	// remove fixed weekday, will be re-set to the new weekday in kolab_calendar::update_event()
	if ($old_start_date != $new_start_date) {
	if (strlen($event['recurrence']['BYDAY']) == 2)
	unset($event['recurrence']['BYDAY']);
	if ($old['recurrence']['BYMONTH'] == $old['start']->format('n'))
	unset($event['recurrence']['BYMONTH']);
	}
	}
	// dates did not change, use the ones from master
	else if ($event['start'] == $old['start'] && $event['end'] == $old['end']) {
	$event['start'] = $master['start'];
	$event['end'] = $master['end'];
	}

	$success = $storage->update_event($event);
	break;
	}

	if ($success && $this->freebusy_trigger)
	$this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));

	return $success;
	}

	/**
	* Get events from source.
	*
	* @param integer Event's new start (unix timestamp)
	* @param integer Event's new end (unix timestamp)
	* @param string Search query (optional)
	* @param mixed List of calendar IDs to load events from (either as array or comma-separated string)
	* @param boolean Strip virtual events (optional)
	* @return array A list of event records
	*/
	public function load_events($start, $end, $search = null, $calendars = null, $virtual = 1)
	{
	if ($calendars && is_string($calendars))
	$calendars = explode(',', $calendars);

	$events = $categories = array();
	foreach (array_keys($this->calendars) as $cid) {
	if ($calendars && !in_array($cid, $calendars))
	continue;

	$events = array_merge($events, $this->calendars[$cid]->list_events($start, $end, $search, $virtual));
	$categories += $this->calendars[$cid]->categories;
	}

	// add new categories to user prefs
	$old_categories = $this->rc->config->get('calendar_categories', $this->default_categories);
	if ($newcats = array_diff(array_map('strtolower', array_keys($categories)), array_map('strtolower', array_keys($old_categories)))) {
	foreach ($newcats as $category)
	$old_categories[$category] = ''; // no color set yet
	$this->rc->user->save_prefs(array('calendar_categories' => $old_categories));
	}

	return $events;
	}

	/**
	* Get a list of pending alarms to be displayed to the user
	*
	* @see calendar_driver::pending_alarms()
	*/
	public function pending_alarms($time, $calendars = null)
	{
	$interval = 300;
	$time -= $time % 60;

	$slot = $time;
	$slot -= $slot % $interval;

	$last = $time - max(60, $this->rc->config->get('refresh_interval', 0));
	$last -= $last % $interval;

	// only check for alerts once in 5 minutes
	if ($last == $slot)
	return array();

	if ($calendars && is_string($calendars))
	$calendars = explode(',', $calendars);

	$time = $slot + $interval;

	$events = array();
	$query = array(array('tags', '=', 'x-has-alarms'));
	foreach ($this->calendars as $cid => $calendar) {
	// skip calendars with alarms disabled
	if (!$calendar->alarms \|\| ($calendars && !in_array($cid, $calendars)))
	continue;

	foreach ($calendar->list_events($time, $time + 86400 * 365, null, 1, $query) as $e) {
	// add to list if alarm is set
	$alarm = libcalendaring::get_next_alarm($e);
	if ($alarm && $alarm['time'] && $alarm['time'] <= $time && $alarm['action'] == 'DISPLAY') {
	$id = $e['id'];
	$events[$id] = $e;
	$events[$id]['notifyat'] = $alarm['time'];
	}
	}
	}

	// get alarm information stored in local database
	if (!empty($events)) {
	$event_ids = array_map(array($this->rc->db, 'quote'), array_keys($events));
	$result = $this->rc->db->query(sprintf(
	"SELECT * FROM kolab_alarms
	WHERE event_id IN (%s) AND user_id=?",
	join(',', $event_ids),
	$this->rc->db->now()
	),
	$this->rc->user->ID
	);

	while ($result && ($e = $this->rc->db->fetch_assoc($result))) {
	$dbdata[$e['event_id']] = $e;
	}
	}

	$alarms = array();
	foreach ($events as $id => $e) {
	// skip dismissed
	if ($dbdata[$id]['dismissed'])
	continue;

	// snooze function may have shifted alarm time
	$notifyat = $dbdata[$id]['notifyat'] ? strtotime($dbdata[$id]['notifyat']) : $e['notifyat'];
	if ($notifyat <= $time)
	$alarms[] = $e;
	}

	return $alarms;
	}

	/**
	* Feedback after showing/sending an alarm notification
	*
	* @see calendar_driver::dismiss_alarm()
	*/
	public function dismiss_alarm($event_id, $snooze = 0)
	{
	// delete old alarm entry
	$this->rc->db->query(
	"DELETE FROM kolab_alarms
	WHERE event_id=? AND user_id=?",
	$event_id,
	$this->rc->user->ID
	);

	// set new notifyat time or unset if not snoozed
	$notifyat = $snooze > 0 ? date('Y-m-d H:i:s', time() + $snooze) : null;

	$query = $this->rc->db->query(
	"INSERT INTO kolab_alarms
	(event_id, user_id, dismissed, notifyat)
	VALUES(?, ?, ?, ?)",
	$event_id,
	$this->rc->user->ID,
	$snooze > 0 ? 0 : 1,
	$notifyat
	);

	return $this->rc->db->affected_rows($query);
	}

	/**
	* List attachments from the given event
	*/
	public function list_attachments($event)
	{
	if (!($storage = $this->calendars[$event['calendar']]))
	return false;

	$event = $storage->get_event($event['id']);

	return $event['attachments'];
	}

	/**
	* Get attachment properties
	*/
	public function get_attachment($id, $event)
	{
	if (!($storage = $this->calendars[$event['calendar']]))
	return false;

	$event = $storage->get_event($event['id']);

	if ($event && !empty($event['attachments'])) {
	foreach ($event['attachments'] as $att) {
	if ($att['id'] == $id) {
	return $att;
	}
	}
	}

	return null;
	}

	/**
	* Get attachment body
	* @see calendar_driver::get_attachment_body()
	*/
	public function get_attachment_body($id, $event)
	{
	if (!($cal = $this->calendars[$event['calendar']]))
	return false;

	return $cal->storage->get_attachment($event['id'], $id);
	}

	/**
	* List availabale categories
	* The default implementation reads them from config/user prefs
	*/
	public function list_categories()
	{
	// FIXME: complete list with categories saved in config objects (KEP:12)
	return $this->rc->config->get('calendar_categories', $this->default_categories);
	}

	/**
	* Fetch free/busy information from a person within the given range
	*/
	public function get_freebusy_list($email, $start, $end)
	{
	require_once('HTTP/Request2.php');

	if (empty($email)/* \|\| $end < time()*/)
	return false;

	// map vcalendar fbtypes to internal values
	$fbtypemap = array(
	'FREE' => calendar::FREEBUSY_FREE,
	'BUSY-TENTATIVE' => calendar::FREEBUSY_TENTATIVE,
	'X-OUT-OF-OFFICE' => calendar::FREEBUSY_OOF,
	'OOF' => calendar::FREEBUSY_OOF);

	// ask kolab server first
	try {
	$rcmail = rcube::get_instance();
	$request = new HTTP_Request2(kolab_storage::get_freebusy_url($email));
	$request->setConfig(array(
	'store_body' => true,
	'follow_redirects' => true,
	'ssl_verify_peer' => $rcmail->config->get('kolab_ssl_verify_peer', true),
	));

	$response = $request->send();

	// authentication required
	if ($response->getStatus() == 401) {
	$request->setAuth($this->rc->user->get_username(), $this->rc->decrypt($_SESSION['password']));
	$response = $request->send();
	}

	if ($response->getStatus() == 200)
	$fbdata = $response->getBody();

	unset($request, $response);
	}
	catch (Exception $e) {
	PEAR::raiseError("Error fetching free/busy information: " . $e->getMessage());
	}

	// get free-busy url from contacts
	if (!$fbdata) {
	$fburl = null;
	foreach ((array)$this->rc->config->get('autocomplete_addressbooks', 'sql') as $book) {
	$abook = $this->rc->get_address_book($book);

	if ($result = $abook->search(array('email'), $email, true, true, true/, 'freebusyurl'/)) {
	while ($contact = $result->iterate()) {
	if ($fburl = $contact['freebusyurl']) {
	$fbdata = @file_get_contents($fburl);
	break;
	}
	}
	}

	if ($fbdata)
	break;
	}
	}

	// parse free-busy information using Horde classes
	if ($fbdata) {
	$fbcal = $this->cal->get_ical()->get_parser();
	$fbcal->parsevCalendar($fbdata);
	if ($fb = $fbcal->findComponent('vfreebusy')) {
	$result = array();
	$params = $fb->getExtraParams();
	foreach ($fb->getBusyPeriods() as $from => $to) {
	if ($to == null) // no information, assume free
	break;
	$type = $params[$from]['FBTYPE'];
	$result[] = array($from, $to, isset($fbtypemap[$type]) ? $fbtypemap[$type] : calendar::FREEBUSY_BUSY);
	}

	// we take 'dummy' free-busy lists as "unknown"
	if (empty($result) && ($comment = $fb->getAttribute('COMMENT')) && stripos($comment, 'dummy'))
	return false;

	// set period from $start till the begin of the free-busy information as 'unknown'
	if (($fbstart = $fb->getStart()) && $start < $fbstart) {
	array_unshift($result, array($start, $fbstart, calendar::FREEBUSY_UNKNOWN));
	}
	// pad period till $end with status 'unknown'
	if (($fbend = $fb->getEnd()) && $fbend < $end) {
	$result[] = array($fbend, $end, calendar::FREEBUSY_UNKNOWN);
	}

	return $result;
	}
	}

	return false;
	}

	/**
	* Handler to push folder triggers when sent from client.
	* Used to push free-busy changes asynchronously after updating an event
	*/
	public function push_freebusy()
	{
	// make shure triggering completes
	set_time_limit(0);
	ignore_user_abort(true);

	$cal = get_input_value('source', RCUBE_INPUT_GPC);
	if (!($cal = $this->calendars[$cal]))
	return false;

	// trigger updates on folder
	$trigger = $cal->storage->trigger();
	if (is_object($trigger) && is_a($trigger, 'PEAR_Error')) {
	rcube::raise_error(array(
	'code' => 900, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Failed triggering folder. Error was " . $trigger->getMessage()),
	true, false);
	}

	exit;
	}

	/**
	* Callback function to produce driver-specific calendar create/edit form
	*
	* @param string Request action 'form-edit\|form-new'
	* @param array Calendar properties (e.g. id, color)
	* @param array Edit form fields
	*
	* @return string HTML content of the form
	*/
	public function calendar_form($action, $calendar, $formfields)
	{
	if ($calendar['id'] && ($cal = $this->calendars[$calendar['id']])) {
	$folder = $cal->get_realname(); // UTF7
	$color = $cal->get_color();
	}
	else {
	$folder = '';
	$color = '';
	}

	$hidden_fields[] = array('name' => 'oldname', 'value' => $folder);

	$storage = $this->rc->get_storage();
	$delim = $storage->get_hierarchy_delimiter();
	$form = array();

	if (strlen($folder)) {
	$path_imap = explode($delim, $folder);
	array_pop($path_imap); // pop off name part
	$path_imap = implode($path_imap, $delim);

	$options = $storage->folder_info($folder);
	}
	else {
	$path_imap = '';
	}

	// General tab
	$form['props'] = array(
	'name' => $this->rc->gettext('properties'),
	);

	// Disable folder name input
	if (!empty($options) && ($options['norename'] \|\| $options['protected'])) {
	$input_name = new html_hiddenfield(array('name' => 'name', 'id' => 'calendar-name'));
	$formfields['name']['value'] = Q(str_replace($delim, ' » ', kolab_storage::object_name($folder)))
	. $input_name->show($folder);
	}

	// calendar name (default field)
	$form['props']['fieldsets']['location'] = array(
	'name' => $this->rc->gettext('location'),
	'content' => array(
	'name' => $formfields['name']
	),
	);

	if (!empty($options) && ($options['norename'] \|\| $options['protected'])) {
	// prevent user from moving folder
	$hidden_fields[] = array('name' => 'parent', 'value' => $path_imap);
	}
	else {
	$select = kolab_storage::folder_selector('event', array('name' => 'parent'), $folder);
	$form['props']['fieldsets']['location']['content']['path'] = array(
	'label' => $this->cal->gettext('parentcalendar'),
	'value' => $select->show(strlen($folder) ? $path_imap : ''),
	);
	}

	// calendar color (default field)
	$form['props']['fieldsets']['settings'] = array(
	'name' => $this->rc->gettext('settings'),
	'content' => array(
	'color' => $formfields['color'],
	'showalarms' => $formfields['showalarms'],
	),
	);


	if ($action != 'form-new') {
	$form['sharing'] = array(
	'name' => Q($this->cal->gettext('tabsharing')),
	'content' => html::tag('iframe', array(
	'src' => $this->cal->rc->url(array('_action' => 'calendar-acl', 'id' => $calendar['id'], 'framed' => 1)),
	'width' => '100%',
	'height' => 350,
	'border' => 0,
	'style' => 'border:0'),
	''),
	);
	}

	$this->form_html = '';
	if (is_array($hidden_fields)) {
	foreach ($hidden_fields as $field) {
	$hiddenfield = new html_hiddenfield($field);
	$this->form_html .= $hiddenfield->show() . "\n";
	}
	}

	// Create form output
	foreach ($form as $tab) {
	if (!empty($tab['fieldsets']) && is_array($tab['fieldsets'])) {
	$content = '';
	foreach ($tab['fieldsets'] as $fieldset) {
	$subcontent = $this->get_form_part($fieldset);
	if ($subcontent) {
	$content .= html::tag('fieldset', null, html::tag('legend', null, Q($fieldset['name'])) . $subcontent) ."\n";
	}
	}
	}
	else {
	$content = $this->get_form_part($tab);
	}

	if ($content) {
	$this->form_html .= html::tag('fieldset', null, html::tag('legend', null, Q($tab['name'])) . $content) ."\n";
	}
	}

	// Parse form template for skin-dependent stuff
	$this->rc->output->add_handler('calendarform', array($this, 'calendar_form_html'));
	return $this->rc->output->parse('calendar.kolabform', false, false);
	}

	/**
	* Handler for template object
	*/
	public function calendar_form_html()
	{
	return $this->form_html;
	}

	/**
	* Helper function used in calendar_form_content(). Creates a part of the form.
	*/
	private function get_form_part($form)
	{
	$content = '';

	if (is_array($form['content']) && !empty($form['content'])) {
	$table = new html_table(array('cols' => 2));
	foreach ($form['content'] as $col => $colprop) {
	$colprop['id'] = '_'.$col;
	$label = !empty($colprop['label']) ? $colprop['label'] : rcube_label($col);

	$table->add('title', sprintf('<label for="%s">%s</label>', $colprop['id'], Q($label)));
	$table->add(null, $colprop['value']);
	}
	$content = $table->show();
	}
	else {
	$content = $form['content'];
	}

	return $content;
	}


	/**
	* Handler to render ACL form for a calendar folder
	*/
	public function calendar_acl()
	{
	$this->rc->output->add_handler('folderacl', array($this, 'calendar_acl_form'));
	$this->rc->output->send('calendar.kolabacl');
	}

	/**
	* Handler for ACL form template object
	*/
	public function calendar_acl_form()
	{
	$calid = get_input_value('_id', RCUBE_INPUT_GPC);
	if ($calid && ($cal = $this->calendars[$calid])) {
	$folder = $cal->get_realname(); // UTF7
	$color = $cal->get_color();
	}
	else {
	$folder = '';
	$color = '';
	}

	$storage = $this->rc->get_storage();
	$delim = $storage->get_hierarchy_delimiter();
	$form = array();

	if (strlen($folder)) {
	$path_imap = explode($delim, $folder);
	array_pop($path_imap); // pop off name part
	$path_imap = implode($path_imap, $delim);

	$options = $storage->folder_info($folder);

	// Allow plugins to modify the form content (e.g. with ACL form)
	$plugin = $this->rc->plugins->exec_hook('calendar_form_kolab',
	array('form' => $form, 'options' => $options, 'name' => $folder));
	}

	if (!$plugin['form']['sharing']['content'])
	$plugin['form']['sharing']['content'] = html::div('hint', $this->cal->gettext('aclnorights'));

	return $plugin['form']['sharing']['content'];
	}


	/**
	* Return a (limited) list of color values to be used for calendar and category coloring
	*
	* @return mixed List for colors as hex values or false if no presets should be shown
	*/
	public function get_color_values()
	{
	// selection from http://msdn.microsoft.com/en-us/library/aa358802%28v=VS.85%29.aspx
	return array('000000','006400','2F4F4F','800000','808000','008000',
	'008080','000080','800080','4B0082','191970','8B0000','008B8B',
	'00008B','8B008B','556B2F','8B4513','228B22','6B8E23','2E8B57',
	'B8860B','483D8B','A0522D','0000CD','A52A2A','00CED1','696969',
	'20B2AA','9400D3','B22222','C71585','3CB371','D2691E','DC143C',
	'DAA520','00FA9A','4682B4','7CFC00','9932CC','FF0000','FF4500',
	'FF8C00','FFA500','FFD700','FFFF00','9ACD32','32CD32','00FF00',
	'00FF7F','00FFFF','5F9EA0','00BFFF','0000FF','FF00FF','808080',
	'708090','CD853F','8A2BE2','778899','FF1493','48D1CC','1E90FF',
	'40E0D0','4169E1','6A5ACD','BDB76B','BA55D3','CD5C5C','ADFF2F',
	'66CDAA','FF6347','8FBC8B','DA70D6','BC8F8F','9370DB','DB7093',
	'FF7F50','6495ED','A9A9A9','F4A460','7B68EE','D2B48C','E9967A',
	'DEB887','FF69B4','FA8072','F08080','EE82EE','87CEEB','FFA07A',
	'F0E68C','DDA0DD','90EE90','7FFFD4','C0C0C0','87CEFA','B0C4DE',
	'98FB98','ADD8E6','B0E0E6','D8BFD8','EEE8AA','AFEEEE','D3D3D3',
	'FFDEAD');
	}

	}
	diff --git a/plugins/libkolab/lib/kolab_format_xcal.php b/plugins/libkolab/lib/kolab_format_xcal.php
	index ff10a100..34f2d81c 100644
	--- a/plugins/libkolab/lib/kolab_format_xcal.php
	+++ b/plugins/libkolab/lib/kolab_format_xcal.php
	@@ -1,411 +1,412 @@
	<?php

	/**
	* Xcal based Kolab format class wrapping libkolabxml bindings
	*
	* Base class for xcal-based Kolab groupware objects such as event, todo, journal
	*
	* @version @package_version@
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	abstract class kolab_format_xcal extends kolab_format
	{
	public $CTYPE = 'application/calendar+xml';

	public static $fulltext_cols = array('title', 'description', 'location', 'attendees:name', 'attendees:email', 'categories');

	protected $sensitivity_map = array(
	'public' => kolabformat::ClassPublic,
	'private' => kolabformat::ClassPrivate,
	'confidential' => kolabformat::ClassConfidential,
	);

	protected $role_map = array(
	'REQ-PARTICIPANT' => kolabformat::Required,
	'OPT-PARTICIPANT' => kolabformat::Optional,
	'NON-PARTICIPANT' => kolabformat::NonParticipant,
	'CHAIR' => kolabformat::Chair,
	);

	protected $cutype_map = array(
	'INDIVIDUAL' => kolabformat::CutypeIndividual,
	'GROUP' => kolabformat::CutypeGroup,
	'ROOM' => kolabformat::CutypeRoom,
	'RESOURCE' => kolabformat::CutypeResource,
	'UNKNOWN' => kolabformat::CutypeUnknown,
	);

	protected $rrule_type_map = array(
	'MINUTELY' => RecurrenceRule::Minutely,
	'HOURLY' => RecurrenceRule::Hourly,
	'DAILY' => RecurrenceRule::Daily,
	'WEEKLY' => RecurrenceRule::Weekly,
	'MONTHLY' => RecurrenceRule::Monthly,
	'YEARLY' => RecurrenceRule::Yearly,
	);

	protected $weekday_map = array(
	'MO' => kolabformat::Monday,
	'TU' => kolabformat::Tuesday,
	'WE' => kolabformat::Wednesday,
	'TH' => kolabformat::Thursday,
	'FR' => kolabformat::Friday,
	'SA' => kolabformat::Saturday,
	'SU' => kolabformat::Sunday,
	);

	protected $alarm_type_map = array(
	'DISPLAY' => Alarm::DisplayAlarm,
	'EMAIL' => Alarm::EMailAlarm,
	'AUDIO' => Alarm::AudioAlarm,
	);

	private $status_map = array(
	'NEEDS-ACTION' => kolabformat::StatusNeedsAction,
	'IN-PROCESS' => kolabformat::StatusInProcess,
	'COMPLETED' => kolabformat::StatusCompleted,
	'CANCELLED' => kolabformat::StatusCancelled,
	);

	protected $part_status_map = array(
	'UNKNOWN' => kolabformat::PartNeedsAction,
	'NEEDS-ACTION' => kolabformat::PartNeedsAction,
	'TENTATIVE' => kolabformat::PartTentative,
	'ACCEPTED' => kolabformat::PartAccepted,
	'DECLINED' => kolabformat::PartDeclined,
	'DELEGATED' => kolabformat::PartDelegated,
	);


	/**
	* Convert common xcard properties into a hash array data structure
	*
	* @param array Additional data for merge
	*
	* @return array Object data as hash array
	*/
	public function to_array($data = array())
	{
	// read common object props
	$object = parent::to_array($data);

	$status_map = array_flip($this->status_map);
	$sensitivity_map = array_flip($this->sensitivity_map);

	$object += array(
	'sequence' => intval($this->obj->sequence()),
	'title' => $this->obj->summary(),
	'location' => $this->obj->location(),
	'description' => $this->obj->description(),
	'url' => $this->obj->url(),
	'status' => $status_map[$this->obj->status()],
	'sensitivity' => $sensitivity_map[$this->obj->classification()],
	'priority' => $this->obj->priority(),
	'categories' => self::vector2array($this->obj->categories()),
	'start' => self::php_datetime($this->obj->start()),
	);

	// read organizer and attendees
	if (($organizer = $this->obj->organizer()) && ($organizer->email() \|\| $organizer->name())) {
	$object['organizer'] = array(
	'email' => $organizer->email(),
	'name' => $organizer->name(),
	);
	}

	$role_map = array_flip($this->role_map);
	$cutype_map = array_flip($this->cutype_map);
	$part_status_map = array_flip($this->part_status_map);
	$attvec = $this->obj->attendees();
	for ($i=0; $i < $attvec->size(); $i++) {
	$attendee = $attvec->get($i);
	$cr = $attendee->contact();
	if ($cr->email() != $object['organizer']['email']) {
	$object['attendees'][] = array(
	'role' => $role_map[$attendee->role()],
	'cutype' => $cutype_map[$attendee->cutype()],
	'status' => $part_status_map[$attendee->partStat()],
	'rsvp' => $attendee->rsvp(),
	'email' => $cr->email(),
	'name' => $cr->name(),
	);
	}
	}

	// read recurrence rule
	if (($rr = $this->obj->recurrenceRule()) && $rr->isValid()) {
	$rrule_type_map = array_flip($this->rrule_type_map);
	$object['recurrence'] = array('FREQ' => $rrule_type_map[$rr->frequency()]);

	if ($intvl = $rr->interval())
	$object['recurrence']['INTERVAL'] = $intvl;

	if (($count = $rr->count()) && $count > 0) {
	$object['recurrence']['COUNT'] = $count;
	}
	else if ($until = self::php_datetime($rr->end())) {
	$until->setTime($object['start']->format('G'), $object['start']->format('i'), 0);
	$object['recurrence']['UNTIL'] = $until;
	}

	if (($byday = $rr->byday()) && $byday->size()) {
	$weekday_map = array_flip($this->weekday_map);
	$weekdays = array();
	for ($i=0; $i < $byday->size(); $i++) {
	$daypos = $byday->get($i);
	$prefix = $daypos->occurence();
	$weekdays[] = ($prefix ? $prefix : '') . $weekday_map[$daypos->weekday()];
	}
	$object['recurrence']['BYDAY'] = join(',', $weekdays);
	}

	if (($bymday = $rr->bymonthday()) && $bymday->size()) {
	$object['recurrence']['BYMONTHDAY'] = join(',', self::vector2array($bymday));
	}

	if (($bymonth = $rr->bymonth()) && $bymonth->size()) {
	$object['recurrence']['BYMONTH'] = join(',', self::vector2array($bymonth));
	}

	if ($exdates = $this->obj->exceptionDates()) {
	for ($i=0; $i < $exdates->size(); $i++) {
	if ($exdate = self::php_datetime($exdates->get($i)))
	$object['recurrence']['EXDATE'][] = $exdate;
	}
	}
	}

	// read alarm
	$valarms = $this->obj->alarms();
	$alarm_types = array_flip($this->alarm_type_map);
	for ($i=0; $i < $valarms->size(); $i++) {
	$alarm = $valarms->get($i);
	$type = $alarm_types[$alarm->type()];

	if ($type == 'DISPLAY' \|\| $type == 'EMAIL') { // only DISPLAY and EMAIL alarms are supported
	if ($start = self::php_datetime($alarm->start())) {
	$object['alarms'] = '@' . $start->format('U');
	}
	else if ($offset = $alarm->relativeStart()) {
	$value = $alarm->relativeTo() == kolabformat::End ? '+' : '-';
	if ($w = $offset->weeks()) $value .= $w . 'W';
	else if ($d = $offset->days()) $value .= $d . 'D';
	else if ($h = $offset->hours()) $value .= $h . 'H';
	else if ($m = $offset->minutes()) $value .= $m . 'M';
	else if ($s = $offset->seconds()) $value .= $s . 'S';
	else continue;

	$object['alarms'] = $value;
	}
	$object['alarms'] .= ':' . $type;
	break;
	}
	}

	return $object;
	}


	/**
	* Set common xcal properties to the kolabformat object
	*
	* @param array Event data as hash array
	*/
	public function set(&$object)
	{
	$this->init();

	$is_new = !$this->obj->uid();

	// set common object properties
	parent::set($object);

	// increment sequence on updates
	- $object['sequence'] = !$is_new ? $this->obj->sequence()+1 : 0;
	+ if (empty($object['sequence']))
	+ $object['sequence'] = !$is_new ? $this->obj->sequence()+1 : 0;
	$this->obj->setSequence($object['sequence']);

	$this->obj->setSummary($object['title']);
	$this->obj->setLocation($object['location']);
	$this->obj->setDescription($object['description']);
	$this->obj->setPriority($object['priority']);
	$this->obj->setClassification($this->sensitivity_map[$object['sensitivity']]);
	$this->obj->setCategories(self::array2vector($object['categories']));
	$this->obj->setUrl(strval($object['url']));

	// process event attendees
	$attendees = new vectorattendee;
	foreach ((array)$object['attendees'] as $attendee) {
	if ($attendee['role'] == 'ORGANIZER') {
	$object['organizer'] = $attendee;
	}
	else if ($attendee['email'] != $object['organizer']['email']) {
	$cr = new ContactReference(ContactReference::EmailReference, $attendee['email']);
	$cr->setName($attendee['name']);

	$att = new Attendee;
	$att->setContact($cr);
	$att->setPartStat($this->part_status_map[$attendee['status']]);
	$att->setRole($this->role_map[$attendee['role']] ? $this->role_map[$attendee['role']] : kolabformat::Required);
	$att->setCutype($this->cutype_map[$attendee['cutype']] ? $this->cutype_map[$attendee['cutype']] : kolabformat::CutypeIndividual);
	$att->setRSVP((bool)$attendee['rsvp']);

	if ($att->isValid()) {
	$attendees->push($att);
	}
	else {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid event attendee: " . json_encode($attendee),
	), true);
	}
	}
	}
	$this->obj->setAttendees($attendees);

	if ($object['organizer']) {
	$organizer = new ContactReference(ContactReference::EmailReference, $object['organizer']['email']);
	$organizer->setName($object['organizer']['name']);
	$this->obj->setOrganizer($organizer);
	}

	// save recurrence rule
	$rr = new RecurrenceRule;
	$rr->setFrequency(RecurrenceRule::FreqNone);

	if ($object['recurrence']) {
	$rr->setFrequency($this->rrule_type_map[$object['recurrence']['FREQ']]);

	if ($object['recurrence']['INTERVAL'])
	$rr->setInterval(intval($object['recurrence']['INTERVAL']));

	if ($object['recurrence']['BYDAY']) {
	$byday = new vectordaypos;
	foreach (explode(',', $object['recurrence']['BYDAY']) as $day) {
	$occurrence = 0;
	if (preg_match('/^([\d-]+)([A-Z]+)$/', $day, $m)) {
	$occurrence = intval($m[1]);
	$day = $m[2];
	}
	if (isset($this->weekday_map[$day]))
	$byday->push(new DayPos($occurrence, $this->weekday_map[$day]));
	}
	$rr->setByday($byday);
	}

	if ($object['recurrence']['BYMONTHDAY']) {
	$bymday = new vectori;
	foreach (explode(',', $object['recurrence']['BYMONTHDAY']) as $day)
	$bymday->push(intval($day));
	$rr->setBymonthday($bymday);
	}

	if ($object['recurrence']['BYMONTH']) {
	$bymonth = new vectori;
	foreach (explode(',', $object['recurrence']['BYMONTH']) as $month)
	$bymonth->push(intval($month));
	$rr->setBymonth($bymonth);
	}

	if ($object['recurrence']['COUNT'])
	$rr->setCount(intval($object['recurrence']['COUNT']));
	else if ($object['recurrence']['UNTIL'])
	$rr->setEnd(self::get_datetime($object['recurrence']['UNTIL'], null, true));

	if ($rr->isValid()) {
	// add exception dates (only if recurrence rule is valid)
	$exdates = new vectordatetime;
	foreach ((array)$object['recurrence']['EXDATE'] as $exdate)
	$exdates->push(self::get_datetime($exdate, null, true));
	$this->obj->setExceptionDates($exdates);
	}
	else {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid event recurrence rule: " . json_encode($object['recurrence']),
	), true);
	}
	}

	$this->obj->setRecurrenceRule($rr);

	// save alarm
	$valarms = new vectoralarm;
	if ($object['alarms']) {
	list($offset, $type) = explode(":", $object['alarms']);

	if ($type == 'EMAIL') { // email alarms implicitly go to event owner
	$recipients = new vectorcontactref;
	$recipients->push(new ContactReference(ContactReference::EmailReference, $object['_owner']));
	$alarm = new Alarm($object['title'], strval($object['description']), $recipients);
	}
	else { // default: display alarm
	$alarm = new Alarm($object['title']);
	}

	if (preg_match('/^@(\d+)/', $offset, $d)) {
	$alarm->setStart(self::get_datetime($d[1], new DateTimeZone('UTC')));
	}
	else if (preg_match('/^([-+]?)(\d+)([SMHDW])/', $offset, $d)) {
	$days = $hours = $minutes = $seconds = 0;
	switch ($d[3]) {
	case 'W': $days = 7*intval($d[2]); break;
	case 'D': $days = intval($d[2]); break;
	case 'H': $hours = intval($d[2]); break;
	case 'M': $minutes = intval($d[2]); break;
	case 'S': $seconds = intval($d[2]); break;
	}
	$alarm->setRelativeStart(new Duration($days, $hours, $minutes, $seconds, $d[1] == '-'), $d[1] == '-' ? kolabformat::Start : kolabformat::End);
	}

	$valarms->push($alarm);
	}
	$this->obj->setAlarms($valarms);
	}

	/**
	* Callback for kolab_storage_cache to get words to index for fulltext search
	*
	* @return array List of words to save in cache
	*/
	public function get_words()
	{
	$data = '';
	foreach (self::$fulltext_cols as $colname) {
	list($col, $field) = explode(':', $colname);

	if ($field) {
	$a = array();
	foreach ((array)$this->data[$col] as $attr)
	$a[] = $attr[$field];
	$val = join(' ', $a);
	}
	else {
	$val = is_array($this->data[$col]) ? join(' ', $this->data[$col]) : $this->data[$col];
	}

	if (strlen($val))
	$data .= $val . ' ';
	}

	return array_unique(rcube_utils::normalize_string($data, true));
	}

	}
	\ No newline at end of file

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jun 9, 7:04 AM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 196774
Default Alt Text: (90 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions