No OneTemporary
Actions

Size

172 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/plugins/calendar/calendar.php b/plugins/calendar/calendar.php
	index e7ecd2ec..35df4684 100644
	--- a/plugins/calendar/calendar.php
	+++ b/plugins/calendar/calendar.php
	@@ -1,2477 +1,2478 @@
	<?php

	/**
	* Calendar plugin for Roundcube webmail
	*
	* @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) 2011, 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 calendar extends rcube_plugin
	{
	const FREEBUSY_UNKNOWN = 0;
	const FREEBUSY_FREE = 1;
	const FREEBUSY_BUSY = 2;
	const FREEBUSY_TENTATIVE = 3;
	const FREEBUSY_OOF = 4;

	public $task = '?(?!logout).*';
	public $rc;
	public $driver;
	public $home; // declare public to be used in other classes
	public $urlbase;
	public $timezone;
	public $timezone_offset;
	public $gmt_offset;

	public $ical;
	public $ui;

	public $defaults = array(
	'calendar_default_view' => "agendaWeek",
	'calendar_date_format' => "yyyy-MM-dd",
	'calendar_date_short' => "M-d",
	'calendar_date_long' => "MMM d yyyy",
	'calendar_date_agenda' => "ddd MM-dd",
	'calendar_time_format' => "HH:mm",
	'calendar_timeslots' => 2,
	'calendar_first_day' => 1,
	'calendar_first_hour' => 6,
	'calendar_work_start' => 6,
	'calendar_work_end' => 18,
	'calendar_agenda_range' => 60,
	'calendar_agenda_sections' => 'smart',
	'calendar_event_coloring' => 0,
	'calendar_time_indicator' => true,
	'calendar_date_format_sets' => array(
	'yyyy-MM-dd' => array('MMM d yyyy', 'M-d', 'ddd MM-dd'),
	'dd-MM-yyyy' => array('d MMM yyyy', 'd-M', 'ddd dd-MM'),
	'yyyy/MM/dd' => array('MMM d yyyy', 'M/d', 'ddd MM/dd'),
	'MM/dd/yyyy' => array('MMM d yyyy', 'M/d', 'ddd MM/dd'),
	'dd/MM/yyyy' => array('d MMM yyyy', 'd/M', 'ddd dd/MM'),
	'dd.MM.yyyy' => array('dd. MMM yyyy', 'd.M', 'ddd dd.MM.'),
	'd.M.yyyy' => array('d. MMM yyyy', 'd.M', 'ddd d.MM.'),
	),
	);

	private $default_categories = array(
	'Personal' => 'c0c0c0',
	'Work' => 'ff0000',
	'Family' => '00ff00',
	'Holiday' => 'ff6600',
	);

	private $ics_parts = array();


	/**
	* Plugin initialization.
	*/
	function init()
	{
	$this->rc = rcmail::get_instance();

	$this->register_task('calendar', 'calendar');

	// load calendar configuration
	$this->load_config();

	// load localizations
	$this->add_texts('localization/', $this->rc->task == 'calendar' && (!$this->rc->action \|\| $this->rc->action == 'print'));

	// set user's timezone
	$this->timezone = new DateTimeZone($this->rc->config->get('timezone', 'GMT'));
	$now = new DateTime('now', $this->timezone);
	$this->gmt_offset = $now->getOffset();
	$this->dst_active = $now->format('I');
	$this->timezone_offset = $this->gmt_offset / 3600 - $this->dst_active;

	require($this->home . '/lib/calendar_ui.php');
	$this->ui = new calendar_ui($this);

	// load Calendar user interface which includes jquery-ui
	if (!$this->rc->output->ajax_call && !$this->rc->output->env['framed']) {
	$this->require_plugin('jqueryui');

	$this->ui->init();

	// settings are required in (almost) every GUI step
	if ($this->rc->action != 'attend')
	$this->rc->output->set_env('calendar_settings', $this->load_settings());
	}

	// catch iTIP confirmation requests that don're require a valid session
	if ($this->rc->action == 'attend' && !empty($_REQUEST['_t'])) {
	$this->add_hook('startup', array($this, 'itip_attend_response'));
	}
	else if ($this->rc->action == 'feed' && !empty($_REQUEST['_cal'])) {
	$this->add_hook('startup', array($this, 'ical_feed_export'));
	}
	else if ($this->rc->task == 'calendar' && $this->rc->action != 'save-pref') {
	if ($this->rc->action != 'upload') {
	$this->load_driver();
	}

	// register calendar actions
	$this->register_action('index', array($this, 'calendar_view'));
	$this->register_action('event', array($this, 'event_action'));
	$this->register_action('calendar', array($this, 'calendar_action'));
	$this->register_action('load_events', array($this, 'load_events'));
	$this->register_action('export_events', array($this, 'export_events'));
	$this->register_action('import_events', array($this, 'import_events'));
	$this->register_action('upload', array($this, 'attachment_upload'));
	$this->register_action('get-attachment', array($this, 'attachment_get'));
	$this->register_action('freebusy-status', array($this, 'freebusy_status'));
	$this->register_action('freebusy-times', array($this, 'freebusy_times'));
	$this->register_action('randomdata', array($this, 'generate_randomdata'));
	$this->register_action('print', array($this,'print_view'));
	$this->register_action('mailimportevent', array($this, 'mail_import_event'));
	$this->register_action('mailtoevent', array($this, 'mail_message2event'));
	$this->register_action('inlineui', array($this, 'get_inline_ui'));
	$this->register_action('check-recent', array($this, 'check_recent'));

	// remove undo information...
	if ($undo = $_SESSION['calendar_event_undo']) {
	// ...after timeout
	$undo_time = $this->rc->config->get('undo_timeout', 0);
	if ($undo['ts'] < time() - $undo_time) {
	$this->rc->session->remove('calendar_event_undo');
	// @TODO: do EXPUNGE on kolab objects?
	}
	}
	}
	else if ($this->rc->task == 'settings') {
	// add hooks for Calendar settings
	$this->add_hook('preferences_sections_list', array($this, 'preferences_sections_list'));
	$this->add_hook('preferences_list', array($this, 'preferences_list'));
	$this->add_hook('preferences_save', array($this, 'preferences_save'));
	}
	else if ($this->rc->task == 'mail') {
	// hooks to catch event invitations on incoming mails
	if ($this->rc->action == 'show' \|\| $this->rc->action == 'preview') {
	$this->add_hook('message_load', array($this, 'mail_message_load'));
	$this->add_hook('template_object_messagebody', array($this, 'mail_messagebody_html'));
	}

	// add 'Create event' item to message menu
	if ($this->api->output->type == 'html') {
	$this->api->add_content(html::tag('li', null,
	$this->api->output->button(array(
	'command' => 'calendar-create-from-mail',
	'label' => 'calendar.createfrommail',
	'type' => 'link',
	'classact' => 'icon calendarlink active',
	'class' => 'icon calendarlink',
	'innerclass' => 'icon calendar',
	))),
	'messagemenu');
	}
	}

	// add hook to display alarms
	$this->add_hook('keep_alive', array($this, 'keep_alive'));
	}

	/**
	* Helper method to load the backend driver according to local config
	*/
	private function load_driver()
	{
	if (is_object($this->driver))
	return;

	$driver_name = $this->rc->config->get('calendar_driver', 'database');
	$driver_class = $driver_name . '_driver';

	require_once($this->home . '/drivers/calendar_driver.php');
	require_once($this->home . '/drivers/' . $driver_name . '/' . $driver_class . '.php');

	switch ($driver_name) {
	case "kolab":
	$this->require_plugin('libkolab');
	default:
	$this->driver = new $driver_class($this);
	break;
	}
	}

	/**
	* Load iTIP functions
	*/
	private function load_itip()
	{
	if (!$this->itip) {
	require_once($this->home . '/lib/calendar_itip.php');
	$this->itip = new calendar_itip($this);
	}

	return $this->itip;
	}

	/**
	* Load iCalendar functions
	*/
	public function get_ical()
	{
	if (!$this->ical) {
	require_once($this->home . '/lib/calendar_ical.php');
	$this->ical = new calendar_ical($this);
	}

	return $this->ical;
	}

	/**
	*
	*/
	public function get_default_calendar($writeable = false)
	{
	$cal_id = $this->rc->config->get('calendar_default_calendar');
	$calendars = $this->driver->list_calendars();
	$calendar = $calendars[$cal_id] ? $calendars[$cal_id] : null;
	if (!$calendar \|\| ($writeable && $calendar['readonly'])) {
	foreach ($calendars as $cal) {
	if (!$writeable \|\| !$cal['readonly']) {
	$calendar = $cal;
	break;
	}
	}
	}

	return $calendar;
	}


	/**
	* Render the main calendar view from skin template
	*/
	function calendar_view()
	{
	$this->rc->output->set_pagetitle($this->gettext('calendar'));

	// Add CSS stylesheets to the page header
	$this->ui->addCSS();

	// Add JS files to the page header
	$this->ui->addJS();

	$this->ui->init_templates();
	$this->rc->output->add_label('lowest','low','normal','high','highest','delete','cancel','uploading','noemailwarning');

	// initialize attendees autocompletion
	rcube_autocomplete_init();

	$this->rc->output->set_env('calendar_driver', $this->rc->config->get('calendar_driver'), false);
	$this->rc->output->set_env('mscolors', $this->driver->get_color_values());

	$view = get_input_value('view', RCUBE_INPUT_GPC);
	if (in_array($view, array('agendaWeek', 'agendaDay', 'month', 'table')))
	$this->rc->output->set_env('view', $view);

	if ($date = get_input_value('date', RCUBE_INPUT_GPC))
	$this->rc->output->set_env('date', $date);

	$this->rc->output->send("calendar.calendar");
	}

	/**
	* Handler for preferences_sections_list hook.
	* Adds Calendar settings sections into preferences sections list.
	*
	* @param array Original parameters
	* @return array Modified parameters
	*/
	function preferences_sections_list($p)
	{
	$p['list']['calendar'] = array(
	'id' => 'calendar', 'section' => $this->gettext('calendar'),
	);

	return $p;
	}

	/**
	* Handler for preferences_list hook.
	* Adds options blocks into Calendar settings sections in Preferences.
	*
	* @param array Original parameters
	* @return array Modified parameters
	*/
	function preferences_list($p)
	{
	if ($p['section'] == 'calendar') {
	$this->load_driver();

	$p['blocks']['view']['name'] = $this->gettext('mainoptions');

	$field_id = 'rcmfd_default_view';
	$select = new html_select(array('name' => '_default_view', 'id' => $field_id));
	$select->add($this->gettext('day'), "agendaDay");
	$select->add($this->gettext('week'), "agendaWeek");
	$select->add($this->gettext('month'), "month");
	$select->add($this->gettext('agenda'), "table");
	$p['blocks']['view']['options']['default_view'] = array(
	'title' => html::label($field_id, Q($this->gettext('default_view'))),
	'content' => $select->show($this->rc->config->get('calendar_default_view', $this->defaults['calendar_default_view'])),
	);

	$field_id = 'rcmfd_timeslot';
	$choices = array('1', '2', '3', '4', '6');
	$select = new html_select(array('name' => '_timeslots', 'id' => $field_id));
	$select->add($choices);
	$p['blocks']['view']['options']['timeslots'] = array(
	'title' => html::label($field_id, Q($this->gettext('timeslots'))),
	'content' => $select->show($this->rc->config->get('calendar_timeslots', $this->defaults['calendar_timeslots'])),
	);

	$field_id = 'rcmfd_firstday';
	$select = new html_select(array('name' => '_first_day', 'id' => $field_id));
	$select->add(rcube_label('sunday'), '0');
	$select->add(rcube_label('monday'), '1');
	$select->add(rcube_label('tuesday'), '2');
	$select->add(rcube_label('wednesday'), '3');
	$select->add(rcube_label('thursday'), '4');
	$select->add(rcube_label('friday'), '5');
	$select->add(rcube_label('saturday'), '6');
	$p['blocks']['view']['options']['first_day'] = array(
	'title' => html::label($field_id, Q($this->gettext('first_day'))),
	'content' => $select->show($this->rc->config->get('calendar_first_day', $this->defaults['calendar_first_day'])),
	);

	$time_format = $this->rc->config->get('time_format', self::to_php_date_format($this->rc->config->get('calendar_time_format', $this->defaults['calendar_time_format'])));
	$select_hours = new html_select();
	for ($h = 0; $h < 24; $h++)
	$select_hours->add(date($time_format, mktime($h, 0, 0)), $h);

	$field_id = 'rcmfd_firsthour';
	$p['blocks']['view']['options']['first_hour'] = array(
	'title' => html::label($field_id, Q($this->gettext('first_hour'))),
	'content' => $select_hours->show($this->rc->config->get('calendar_first_hour', $this->defaults['calendar_first_hour']), array('name' => '_first_hour', 'id' => $field_id)),
	);

	$field_id = 'rcmfd_workstart';
	$p['blocks']['view']['options']['workinghours'] = array(
	'title' => html::label($field_id, Q($this->gettext('workinghours'))),
	'content' => $select_hours->show($this->rc->config->get('calendar_work_start', $this->defaults['calendar_work_start']), array('name' => '_work_start', 'id' => $field_id)) .
	' — ' . $select_hours->show($this->rc->config->get('calendar_work_end', $this->defaults['calendar_work_end']), array('name' => '_work_end', 'id' => $field_id)),
	);

	$field_id = 'rcmfd_coloing';
	$select_colors = new html_select(array('name' => '_event_coloring', 'id' => $field_id));
	$select_colors->add($this->gettext('coloringmode0'), 0);
	$select_colors->add($this->gettext('coloringmode1'), 1);
	$select_colors->add($this->gettext('coloringmode2'), 2);
	$select_colors->add($this->gettext('coloringmode3'), 3);

	$p['blocks']['view']['options']['eventcolors'] = array(
	'title' => html::label($field_id . 'value', Q($this->gettext('eventcoloring'))),
	'content' => $select_colors->show($this->rc->config->get('calendar_event_coloring', $this->defaults['calendar_event_coloring'])),
	);

	$field_id = 'rcmfd_alarm';
	$select_type = new html_select(array('name' => '_alarm_type', 'id' => $field_id));
	$select_type->add($this->gettext('none'), '');
	foreach ($this->driver->alarm_types as $type)
	$select_type->add($this->gettext(strtolower("alarm{$type}option")), $type);

	$input_value = new html_inputfield(array('name' => '_alarm_value', 'id' => $field_id . 'value', 'size' => 3));
	$select_offset = new html_select(array('name' => '_alarm_offset', 'id' => $field_id . 'offset'));
	foreach (array('-M','-H','-D','+M','+H','+D') as $trigger)
	$select_offset->add($this->gettext('trigger' . $trigger), $trigger);

	$p['blocks']['view']['options']['alarmtype'] = array(
	'title' => html::label($field_id, Q($this->gettext('defaultalarmtype'))),
	'content' => $select_type->show($this->rc->config->get('calendar_default_alarm_type', '')),
	);
	$preset = self::parse_alaram_value($this->rc->config->get('calendar_default_alarm_offset', '-15M'));
	$p['blocks']['view']['options']['alarmoffset'] = array(
	'title' => html::label($field_id . 'value', Q($this->gettext('defaultalarmoffset'))),
	'content' => $input_value->show($preset[0]) . ' ' . $select_offset->show($preset[1]),
	);

	// default calendar selection
	$field_id = 'rcmfd_default_calendar';
	$select_cal = new html_select(array('name' => '_default_calendar', 'id' => $field_id));
	foreach ((array)$this->driver->list_calendars() as $id => $prop) {
	if (!$prop['readonly'])
	$select_cal->add($prop['name'], strval($id));
	}
	$p['blocks']['view']['options']['defaultcalendar'] = array(
	'title' => html::label($field_id . 'value', Q($this->gettext('defaultcalendar'))),
	'content' => $select_cal->show($this->rc->config->get('calendar_default_calendar', '')),
	);


	// category definitions
	if (!$this->driver->nocategories) {
	$p['blocks']['categories']['name'] = $this->gettext('categories');

	$categories = (array) $this->driver->list_categories();
	$categories_list = '';
	foreach ($categories as $name => $color) {
	$key = md5($name);
	$field_class = 'rcmfd_category_' . str_replace(' ', '_', $name);
	$category_remove = new html_inputfield(array('type' => 'button', 'value' => 'X', 'class' => 'button', 'onclick' => '$(this).parent().remove()', 'title' => $this->gettext('remove_category')));
	$category_name = new html_inputfield(array('name' => "_categories[$key]", 'class' => $field_class, 'size' => 30, 'disabled' => $this->driver->categoriesimmutable));
	$category_color = new html_inputfield(array('name' => "_colors[$key]", 'class' => "$field_class colors", 'size' => 6));
	$hidden = $this->driver->categoriesimmutable ? html::tag('input', array('type' => 'hidden', 'name' => "_categories[$key]", 'value' => $name)) : '';
	$categories_list .= html::div(null, $hidden . $category_name->show($name) . ' ' . $category_color->show($color) . ' ' . $category_remove->show());
	}

	$p['blocks']['categories']['options']['category_' . $name] = array(
	'content' => html::div(array('id' => 'calendarcategories'), $categories_list),
	);

	$field_id = 'rcmfd_new_category';
	$new_category = new html_inputfield(array('name' => '_new_category', 'id' => $field_id, 'size' => 30));
	$add_category = new html_inputfield(array('type' => 'button', 'class' => 'button', 'value' => $this->gettext('add_category'), 'onclick' => "rcube_calendar_add_category()"));
	$p['blocks']['categories']['options']['categories'] = array(
	'content' => $new_category->show('') . ' ' . $add_category->show(),
	);

	$this->rc->output->add_script('function rcube_calendar_add_category(){
	var name = $("#rcmfd_new_category").val();
	if (name.length) {
	var input = $("<input>").attr("type", "text").attr("name", "_categories[]").attr("size", 30).val(name);
	var color = $("<input>").attr("type", "text").attr("name", "_colors[]").attr("size", 6).addClass("colors").val("000000");
	var button = $("<input>").attr("type", "button").attr("value", "X").addClass("button").click(function(){ $(this).parent().remove() });
	$("<div>").append(input).append(" ").append(color).append(" ").append(button).appendTo("#calendarcategories");
	color.miniColors({ colorValues:mscolors });
	}
	}');

	// include color picker
	$this->include_script('lib/js/jquery.miniColors.min.js');
	$this->include_stylesheet('skins/' .$this->rc->config->get('skin') . '/jquery.miniColors.css');
	$this->rc->output->set_env('mscolors', $this->driver->get_color_values());
	$this->rc->output->add_script('$("input.colors").miniColors({ colorValues:rcmail.env.mscolors })', 'docready');
	}
	}

	return $p;
	}

	/**
	* Handler for preferences_save hook.
	* Executed on Calendar settings form submit.
	*
	* @param array Original parameters
	* @return array Modified parameters
	*/
	function preferences_save($p)
	{
	if ($p['section'] == 'calendar') {
	$this->load_driver();

	// compose default alarm preset value
	$alarm_offset = get_input_value('_alarm_offset', RCUBE_INPUT_POST);
	$default_alam = $alarm_offset[0] . intval(get_input_value('_alarm_value', RCUBE_INPUT_POST)) . $alarm_offset[1];

	$p['prefs'] = array(
	'calendar_default_view' => get_input_value('_default_view', RCUBE_INPUT_POST),
	'calendar_timeslots' => get_input_value('_timeslots', RCUBE_INPUT_POST),
	'calendar_first_day' => get_input_value('_first_day', RCUBE_INPUT_POST),
	'calendar_first_hour' => intval(get_input_value('_first_hour', RCUBE_INPUT_POST)),
	'calendar_work_start' => intval(get_input_value('_work_start', RCUBE_INPUT_POST)),
	'calendar_work_end' => intval(get_input_value('_work_end', RCUBE_INPUT_POST)),
	'calendar_event_coloring' => intval(get_input_value('_event_coloring', RCUBE_INPUT_POST)),
	'calendar_default_alarm_type' => get_input_value('_alarm_type', RCUBE_INPUT_POST),
	'calendar_default_alarm_offset' => $default_alam,
	'calendar_default_calendar' => get_input_value('_default_calendar', RCUBE_INPUT_POST),
	'calendar_date_format' => null, // clear previously saved values
	'calendar_time_format' => null,
	);

	// categories
	if (!$this->driver->nocategories) {
	$old_categories = $new_categories = array();
	foreach ($this->driver->list_categories() as $name => $color) {
	$old_categories[md5($name)] = $name;
	}
	$categories = get_input_value('_categories', RCUBE_INPUT_POST);
	$colors = get_input_value('_colors', RCUBE_INPUT_POST);
	foreach ($categories as $key => $name) {
	$color = preg_replace('/^#/', '', strval($colors[$key]));

	// rename categories in existing events -> driver's job
	if ($oldname = $old_categories[$key]) {
	$this->driver->replace_category($oldname, $name, $color);
	unset($old_categories[$key]);
	}
	else
	$this->driver->add_category($name, $color);

	$new_categories[$name] = $color;
	}

	// these old categories have been removed, alter events accordingly -> driver's job
	foreach ((array)$old_categories[$key] as $key => $name) {
	$this->driver->remove_category($name);
	}

	$p['prefs']['calendar_categories'] = $new_categories;
	}
	}

	return $p;
	}

	/**
	* Dispatcher for calendar actions initiated by the client
	*/
	function calendar_action()
	{
	$action = get_input_value('action', RCUBE_INPUT_GPC);
	$cal = get_input_value('c', RCUBE_INPUT_GPC);
	$success = $reload = false;

	if (isset($cal['showalarms']))
	$cal['showalarms'] = intval($cal['showalarms']);

	switch ($action) {
	case "form-new":
	case "form-edit":
	echo $this->ui->calendar_editform($action, $cal);
	exit;
	case "new":
	$success = $this->driver->create_calendar($cal);
	$reload = true;
	break;
	case "edit":
	$success = $this->driver->edit_calendar($cal);
	$reload = true;
	break;
	case "remove":
	if ($success = $this->driver->remove_calendar($cal))
	$this->rc->output->command('plugin.destroy_source', array('id' => $cal['id']));
	break;
	case "subscribe":
	if (!$this->driver->subscribe_calendar($cal))
	$this->rc->output->show_message($this->gettext('errorsaving'), 'error');
	return;
	}

	if ($success)
	$this->rc->output->show_message('successfullysaved', 'confirmation');
	else {
	$error_msg = $this->gettext('errorsaving') . ($this->driver->last_error ? ': ' . $this->driver->last_error :'');
	$this->rc->output->show_message($error_msg, 'error');
	}

	$this->rc->output->command('plugin.unlock_saving');

	// TODO: keep view and date selection
	if ($success && $reload)
	$this->rc->output->redirect('');
	}


	/**
	* Dispatcher for event actions initiated by the client
	*/
	function event_action()
	{
	$action = get_input_value('action', RCUBE_INPUT_GPC);
	$event = get_input_value('e', RCUBE_INPUT_POST, true);
	$success = $reload = $got_msg = false;

	// don't notify if modifying a recurring instance (really?)
	if ($event['_savemode'] && $event['_savemode'] != 'all' && $event['_notify'])
	unset($event['_notify']);

	// read old event data in order to find changes
	if (($event['_notify'] \|\| $event['decline']) && $action != 'new')
	$old = $this->driver->get_event($event);

	switch ($action) {
	case "new":
	// create UID for new event
	$event['uid'] = $this->generate_uid();
	$this->prepare_event($event, $action);
	if ($success = $this->driver->new_event($event)) {
	$event['id'] = $event['uid'];
	$this->cleanup_event($event);
	}
	$reload = $success && $event['recurrence'] ? 2 : 1;
	break;

	case "edit":
	$this->prepare_event($event, $action);
	if ($success = $this->driver->edit_event($event))
	$this->cleanup_event($event);
	$reload = $success && ($event['recurrence'] \|\| $event['_savemode'] \|\| $event['_fromcalendar']) ? 2 : 1;
	break;

	case "resize":
	$this->prepare_event($event, $action);
	$success = $this->driver->resize_event($event);
	$reload = $event['_savemode'] ? 2 : 1;
	break;

	case "move":
	$this->prepare_event($event, $action);
	$success = $this->driver->move_event($event);
	$reload = $success && $event['_savemode'] ? 2 : 1;
	break;

	case "remove":
	// remove previous deletes
	$undo_time = $this->driver->undelete ? $this->rc->config->get('undo_timeout', 0) : 0;
	$this->rc->session->remove('calendar_event_undo');

	// search for event if only UID is given
	if (!isset($event['calendar']) && $event['uid']) {
	if (!($event = $this->driver->get_event($event, true))) {
	break;
	}
	$undo_time = 0;
	}

	$success = $this->driver->remove_event($event, $undo_time < 1);
	$reload = (!$success \|\| $event['_savemode']) ? 2 : 1;

	if ($undo_time > 0 && $success) {
	$_SESSION['calendar_event_undo'] = array('ts' => time(), 'data' => $event);
	// display message with Undo link.
	$msg = html::span(null, $this->gettext('successremoval'))
	. ' ' . html::a(array('onclick' => sprintf("%s.http_request('event', 'action=undo', %s.display_message('', 'loading'))",
	JS_OBJECT_NAME, JS_OBJECT_NAME)), rcube_label('undo'));
	$this->rc->output->show_message($msg, 'confirmation', null, true, $undo_time);
	$got_msg = true;
	}
	else if ($success) {
	$this->rc->output->show_message('calendar.successremoval', 'confirmation');
	$got_msg = true;
	}

	// send iTIP reply that participant has declined the event
	if ($success && $event['decline']) {
	$emails = $this->get_user_emails();
	foreach ($old['attendees'] as $i => $attendee) {
	if ($attendee['role'] == 'ORGANIZER')
	$organizer = $attendee;
	else if ($attendee['email'] && in_array($attendee['email'], $emails)) {
	$old['attendees'][$i]['status'] = 'DECLINED';
	}
	}

	$itip = $this->load_itip();
	if ($organizer && $itip->send_itip_message($old, 'REPLY', $organizer, 'itipsubjectdeclined', 'itipmailbodydeclined'))
	$this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $organizer['name'] ? $organizer['name'] : $organizer['email']))), 'confirmation');
	else
	$this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
	}
	break;

	case "undo":
	// Restore deleted event
	$event = $_SESSION['calendar_event_undo']['data'];

	if ($event)
	$success = $this->driver->restore_event($event);

	if ($success) {
	$this->rc->session->remove('calendar_event_undo');
	$this->rc->output->show_message('calendar.successrestore', 'confirmation');
	$got_msg = true;
	$reload = 2;
	}

	break;

	case "rsvp-status":
	$action = 'rsvp';
	$status = $event['fallback'];
	$html = html::div('rsvp-status', $status != 'CANCELLED' ? $this->gettext('acceptinvitation') : '');
	$this->load_driver();
	if ($existing = $this->driver->get_event($event, true)) {
	$emails = $this->get_user_emails();
	foreach ($existing['attendees'] as $i => $attendee) {
	if ($attendee['email'] && in_array($attendee['email'], $emails)) {
	$status = $attendee['status'];
	break;
	}
	}
	}
	else {
	// get a list of writeable calendars
	$calendars = $this->driver->list_calendars();
	$calendar_select = new html_select(array('name' => 'calendar', 'id' => 'calendar-saveto'));
	$numcals = 0;
	foreach ($calendars as $calendar) {
	if (!$calendar['readonly']) {
	$calendar_select->add($calendar['name'], $calendar['id']);
	$numcals++;
	}
	}
	if ($numcals <= 1)
	$calendar_select = null;
	}

	if ($status == 'unknown') {
	$html = html::div('rsvp-status', $this->gettext('notanattendee'));
	$action = 'import';
	}
	else if (in_array($status, array('ACCEPTED','TENTATIVE','DECLINED'))) {
	$html = html::div('rsvp-status ' . strtolower($status), $this->gettext('youhave'.strtolower($status)));
	if ($existing['changed'] && $event['changed'] < $existing['changed']) {
	$action = '';
	}
	}

	$this->rc->output->command('plugin.update_event_rsvp_status', array(
	'uid' => $event['uid'],
	'id' => asciiwords($event['uid'], true),
	'status' => $status,
	'action' => $action,
	'html' => $html,
	'select' => $calendar_select ? html::span('calendar-select', $this->gettext('saveincalendar') . ' ' . $calendar_select->show($this->rc->config->get('calendar_default_calendar'))) : '',
	));
	return;

	case "rsvp":
	$ev = $this->driver->get_event($event);
	$ev['attendees'] = $event['attendees'];
	$event = $ev;

	if ($success = $this->driver->edit_event($event)) {
	$status = get_input_value('status', RCUBE_INPUT_GPC);
	$organizer = null;
	foreach ($event['attendees'] as $i => $attendee) {
	if ($attendee['role'] == 'ORGANIZER') {
	$organizer = $attendee;
	break;
	}
	}
	$itip = $this->load_itip();
	if ($organizer && $itip->send_itip_message($event, 'REPLY', $organizer, 'itipsubject' . $status, 'itipmailbody' . $status))
	$this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $organizer['name'] ? $organizer['name'] : $organizer['email']))), 'confirmation');
	else
	$this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
	}
	break;

	case "dismiss":
	foreach (explode(',', $event['id']) as $id)
	$success \|= $this->driver->dismiss_alarm($id, $event['snooze']);
	break;
	}

	// send out notifications
	if ($success && $event['_notify'] && ($event['attendees'] \|\| $old['attendees'])) {
	// make sure we have the complete record
	$event = $action == 'remove' ? $old : $this->driver->get_event($event);

	// only notify if data really changed (TODO: do diff check on client already)
	if (!$old \|\| $action == 'remove' \|\| self::event_diff($event, $old)) {
	if ($this->notify_attendees($event, $old, $action) < 0)
	$this->rc->output->show_message('calendar.errornotifying', 'error');
	}
	}

	// show confirmation/error message
	if (!$got_msg) {
	if ($success)
	$this->rc->output->show_message('successfullysaved', 'confirmation');
	else
	$this->rc->output->show_message('calendar.errorsaving', 'error');
	}

	// unlock client
	$this->rc->output->command('plugin.unlock_saving');

	// update event object on the client or trigger a complete refretch if too complicated
	if ($reload) {
	$args = array('source' => $event['calendar']);
	if ($reload > 1)
	$args['refetch'] = true;
	else if ($success && $action != 'remove')
	$args['update'] = $this->_client_event($this->driver->get_event($event));
	$this->rc->output->command('plugin.refresh_calendar', $args);
	}
	}

	/**
	* Handler for load-requests from fullcalendar
	* This will return pure JSON formatted output
	*/
	function load_events()
	{
	$events = $this->driver->load_events(
	get_input_value('start', RCUBE_INPUT_GET),
	get_input_value('end', RCUBE_INPUT_GET),
	($query = get_input_value('q', RCUBE_INPUT_GET)),
	get_input_value('source', RCUBE_INPUT_GET)
	);
	echo $this->encode($events, !empty($query));
	exit;
	}

	/**
	* Handler for keep-alive requests
	* This will check for pending notifications and pass them to the client
	*/
	function keep_alive($attr)
	{
	$this->load_driver();
	$alarms = $this->driver->pending_alarms(time());
	if ($alarms) {
	// make sure texts and env vars are available on client
	if ($this->rc->task != 'calendar') {
	$this->add_texts('localization/', true);
	$this->rc->output->set_env('snooze_select', $this->ui->snooze_select());
	}
	$this->rc->output->command('plugin.display_alarms', $this->_alarms_output($alarms));
	}
	}

	/**
	* Handler for check-recent requests which are accidentally sent to calendar taks
	*/
	function check_recent()
	{
	// NOP
	$this->rc->output->send();
	}

	/**
	*
	*/
	function import_events()
	{
	// Upload progress update
	if (!empty($_GET['_progress'])) {
	rcube_upload_progress();
	}

	$calendar = get_input_value('calendar', RCUBE_INPUT_GPC);
	$uploadid = get_input_value('_uploadid', RCUBE_INPUT_GPC);

	// process uploaded file if there is no error
	$err = $_FILES['_data']['error'];

	if (!$err && $_FILES['_data']['tmp_name']) {
	$calendar = get_input_value('calendar', RCUBE_INPUT_GPC);
	$events = $this->get_ical()->import_from_file($_FILES['_data']['tmp_name']);

	$count = $errors = 0;
	$rangestart = $_REQUEST['_range'] ? strtotime("now -" . intval($_REQUEST['_range']) . " months") : 0;
	foreach ($events as $event) {
	// TODO: correctly handle recurring events which start before $rangestart
	if ($event['end'] < $rangestart && (!$event['recurrence'] \|\| ($event['recurrence']['until'] && $event['recurrence']['until'] < $rangestart)))
	continue;

	$event['calendar'] = $calendar;
	if ($success = $this->driver->new_event($event)) {
	$count++;
	}
	else
	$errors++;
	}

	if ($count) {
	$this->rc->output->command('display_message', $this->gettext(array('name' => 'importsuccess', 'vars' => array('nr' => $count))), 'confirmation');
	$this->rc->output->command('plugin.import_success', array('source' => $calendar, 'refetch' => true));
	}
	else if (!$errors) {
	$this->rc->output->command('display_message', $this->gettext('importnone'), 'notice');
	$this->rc->output->command('plugin.import_success', array('source' => $calendar));
	}
	else
	$this->rc->output->command('display_message', $this->gettext('importerror'), 'error');
	}
	else {
	if ($err == UPLOAD_ERR_INI_SIZE \|\| $err == UPLOAD_ERR_FORM_SIZE) {
	$msg = rcube_label(array('name' => 'filesizeerror', 'vars' => array(
	'size' => show_bytes(parse_bytes(ini_get('upload_max_filesize'))))));
	}
	else {
	$msg = rcube_label('fileuploaderror');
	}

	$this->rc->output->command('display_message', $msg, 'error');
	$this->rc->output->command('plugin.unlock_saving', false);
	}

	$this->rc->output->send('iframe');
	}

	/**
	* Construct the ics file for exporting events to iCalendar format;
	*/
	function export_events($terminate = true)
	{
	$start = get_input_value('start', RCUBE_INPUT_GET);
	$end = get_input_value('end', RCUBE_INPUT_GET);
	if (!$start) $start = mktime(0, 0, 0, 1, date('n'), date('Y')-1);
	if (!$end) $end = mktime(0, 0, 0, 31, 12, date('Y')+10);
	$calid = $calname = get_input_value('source', RCUBE_INPUT_GET);
	$calendars = $this->driver->list_calendars();

	if ($calendars[$calid]) {
	$calname = $calendars[$calid]['name'] ? $calendars[$calid]['name'] : $calid;
	$events = $this->driver->load_events($start, $end, null, $calid, 0);
	}
	else
	$events = array();

	header("Content-Type: text/calendar");
	header("Content-Disposition: inline; filename=".$calname.'.ics');

	$this->get_ical()->export($events, '', true);

	if ($terminate)
	exit;
	}


	/**
	* Handler for iCal feed requests
	*/
	function ical_feed_export()
	{
	// process HTTP auth info
	if (!empty($_SERVER['PHP_AUTH_USER']) && isset($_SERVER['PHP_AUTH_PW'])) {
	$_POST['_user'] = $_SERVER['PHP_AUTH_USER']; // used for rcmail::autoselect_host()
	$auth = $this->rc->plugins->exec_hook('authenticate', array(
	'host' => $this->rc->autoselect_host(),
	'user' => trim($_SERVER['PHP_AUTH_USER']),
	'pass' => $_SERVER['PHP_AUTH_PW'],
	'cookiecheck' => true,
	'valid' => true,
	));
	if ($auth['valid'] && !$auth['abort'])
	$this->rc->login($auth['user'], $auth['pass'], $auth['host']);
	}

	// require HTTP auth
	if (empty($_SESSION['user_id'])) {
	header('WWW-Authenticate: Basic realm="Roundcube Calendar"');
	header('HTTP/1.0 401 Unauthorized');
	exit;
	}

	// decode calendar feed hash
	$format = 'ics';
	$calhash = get_input_value('_cal', RCUBE_INPUT_GET);
	if (preg_match(($suff_regex = '/\.([a-z0-9]{3,5})$/i'), $calhash, $m)) {
	$format = strtolower($m[1]);
	$calhash = preg_replace($suff_regex, '', $calhash);
	}

	if (!strpos($calhash, ':'))
	$calhash = base64_decode($calhash);

	list($user, $_GET['source']) = explode(':', $calhash, 2);

	// sanity check user
	if ($this->rc->user->get_username() == $user) {
	$this->load_driver();
	$this->export_events(false);
	}
	else {
	header('HTTP/1.0 404 Not Found');
	}

	// don't save session data
	session_destroy();
	exit;
	}


	/**
	*
	*/
	function load_settings()
	{
	$this->date_format_defaults();
	$settings = array();

	// configuration
	$settings['default_calendar'] = $this->rc->config->get('calendar_default_calendar');
	$settings['default_view'] = (string)$this->rc->config->get('calendar_default_view', $this->defaults['calendar_default_view']);

	$settings['date_format'] = (string)$this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format']);
	$settings['time_format'] = (string)$this->rc->config->get('calendar_time_format', $this->defaults['calendar_time_format']);
	$settings['date_short'] = (string)$this->rc->config->get('calendar_date_short', $this->defaults['calendar_date_short']);
	$settings['date_long'] = (string)$this->rc->config->get('calendar_date_long', $this->defaults['calendar_date_long']);
	$settings['dates_long'] = str_replace(' yyyy', '[ yyyy]', $settings['date_long']) . "{ '—' " . $settings['date_long'] . '}';
	$settings['date_agenda'] = (string)$this->rc->config->get('calendar_date_agenda', $this->defaults['calendar_date_agenda']);

	$settings['timeslots'] = (int)$this->rc->config->get('calendar_timeslots', $this->defaults['calendar_timeslots']);
	$settings['first_day'] = (int)$this->rc->config->get('calendar_first_day', $this->defaults['calendar_first_day']);
	$settings['first_hour'] = (int)$this->rc->config->get('calendar_first_hour', $this->defaults['calendar_first_hour']);
	$settings['work_start'] = (int)$this->rc->config->get('calendar_work_start', $this->defaults['calendar_work_start']);
	$settings['work_end'] = (int)$this->rc->config->get('calendar_work_end', $this->defaults['calendar_work_end']);
	$settings['agenda_range'] = (int)$this->rc->config->get('calendar_agenda_range', $this->defaults['calendar_agenda_range']);
	$settings['agenda_sections'] = $this->rc->config->get('calendar_agenda_sections', $this->defaults['calendar_agenda_sections']);
	$settings['event_coloring'] = (int)$this->rc->config->get('calendar_event_coloring', $this->defaults['calendar_event_coloring']);
	$settings['time_indicator'] = (int)$this->rc->config->get('calendar_time_indicator', $this->defaults['calendar_time_indicator']);
	$settings['timezone'] = $this->timezone_offset;
	$settings['dst'] = $this->dst_active;

	// localization
	$settings['days'] = array(
	rcube_label('sunday'), rcube_label('monday'),
	rcube_label('tuesday'), rcube_label('wednesday'),
	rcube_label('thursday'), rcube_label('friday'),
	rcube_label('saturday')
	);
	$settings['days_short'] = array(
	rcube_label('sun'), rcube_label('mon'),
	rcube_label('tue'), rcube_label('wed'),
	rcube_label('thu'), rcube_label('fri'),
	rcube_label('sat')
	);
	$settings['months'] = array(
	$this->rc->gettext('longjan'), $this->rc->gettext('longfeb'),
	$this->rc->gettext('longmar'), $this->rc->gettext('longapr'),
	$this->rc->gettext('longmay'), $this->rc->gettext('longjun'),
	$this->rc->gettext('longjul'), $this->rc->gettext('longaug'),
	$this->rc->gettext('longsep'), $this->rc->gettext('longoct'),
	$this->rc->gettext('longnov'), $this->rc->gettext('longdec')
	);
	$settings['months_short'] = array(
	$this->rc->gettext('jan'), $this->rc->gettext('feb'),
	$this->rc->gettext('mar'), $this->rc->gettext('apr'),
	$this->rc->gettext('may'), $this->rc->gettext('jun'),
	$this->rc->gettext('jul'), $this->rc->gettext('aug'),
	$this->rc->gettext('sep'), $this->rc->gettext('oct'),
	$this->rc->gettext('nov'), $this->rc->gettext('dec')
	);
	$settings['today'] = $this->rc->gettext('today');

	// get user identity to create default attendee
	if ($this->ui->screen == 'calendar') {
	foreach ($this->rc->user->list_identities() as $rec) {
	if (!$identity)
	$identity = $rec;
	$identity['emails'][] = $rec['email'];
	}
	$identity['emails'][] = $this->rc->user->get_username();
	$settings['identity'] = array('name' => $identity['name'], 'email' => $identity['email'], 'emails' => ';' . join(';', $identity['emails']));
	}

	// define list of file types which can be displayed inline
	// same as in program/steps/mail/show.inc
	$mimetypes = $this->rc->config->get('client_mimetypes', 'text/plain,text/html,text/xml,image/jpeg,image/gif,image/png,application/x-javascript,application/pdf,application/x-shockwave-flash');
	$settings['mimetypes'] = is_string($mimetypes) ? explode(',', $mimetypes) : (array)$mimetypes;

	return $settings;
	}

	/**
	* Helper function to set date/time format according to config and user preferences
	*/
	private function date_format_defaults()
	{
	static $defaults = array();

	// nothing to be done
	if (isset($defaults['date_format']))
	return;

	$defaults['date_format'] = $this->rc->config->get('calendar_date_format', self::from_php_date_format($this->rc->config->get('date_format')));
	$defaults['time_format'] = $this->rc->config->get('calendar_time_format', self::from_php_date_format($this->rc->config->get('time_format')));

	// override defaults
	if ($defaults['date_format'])
	$this->defaults['calendar_date_format'] = $defaults['date_format'];
	if ($defaults['time_format'])
	$this->defaults['calendar_time_format'] = $defaults['time_format'];

	// derive format variants from basic date format
	$format_sets = $this->rc->config->get('calendar_date_format_sets', $this->defaults['calendar_date_format_sets']);
	if ($format_set = $format_sets[$this->defaults['calendar_date_format']]) {
	$this->defaults['calendar_date_long'] = $format_set[0];
	$this->defaults['calendar_date_short'] = $format_set[1];
	$this->defaults['calendar_date_agenda'] = $format_set[2];
	}
	}

	/**
	* Convert the given date string into a GMT-based time stamp
	*/
	function fromGMT($datetime)
	{
	$ts = is_numeric($datetime) ? $datetime : strtotime($datetime);
	return $ts + $this->gmt_offset;
	}

	/**
	* Encode events as JSON
	*
	* @param array Events as array
	* @param boolean Add CSS class names according to calendar and categories
	* @return string JSON encoded events
	*/
	function encode($events, $addcss = false)
	{
	$json = array();
	foreach ($events as $event) {
	$json[] = $this->_client_event($event, $addcss);
	}
	return json_encode($json);
	}

	/**
	* Convert an event object to be used on the client
	*/
	private function _client_event($event, $addcss = false)
	{
	// compose a human readable strings for alarms_text and recurrence_text
	if ($event['alarms'])
	$event['alarms_text'] = $this->_alarms_text($event['alarms']);
	if ($event['recurrence'])
	$event['recurrence_text'] = $this->_recurrence_text($event['recurrence']);

	foreach ((array)$event['attachments'] as $k => $attachment) {
	$event['attachments'][$k]['classname'] = rcmail_filetype2classname($attachment['mimetype'], $attachment['name']);
	}

	return array(
	'start' => gmdate('c', $this->fromGMT($event['start'])), // client treats date strings as they were in users's timezone
	'end' => gmdate('c', $this->fromGMT($event['end'])), // so shift timestamps to users's timezone and render a date string
	+ 'title' => strval($event['title']),
	'description' => strval($event['description']),
	'location' => strval($event['location']),
	'className' => ($addcss ? 'fc-event-cal-'.asciiwords($event['calendar'], true).' ' : '') . 'fc-event-cat-' . asciiwords(strtolower($event['categories']), true),
	'allDay' => ($event['allday'] == 1),
	) + $event;
	}


	/**
	* Generate reduced and streamlined output for pending alarms
	*/
	private function _alarms_output($alarms)
	{
	$out = array();
	foreach ($alarms as $alarm) {
	$out[] = array(
	'id' => $alarm['id'],
	'start' => gmdate('c', $this->fromGMT($alarm['start'])),
	'end' => gmdate('c', $this->fromGMT($alarm['end'])),
	'allDay' => ($event['allday'] == 1)?true:false,
	'title' => $alarm['title'],
	'location' => $alarm['location'],
	'calendar' => $alarm['calendar'],
	);
	}

	return $out;
	}

	/**
	* Render localized text for alarm settings
	*/
	private function _alarms_text($alarm)
	{
	list($trigger, $action) = explode(':', $alarm);

	$text = '';
	switch ($action) {
	case 'EMAIL':
	$text = $this->gettext('alarmemail');
	break;
	case 'DISPLAY':
	$text = $this->gettext('alarmdisplay');
	break;
	}

	if (preg_match('/@(\d+)/', $trigger, $m)) {
	$text .= ' ' . $this->gettext(array('name' => 'alarmat', 'vars' => array('datetime' => format_date($m[1]))));
	}
	else if ($val = self::parse_alaram_value($trigger)) {
	$text .= ' ' . intval($val[0]) . ' ' . $this->gettext('trigger' . $val[1]);
	}
	else
	return false;

	return $text;
	}

	/**
	* Render localized text describing the recurrence rule of an event
	*/
	private function _recurrence_text($rrule)
	{
	// TODO: finish this
	$freq = sprintf('%s %d ', $this->gettext('every'), $rrule['INTERVAL']);
	$details = '';
	switch ($rrule['FREQ']) {
	case 'DAILY':
	$freq .= $this->gettext('days');
	break;
	case 'WEEKLY':
	$freq .= $this->gettext('weeks');
	break;
	case 'MONTHLY':
	$freq .= $this->gettext('months');
	break;
	case 'YEARY':
	$freq .= $this->gettext('years');
	break;
	}

	if ($rrule['INTERVAL'] <= 1)
	$freq = $this->gettext(strtolower($rrule['FREQ']));

	if ($rrule['COUNT'])
	$until = $this->gettext(array('name' => 'forntimes', 'vars' => array('nr' => $rrule['COUNT'])));
	else if ($rrule['UNTIL'])
	$until = $this->gettext('recurrencend') . ' ' . format_date($rrule['UNTIL'], self::to_php_date_format($this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format'])));
	else
	$until = $this->gettext('forever');

	return rtrim($freq . $details . ', ' . $until);
	}

	/**
	* Generate a unique identifier for an event
	*/
	public function generate_uid()
	{
	return strtoupper(md5(time() . uniqid(rand())) . '-' . substr(md5($this->rc->user->get_username()), 0, 16));
	}

	/**
	* Helper function to convert alarm trigger strings
	* into two-field values (e.g. "-45M" => 45, "-M")
	*/
	public static function parse_alaram_value($val)
	{
	if ($val[0] == '@')
	return array(substr($val, 1));
	else if (preg_match('/([+-])(\d+)([HMD])/', $val, $m))
	return array($m[2], $m[1].$m[3]);

	return false;
	}

	/**
	* Get the next alarm (time & action) for the given event
	*
	* @param array Event data
	* @return array Hash array with alarm time/type or null if no alarms are configured
	*/
	public static function get_next_alarm($event)
	{
	if (!$event['alarms'])
	return null;

	// TODO: handle multiple alarms (currently not supported)
	list($trigger, $action) = explode(':', $event['alarms'], 2);

	$notify = self::parse_alaram_value($trigger);
	if (!empty($notify[1])){ // offset
	$mult = 1;
	switch ($notify[1]) {
	case '-S': $mult = -1; break;
	case '+S': $mult = 1; break;
	case '-M': $mult = -60; break;
	case '+M': $mult = 60; break;
	case '-H': $mult = -3600; break;
	case '+H': $mult = 3600; break;
	case '-D': $mult = -86400; break;
	case '+D': $mult = 86400; break;
	case '-W': $mult = -604800; break;
	case '+W': $mult = 604800; break;
	}
	$offset = $notify[0] * $mult;
	$refdate = $mult > 0 ? $event['end'] : $event['start'];
	$notify_at = $refdate + $offset;
	}
	else { // absolute timestamp
	$notify_at = $notify[0];
	}

	return array('time' => $notify_at, 'action' => $action ? strtoupper($action) : 'DISPLAY');
	}

	/**
	* Convert the internal structured data into a vcalendar rrule 2.0 string
	*/
	public static function to_rrule($recurrence)
	{
	if (is_string($recurrence))
	return $recurrence;

	$rrule = '';
	foreach ((array)$recurrence as $k => $val) {
	$k = strtoupper($k);
	switch ($k) {
	case 'UNTIL':
	$val = gmdate('Ymd\THis', $val);
	break;
	case 'EXDATE':
	foreach ((array)$val as $i => $ex)
	$val[$i] = gmdate('Ymd\THis', $ex);
	$val = join(',', (array)$val);
	break;
	}
	$rrule .= $k . '=' . $val . ';';
	}

	return $rrule;
	}

	/**
	* Convert from fullcalendar date format to PHP date() format string
	*/
	private static function to_php_date_format($from)
	{
	// "dd.MM.yyyy HH:mm:ss" => "d.m.Y H:i:s"
	return strtr(strtr($from, array(
	'yyyy' => 'Y',
	'yy' => 'y',
	'MMMM' => 'F',
	'MMM' => 'M',
	'MM' => 'm',
	'M' => 'n',
	'dddd' => 'l',
	'ddd' => 'D',
	'dd' => 'd',
	'HH' => '**',
	'hh' => '%%',
	'H' => 'G',
	'h' => 'g',
	'mm' => 'i',
	'ss' => 's',
	'TT' => 'A',
	'tt' => 'a',
	'T' => 'A',
	't' => 'a',
	'u' => 'c',
	)), array(
	'**' => 'H',
	'%%' => 'h',
	));
	}

	/**
	* Convert from PHP date() format to fullcalendar format string
	*/
	private static function from_php_date_format($from)
	{
	// "d.m.Y H:i:s" => "dd.MM.yyyy HH:mm:ss"
	return strtr($from, array(
	'y' => 'yy',
	'Y' => 'yyyy',
	'M' => 'MMM',
	'F' => 'MMMM',
	'm' => 'MM',
	'n' => 'M',
	'd' => 'dd',
	'D' => 'ddd',
	'l' => 'dddd',
	'H' => 'HH',
	'h' => 'hh',
	'G' => 'H',
	'g' => 'h',
	'i' => 'mm',
	's' => 'ss',
	'A' => 'TT',
	'a' => 'tt',
	'c' => 'u',
	));
	}

	/**
	* TEMPORARY: generate random event data for testing
	* Create events by opening http://<roundcubeurl>/?_task=calendar&_action=randomdata&_num=500
	*/
	public function generate_randomdata()
	{
	$num = $_REQUEST['_num'] ? intval($_REQUEST['_num']) : 100;
	$cats = array_keys($this->driver->list_categories());
	$cals = array();
	foreach ($this->driver->list_calendars() as $cid => $cal) {
	if ($cal['active'])
	$cals[$cid] = $cal;
	}

	while ($count++ < $num) {
	$start = round((time() + rand(-2600, 2600) * 1000) / 300) * 300;
	$duration = round(rand(30, 360) / 30) * 30 * 60;
	$allday = rand(0,20) > 18;
	$alarm = rand(-30,12) * 5;
	$fb = rand(0,2);

	if (date('G', $start) > 23)
	$start -= 3600;

	if ($allday) {
	$start = strtotime(date('Y-m-d 00:00:00', $start));
	$duration = 86399;
	}

	$title = '';
	$len = rand(2, 12);
	$words = explode(" ", "The Hough transform is named after Paul Hough who patented the method in 1962. It is a technique which can be used to isolate features of a particular shape within an image. Because it requires that the desired features be specified in some parametric form, the classical Hough transform is most commonly used for the de- tection of regular curves such as lines, circles, ellipses, etc. A generalized Hough transform can be employed in applications where a simple analytic description of a feature(s) is not possible. Due to the computational complexity of the generalized Hough algorithm, we restrict the main focus of this discussion to the classical Hough transform. Despite its domain restrictions, the classical Hough transform (hereafter referred to without the classical prefix ) retains many applications, as most manufac- tured parts (and many anatomical parts investigated in medical imagery) contain feature boundaries which can be described by regular curves. The main advantage of the Hough transform technique is that it is tolerant of gaps in feature boundary descriptions and is relatively unaffected by image noise.");
	$chars = "!# abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890";
	for ($i = 0; $i < $len; $i++)
	$title .= $words[rand(0,count($words)-1)] . " ";

	$this->driver->new_event(array(
	'uid' => $this->generate_uid(),
	'start' => $start,
	'end' => $start + $duration,
	'allday' => $allday,
	'title' => rtrim($title),
	'free_busy' => $fb == 2 ? 'outofoffice' : ($fb ? 'busy' : 'free'),
	'categories' => $cats[array_rand($cats)],
	'calendar' => array_rand($cals),
	'alarms' => $alarm > 0 ? "-{$alarm}M:DISPLAY" : '',
	'priority' => rand(0,9),
	));
	}

	$this->rc->output->redirect('');
	}

	/**
	* Handler for attachments upload
	*/
	public function attachment_upload()
	{
	// Upload progress update
	if (!empty($_GET['_progress'])) {
	rcube_upload_progress();
	}

	$event = get_input_value('_id', RCUBE_INPUT_GPC);
	$calendar = get_input_value('calendar', RCUBE_INPUT_GPC);
	$uploadid = get_input_value('_uploadid', RCUBE_INPUT_GPC);

	$eventid = 'cal:'.$event;

	if (!is_array($_SESSION['event_session']) \|\| $_SESSION['event_session']['id'] != $eventid) {
	$_SESSION['event_session'] = array();
	$_SESSION['event_session']['id'] = $eventid;
	$_SESSION['event_session']['attachments'] = array();
	}

	// clear all stored output properties (like scripts and env vars)
	$this->rc->output->reset();

	if (is_array($_FILES['_attachments']['tmp_name'])) {
	foreach ($_FILES['_attachments']['tmp_name'] as $i => $filepath) {
	// Process uploaded attachment if there is no error
	$err = $_FILES['_attachments']['error'][$i];

	if (!$err) {
	$attachment = array(
	'path' => $filepath,
	'size' => $_FILES['_attachments']['size'][$i],
	'name' => $_FILES['_attachments']['name'][$i],
	'mimetype' => rc_mime_content_type($filepath, $_FILES['_attachments']['name'][$i], $_FILES['_attachments']['type'][$i]),
	'group' => $eventid,
	);

	$attachment = $this->rc->plugins->exec_hook('attachment_upload', $attachment);
	}

	if (!$err && $attachment['status'] && !$attachment['abort']) {
	$id = $attachment['id'];

	// store new attachment in session
	unset($attachment['status'], $attachment['abort']);
	$_SESSION['event_session']['attachments'][$id] = $attachment;

	if (($icon = $_SESSION['calendar_deleteicon']) && is_file($icon)) {
	$button = html::img(array(
	'src' => $icon,
	'alt' => rcube_label('delete')
	));
	}
	else {
	$button = Q(rcube_label('delete'));
	}

	$content = html::a(array(
	'href' => "#delete",
	'class' => 'delete',
	'onclick' => sprintf("return %s.remove_from_attachment_list('rcmfile%s')", JS_OBJECT_NAME, $id),
	'title' => rcube_label('delete'),
	), $button);

	$content .= Q($attachment['name']);

	$this->rc->output->command('add2attachment_list', "rcmfile$id", array(
	'html' => $content,
	'name' => $attachment['name'],
	'mimetype' => $attachment['mimetype'],
	'classname' => rcmail_filetype2classname($attachment['mimetype'], $attachment['name']),
	'complete' => true), $uploadid);
	}
	else { // upload failed
	if ($err == UPLOAD_ERR_INI_SIZE \|\| $err == UPLOAD_ERR_FORM_SIZE) {
	$msg = rcube_label(array('name' => 'filesizeerror', 'vars' => array(
	'size' => show_bytes(parse_bytes(ini_get('upload_max_filesize'))))));
	}
	else if ($attachment['error']) {
	$msg = $attachment['error'];
	}
	else {
	$msg = rcube_label('fileuploaderror');
	}

	$this->rc->output->command('display_message', $msg, 'error');
	$this->rc->output->command('remove_from_attachment_list', $uploadid);
	}
	}
	}
	else if ($_SERVER['REQUEST_METHOD'] == 'POST') {
	// if filesize exceeds post_max_size then $_FILES array is empty,
	// show filesizeerror instead of fileuploaderror
	if ($maxsize = ini_get('post_max_size'))
	$msg = rcube_label(array('name' => 'filesizeerror', 'vars' => array(
	'size' => show_bytes(parse_bytes($maxsize)))));
	else
	$msg = rcube_label('fileuploaderror');

	$this->rc->output->command('display_message', $msg, 'error');
	$this->rc->output->command('remove_from_attachment_list', $uploadid);
	}

	$this->rc->output->send('iframe');
	}

	/**
	* Handler for attachments download/displaying
	*/
	public function attachment_get()
	{
	$event = get_input_value('_event', RCUBE_INPUT_GPC);
	$calendar = get_input_value('_cal', RCUBE_INPUT_GPC);
	$id = get_input_value('_id', RCUBE_INPUT_GPC);

	$event = array('id' => $event, 'calendar' => $calendar);

	// show loading page
	if (!empty($_GET['_preload'])) {
	$url = str_replace('&_preload=1', '', $_SERVER['REQUEST_URI']);
	$message = rcube_label('loadingdata');

	header('Content-Type: text/html; charset=' . RCMAIL_CHARSET);
	print "<html>\n<head>\n"
	. '<meta http-equiv="refresh" content="0; url='.Q($url).'">' . "\n"
	. '<meta http-equiv="content-type" content="text/html; charset='.RCMAIL_CHARSET.'">' . "\n"
	. "</head>\n<body>\n$message\n</body>\n</html>";
	exit;
	}

	ob_end_clean();

	$attachment = $GLOBALS['calendar_attachment'] = $this->driver->get_attachment($id, $event);

	// show part page
	if (!empty($_GET['_frame'])) {
	$this->attachment = $attachment;
	$this->register_handler('plugin.attachmentframe', array($this, 'attachment_frame'));
	$this->register_handler('plugin.attachmentcontrols', array($this->ui, 'attachment_controls'));
	$this->rc->output->send('calendar.attachment');
	exit;
	}

	if ($attachment) {
	// allow post-processing of the attachment body
	$part = new rcube_message_part;
	$part->filename = $attachment['name'];
	$part->size = $attachment['size'];
	$part->mimetype = $attachment['mimetype'];

	$plugin = $this->rc->plugins->exec_hook('message_part_get', array(
	'body' => $this->driver->get_attachment_body($id, $event),
	'mimetype' => strtolower($attachment['mimetype']),
	'download' => !empty($_GET['_download']),
	'part' => $part,
	));

	if ($plugin['abort'])
	exit;

	$mimetype = $plugin['mimetype'];
	list($ctype_primary, $ctype_secondary) = explode('/', $mimetype);

	$browser = $this->rc->output->browser;

	// send download headers
	if ($plugin['download']) {
	header("Content-Type: application/octet-stream");
	if ($browser->ie)
	header("Content-Type: application/force-download");
	}
	else if ($ctype_primary == 'text') {
	header("Content-Type: text/$ctype_secondary");
	}
	else {
	// $mimetype = rcmail_fix_mimetype($mimetype);
	header("Content-Type: $mimetype");
	header("Content-Transfer-Encoding: binary");
	}

	// display page, @TODO: support text/plain (and maybe some other text formats)
	if ($mimetype == 'text/html' && empty($_GET['_download'])) {
	$OUTPUT = new rcube_html_page();
	// @TODO: use washtml on $body
	$OUTPUT->write($plugin['body']);
	}
	else {
	// don't kill the connection if download takes more than 30 sec.
	@set_time_limit(0);

	$filename = $attachment['name'];
	$filename = preg_replace('[\r\n]', '', $filename);

	if ($browser->ie && $browser->ver < 7)
	$filename = rawurlencode(abbreviate_string($filename, 55));
	else if ($browser->ie)
	$filename = rawurlencode($filename);
	else
	$filename = addcslashes($filename, '"');

	$disposition = !empty($_GET['_download']) ? 'attachment' : 'inline';
	header("Content-Disposition: $disposition; filename=\"$filename\"");

	echo $plugin['body'];
	}

	exit;
	}

	// if we arrive here, the requested part was not found
	header('HTTP/1.1 404 Not Found');
	exit;
	}

	/**
	* Template object for attachment display frame
	*/
	public function attachment_frame($attrib)
	{
	$attachment = $GLOBALS['calendar_attachment'];

	$mimetype = strtolower($attachment['mimetype']);
	list($ctype_primary, $ctype_secondary) = explode('/', $mimetype);

	$attrib['src'] = './?' . str_replace('_frame=', ($ctype_primary == 'text' ? '_show=' : '_preload='), $_SERVER['QUERY_STRING']);

	return html::iframe($attrib);
	}

	/**
	* Prepares new/edited event properties before save
	*/
	private function prepare_event(&$event, $action)
	{
	$attachments = array();
	$eventid = 'cal:'.$event['id'];
	if (is_array($_SESSION['event_session']) && $_SESSION['event_session']['id'] == $eventid) {
	if (!empty($_SESSION['event_session']['attachments'])) {
	foreach ($_SESSION['event_session']['attachments'] as $id => $attachment) {
	if (is_array($event['attachments']) && in_array($id, $event['attachments'])) {
	$attachments[$id] = $this->rc->plugins->exec_hook('attachment_get', $attachment);
	}
	}
	}
	}

	$event['attachments'] = $attachments;

	// check for organizer in attendees
	if ($event['attendees'] && ($action == 'new' \|\| $action == 'edit')) {
	$emails = $this->get_user_emails();
	$organizer = $owner = false;
	foreach ($event['attendees'] as $i => $attendee) {
	if ($attendee['role'] == 'ORGANIZER')
	$organizer = true;
	if ($attendee['email'] == in_array($attendee['email'], $emails))
	$owner = $i;
	else if (!isset($attendee['rsvp']))
	$event['attendees'][$i]['rsvp'] = true;
	}

	// set owner as organizer if yet missing
	if (!$organizer && $owner !== false) {
	$event['attendees'][$owner]['role'] = 'ORGANIZER';
	unset($event['attendees'][$owner]['rsvp']);
	}
	else if (!$organizer && $action == 'new' && ($identity = $this->rc->user->get_identity()) && $identity['email']) {
	array_unshift($event['attendees'], array('role' => 'ORGANIZER', 'name' => $identity['name'], 'email' => $identity['email'], 'status' => 'ACCEPTED'));
	}
	}
	}

	/**
	* Releases some resources after successful event save
	*/
	private function cleanup_event(&$event)
	{
	// remove temp. attachment files
	$eventid = 'cal:'.$event['id'];
	if (!empty($_SESSION['event_session']) && ($eventid = $_SESSION['event_session']['id'])) {
	$this->rc->plugins->exec_hook('attachments_cleanup', array('group' => $eventid));
	unset($_SESSION['event_session']);
	}
	}

	/**
	* Send out an invitation/notification to all event attendees
	*/
	private function notify_attendees($event, $old, $action = 'edit')
	{
	if ($action == 'remove') {
	$event['cancelled'] = true;
	$is_cancelled = true;
	}

	$itip = $this->load_itip();
	$emails = $this->get_user_emails();

	// compose multipart message using PEAR:Mail_Mime
	$method = $action == 'remove' ? 'CANCEL' : 'REQUEST';
	$message = $itip->compose_itip_message($event, $method);

	// list existing attendees from $old event
	$old_attendees = array();
	foreach ((array)$old['attendees'] as $attendee) {
	$old_attendees[] = $attendee['email'];
	}

	// send to every attendee
	$sent = 0;
	foreach ((array)$event['attendees'] as $attendee) {
	// skip myself for obvious reasons
	if (!$attendee['email'] \|\| in_array($attendee['email'], $emails))
	continue;

	// which template to use for mail text
	$is_new = !in_array($attendee['email'], $old_attendees);
	$bodytext = $is_cancelled ? 'eventcancelmailbody' : ($is_new ? 'invitationmailbody' : 'eventupdatemailbody');
	$subject = $is_cancelled ? 'eventcancelsubject' : ($is_new ? 'invitationsubject' : ($event['title'] ? 'eventupdatesubject':'eventupdatesubjectempty'));

	// finally send the message
	if ($itip->send_itip_message($event, $method, $attendee, $subject, $bodytext, $message))
	$sent++;
	else
	$sent = -100;
	}

	return $sent;
	}

	/**
	* Compose a date string for the given event
	*/
	public function event_date_text($event, $tzinfo = false)
	{
	$fromto = '';
	$duration = $event['end'] - $event['start'];

	$this->date_format_defaults();
	$date_format = self::to_php_date_format($this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format']));
	$time_format = self::to_php_date_format($this->rc->config->get('calendar_time_format', $this->defaults['calendar_time_format']));

	if ($event['allday']) {
	$fromto = format_date($event['start'], $date_format);
	if (($todate = format_date($event['end'], $date_format)) != $fromto)
	$fromto .= ' - ' . $todate;
	}
	else if ($duration < 86400 && gmdate('d', $event['start']) == gmdate('d', $event['end'])) {
	$fromto = format_date($event['start'], $date_format) . ' ' . format_date($event['start'], $time_format) .
	' - ' . format_date($event['end'], $time_format);
	}
	else {
	$fromto = format_date($event['start'], $date_format) . ' ' . format_date($event['start'], $time_format) .
	' - ' . format_date($event['end'], $date_format) . ' ' . format_date($event['end'], $time_format);
	}

	// add timezone information
	if ($tzinfo && ($tzname = $this->timezone->getName())) {
	$fromto .= ' (' . strtr($tzname, '_', ' ') . ')';
	}

	return $fromto;
	}

	/**
	* Echo simple free/busy status text for the given user and time range
	*/
	public function freebusy_status()
	{
	$email = get_input_value('email', RCUBE_INPUT_GPC);
	$start = get_input_value('start', RCUBE_INPUT_GPC);
	$end = get_input_value('end', RCUBE_INPUT_GPC);

	if (!$start) $start = time();
	if (!$end) $end = $start + 3600;

	$fbtypemap = array(calendar::FREEBUSY_UNKNOWN => 'UNKNOWN', calendar::FREEBUSY_FREE => 'FREE', calendar::FREEBUSY_BUSY => 'BUSY', calendar::FREEBUSY_TENTATIVE => 'TENTATIVE', calendar::FREEBUSY_OOF => 'OUT-OF-OFFICE');
	$status = 'UNKNOWN';

	// if the backend has free-busy information
	$fblist = $this->driver->get_freebusy_list($email, $start, $end);
	if (is_array($fblist)) {
	$status = 'FREE';

	foreach ($fblist as $slot) {
	list($from, $to, $type) = $slot;
	if ($from < $end && $to > $start) {
	$status = isset($type) && $fbtypemap[$type] ? $fbtypemap[$type] : 'BUSY';
	break;
	}
	}
	}

	// let this information be cached for 5min
	send_future_expire_header(300);

	echo $status;
	exit;
	}

	/**
	* Return a list of free/busy time slots within the given period
	* Echo data in JSON encoding
	*/
	public function freebusy_times()
	{
	$email = get_input_value('email', RCUBE_INPUT_GPC);
	$start = get_input_value('start', RCUBE_INPUT_GPC);
	$end = get_input_value('end', RCUBE_INPUT_GPC);
	$interval = intval(get_input_value('interval', RCUBE_INPUT_GPC));

	if (!$start) $start = time();
	if (!$end) $end = $start + 86400 * 30;
	if (!$interval) $interval = 60; // 1 hour

	$fblist = $this->driver->get_freebusy_list($email, $start, $end);
	$slots = array();

	// build a list from $start till $end with blocks representing the fb-status
	for ($s = 0, $t = $start; $t <= $end; $s++) {
	$status = self::FREEBUSY_UNKNOWN;
	$t_end = $t + $interval * 60;

	// determine attendee's status
	if (is_array($fblist)) {
	$status = self::FREEBUSY_FREE;
	foreach ($fblist as $slot) {
	list($from, $to, $type) = $slot;
	if ($from < $t_end && $to > $t) {
	$status = isset($type) ? $type : self::FREEBUSY_BUSY;
	if ($status == self::FREEBUSY_BUSY) // can't get any worse :-)
	break;
	}
	}
	}

	$slots[$s] = $status;
	$t = $t_end;
	}

	// let this information be cached for 5min
	send_future_expire_header(300);

	echo json_encode(array('email' => $email, 'start' => intval($start), 'end' => intval($t_end), 'interval' => $interval, 'slots' => $slots));
	exit;
	}

	/**
	* Handler for printing calendars
	*/
	public function print_view()
	{
	$title = $this->gettext('print');

	$view = get_input_value('view', RCUBE_INPUT_GPC);
	if (!in_array($view, array('agendaWeek', 'agendaDay', 'month', 'table')))
	$view = 'agendaDay';

	$this->rc->output->set_env('view',$view);

	if ($date = get_input_value('date', RCUBE_INPUT_GPC))
	$this->rc->output->set_env('date', $date);

	if ($range = get_input_value('range', RCUBE_INPUT_GPC))
	$this->rc->output->set_env('listRange', intval($range));

	if (isset($_REQUEST['sections']))
	$this->rc->output->set_env('listSections', get_input_value('sections', RCUBE_INPUT_GPC));

	if ($search = get_input_value('search', RCUBE_INPUT_GPC)) {
	$this->rc->output->set_env('search', $search);
	$title .= ' "' . $search . '"';
	}

	// Add CSS stylesheets to the page header
	$skin = $this->rc->config->get('skin');
	$this->include_stylesheet('skins/' . $skin . '/fullcalendar.css');
	$this->include_stylesheet('skins/' . $skin . '/print.css');

	// Add JS files to the page header
	$this->include_script('print.js');

	$this->register_handler('plugin.calendar_css', array($this->ui, 'calendar_css'));
	$this->register_handler('plugin.calendar_list', array($this->ui, 'calendar_list'));

	$this->rc->output->set_pagetitle($title);
	$this->rc->output->send("calendar.print");
	}

	/**
	*
	*/
	public function get_inline_ui()
	{
	foreach (array('save','cancel','savingdata') as $label)
	$texts['calendar.'.$label] = $this->gettext($label);

	$texts['calendar.new_event'] = $this->gettext('createfrommail');

	$this->ui->init_templates();
	$this->ui->calendar_list(); # set env['calendars']
	echo $this->api->output->parse('calendar.eventedit', false, false);
	echo html::tag('script', array('type' => 'text/javascript'),
	"rcmail.set_env('calendars', " . json_encode($this->api->output->env['calendars']) . ");\n".
	"rcmail.set_env('deleteicon', '" . $this->api->output->env['deleteicon'] . "');\n".
	"rcmail.set_env('cancelicon', '" . $this->api->output->env['cancelicon'] . "');\n".
	"rcmail.set_env('loadingicon', '" . $this->api->output->env['loadingicon'] . "');\n".
	"rcmail.add_label(" . json_encode($texts) . ");\n"
	);
	exit;
	}

	/**
	* Compare two event objects and return differing properties
	*
	* @param array Event A
	* @param array Event B
	* @return array List of differing event properties
	*/
	public static function event_diff($a, $b)
	{
	$diff = array();
	$ignore = array('changed' => 1, 'attachments' => 1);
	foreach (array_unique(array_merge(array_keys($a), array_keys($b))) as $key) {
	if (!$ignore[$key] && $a[$key] != $b[$key])
	$diff[] = $key;
	}

	// only compare number of attachments
	if (count($a['attachments']) != count($b['attachments']))
	$diff[] = 'attachments';

	return $diff;
	}


	/** Event invitation plugin hooks **/

	/**
	* Handler for URLs that allow an invitee to respond on his invitation mail
	*/
	public function itip_attend_response($p)
	{
	if ($p['action'] == 'attend') {
	$this->rc->output->set_env('task', 'calendar'); // override some env vars
	$this->rc->output->set_env('keep_alive', 0);
	$this->rc->output->set_pagetitle($this->gettext('calendar'));

	$itip = $this->load_itip();
	$token = get_input_value('_t', RCUBE_INPUT_GPC);

	// read event info stored under the given token
	if ($invitation = $itip->get_invitation($token)) {
	$this->token = $token;
	$this->event = $invitation['event'];

	// show message about cancellation
	if ($invitation['cancelled']) {
	$this->invitestatus = html::div('rsvp-status declined', $this->gettext('eventcancelled'));
	}
	// save submitted RSVP status
	else if (!empty($_POST['rsvp'])) {
	$status = null;
	foreach (array('accepted','tentative','declined') as $method) {
	if ($_POST['rsvp'] == $this->gettext('itip' . $method)) {
	$status = $method;
	break;
	}
	}

	// send itip reply to organizer
	if ($status && $itip->update_invitation($invitation, $invitation['attendee'], strtoupper($status))) {
	$this->invitestatus = html::div('rsvp-status ' . strtolower($status), $this->gettext('youhave'.strtolower($status)));
	}
	else
	$this->rc->output->command('display_message', $this->gettext('errorsaving'), 'error', -1);

	// if user is logged in...
	if ($this->rc->user->ID) {
	$this->load_driver();
	$invitation = $itip->get_invitation($token);

	// save the event to his/her default calendar if not yet present
	if (!$this->driver->get_event($this->event) && ($calendar = $this->get_default_calendar(true))) {
	$invitation['event']['calendar'] = $calendar['id'];
	if ($this->driver->new_event($invitation['event']))
	$this->rc->output->command('display_message', $this->gettext(array('name' => 'importedsuccessfully', 'vars' => array('calendar' => $calendar['name']))), 'confirmation');
	}
	}
	}

	$this->register_handler('plugin.event_inviteform', array($this, 'itip_event_inviteform'));
	$this->register_handler('plugin.event_invitebox', array($this->ui, 'event_invitebox'));

	if (!$this->invitestatus)
	$this->register_handler('plugin.event_rsvp_buttons', array($this->ui, 'event_rsvp_buttons'));

	$this->rc->output->set_pagetitle($this->gettext('itipinvitation') . ' ' . $this->event['title']);
	}
	else
	$this->rc->output->command('display_message', $this->gettext('itipinvalidrequest'), 'error', -1);

	$this->rc->output->send('calendar.itipattend');
	}
	}

	/**
	*
	*/
	public function itip_event_inviteform($attrib)
	{
	$hidden = new html_hiddenfield(array('name' => "_t", 'value' => $this->token));
	return html::tag('form', array('action' => $this->rc->url(array('task' => 'calendar', 'action' => 'attend')), 'method' => 'post', 'noclose' => true) + $attrib) . $hidden->show();
	}

	/**
	* Check mail message structure of there are .ics files attached
	*/
	public function mail_message_load($p)
	{
	$this->message = $p['object'];
	$itip_part = null;

	// check all message parts for .ics files
	foreach ((array)$this->message->mime_parts as $idx => $part) {
	if ($this->is_vcalendar($part)) {
	if ($part->ctype_parameters['method'])
	$itip_part = $part->mime_id;
	else
	$this->ics_parts[] = $part->mime_id;
	}
	}

	// priorize part with method parameter
	if ($itip_part)
	$this->ics_parts = array($itip_part);
	}

	/**
	* Add UI element to copy event invitations or updates to the calendar
	*/
	public function mail_messagebody_html($p)
	{
	// load iCalendar functions (if necessary)
	if (!empty($this->ics_parts)) {
	$this->get_ical();
	}

	$html = '';
	foreach ($this->ics_parts as $mime_id) {
	$part = $this->message->mime_parts[$mime_id];
	$charset = $part->ctype_parameters['charset'] ? $part->ctype_parameters['charset'] : RCMAIL_CHARSET;
	$events = $this->ical->import($this->message->get_part_content($mime_id), $charset);
	$title = $this->gettext('title');

	// successfully parsed events?
	if (empty($events))
	continue;

	// show a box for every event in the file
	foreach ($events as $idx => $event) {
	// define buttons according to method
	if ($this->ical->method == 'REPLY') {
	$title = $this->gettext('itipreply');
	$buttons = html::tag('input', array(
	'type' => 'button',
	'class' => 'button',
	'onclick' => "rcube_calendar.add_event_from_mail('" . JQ($mime_id.':'.$idx) . "')",
	'value' => $this->gettext('updateattendeestatus'),
	));
	}
	else if ($this->ical->method == 'REQUEST') {
	$emails = $this->get_user_emails();
	$title = $event['SEQUENCE'] > 0 ? $this->gettext('itipupdate') : $this->gettext('itipinvitation');

	// add (hidden) buttons and activate them from asyncronous request
	foreach (array('accepted','tentative','declined') as $method) {
	$rsvp_buttons .= html::tag('input', array(
	'type' => 'button',
	'class' => 'button',
	'onclick' => "rcube_calendar.add_event_from_mail('" . JQ($mime_id.':'.$idx) . "', '$method')",
	'value' => $this->gettext('itip' . $method),
	));
	}
	$import_button = html::tag('input', array(
	'type' => 'button',
	'class' => 'button',
	'onclick' => "rcube_calendar.add_event_from_mail('" . JQ($mime_id.':'.$idx) . "')",
	'value' => $this->gettext('importtocalendar'),
	));

	// check my status
	$status = 'unknown';
	foreach ($event['attendees'] as $i => $attendee) {
	if ($attendee['email'] && in_array($attendee['email'], $emails)) {
	$status = strtoupper($attendee['status']);
	break;
	}
	}

	$dom_id = asciiwords($event['uid'], true);
	$buttons = html::div(array('id' => 'rsvp-'.$dom_id, 'style' => 'display:none'), $rsvp_buttons);
	$buttons .= html::div(array('id' => 'import-'.$dom_id, 'style' => 'display:none'), $import_button);
	$buttons_pre = html::div(array('id' => 'loading-'.$dom_id, 'class' => 'rsvp-status loading'), $this->gettext('loading'));

	$this->rc->output->add_script('rcube_calendar.fetch_event_rsvp_status(' . json_serialize(array('uid' => $event['uid'], 'changed' => $event['changed'], 'fallback' => $status)) . ')', 'docready');
	}
	else if ($this->ical->method == 'CANCEL') {
	$title = $this->gettext('itipcancellation');

	// create buttons to be activated from async request checking existence of this event in local calendars
	$button_import = html::tag('input', array(
	'type' => 'button',
	'class' => 'button',
	'onclick' => "rcube_calendar.add_event_from_mail('" . JQ($mime_id.':'.$idx) . "')",
	'value' => $this->gettext('importtocalendar'),
	));
	$button_remove = html::tag('input', array(
	'type' => 'button',
	'class' => 'button',
	'onclick' => "rcube_calendar.remove_event_from_mail('" . JQ($event['uid']) . "', '" . JQ($event['title']) . "')",
	'value' => $this->gettext('removefromcalendar'),
	));

	$dom_id = asciiwords($event['uid'], true);
	$buttons = html::div(array('id' => 'rsvp-'.$dom_id, 'style' => 'display:none'), $button_remove);
	$buttons .= html::div(array('id' => 'import-'.$dom_id, 'style' => 'display:none'), $button_import);
	$buttons_pre = html::div(array('id' => 'loading-'.$dom_id, 'class' => 'rsvp-status loading'), $this->gettext('loading'));

	$this->rc->output->add_script('rcube_calendar.fetch_event_rsvp_status(' . json_serialize(array('uid' => $event['uid'], 'changed' => $event['changed'], 'fallback' => 'CANCELLED')) . ')', 'docready');
	}
	else {
	$buttons = html::tag('input', array(
	'type' => 'button',
	'class' => 'button',
	'onclick' => "rcube_calendar.add_event_from_mail('" . JQ($mime_id.':'.$idx) . "')",
	'value' => $this->gettext('importtocalendar'),
	));
	}

	// show event details with buttons
	$html .= html::div('calendar-invitebox', $this->ui->event_details_table($event, $title) . $buttons_pre . html::div('rsvp-buttons', $buttons));

	// limit listing
	if ($idx >= 3)
	break;
	}
	}

	// prepend event boxes to message body
	if ($html) {
	$this->ui->init();
	$p['content'] = $html . $p['content'];
	$this->rc->output->add_label('calendar.savingdata','calendar.deleteventconfirm');
	}

	return $p;
	}


	/**
	* Handler for POST request to import an event attached to a mail message
	*/
	public function mail_import_event()
	{
	$uid = get_input_value('_uid', RCUBE_INPUT_POST);
	$mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
	$mime_id = get_input_value('_part', RCUBE_INPUT_POST);
	$status = get_input_value('_status', RCUBE_INPUT_POST);
	$charset = RCMAIL_CHARSET;

	// establish imap connection
	$imap = $this->rc->get_storage();
	$imap->set_mailbox($mbox);

	if ($uid && $mime_id) {
	list($mime_id, $index) = explode(':', $mime_id);
	$part = $imap->get_message_part($uid, $mime_id);
	if ($part->ctype_parameters['charset'])
	$charset = $part->ctype_parameters['charset'];
	$headers = $imap->get_message_headers($uid);
	}

	$events = $this->get_ical()->import($part, $charset);

	$error_msg = $this->gettext('errorimportingevent');
	$success = false;

	// successfully parsed events?
	if (!empty($events) && ($event = $events[$index])) {
	// find writeable calendar to store event
	$cal_id = !empty($_REQUEST['_calendar']) ? get_input_value('_calendar', RCUBE_INPUT_POST) : $this->rc->config->get('calendar_default_calendar');
	$calendars = $this->driver->list_calendars();
	$calendar = $calendars[$cal_id] ? $calendars[$cal_id] : null;
	if (!$calendar \|\| $calendar['readonly']) {
	foreach ($calendars as $cal) {
	if (!$cal['readonly']) {
	$calendar = $cal;
	break;
	}
	}
	}

	// update my attendee status according to submitted method
	if (!empty($status)) {
	$organizer = null;
	$emails = $this->get_user_emails();
	foreach ($event['attendees'] as $i => $attendee) {
	if ($attendee['role'] == 'ORGANIZER') {
	$organizer = $attendee;
	}
	else if ($attendee['email'] && in_array($attendee['email'], $emails)) {
	$event['attendees'][$i]['status'] = strtoupper($status);
	}
	}
	}

	// save to calendar
	if ($calendar && !$calendar['readonly']) {
	$event['id'] = $event['uid'];
	$event['calendar'] = $calendar['id'];

	// check for existing event with the same UID
	$existing = $this->driver->get_event($event['uid'], true);

	if ($existing) {
	// only update attendee status
	if ($this->ical->method == 'REPLY') {
	// try to identify the attendee using the email sender address
	$sender = preg_match('/([a-z0-9][a-z0-9\-\.\+\_]@[^&@"\'.][^@&"\']\\.([^\\x00-\\x40\\x5b-\\x60\\x7b-\\x7f]{2,}\|xn--[a-z0-9]{2,}))/', $headers->from, $m) ? $m[1] : '';
	$sender_utf = rcube_idn_to_utf8($sender);

	$existing_attendee = -1;
	foreach ($existing['attendees'] as $i => $attendee) {
	if ($sender && ($attendee['email'] == $sender \|\| $attendee['email'] == $sender_utf)) {
	$existing_attendee = $i;
	break;
	}
	}
	$event_attendee = null;
	foreach ($event['attendees'] as $attendee) {
	if ($sender && ($attendee['email'] == $sender \|\| $attendee['email'] == $sender_utf)) {
	$event_attendee = $attendee;
	break;
	}
	}

	// found matching attendee entry in both existing and new events
	if ($existing_attendee >= 0 && $event_attendee) {
	$existing['attendees'][$existing_attendee] = $event_attendee;
	$success = $this->driver->edit_event($existing);
	}
	// update the entire attendees block
	else if ($event['changed'] >= $existing['changed'] && $event['attendees']) {
	$existing['attendees'] = $event['attendees'];
	$success = $this->driver->edit_event($existing);
	}
	else {
	$error_msg = $this->gettext('newerversionexists');
	}
	}
	// import the (newer) event
	// TODO: compare SEQUENCE numbers instead of changed dates
	else if ($event['changed'] >= $existing['changed']) {
	$success = $this->driver->edit_event($event);
	}
	else if (!empty($status)) {
	$existing['attendees'] = $event['attendees'];
	$success = $this->driver->edit_event($existing);
	}
	else
	$error_msg = $this->gettext('newerversionexists');
	}
	else if (!$existing && $status != 'declined') {
	$success = $this->driver->new_event($event);
	}
	else if ($status == 'declined')
	$error_msg = null;
	}
	else if ($status == 'declined')
	$error_msg = null;
	else
	$error_msg = $this->gettext('nowritecalendarfound');
	}

	if ($success) {
	$message = $this->ical->method == 'REPLY' ? 'attendeupdateesuccess' : 'importedsuccessfully';
	$this->rc->output->command('display_message', $this->gettext(array('name' => $message, 'vars' => array('calendar' => $calendar['name']))), 'confirmation');
	$error_msg = null;
	}
	else if ($error_msg)
	$this->rc->output->command('display_message', $error_msg, 'error');


	// send iTip reply
	if ($this->ical->method == 'REQUEST' && $organizer && !in_array($organizer['email'], $emails) && !$error_msg) {
	$itip = $this->load_itip();
	if ($itip->send_itip_message($event, 'REPLY', $organizer, 'itipsubject' . $status, 'itipmailbody' . $status))
	$this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $organizer['name'] ? $organizer['name'] : $organizer['email']))), 'confirmation');
	else
	$this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
	}

	$this->rc->output->send();
	}


	/**
	* Read email message and return contents for a new event based on that message
	*/
	public function mail_message2event()
	{
	$uid = get_input_value('_uid', RCUBE_INPUT_POST);
	$mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
	$event = array();

	// establish imap connection
	$imap = $this->rc->get_storage();
	$imap->set_mailbox($mbox);
	$message = new rcube_message($uid);

	if ($message->headers) {
	$event['title'] = trim($message->subject);
	$event['description'] = trim($message->first_text_part());

	// copy mail attachments to event
	if ($message->attachments) {
	$eventid = 'cal:';
	if (!is_array($_SESSION['event_session']) \|\| $_SESSION['event_session']['id'] != $eventid) {
	$_SESSION['event_session'] = array();
	$_SESSION['event_session']['id'] = $eventid;
	$_SESSION['event_session']['attachments'] = array();
	}

	foreach ((array)$message->attachments as $part) {
	$attachment = array(
	'data' => $imap->get_message_part($uid, $part->mime_id, $part),
	'size' => $part->size,
	'name' => $part->filename,
	'mimetype' => $part->mimetype,
	'group' => $eventid,
	);

	$attachment = $this->rc->plugins->exec_hook('attachment_save', $attachment);

	if ($attachment['status'] && !$attachment['abort']) {
	$id = $attachment['id'];

	// store new attachment in session
	unset($attachment['status'], $attachment['abort'], $attachment['data']);
	$_SESSION['event_session']['attachments'][$id] = $attachment;

	$attachment['id'] = 'rcmfile' . $attachment['id']; # add prefix to consider it 'new'
	$event['attachments'][] = $attachment;
	}
	}
	}

	$this->rc->output->command('plugin.mail2event_dialog', $event);
	}
	else {
	$this->rc->output->command('display_message', $this->gettext('messageopenerror'), 'error');
	}

	$this->rc->output->send();
	}


	/**
	* Checks if specified message part is a vcalendar data
	*
	* @param rcube_message_part Part object
	* @return boolean True if part is of type vcard
	*/
	private function is_vcalendar($part)
	{
	return (
	in_array($part->mimetype, array('text/calendar', 'text/x-vcalendar', 'application/ics')) \|\|
	// Apple sends files as application/x-any (!?)
	($part->mimetype == 'application/x-any' && $part->filename && preg_match('/\.ics$/i', $part->filename))
	);
	}


	/**
	* Get a list of email addresses of the current user (from login and identities)
	*/
	private function get_user_emails()
	{
	$emails = array($this->rc->user->get_username());
	foreach ($this->rc->user->list_identities() as $identity)
	$emails[] = $identity['email'];

	return array_unique($emails);
	}


	/**
	* Build an absolute URL with the given parameters
	*/
	public function get_url($param = array())
	{
	$param += array('task' => 'calendar');

	$schema = 'http';
	$default_port = 80;
	if (rcube_https_check()) {
	$schema = 'https';
	$default_port = 443;
	}
	$url = $schema . '://' . $_SERVER['HTTP_HOST'];
	if ($_SERVER['SERVER_PORT'] != $default_port)
	$url .= ':' . $_SERVER['SERVER_PORT'];
	if (dirname($_SERVER['SCRIPT_NAME']) != '/')
	$url .= dirname($_SERVER['SCRIPT_NAME']);
	$url .= preg_replace('!^\./!', '/', $this->rc->url($param));

	return $url;
	}


	public function ical_feed_hash($source)
	{
	return base64_encode($this->rc->user->get_username() . ':' . $source);
	}

	}
	diff --git a/plugins/libkolab/lib/kolab_format.php b/plugins/libkolab/lib/kolab_format.php
	index a7b1e487..b7ce0578 100644
	--- a/plugins/libkolab/lib/kolab_format.php
	+++ b/plugins/libkolab/lib/kolab_format.php
	@@ -1,289 +1,309 @@
	<?php

	/**
	* Kolab format model class wrapping libkolabxml bindings
	*
	* Abstract base class for different Kolab groupware objects read from/written
	* to the new Kolab 3 format using the PHP bindings of libkolabxml.
	*
	* @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
	{
	public static $timezone;

	+ public /abstract/ $CTYPE;
	+
	+ protected /abstract/ $read_func;
	+ protected /abstract/ $write_func;
	+
	protected $obj;
	protected $data;
	protected $xmldata;
	protected $loaded = false;

	/**
	* Factory method to instantiate a kolab_format object of the given type
	*
	* @param string Object type to instantiate
	* @param string Cached xml data to initialize with
	* @return object kolab_format
	*/
	public static function factory($type, $xmldata = null)
	{
	if (!isset(self::$timezone))
	self::$timezone = new DateTimeZone('UTC');

	$suffix = preg_replace('/[^a-z]+/', '', $type);
	$classname = 'kolab_format_' . $suffix;
	if (class_exists($classname))
	return new $classname($xmldata);

	return PEAR::raiseError(sprintf("Failed to load Kolab Format wrapper for type %s", $type));
	}

	/**
	* Convert the given date/time value into a cDateTime object
	*
	* @param mixed Date/Time value either as unix timestamp, date string or PHP DateTime object
	* @param DateTimeZone The timezone the date/time is in. Use global default if empty
	* @param boolean True of the given date has no time component
	* @return object The libkolabxml date/time object
	*/
	public static function get_datetime($datetime, $tz = null, $dateonly = false)
	{
	if (!$tz) $tz = self::$timezone;
	$result = new cDateTime();

	// got a unix timestamp (in UTC)
	if (is_numeric($datetime)) {
	$datetime = new DateTime('@'.$datetime, new DateTimeZone('UTC'));
	if ($tz) $datetime->setTimezone($tz);
	}
	else if (is_string($datetime) && strlen($datetime))
	$datetime = new DateTime($datetime, $tz);

	if (is_a($datetime, 'DateTime')) {
	$result->setDate($datetime->format('Y'), $datetime->format('n'), $datetime->format('j'));

	if (!$dateonly)
	$result->setTime($datetime->format('G'), $datetime->format('i'), $datetime->format('s'));

	if ($tz && $tz->getName() == 'UTC')
	$result->setUTC(true);
	else if ($tz)
	$result->setTimezone($tz->getName());
	}

	return $result;
	}

	/**
	* Convert the given cDateTime into a PHP DateTime object
	*
	* @param object cDateTime The libkolabxml datetime object
	* @return object DateTime PHP datetime instance
	*/
	public static function php_datetime($cdt)
	{
	if (!is_object($cdt) \|\| !$cdt->isValid())
	return null;

	$d = new DateTime;
	$d->setTimezone(self::$timezone);

	try {
	if ($tzs = $cdt->timezone()) {
	$tz = new DateTimeZone($tzs);
	$d->setTimezone($tz);
	}
	else if ($cdt->isUTC()) {
	$d->setTimezone(new DateTimeZone('UTC'));
	}
	}
	catch (Exception $e) { }

	$d->setDate($cdt->year(), $cdt->month(), $cdt->day());

	if ($cdt->isDateOnly()) {
	$d->_dateonly = true;
	$d->setTime(12, 0, 0); // set time to noon to avoid timezone troubles
	}
	else {
	$d->setTime($cdt->hour(), $cdt->minute(), $cdt->second());
	}

	return $d;
	}

	/**
	* Convert a libkolabxml vector to a PHP array
	*
	* @param object vector Object
	* @return array Indexed array contaning vector elements
	*/
	public static function vector2array($vec, $max = PHP_INT_MAX)
	{
	$arr = array();
	for ($i=0; $i < $vec->size() && $i < $max; $i++)
	$arr[] = $vec->get($i);
	return $arr;
	}

	/**
	* Build a libkolabxml vector (string) from a PHP array
	*
	* @param array Array with vector elements
	* @return object vectors
	*/
	public static function array2vector($arr)
	{
	$vec = new vectors;
	foreach ((array)$arr as $val) {
	if (strlen($val))
	$vec->push($val);
	}
	return $vec;
	}

	/**
	* Check for format errors after calling kolabformat::write*()
	*
	* @return boolean True if there were errors, False if OK
	*/
	protected function format_errors()
	{
	$ret = $log = false;
	switch (kolabformat::error()) {
	case kolabformat.NoError:
	$ret = false;
	break;
	case kolabformat.Warning:
	$ret = false;
	$log = "Warning";
	break;
	default:
	$ret = true;
	$log = "Error";
	}

	if ($log) {
	raise_error(array(
	'code' => 660,
	'type' => 'php',
	'file' => __FILE__,
	'line' => __LINE__,
	'message' => "kolabformat write $log: " . kolabformat::errorMessage(),
	), true);
	}

	return $ret;
	}

	/**
	* Save the last generated UID to the object properties.
	* Should be called after kolabformat::writeXXXX();
	*/
	protected function update_uid()
	{
	// get generated UID
	if (!$this->data['uid']) {
	$this->data['uid'] = kolabformat::getSerializedUID();
	$this->obj->setUid($this->data['uid']);
	}
	}

	/**
	* Initialize libkolabxml object with cached xml data
	*/
	protected function init()
	{
	if (!$this->loaded) {
	if ($this->xmldata) {
	$this->load($this->xmldata);
	$this->xmldata = null;
	}
	$this->loaded = true;
	}
	}

	/**
	* Direct getter for object properties
	*/
	public function __get($var)
	{
	return $this->data[$var];
	}

	/**
	* Load Kolab object data from the given XML block
	*
	* @param string XML data
	*/
	- abstract public function load($xml);
	+ public function load($xml)
	+ {
	+ $this->obj = call_user_func($this->read_func, $xml, false);
	+ $this->loaded = !$this->format_errors();
	+ }

	/**
	- * Set properties to the kolabformat object
	+ * Write object data to XML format
	*
	- * @param array Object data as hash array
	+ * @return string XML data
	*/
	- abstract public function set(&$object);
	+ public function write()
	+ {
	+ $this->init();
	+ $this->xmldata = call_user_func($this->write_func, $this->obj);
	+
	+ if (!$this->format_errors())
	+ $this->update_uid();
	+ else
	+ $this->xmldata = null;
	+
	+ return $this->xmldata;
	+ }

	/**
	+ * Set properties to the kolabformat object
	*
	+ * @param array Object data as hash array
	*/
	- abstract public function is_valid();
	+ abstract public function set(&$object);

	/**
	- * Write object data to XML format
	*
	- * @return string XML data
	*/
	- abstract public function write();
	+ abstract public function is_valid();

	/**
	* Convert the Kolab object into a hash array data structure
	*
	* @return array Kolab object data as hash array
	*/
	abstract public function to_array();

	/**
	* Load object data from Kolab2 format
	*
	* @param array Hash array with object properties (produced by Horde Kolab_Format classes)
	*/
	abstract public function fromkolab2($object);

	/**
	* Callback for kolab_storage_cache to get object specific tags to cache
	*
	* @return array List of tags to save in cache
	*/
	public function get_tags()
	{
	return array();
	}

	/**
	* 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()
	{
	return array();
	}
	}
	diff --git a/plugins/libkolab/lib/kolab_format_contact.php b/plugins/libkolab/lib/kolab_format_contact.php
	index d6da2352..d39b32e0 100644
	--- a/plugins/libkolab/lib/kolab_format_contact.php
	+++ b/plugins/libkolab/lib/kolab_format_contact.php
	@@ -1,532 +1,506 @@
	<?php

	/**
	* Kolab Contact model class
	*
	* @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/>.
	*/

	class kolab_format_contact extends kolab_format
	{
	public $CTYPE = 'application/vcard+xml';

	+ protected $read_func = 'kolabformat::readContact';
	+ protected $write_func = 'kolabformat::writeContact';
	+
	public static $fulltext_cols = array('name', 'firstname', 'surname', 'middlename', 'email');

	public $phonetypes = array(
	'home' => Telephone::Home,
	'work' => Telephone::Work,
	'text' => Telephone::Text,
	'main' => Telephone::Voice,
	'homefax' => Telephone::Fax,
	'workfax' => Telephone::Fax,
	'mobile' => Telephone::Cell,
	'video' => Telephone::Video,
	'pager' => Telephone::Pager,
	'car' => Telephone::Car,
	'other' => Telephone::Textphone,
	);

	public $addresstypes = array(
	'home' => Address::Home,
	'work' => Address::Work,
	'office' => 0,
	);

	private $gendermap = array(
	'female' => Contact::Female,
	'male' => Contact::Male,
	);

	private $relatedmap = array(
	'manager' => Related::Manager,
	'assistant' => Related::Assistant,
	'spouse' => Related::Spouse,
	'children' => Related::Child,
	);

	// old Kolab 2 format field map
	private $kolab2_fieldmap = array(
	// kolab => roundcube
	'full-name' => 'name',
	'given-name' => 'firstname',
	'middle-names' => 'middlename',
	'last-name' => 'surname',
	'prefix' => 'prefix',
	'suffix' => 'suffix',
	'nick-name' => 'nickname',
	'organization' => 'organization',
	'department' => 'department',
	'job-title' => 'jobtitle',
	'birthday' => 'birthday',
	'anniversary' => 'anniversary',
	'phone' => 'phone',
	'im-address' => 'im',
	'web-page' => 'website',
	'profession' => 'profession',
	'manager-name' => 'manager',
	'assistant' => 'assistant',
	'spouse-name' => 'spouse',
	'children' => 'children',
	'body' => 'notes',
	'pgp-publickey' => 'pgppublickey',
	'free-busy-url' => 'freebusyurl',
	'picture' => 'photo',
	);
	private $kolab2_phonetypes = array(
	'home1' => 'home',
	'business1' => 'work',
	'business2' => 'work',
	'businessfax' => 'workfax',
	);
	private $kolab2_addresstypes = array(
	'business' => 'work'
	);
	private $kolab2_gender = array(0 => 'male', 1 => 'female');


	/**
	* Default constructor
	*/
	function __construct($xmldata = null)
	{
	$this->obj = new Contact;
	$this->xmldata = $xmldata;

	// complete phone types
	$this->phonetypes['homefax'] \|= Telephone::Home;
	$this->phonetypes['workfax'] \|= Telephone::Work;
	}

	- /**
	- * Load Contact object data from the given XML block
	- *
	- * @param string XML data
	- */
	- public function load($xml)
	- {
	- $this->obj = kolabformat::readContact($xml, false);
	- $this->loaded = true;
	- }
	-
	- /**
	- * Write Contact object data to XML format
	- *
	- * @return string XML data
	- */
	- public function write()
	- {
	- $this->init();
	- $this->xmldata = kolabformat::writeContact($this->obj);
	-
	- if (!parent::format_errors())
	- parent::update_uid();
	- else
	- $this->xmldata = null;
	-
	- return $this->xmldata;
	- }
	-
	/**
	* Set contact properties to the kolabformat object
	*
	* @param array Contact data as hash array
	*/
	public function set(&$object)
	{
	$this->init();

	// set some automatic values if missing
	if (false && !$this->obj->created()) {
	if (!empty($object['created']))
	$object['created'] = new DateTime('now', self::$timezone);
	$this->obj->setCreated(self::get_datetime($object['created']));
	}

	if (!empty($object['uid']))
	$this->obj->setUid($object['uid']);

	// do the hard work of setting object values
	$nc = new NameComponents;
	$nc->setSurnames(self::array2vector($object['surname']));
	$nc->setGiven(self::array2vector($object['firstname']));
	$nc->setAdditional(self::array2vector($object['middlename']));
	$nc->setPrefixes(self::array2vector($object['prefix']));
	$nc->setSuffixes(self::array2vector($object['suffix']));
	$this->obj->setNameComponents($nc);
	$this->obj->setName($object['name']);

	if (isset($object['nickname']))
	$this->obj->setNickNames(self::array2vector($object['nickname']));
	if (isset($object['profession']))
	$this->obj->setTitles(self::array2vector($object['profession']));

	// organisation related properties (affiliation)
	$org = new Affiliation;
	$offices = new vectoraddress;
	if ($object['organization'])
	$org->setOrganisation($object['organization']);
	if ($object['department'])
	$org->setOrganisationalUnits(self::array2vector($object['department']));
	if ($object['jobtitle'])
	$org->setRoles(self::array2vector($object['jobtitle']));

	$rels = new vectorrelated;
	if ($object['manager']) {
	foreach ((array)$object['manager'] as $manager)
	$rels->push(new Related(Related::Text, $manager, Related::Manager));
	}
	if ($object['assistant']) {
	foreach ((array)$object['assistant'] as $assistant)
	$rels->push(new Related(Related::Text, $assistant, Related::Assistant));
	}
	$org->setRelateds($rels);

	// email, im, url
	$this->obj->setEmailAddresses(self::array2vector($object['email']));
	$this->obj->setIMaddresses(self::array2vector($object['im']));

	$vurls = new vectorurl;
	foreach ((array)$object['website'] as $url) {
	$type = $url['type'] == 'blog' ? Url::Blog : Url::None;
	$vurls->push(new Url($url['url'], $type));
	}
	$this->obj->setUrls($vurls);

	// addresses
	$adrs = new vectoraddress;
	foreach ((array)$object['address'] as $address) {
	$adr = new Address;
	$type = $this->addresstypes[$address['type']];
	if (isset($type))
	$adr->setTypes($type);
	else if ($address['type'])
	$adr->setLabel($address['type']);
	if ($address['street'])
	$adr->setStreet($address['street']);
	if ($address['locality'])
	$adr->setLocality($address['locality']);
	if ($address['code'])
	$adr->setCode($address['code']);
	if ($address['region'])
	$adr->setRegion($address['region']);
	if ($address['country'])
	$adr->setCountry($address['country']);

	if ($address['type'] == 'office')
	$offices->push($adr);
	else
	$adrs->push($adr);
	}
	$this->obj->setAddresses($adrs);
	$org->setAddresses($offices);

	// add org affiliation after addresses are set
	$orgs = new vectoraffiliation;
	$orgs->push($org);
	$this->obj->setAffiliations($orgs);

	// telephones
	$tels = new vectortelephone;
	foreach ((array)$object['phone'] as $phone) {
	$tel = new Telephone;
	if (isset($this->phonetypes[$phone['type']]))
	$tel->setTypes($this->phonetypes[$phone['type']]);
	$tel->setNumber($phone['number']);
	$tels->push($tel);
	}
	$this->obj->setTelephones($tels);

	if (isset($object['gender']))
	$this->obj->setGender($this->gendermap[$object['gender']] ? $this->gendermap[$object['gender']] : Contact::NotSet);
	if (isset($object['notes']))
	$this->obj->setNote($object['notes']);
	if (isset($object['freebusyurl']))
	$this->obj->setFreeBusyUrl($object['freebusyurl']);
	if (isset($object['birthday']))
	$this->obj->setBDay(self::get_datetime($object['birthday'], null, true));
	if (isset($object['anniversary']))
	$this->obj->setAnniversary(self::get_datetime($object['anniversary'], null, true));

	if (!empty($object['photo'])) {
	if ($type = rc_image_content_type($object['photo']))
	$this->obj->setPhoto($object['photo'], $type);
	}
	else if (isset($object['photo']))
	$this->obj->setPhoto('','');
	else if ($this->obj->photoMimetype()) // load saved photo for caching
	$object['photo'] = $this->obj->photo();

	// spouse and children are relateds
	$rels = new vectorrelated;
	if ($object['spouse']) {
	$rels->push(new Related(Related::Text, $object['spouse'], Related::Spouse));
	}
	if ($object['children']) {
	foreach ((array)$object['children'] as $child)
	$rels->push(new Related(Related::Text, $child, Related::Child));
	}
	$this->obj->setRelateds($rels);

	// insert/replace crypto keys
	$pgp_index = $pkcs7_index = -1;
	$keys = $this->obj->keys();
	for ($i=0; $i < $keys->size(); $i++) {
	$key = $keys->get($i);
	if ($pgp_index < 0 && $key->type() == Key::PGP)
	$pgp_index = $i;
	else if ($pkcs7_index < 0 && $key->type() == Key::PKCS7_MIME)
	$pkcs7_index = $i;
	}

	$pgpkey = $object['pgppublickey'] ? new Key($object['pgppublickey'], Key::PGP) : new Key();
	$pkcs7key = $object['pkcs7publickey'] ? new Key($object['pkcs7publickey'], Key::PKCS7_MIME) : new Key();

	if ($pgp_index >= 0)
	$keys->set($pgp_index, $pgpkey);
	else if (!empty($object['pgppublickey']))
	$keys->push($pgpkey);
	if ($pkcs7_index >= 0)
	$keys->set($pkcs7_index, $pkcs7key);
	else if (!empty($object['pkcs7publickey']))
	$keys->push($pkcs7key);

	$this->obj->setKeys($keys);

	// TODO: handle language, gpslocation, etc.


	// cache this data
	$this->data = $object;
	unset($this->data['_formatobj']);
	}

	/**
	*
	*/
	public function is_valid()
	{
	return $this->data \|\| (is_object($this->obj) && $this->obj->uid() /$this->obj->isValid()/);
	}

	/**
	* Convert the Contact object into a hash array data structure
	*
	* @return array Contact data as hash array
	*/
	public function to_array()
	{
	// return cached result
	if (!empty($this->data))
	return $this->data;

	$this->init();

	// read object properties into local data object
	$object = array(
	'uid' => $this->obj->uid(),
	# 'changed' => $this->obj->lastModified(),
	'name' => $this->obj->name(),
	);

	$nc = $this->obj->nameComponents();
	$object['surname'] = join(' ', self::vector2array($nc->surnames()));
	$object['firstname'] = join(' ', self::vector2array($nc->given()));
	$object['middlename'] = join(' ', self::vector2array($nc->additional()));
	$object['prefix'] = join(' ', self::vector2array($nc->prefixes()));
	$object['suffix'] = join(' ', self::vector2array($nc->suffixes()));
	$object['nickname'] = join(' ', self::vector2array($this->obj->nickNames()));
	$object['profession'] = join(' ', self::vector2array($this->obj->titles()));

	// organisation related properties (affiliation)
	$orgs = $this->obj->affiliations();
	if ($orgs->size()) {
	$org = $orgs->get(0);
	$object['organization'] = $org->organisation();
	$object['jobtitle'] = join(' ', self::vector2array($org->roles()));
	$object['department'] = join(' ', self::vector2array($org->organisationalUnits()));
	$this->read_relateds($org->relateds(), $object);
	}

	$object['email'] = self::vector2array($this->obj->emailAddresses());
	$object['im'] = self::vector2array($this->obj->imAddresses());

	$urls = $this->obj->urls();
	for ($i=0; $i < $urls->size(); $i++) {
	$url = $urls->get($i);
	$subtype = $url->type() == Url::Blog ? 'blog' : 'homepage';
	$object['website'][] = array('url' => $url->url(), 'type' => $subtype);
	}

	// addresses
	$this->read_addresses($this->obj->addresses(), $object);
	if ($org && ($offices = $org->addresses()))
	$this->read_addresses($offices, $object, 'office');

	// telehones
	$tels = $this->obj->telephones();
	$teltypes = array_flip($this->phonetypes);
	for ($i=0; $i < $tels->size(); $i++) {
	$tel = $tels->get($i);
	$object['phone'][] = array('number' => $tel->number(), 'type' => $teltypes[$tel->types()]);
	}

	$object['notes'] = $this->obj->note();
	$object['freebusyurl'] = $this->obj->freeBusyUrl();

	if ($bday = self::php_datetime($this->obj->bDay()))
	$object['birthday'] = $bday->format('c');

	if ($anniversary = self::php_datetime($this->obj->anniversary()))
	$object['anniversary'] = $anniversary->format('c');

	$gendermap = array_flip($this->gendermap);
	if (($g = $this->obj->gender()) && $gendermap[$g])
	$object['gender'] = $gendermap[$g];

	if ($this->obj->photoMimetype())
	$object['photo'] = $this->obj->photo();

	// relateds -> spouse, children
	$this->read_relateds($this->obj->relateds(), $object);

	// crypto settings: currently only key values are supported
	$keys = $this->obj->keys();
	for ($i=0; is_object($keys) && $i < $keys->size(); $i++) {
	$key = $keys->get($i);
	if ($key->type() == Key::PGP)
	$object['pgppublickey'] = $key->key();
	else if ($key->type() == Key::PKCS7_MIME)
	$object['pkcs7publickey'] = $key->key();
	}

	$this->data = $object;
	return $this->data;
	}

	/**
	* 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 $col) {
	$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));
	}

	/**
	* Load data from old Kolab2 format
	*
	* @param array Hash array with object properties
	*/
	public function fromkolab2($record)
	{
	$object = array(
	'uid' => $record['uid'],
	'email' => array(),
	'phone' => array(),
	);

	foreach ($this->kolab2_fieldmap as $kolab => $rcube) {
	if (is_array($record[$kolab]) \|\| strlen($record[$kolab]))
	$object[$rcube] = $record[$kolab];
	}

	if (isset($record['gender']))
	$object['gender'] = $this->kolab2_gender[$record['gender']];

	foreach ((array)$record['email'] as $i => $email)
	$object['email'][] = $email['smtp-address'];

	if (!$record['email'] && $record['emails'])
	$object['email'] = preg_split('/,\s*/', $record['emails']);

	if (is_array($record['address'])) {
	foreach ($record['address'] as $i => $adr) {
	$object['address'][] = array(
	'type' => $this->kolab2_addresstypes[$adr['type']] ? $this->kolab2_addresstypes[$adr['type']] : $adr['type'],
	'street' => $adr['street'],
	'locality' => $adr['locality'],
	'code' => $adr['postal-code'],
	'region' => $adr['region'],
	'country' => $adr['country'],
	);
	}
	}

	// office location goes into an address block
	if ($record['office-location'])
	$object['address'][] = array('type' => 'office', 'locality' => $record['office-location']);

	// merge initials into nickname
	if ($record['initials'])
	$object['nickname'] = trim($object['nickname'] . ', ' . $record['initials'], ', ');

	// remove empty fields
	$this->data = array_filter($object);
	}

	/**
	* Helper method to copy contents of an Address vector to the contact data object
	*/
	private function read_addresses($addresses, &$object, $type = null)
	{
	$adrtypes = array_flip($this->addresstypes);

	for ($i=0; $i < $addresses->size(); $i++) {
	$adr = $addresses->get($i);
	$object['address'][] = array(
	'type' => $type ? $type : ($adrtypes[$adr->types()] ? $adrtypes[$adr->types()] : ''), /$adr->label()),/
	'street' => $adr->street(),
	'code' => $adr->code(),
	'locality' => $adr->locality(),
	'region' => $adr->region(),
	'country' => $adr->country()
	);
	}
	}

	/**
	* Helper method to map contents of a Related vector to the contact data object
	*/
	private function read_relateds($rels, &$object)
	{
	$typemap = array_flip($this->relatedmap);

	for ($i=0; $i < $rels->size(); $i++) {
	$rel = $rels->get($i);
	if ($rel->type() != Related::Text) // we can't handle UID relations yet
	continue;

	$types = $rel->relationTypes();
	foreach ($typemap as $t => $field) {
	if ($types & $t) {
	$object[$field][] = $rel->text();
	break;
	}
	}
	}
	}
	}
	diff --git a/plugins/libkolab/lib/kolab_format_distributionlist.php b/plugins/libkolab/lib/kolab_format_distributionlist.php
	index 592387e2..3931c61d 100644
	--- a/plugins/libkolab/lib/kolab_format_distributionlist.php
	+++ b/plugins/libkolab/lib/kolab_format_distributionlist.php
	@@ -1,160 +1,140 @@
	<?php

	/**
	* Kolab Distribution List model class
	*
	* @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/>.
	*/

	class kolab_format_distributionlist extends kolab_format
	{
	public $CTYPE = 'application/vcard+xml';

	+ protected $read_func = 'kolabformat::readDistlist';
	+ protected $write_func = 'kolabformat::writeDistlist';
	+
	+
	function __construct($xmldata = null)
	{
	$this->obj = new DistList;
	$this->xmldata = $xmldata;
	}

	/**
	- * Load Kolab object data from the given XML block
	- *
	- * @param string XML data
	- */
	- public function load($xml)
	- {
	- $this->obj = kolabformat::readDistlist($xml, false);
	- $this->loaded = true;
	- }
	-
	- /**
	- * Write object data to XML format
	+ * Set properties to the kolabformat object
	*
	- * @return string XML data
	+ * @param array Object data as hash array
	*/
	- public function write()
	- {
	- $this->init();
	- $this->xmldata = kolabformat::writeDistlist($this->obj);
	-
	- if (!parent::format_errors())
	- parent::update_uid();
	- else
	- $this->xmldata = null;
	-
	- return $this->xmldata;
	- }
	-
	public function set(&$object)
	{
	$this->init();

	// set some automatic values if missing
	if (!empty($object['uid']))
	$this->obj->setUid($object['uid']);

	$this->obj->setName($object['name']);

	$seen = array();
	$members = new vectorcontactref;
	foreach ($object['member'] as $member) {
	if ($member['uid'])
	$m = new ContactReference(ContactReference::UidReference, $member['uid']);
	else if ($member['email'])
	$m = new ContactReference(ContactReference::EmailReference, $member['email']);
	else
	continue;

	$m->setName($member['name']);
	$members->push($m);
	$seen[$member['email']]++;
	}

	$this->obj->setMembers($members);

	// cache this data
	$this->data = $object;
	unset($this->data['_formatobj']);
	}

	public function is_valid()
	{
	return $this->data \|\| (is_object($this->obj) && $this->obj->isValid());
	}

	/**
	* Load data from old Kolab2 format
	*/
	public function fromkolab2($record)
	{
	$object = array(
	'uid' => $record['uid'],
	'changed' => $record['last-modification-date'],
	'name' => $record['last-name'],
	'member' => array(),
	);

	foreach ($record['member'] as $member) {
	$object['member'][] = array(
	'email' => $member['smtp-address'],
	'name' => $member['display-name'],
	'uid' => $member['uid'],
	);
	}

	$this->data = $object;
	}

	/**
	* Convert the Distlist object into a hash array data structure
	*
	* @return array Distribution list data as hash array
	*/
	public function to_array()
	{
	// return cached result
	if (!empty($this->data))
	return $this->data;

	$this->init();

	// read object properties
	$object = array(
	'uid' => $this->obj->uid(),
	-# 'changed' => $this->obj->lastModified(),
	+ 'changed' => $this->obj->lastModified(),
	'name' => $this->obj->name(),
	'member' => array(),
	);

	$members = $this->obj->members();
	for ($i=0; $i < $members->size(); $i++) {
	$member = $members->get($i);
	# if ($member->type() == ContactReference::UidReference && ($uid = $member->uid()))
	$object['member'][] = array(
	'uid' => $member->uid(),
	'email' => $member->email(),
	'name' => $member->name(),
	);
	}

	$this->data = $object;
	return $this->data;
	}

	}
	diff --git a/plugins/libkolab/lib/kolab_format_event.php b/plugins/libkolab/lib/kolab_format_event.php
	index 699cfb81..aec4e8d1 100644
	--- a/plugins/libkolab/lib/kolab_format_event.php
	+++ b/plugins/libkolab/lib/kolab_format_event.php
	@@ -1,638 +1,612 @@
	<?php

	/**
	* Kolab Event model class
	*
	* @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/>.
	*/

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

	+ protected $read_func = 'kolabformat::readEvent';
	+ protected $write_func = 'kolabformat::writeEvent';
	+
	public static $fulltext_cols = array('title', 'description', 'location', 'attendees:name', 'attendees:email');

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

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

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

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

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

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

	private $kolab2_rolemap = array(
	'required' => 'REQ-PARTICIPANT',
	'optional' => 'OPT-PARTICIPANT',
	'resource' => 'CHAIR',
	);
	private $kolab2_statusmap = array(
	'none' => 'NEEDS-ACTION',
	'tentative' => 'TENTATIVE',
	'accepted' => 'CONFIRMED',
	'accepted' => 'ACCEPTED',
	'declined' => 'DECLINED',
	);
	private $kolab2_monthmap = array('', 'january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december');


	/**
	* Default constructor
	*/
	function __construct($xmldata = null)
	{
	$this->obj = new Event;
	$this->xmldata = $xmldata;
	}

	- /**
	- * Load Contact object data from the given XML block
	- *
	- * @param string XML data
	- */
	- public function load($xml)
	- {
	- $this->obj = kolabformat::readEvent($xml, false);
	- $this->loaded = true;
	- }
	-
	- /**
	- * Write Contact object data to XML format
	- *
	- * @return string XML data
	- */
	- public function write()
	- {
	- $this->init();
	- $this->xmldata = kolabformat::writeEvent($this->obj);
	-
	- if (!parent::format_errors())
	- parent::update_uid();
	- else
	- $this->xmldata = null;
	-
	- return $this->xmldata;
	- }
	-
	/**
	* Set contact properties to the kolabformat object
	*
	* @param array Contact data as hash array
	*/
	public function set(&$object)
	{
	$this->init();

	// set some automatic values if missing
	if (!$this->obj->created()) {
	if (!empty($object['created']))
	$object['created'] = new DateTime('now', self::$timezone);
	$this->obj->setCreated(self::get_datetime($object['created']));
	}

	if (!empty($object['uid']))
	$this->obj->setUid($object['uid']);

	// increment sequence
	$this->obj->setSequence($this->obj->sequence()+1);

	// do the hard work of setting object values
	$this->obj->setStart(self::get_datetime($object['start'], null, $object['allday']));
	$this->obj->setEnd(self::get_datetime($object['end'], null, $object['allday']));
	$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->setTransparency($object['free_busy'] == 'free');

	$status = kolabformat::StatusUndefined;
	if ($object['free_busy'] == 'tentative')
	$status = kolabformat::StatusTentative;
	if ($object['cancelled'])
	$status = kolabformat::StatusCancelled;
	$this->obj->setStatus($status);

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

	if ($attendee['role'] == 'ORGANIZER') {
	$organizer = $cr;
	}
	else {
	$att = new Attendee;
	$att->setContact($cr);
	$att->setPartStat($this->status_map[$attendee['status']]);
	$att->setRole($this->role_map[$attendee['role']] ? $this->role_map[$attendee['role']] : kolabformat::Required);
	$att->setRSVP((bool)$attendee['rsvp']);

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

	// save recurrence rule
	if ($object['recurrence']) {
	$rr = new RecurrenceRule;
	$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()) {
	$this->obj->setRecurrenceRule($rr);

	// 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 {
	raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid event recurrence rule: " . json_encode($object['recurrence']),
	), true);
	}
	}

	// 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);

	// save attachments
	$vattach = new vectorattachment;
	foreach ((array)$object['_attachments'] as $name => $attr) {
	if (empty($attr))
	continue;
	$attach = new Attachment;
	$attach->setLabel($name);
	$attach->setUri('cid:' . $name, $attr['mimetype']);
	$vattach->push($attach);
	}
	$this->obj->setAttachments($vattach);

	// cache this data
	$this->data = $object;
	unset($this->data['_formatobj']);
	}

	/**
	*
	*/
	public function is_valid()
	{
	return $this->data \|\| (is_object($this->obj) && $this->obj->isValid() && $this->obj->uid());
	}

	/**
	* Convert the Contact object into a hash array data structure
	*
	* @return array Contact data as hash array
	*/
	public function to_array()
	{
	// return cached result
	if (!empty($this->data))
	return $this->data;

	$this->init();

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

	// read object properties
	$object = array(
	'uid' => $this->obj->uid(),
	'changed' => self::php_datetime($this->obj->lastModified()),
	'title' => $this->obj->summary(),
	'location' => $this->obj->location(),
	'description' => $this->obj->description(),
	'allday' => $this->obj->start()->isDateOnly(),
	'start' => self::php_datetime($this->obj->start()),
	'end' => self::php_datetime($this->obj->end()),
	'categories' => self::vector2array($this->obj->categories()),
	'free_busy' => $this->obj->transparency() ? 'free' : 'busy', // TODO: transparency is only boolean
	'sensitivity' => $sensitivity_map[$this->obj->classification()],
	'priority' => $this->obj->priority(),
	);

	// status defines different event properties...
	$status = $this->obj->status();
	if ($status == kolabformat::StatusTentative)
	$object['free_busy'] = 'tentative';
	else if ($status == kolabformat::StatusCancelled)
	$objec['cancelled'] = true;

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

	$role_map = array_flip($this->role_map);
	$status_map = array_flip($this->status_map);
	$attvec = $this->obj->attendees();
	for ($i=0; $i < $attvec->size(); $i++) {
	$attendee = $attvec->get($i);
	$cr = $attendee->contact();
	$object['attendees'][] = array(
	'role' => $role_map[$attendee->role()],
	'status' => $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->format('U');
	}

	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 ($exceptions = $this->obj->exceptionDates()) {
	for ($i=0; $i < $exceptions->size(); $i++) {
	if ($exdate = self::php_datetime($exceptions->get($i)))
	$object['recurrence']['EXDATE'][] = $exdate->format('U');
	}
	}
	}

	// 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;
	}
	}

	// handle attachments
	$vattach = $this->obj->attachments();
	for ($i=0; $i < $vattach->size(); $i++) {
	$attach = $vattach->get($i);

	// skip cid: attachments which are mime message parts handled by kolab_storage_folder
	if (substr($attach->uri(), 0, 4) != 'cid') {
	$name = $attach->label();
	$data = $attach->data();
	$object['_attachments'][$name] = array(
	'mimetype' => $attach->mimetype(),
	'size' => strlen($data),
	'content' => $data,
	);
	}
	}

	$this->data = $object;
	return $this->data;
	}

	/**
	* Callback for kolab_storage_cache to get object specific tags to cache
	*
	* @return array List of tags to save in cache
	*/
	public function get_tags()
	{
	$tags = array();

	foreach ((array)$this->data['categories'] as $cat) {
	$tags[] = rcube_utils::normalize_string($cat);
	}

	if (!empty($this->data['alarms'])) {
	$tags[] = 'x-has-alarms';
	}

	return $tags;
	}

	/**
	* 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));
	}

	/**
	* Load data from old Kolab2 format
	*/
	public function fromkolab2($rec)
	{
	if (PEAR::isError($rec))
	return;

	$start_time = date('H:i:s', $rec['start-date']);
	$allday = $rec['_is_all_day'] \|\| ($start_time == '00:00:00' && $start_time == date('H:i:s', $rec['end-date']));

	// in Roundcube all-day events go from 12:00 to 13:00
	if ($allday) {
	$now = new DateTime('now', self::$timezone);
	$gmt_offset = $now->getOffset();

	$rec['start-date'] += 12 * 3600;
	$rec['end-date'] -= 11 * 3600;
	$rec['end-date'] -= $gmt_offset - date('Z', $rec['end-date']); // shift times from server's timezone to user's timezone
	$rec['start-date'] -= $gmt_offset - date('Z', $rec['start-date']); // because generated with mktime() in Horde_Kolab_Format_Date::decodeDate()
	// sanity check
	if ($rec['end-date'] <= $rec['start-date'])
	$rec['end-date'] += 86400;
	}

	// convert alarm time into internal format
	if ($rec['alarm']) {
	$alarm_value = $rec['alarm'];
	$alarm_unit = 'M';
	if ($rec['alarm'] % 1440 == 0) {
	$alarm_value /= 1440;
	$alarm_unit = 'D';
	}
	else if ($rec['alarm'] % 60 == 0) {
	$alarm_value /= 60;
	$alarm_unit = 'H';
	}
	$alarm_value *= -1;
	}

	// convert recurrence rules into internal pseudo-vcalendar format
	if ($recurrence = $rec['recurrence']) {
	$rrule = array(
	'FREQ' => strtoupper($recurrence['cycle']),
	'INTERVAL' => intval($recurrence['interval']),
	);

	if ($recurrence['range-type'] == 'number')
	$rrule['COUNT'] = intval($recurrence['range']);
	else if ($recurrence['range-type'] == 'date')
	$rrule['UNTIL'] = $recurrence['range'];

	if ($recurrence['day']) {
	$byday = array();
	$prefix = ($rrule['FREQ'] == 'MONTHLY' \|\| $rrule['FREQ'] == 'YEARLY') ? intval($recurrence['daynumber'] ? $recurrence['daynumber'] : 1) : '';
	foreach ($recurrence['day'] as $day)
	$byday[] = $prefix . substr(strtoupper($day), 0, 2);
	$rrule['BYDAY'] = join(',', $byday);
	}
	if ($recurrence['daynumber']) {
	if ($recurrence['type'] == 'monthday' \|\| $recurrence['type'] == 'daynumber')
	$rrule['BYMONTHDAY'] = $recurrence['daynumber'];
	else if ($recurrence['type'] == 'yearday')
	$rrule['BYYEARDAY'] = $recurrence['daynumber'];
	}
	if ($recurrence['month']) {
	$monthmap = array_flip($this->kolab2_monthmap);
	$rrule['BYMONTH'] = strtolower($monthmap[$recurrence['month']]);
	}

	if ($recurrence['exclusion']) {
	foreach ((array)$recurrence['exclusion'] as $excl)
	$rrule['EXDATE'][] = strtotime($excl . date(' H:i:s', $rec['start-date'])); // use time of event start
	}
	}

	$attendees = array();
	if ($rec['organizer']) {
	$attendees[] = array(
	'role' => 'ORGANIZER',
	'name' => $rec['organizer']['display-name'],
	'email' => $rec['organizer']['smtp-address'],
	'status' => 'ACCEPTED',
	);
	$_attendees .= $rec['organizer']['display-name'] . ' ' . $rec['organizer']['smtp-address'] . ' ';
	}

	foreach ((array)$rec['attendee'] as $attendee) {
	$attendees[] = array(
	'role' => $this->kolab2_rolemap[$attendee['role']],
	'name' => $attendee['display-name'],
	'email' => $attendee['smtp-address'],
	'status' => $this->kolab2_statusmap[$attendee['status']],
	'rsvp' => $attendee['request-response'],
	);
	$_attendees .= $rec['organizer']['display-name'] . ' ' . $rec['organizer']['smtp-address'] . ' ';
	}

	$this->data = array(
	'uid' => $rec['uid'],
	'title' => $rec['summary'],
	'location' => $rec['location'],
	'description' => $rec['body'],
	'start' => $rec['start-date'],
	'end' => $rec['end-date'],
	'allday' => $allday,
	'recurrence' => $rrule,
	'alarms' => $alarm_value . $alarm_unit,
	'categories' => explode(',', $rec['categories']),
	'attachments' => $attachments,
	'attendees' => $attendees,
	'free_busy' => $rec['show-time-as'],
	'priority' => $rec['priority'],
	'sensitivity' => $rec['sensitivity'],
	'changed' => $rec['last-modification-date'],
	);
	}
	}
	diff --git a/plugins/libkolab/lib/kolab_storage_cache.php b/plugins/libkolab/lib/kolab_storage_cache.php
	index be94bb87..370eac1e 100644
	--- a/plugins/libkolab/lib/kolab_storage_cache.php
	+++ b/plugins/libkolab/lib/kolab_storage_cache.php
	@@ -1,568 +1,577 @@
	<?php

	/**
	* Kolab storage cache class providing a local caching layer for Kolab groupware objects.
	*
	* @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/>.
	*/

	class kolab_storage_cache
	{
	private $db;
	private $imap;
	private $folder;
	private $uid2msg;
	private $objects;
	private $index = array();
	private $resource_uri;
	private $enabled = true;
	private $synched = false;
	private $ready = false;

	private $binary_cols = array('photo','pgppublickey','pkcs7publickey');


	/**
	* Default constructor
	*/
	public function __construct(kolab_storage_folder $storage_folder = null)
	{
	$rcmail = rcube::get_instance();
	$this->db = $rcmail->get_dbh();
	$this->imap = $rcmail->get_storage();
	$this->enabled = $rcmail->config->get('kolab_cache', false);

	if ($storage_folder)
	$this->set_folder($storage_folder);
	}


	/**
	* Connect cache with a storage folder
	*
	* @param kolab_storage_folder The storage folder instance to connect with
	*/
	public function set_folder(kolab_storage_folder $storage_folder)
	{
	$this->folder = $storage_folder;

	if (empty($this->folder->name)) {
	$this->ready = false;
	return;
	}

	// compose fully qualified ressource uri for this instance
	$this->resource_uri = $this->folder->get_resource_uri();
	$this->ready = $this->enabled;
	}


	/**
	* Synchronize local cache data with remote
	*/
	public function synchronize()
	{
	// only sync once per request cycle
	if ($this->synched)
	return;

	// lock synchronization for this folder or wait if locked
	$this->_sync_lock();

	// synchronize IMAP mailbox cache
	$this->imap->folder_sync($this->folder->name);

	// compare IMAP index with object cache index
	$imap_index = $this->imap->index($this->folder->name);
	$this->index = $imap_index->get();

	// determine objects to fetch or to invalidate
	if ($this->ready) {
	// read cache index
	$sql_result = $this->db->query(
	"SELECT msguid, uid FROM kolab_cache WHERE resource=? AND type<>?",
	$this->resource_uri,
	'lock'
	);

	$old_index = array();
	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	$old_index[] = $sql_arr['msguid'];
	$this->uid2msg[$sql_arr['uid']] = $sql_arr['msguid'];
	}

	// fetch new objects from imap
	$fetch_index = array_diff($this->index, $old_index);
	foreach ($this->_fetch($fetch_index, '*') as $object) {
	$msguid = $object['_msguid'];
	$this->set($msguid, $object);
	}

	// delete invalid entries from local DB
	$del_index = array_diff($old_index, $this->index);
	if (!empty($del_index)) {
	$quoted_ids = join(',', array_map(array($this->db, 'quote'), $del_index));
	$this->db->query(
	"DELETE FROM kolab_cache WHERE resource=? AND msguid IN ($quoted_ids)",
	$this->resource_uri
	);
	}
	}

	// remove lock
	$this->_sync_unlock();

	$this->synched = time();
	}


	/**
	* Read a single entry from cache or
	*
	* @param string Related IMAP message UID
	* @param string Object type to read
	* @param string IMAP folder name the entry relates to
	* @param array Hash array with object properties or null if not found
	*/
	public function get($msguid, $type = null, $foldername = null)
	{
	// delegate to another cache instance
	if ($foldername && $foldername != $this->folder->name) {
	return kolab_storage::get_folder($foldername)->cache->get($msguid, $object);
	}

	// load object if not in memory
	if (!isset($this->objects[$msguid])) {
	if ($this->ready) {
	$sql_result = $this->db->query(
	"SELECT * FROM kolab_cache ".
	"WHERE resource=? AND msguid=?",
	$this->resource_uri,
	$msguid
	);

	if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	$this->objects[$msguid] = $this->_unserialize($sql_arr);
	}
	}

	// fetch from IMAP if not present in cache
	if (empty($this->objects[$msguid])) {
	$result = $this->_fetch(array($msguid), $type, $foldername);
	$this->objects[$msguid] = $result[0];
	}
	}

	return $this->objects[$msguid];
	}


	/**
	* Insert/Update a cache entry
	*
	* @param string Related IMAP message UID
	* @param mixed Hash array with object properties to save or false to delete the cache entry
	* @param string IMAP folder name the entry relates to
	*/
	public function set($msguid, $object, $foldername = null)
	{
	// delegate to another cache instance
	if ($foldername && $foldername != $this->folder->name) {
	kolab_storage::get_folder($foldername)->cache->set($msguid, $object);
	return;
	}

	// write to cache
	if ($this->ready) {
	// remove old entry
	$this->db->query("DELETE FROM kolab_cache WHERE resource=? AND msguid=?",
	$this->resource_uri, $msguid);

	// write new object data if not false (wich means deleted)
	if ($object) {
	$sql_data = $this->_serialize($object);
	$objtype = $object['_type'] ? $object['_type'] : $this->folder->type;

	$result = $this->db->query(
	"INSERT INTO kolab_cache ".
	" (resource, type, msguid, uid, data, xml, dtstart, dtend, tags, words)".
	" VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
	$this->resource_uri,
	$objtype,
	$msguid,
	$object['uid'],
	$sql_data['data'],
	$sql_data['xml'],
	$sql_data['dtstart'],
	$sql_data['dtend'],
	$sql_data['tags'],
	$sql_data['words']
	);

	if (!$this->db->affected_rows($result)) {
	rcmail::raise_error(array(
	'code' => 900, 'type' => 'php',
	'message' => "Failed to write to kolab cache"
	), true);
	}
	}
	}

	// keep a copy in memory for fast access
	$this->objects[$msguid] = $object;

	if ($object)
	$this->uid2msg[$object['uid']] = $msguid;
	}

	/**
	* Move an existing cache entry to a new resource
	*
	* @param string Entry's IMAP message UID
	* @param string Entry's Object UID
	* @param string Target IMAP folder to move it to
	*/
	public function move($msguid, $objuid, $target_folder)
	{
	$target = kolab_storage::get_folder($target_folder);

	// resolve new message UID in target folder
	if ($new_msguid = $target->cache->uid2msguid($objuid)) {
	$this->db->query(
	"UPDATE kolab_cache SET resource=?, msguid=? ".
	"WHERE resource=? AND msguid=?",
	$target->get_resource_uri(),
	$new_msguid,
	$this->resource_uri,
	$msguid
	);
	}
	else {
	// just clear cache entry
	$this->set($msguid, false);
	}

	unset($this->uid2msg[$uid]);
	}


	/**
	* Remove all objects from local cache
	*/
	public function purge($type = null)
	{
	$result = $this->db->query(
	"DELETE FROM kolab_cache WHERE resource=?".
	($type ? ' AND type=?' : ''),
	$this->resource_uri,
	$type
	);
	return $this->db->affected_rows($result);
	}


	/**
	* Select Kolab objects filtered by the given query
	*
	* @param array Pseudo-SQL query as list of filter parameter triplets
	* triplet: array('<colname>', '<comparator>', '<value>')
	* @return array List of Kolab data objects (each represented as hash array)
	*/
	public function select($query = array())
	{
	$result = array();

	// read from local cache DB (assume it to be synchronized)
	if ($this->ready) {
	$sql_result = $this->db->query(
	"SELECT * FROM kolab_cache ".
	"WHERE resource=? " . $this->_sql_where($query),
	$this->resource_uri
	);

	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	if ($object = $this->_unserialize($sql_arr))
	$result[] = $object;
	}
	}
	else {
	// extract object type from query parameter
	$filter = $this->_query2assoc($query);

	// use 'list' for folder's default objects
	if ($filter['type'] == $this->type) {
	$index = $this->index;
	}
	else { // search by object type
	$search = 'UNDELETED HEADER X-Kolab-Type ' . kolab_storage_folder::KTYPE_PREFIX . $filter['type'];
	$index = $this->imap->search_once($this->folder->name, $search)->get();
	}

	// fetch all messages in $index from IMAP
	$result = $this->_fetch($index, $filter['type']);

	// TODO: post-filter result according to query
	}

	return $result;
	}


	/**
	* Get number of objects mathing the given query
	*
	* @param array $query Pseudo-SQL query as list of filter parameter triplets
	* @return integer The number of objects of the given type
	*/
	public function count($query = array())
	{
	$count = 0;

	// cache is in sync, we can count records in local DB
	if ($this->synched) {
	$sql_result = $this->db->query(
	"SELECT COUNT(*) AS NUMROWS FROM kolab_cache ".
	"WHERE resource=? " . $this->_sql_where($query),
	$this->resource_uri
	);

	$sql_arr = $this->db->fetch_assoc($sql_result);
	$count = intval($sql_arr['NUMROWS']);
	}
	else {
	// search IMAP by object type
	$filter = $this->_query2assoc($query);
	$ctype = kolab_storage_folder::KTYPE_PREFIX . $filter['type'];
	$index = $this->imap->search_once($this->folder->name, 'UNDELETED HEADER X-Kolab-Type ' . $ctype);
	$count = $index->count();
	}

	return $count;
	}


	/**
	* Helper method to compose a valid SQL query from pseudo filter triplets
	*/
	private function _sql_where($query)
	{
	$sql_where = '';
	foreach ($query as $param) {
	if ($param[1] == '=' && is_array($param[2])) {
	$qvalue = '(' . join(',', array_map(array($this->db, 'quote'), $param[2])) . ')';
	$param[1] = 'IN';
	}
	else {
	$qvalue = $this->db->quote($param[2]);
	}

	$sql_where .= sprintf(' AND %s %s %s',
	$this->db->quote_identifier($param[0]),
	$param[1],
	$qvalue
	);
	}

	return $sql_where;
	}

	/**
	* Helper method to convert the given pseudo-query triplets into
	* an associative filter array with 'equals' values only
	*/
	private function _query2assoc($query)
	{
	// extract object type from query parameter
	$filter = array();
	foreach ($query as $param) {
	if ($param[1] == '=')
	$filter[$param[0]] = $param[2];
	}
	return $filter;
	}

	/**
	* Fetch messages from IMAP
	*
	* @param array List of message UIDs to fetch
	* @return array List of parsed Kolab objects
	*/
	private function _fetch($index, $type = null, $folder = null)
	{
	$results = array();
	foreach ((array)$index as $msguid) {
	if ($object = $this->folder->read_object($msguid, $type, $folder)) {
	$results[] = $object;
	$this->uid2msg[$object['uid']] = $msguid;
	}
	}

	return $results;
	}


	/**
	* Helper method to convert the given Kolab object into a dataset to be written to cache
	*/
	private function _serialize($object)
	{
	$bincols = array_flip($this->binary_cols);
	$sql_data = array('dtstart' => null, 'dtend' => null, 'xml' => '', 'tags' => '', 'words' => '');

	// set type specific values
	if ($this->folder->type == 'event') {
	// database runs in server's timezone so using date() is what we want
	$sql_data['dtstart'] = date('Y-m-d H:i:s', is_object($object['start']) ? $object['start']->format('U') : $object['start']);
	$sql_data['dtend'] = date('Y-m-d H:i:s', is_object($object['end']) ? $object['end']->format('U') : $object['end']);

	// extend date range for recurring events
	if ($object['recurrence']) {
	$sql_data['dtend'] = date('Y-m-d H:i:s', $object['recurrence']['UNTIL'] ?: strtotime('now + 2 years'));
	}
	}

	if ($object['_formatobj']) {
	$sql_data['xml'] = (string)$object['_formatobj']->write();
	$sql_data['tags'] = ' ' . join(' ', $object['_formatobj']->get_tags()) . ' '; // pad with spaces for strict/prefix search
	$sql_data['words'] = ' ' . join(' ', $object['_formatobj']->get_words()) . ' ';
	}

	// extract object data
	$data = array();
	foreach ($object as $key => $val) {
	if ($val === "" \|\| $val === null) {
	// skip empty properties
	continue;
	}
	if (isset($bincols[$key])) {
	$data[$key] = base64_encode($val);
	}
	else if ($key[0] != '_') {
	$data[$key] = $val;
	}
	else if ($key == '_attachments') {
	foreach ($val as $k => $att) {
	unset($att['content'], $att['path']);
	if ($att['id'])
	$data[$key][$k] = $att;
	}
	}
	}

	$sql_data['data'] = serialize($data);
	return $sql_data;
	}

	/**
	* Helper method to turn stored cache data into a valid storage object
	*/
	private function _unserialize($sql_arr)
	{
	$object = unserialize($sql_arr['data']);

	// decode binary properties
	foreach ($this->binary_cols as $key) {
	if (!empty($object[$key]))
	$object[$key] = base64_decode($object[$key]);
	}

	// add meta data
	$object['_type'] = $sql_arr['type'];
	$object['_msguid'] = $sql_arr['msguid'];
	$object['_mailbox'] = $this->folder->name;
	$object['_formatobj'] = kolab_format::factory($sql_arr['type'], $sql_arr['xml']);

	return $object;
	}

	/**
	* Check lock record for this folder and wait if locked or set lock
	*/
	private function _sync_lock()
	{
	if (!$this->ready)
	return;

	$sql_arr = $this->db->fetch_assoc($this->db->query(
	"SELECT msguid AS locked, ".$this->db->unixtimestamp('created')." AS created FROM kolab_cache ".
	"WHERE resource=? AND type=?",
	$this->resource_uri,
	'lock'
	));

	+ // abort if database is not set-up
	+ if ($this->db->is_error()) {
	+ $this->ready = false;
	+ return;
	+ }
	+
	// create lock record if not exists
	if (!$sql_arr) {
	$this->db->query(
	"INSERT INTO kolab_cache (resource, type, msguid, created, uid, data, xml)".
	" VALUES (?, ?, 1, ?, '', '', '')",
	$this->resource_uri,
	'lock',
	date('Y-m-d H:i:s')
	);
	}
	// wait if locked (expire locks after 10 minutes)
	else if (intval($sql_arr['locked']) > 0 && (time() - $sql_arr['created']) < 600) {
	usleep(500000);
	return $this->_sync_lock();
	}
	// set lock
	else {
	$this->db->query(
	"UPDATE kolab_cache SET msguid=1, created=? ".
	"WHERE resource=? AND type=?",
	date('Y-m-d H:i:s'),
	$this->resource_uri,
	'lock'
	);
	}
	}

	/**
	* Remove lock for this folder
	*/
	private function _sync_unlock()
	{
	+ if (!$this->ready)
	+ return;
	+
	$this->db->query(
	"UPDATE kolab_cache SET msguid=0, created='' ".
	"WHERE resource=? AND type=?",
	$this->resource_uri,
	'lock'
	);
	}

	/**
	* Resolve an object UID into an IMAP message UID
	*
	* @param string Kolab object UID
	* @param boolean Include deleted objects
	* @return int The resolved IMAP message UID
	*/
	public function uid2msguid($uid, $deleted = false)
	{
	if (!isset($this->uid2msg[$uid])) {
	// use IMAP SEARCH to get the right message
	$index = $this->imap->search_once($this->folder->name, ($deleted ? '' : 'UNDELETED ') . 'HEADER SUBJECT ' . $uid);
	$results = $index->get();
	$this->uid2msg[$uid] = $results[0];
	}

	return $this->uid2msg[$uid];
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Aug 17, 4:09 PM (1 d, 4 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1257223
Default Alt Text: (172 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions