No OneTemporary
Actions

Size

276 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/plugins/calendar/calendar.php b/plugins/calendar/calendar.php
	index ef396659..4bfe0d92 100644
	--- a/plugins/calendar/calendar.php
	+++ b/plugins/calendar/calendar.php
	@@ -1,2721 +1,2732 @@
	<?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) 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 calendar extends rcube_plugin
	{
	const FREEBUSY_UNKNOWN = 0;
	const FREEBUSY_FREE = 1;
	const FREEBUSY_BUSY = 2;
	const FREEBUSY_TENTATIVE = 3;
	const FREEBUSY_OOF = 4;

	const SESSION_KEY = 'calendar_temp';

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

	public $defaults = array(
	'calendar_default_view' => "agendaWeek",
	'calendar_timeslots' => 2,
	'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_allow_invite_shared' => false,
	);

	private $ical;
	private $itip;
	private $driver;
	private $ics_parts = array();


	/**
	* Plugin initialization.
	*/
	function init()
	{
	$this->require_plugin('libcalendaring');

	$this->rc = rcube::get_instance();
	$this->lib = libcalendaring::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'));

	$this->timezone = $this->lib->timezone;
	$this->gmt_offset = $this->lib->gmt_offset;
	$this->dst_active = $this->lib->dst_active;
	$this->timezone_offset = $this->gmt_offset / 3600 - $this->dst_active;

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

	// 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 {
	// default startup routine
	$this->add_hook('startup', array($this, 'startup'));
	}
	+
	+ $this->add_hook('user_delete', array($this, 'user_delete'));
	}

	/**
	* Startup hook
	*/
	public function startup($args)
	{
	// the calendar module can be enabled/disabled by the kolab_auth plugin
	if ($this->rc->config->get('calendar_disabled', false) \|\| !$this->rc->config->get('calendar_enabled', true))
	return;

	// load Calendar user interface
	if (!$this->rc->output->ajax_call && (!$this->rc->output->env['framed'] \|\| $args['action'] == 'preview')) {
	$this->ui->init();

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

	if ($args['task'] == 'calendar' && $args['action'] != 'save-pref') {
	if ($args['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('mailimportitip', array($this, 'mail_import_itip'));
	$this->register_action('mailimportattach', array($this, 'mail_import_attachment'));
	$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'));
	$this->register_action('itip-status', array($this, 'event_itip_status'));
	$this->register_action('itip-remove', array($this, 'event_itip_remove'));
	$this->register_action('itip-decline-reply', array($this, 'mail_itip_decline_reply'));
	$this->register_action('resources-list', array($this, 'resources_list'));
	$this->register_action('resources-owner', array($this, 'resources_owner'));
	$this->register_action('resources-calendar', array($this, 'resources_calendar'));
	$this->register_action('resources-autocomplete', array($this, 'resources_autocomplete'));
	$this->add_hook('refresh', array($this, 'refresh'));

	// 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 ($args['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 ($args['task'] == 'mail') {
	// hooks to catch event invitations on incoming mails
	if ($args['action'] == 'show' \|\| $args['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');

	$this->api->output->add_label('calendar.createfrommail');
	}

	$this->add_hook('messages_list', array($this, 'mail_messages_list'));
	}
	else if ($args['task'] == 'addressbook') {
	if ($this->rc->config->get('calendar_contact_birthdays')) {
	$this->add_hook('contact_update', array($this, 'contact_update'));
	$this->add_hook('contact_create', array($this, 'contact_update'));
	}
	}

	// add hooks to display alarms
	$this->add_hook('pending_alarms', array($this, 'pending_alarms'));
	$this->add_hook('dismiss_alarms', array($this, 'dismiss_alarms'));
	}

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

	$this->driver = new $driver_class($this);

	if ($this->driver->undelete)
	$this->driver->undelete = $this->rc->config->get('undo_timeout', 0) > 0;
	}

	/**
	* 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) {
	$this->ical = libcalendaring::get_ical();
	}

	return $this->ical;
	}

	/**
	* Get properties of the calendar this user has specified as default
	*/
	public function get_default_calendar($writeable = false)
	{
	$default_id = $this->rc->config->get('calendar_default_calendar');
	$calendars = $this->driver->list_calendars(false, true);
	$calendar = $calendars[$default_id] ?: null;
	if (!$calendar \|\| ($writeable && $calendar['readonly'])) {
	foreach ($calendars as $cal) {
	if ($cal['default']) {
	$calendar = $cal;
	break;
	}
	if (!$writeable \|\| !$cal['readonly']) {
	$first = $cal;
	}
	}
	}

	return $calendar ?: $first;
	}


	/**
	* 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','close');

	// initialize attendees autocompletion
	rcube_autocomplete_init();

	$this->rc->output->set_env('timezone', $this->timezone->getName());
	$this->rc->output->set_env('calendar_driver', $this->rc->config->get('calendar_driver'), false);
	$this->rc->output->set_env('calendar_resources', (bool)$this->rc->config->get('calendar_resources_driver'));
	$this->rc->output->set_env('mscolors', jqueryui::get_color_values());
	$this->rc->output->set_env('identities-selector', $this->ui->identity_select(array('id' => 'edit-identities-list')));

	$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') {
	return $p;
	}

	$no_override = array_flip((array)$this->rc->config->get('dont_override'));

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

	if (!isset($no_override['calendar_default_view'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}

	$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'])),
	);
	}

	if (!isset($no_override['calendar_timeslots'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}

	$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(strval($this->rc->config->get('calendar_timeslots', $this->defaults['calendar_timeslots']))),
	);
	}

	if (!isset($no_override['calendar_first_day'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}

	$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(strval($this->rc->config->get('calendar_first_day', $this->defaults['calendar_first_day']))),
	);
	}

	if (!isset($no_override['calendar_first_hour'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}

	$time_format = $this->rc->config->get('time_format', libcalendaring::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)),
	);
	}

	if (!isset($no_override['calendar_work_start'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}

	$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)),
	);
	}

	if (!isset($no_override['calendar_event_coloring'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}

	$field_id = 'rcmfd_coloring';
	$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'])),
	);
	}

	// loading driver is expensive, don't do it if not needed
	$this->load_driver();

	if (!isset($no_override['calendar_default_alarm_type'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}

	$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(rcube_label(strtolower("alarm{$type}option"), 'libcalendaring'), $type);

	$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', '')),
	);
	}

	if (!isset($no_override['calendar_default_alarm_offset'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}

	$field_id = 'rcmfd_alarm';
	$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(rcube_label('trigger' . $trigger, 'libcalendaring'), $trigger);

	$preset = libcalendaring::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]),
	);
	}

	if (!isset($no_override['calendar_default_calendar'])) {
	if (!$p['current']) {
	$p['blocks']['view']['content'] = true;
	return $p;
	}
	// default calendar selection
	$field_id = 'rcmfd_default_calendar';
	$select_cal = new html_select(array('name' => '_default_calendar', 'id' => $field_id, 'is_escaped' => true));
	foreach ((array)$this->driver->list_calendars(false, true) as $id => $prop) {
	$select_cal->add($prop['name'], strval($id));
	if ($prop['default'])
	$default_calendar = $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', $default_calendar)),
	);
	}

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

	if (!$p['current']) {
	$p['blocks']['categories']['content'] = true;
	return $p;
	}

	$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:(rcmail.env.mscolors \|\| []) });
	$("#rcmfd_new_category").val("");
	}
	}');

	$this->rc->output->add_script('$("#rcmfd_new_category").keypress(function(event){
	if (event.which == 13) {
	rcube_calendar_add_category();
	event.preventDefault();
	}
	});
	', 'docready');

	// load miniColors js/css files
	jqueryui::miniColors();
	}

	// virtual birthdays calendar
	if (!isset($no_override['calendar_contact_birthdays'])) {
	$p['blocks']['birthdays']['name'] = $this->gettext('birthdayscalendar');

	if (!$p['current']) {
	$p['blocks']['birthdays']['content'] = true;
	return $p;
	}

	$field_id = 'rcmfd_contact_birthdays';
	$input = new html_checkbox(array('name' => '_contact_birthdays', 'id' => $field_id, 'value' => 1, 'onclick' => '$(".calendar_birthday_props").prop("disabled",!this.checked)'));

	$p['blocks']['birthdays']['options']['contact_birthdays'] = array(
	'title' => html::label($field_id, $this->gettext('displaybirthdayscalendar')),
	'content' => $input->show($this->rc->config->get('calendar_contact_birthdays')?1:0),
	);

	$input_attrib = array(
	'class' => 'calendar_birthday_props',
	'disabled' => !$this->rc->config->get('calendar_contact_birthdays'),
	);

	$sources = array();
	$checkbox = new html_checkbox(array('name' => '_birthday_adressbooks[]') + $input_attrib);
	foreach ($this->rc->get_address_sources(false, true) as $source) {
	$active = in_array($source['id'], (array)$this->rc->config->get('calendar_birthday_adressbooks', array())) ? $source['id'] : '';
	$sources[] = html::label(null, $checkbox->show($active, array('value' => $source['id'])) . ' ' . rcube::Q($source['realname'] ?: $source['name']));
	}

	$p['blocks']['birthdays']['options']['birthday_adressbooks'] = array(
	'title' => rcube::Q($this->gettext('birthdayscalendarsources')),
	'content' => join(html::br(), $sources),
	);

	$field_id = 'rcmfd_birthdays_alarm';
	$select_type = new html_select(array('name' => '_birthdays_alarm_type', 'id' => $field_id) + $input_attrib);
	$select_type->add($this->gettext('none'), '');
	foreach ($this->driver->alarm_types as $type) {
	$select_type->add(rcube_label(strtolower("alarm{$type}option"), 'libcalendaring'), $type);
	}

	$input_value = new html_inputfield(array('name' => '_birthdays_alarm_value', 'id' => $field_id . 'value', 'size' => 3) + $input_attrib);
	$select_offset = new html_select(array('name' => '_birthdays_alarm_offset', 'id' => $field_id . 'offset') + $input_attrib);
	foreach (array('-M','-H','-D') as $trigger)
	$select_offset->add(rcube_label('trigger' . $trigger, 'libcalendaring'), $trigger);

	$preset = libcalendaring::parse_alaram_value($this->rc->config->get('calendar_birthdays_alarm_offset', '-1D'));
	$p['blocks']['birthdays']['options']['birthdays_alarmoffset'] = array(
	'title' => html::label($field_id . 'value', rcube::Q($this->gettext('showalarms'))),
	'content' => $select_type->show($this->rc->config->get('calendar_birthdays_alarm_type', '')) . ' ' . $input_value->show($preset[0]) . ' ' . $select_offset->show($preset[1]),
	);
	}

	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_alarm = $alarm_offset[0] . intval(get_input_value('_alarm_value', RCUBE_INPUT_POST)) . $alarm_offset[1];

	$birthdays_alarm_offset = get_input_value('_birthdays_alarm_offset', RCUBE_INPUT_POST);
	$birthdays_alarm_value = $birthdays_alarm_offset[0] . intval(get_input_value('_birthdays_alarm_value', RCUBE_INPUT_POST)) . $birthdays_alarm_offset[1];

	$p['prefs'] = array(
	'calendar_default_view' => get_input_value('_default_view', RCUBE_INPUT_POST),
	'calendar_timeslots' => intval(get_input_value('_timeslots', RCUBE_INPUT_POST)),
	'calendar_first_day' => intval(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_alarm,
	'calendar_default_calendar' => get_input_value('_default_calendar', RCUBE_INPUT_POST),
	'calendar_date_format' => null, // clear previously saved values
	'calendar_time_format' => null,
	'calendar_contact_birthdays' => get_input_value('_contact_birthdays', RCUBE_INPUT_POST) ? true : false,
	'calendar_birthday_adressbooks' => (array)get_input_value('_birthday_adressbooks', RCUBE_INPUT_POST),
	'calendar_birthdays_alarm_type' => get_input_value('_birthdays_alarm_type', RCUBE_INPUT_POST),
	'calendar_birthdays_alarm_offset' => $birthdays_alarm_value ?: 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 = (array) get_input_value('_categories', RCUBE_INPUT_POST);
	$colors = (array) 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');

	if ($success && $reload)
	$this->rc->output->command('plugin.reload_view');
	}


	/**
	* 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->write_preprocess($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->write_preprocess($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->write_preprocess($event, $action);
	$success = $this->driver->resize_event($event);
	$reload = $event['_savemode'] ? 2 : 1;
	break;

	case "move":
	$this->write_preprocess($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(strtolower($attendee['email']), $emails)) {
	$old['attendees'][$i]['status'] = 'DECLINED';
	$reply_sender = $attendee['email'];
	}
	}

	$itip = $this->load_itip();
	$itip->set_sender_email($reply_sender);
	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":
	$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":
	$event['ids'] = explode(',', $event['id']);
	$plugin = $this->rc->plugins->exec_hook('dismiss_alarms', $event);
	$success = $plugin['success'];
	foreach ($event['ids'] as $id) {
	if (strpos($id, 'cal:') === 0)
	$success \|= $this->driver->dismiss_alarm(substr($id, 4), $event['snooze']);
	}
	break;
	}

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

	// 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)) {
	$sent = $this->notify_attendees($event, $old, $action);
	if ($sent > 0)
	$this->rc->output->show_message('calendar.itipsendsuccess', 'confirmation');
	else if ($sent < 0)
	$this->rc->output->show_message('calendar.errornotifying', '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 updated data in active calendars and sync them to the client
	*/
	public function refresh($attr)
	{
	// refresh the entire calendar every 10th time to also sync deleted events
	if (rand(0,10) == 10) {
	$this->rc->output->command('plugin.refresh_calendar', array('refetch' => true));
	return;
	}

	foreach ($this->driver->list_calendars(true) as $cal) {
	$events = $this->driver->load_events(
	get_input_value('start', RCUBE_INPUT_GET),
	get_input_value('end', RCUBE_INPUT_GET),
	get_input_value('q', RCUBE_INPUT_GET),
	$cal['id'],
	1,
	$attr['last']
	);

	foreach ($events as $event) {
	$this->rc->output->command('plugin.refresh_calendar',
	array('source' => $cal['id'], 'update' => $this->_client_event($event)));
	}
	}
	}

	/**
	* Handler for pending_alarms plugin hook triggered by the calendar module on keep-alive requests.
	* This will check for pending notifications and pass them to the client
	*/
	public function pending_alarms($p)
	{
	$this->load_driver();
	$time = $p['time'] ?: time();
	if ($alarms = $this->driver->pending_alarms($time)) {
	foreach ($alarms as $alarm) {
	$alarm['id'] = 'cal:' . $alarm['id']; // prefix ID with cal:
	$p['alarms'][] = $alarm;
	}
	}

	// get alarms for birthdays calendar
	if ($this->rc->config->get('calendar_contact_birthdays') && $this->rc->config->get('calendar_birthdays_alarm_type') == 'DISPLAY') {
	$cache = $this->rc->get_cache('calendar.birthdayalarms', 'db');

	foreach ($this->driver->load_birthday_events($time, $time + 86400 * 60) as $e) {
	$alarm = libcalendaring::get_next_alarm($e);

	// overwrite alarm time with snooze value (or null if dismissed)
	if ($dismissed = $cache->get($e['id']))
	$alarm['time'] = $dismissed['notifyat'];

	// add to list if alarm is set
	if ($alarm && $alarm['time'] && $alarm['time'] <= $time) {
	$e['id'] = 'cal:bday:' . $e['id'];
	$e['notifyat'] = $alarm['time'];
	$p['alarms'][] = $e;
	}
	}
	}

	return $p;
	}

	/**
	* Handler for alarm dismiss hook triggered by libcalendaring
	*/
	public function dismiss_alarms($p)
	{
	$this->load_driver();
	foreach ((array)$p['ids'] as $id) {
	if (strpos($id, 'cal:bday:') === 0) {
	$p['success'] \|= $this->driver->dismiss_birthday_alarm(substr($id, 9), $p['snooze']);
	}
	else if (strpos($id, 'cal:') === 0) {
	$p['success'] \|= $this->driver->dismiss_alarm(substr($id, 4), $p['snooze']);
	}
	}

	return $p;
	}

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

	/**
	* Hook triggered when a contact is saved
	*/
	function contact_update($p)
	{
	// clear birthdays calendar cache
	if (!empty($p['record']['birthday'])) {
	$cache = $this->rc->get_cache('calendar.birthdays', 'db');
	$cache->remove();
	}
	}

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

	@set_time_limit(0);

	// 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);
	$rangestart = $_REQUEST['_range'] ? date_create("now -" . intval($_REQUEST['_range']) . " months") : 0;

	// extract zip file
	if ($_FILES['_data']['type'] == 'application/zip') {
	$count = 0;
	if (class_exists('ZipArchive', false)) {
	$zip = new ZipArchive();
	if ($zip->open($_FILES['_data']['tmp_name'])) {
	$randname = uniqid('zip-' . session_id(), true);
	$tmpdir = slashify($this->rc->config->get('temp_dir', sys_get_temp_dir())) . $randname;
	mkdir($tmpdir, 0700);

	// extract each ical file from the archive and import it
	for ($i = 0; $i < $zip->numFiles; $i++) {
	$filename = $zip->getNameIndex($i);
	if (preg_match('/\.ics$/i', $filename)) {
	$tmpfile = $tmpdir . '/' . basename($filename);
	if (copy('zip://' . $_FILES['_data']['tmp_name'] . '#'.$filename, $tmpfile)) {
	$count += $this->import_from_file($tmpfile, $calendar, $rangestart, $errors);
	unlink($tmpfile);
	}
	}
	}

	rmdir($tmpdir);
	$zip->close();
	}
	else {
	$errors = 1;
	$msg = 'Failed to open zip file.';
	}
	}
	else {
	$errors = 1;
	$msg = 'Zip files are not supported for import.';
	}
	}
	else {
	// attempt to import teh uploaded file directly
	$count = $this->import_from_file($_FILES['_data']['tmp_name'], $calendar, $rangestart, $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('plugin.import_error', array('message' => $this->gettext('importerror') . ($msg ? ': ' . $msg : '')));
	}
	}
	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('plugin.import_error', array('message' => $msg));
	}

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

	/**
	* Helper function to parse and import a single .ics file
	*/
	private function import_from_file($filepath, $calendar, $rangestart, &$errors)
	{
	$user_email = $this->rc->user->get_username();

	$ical = $this->get_ical();
	$errors = !$ical->fopen($filepath);
	$count = $i = 0;
	foreach ($ical as $event) {
	// keep the browser connection alive on long import jobs
	if (++$i > 100 && $i % 100 == 0) {
	echo "<!-- -->";
	ob_flush();
	}

	// TODO: correctly handle recurring events which start before $rangestart
	if ($event['end'] < $rangestart && (!$event['recurrence'] \|\| ($event['recurrence']['until'] && $event['recurrence']['until'] < $rangestart)))
	continue;

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

	return $count;
	}


	/**
	* 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 (!isset($start))
	$start = 'today -1 year';
	if (!is_numeric($start))
	$start = strtotime($start . ' 00:00:00');
	if (!$end)
	$end = 'today +10 years';
	if (!is_numeric($end))
	$end = strtotime($end . ' 23:59:59');

	$attachments = get_input_value('attachments', RCUBE_INPUT_GET);
	$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;
	$calname = preg_replace('/[^a-z0-9_.-]/i', '', html_entity_decode($calname)); // to 7bit ascii
	if (empty($calname)) $calname = $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, $attachments ? array($this->driver, 'get_attachment_body') : null);

	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->lib->load_settings();
	$this->defaults += $this->lib->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_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['invite_shared'] = (int)$this->rc->config->get('calendar_allow_invite_shared', $this->defaults['calendar_allow_invite_shared']);

	// 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'];
	$settings['identities'][$rec['identity_id']] = $rec['email'];
	}
	$identity['emails'][] = $this->rc->user->get_username();
	$settings['identity'] = array('name' => $identity['name'], 'email' => strtolower($identity['email']), 'emails' => ';' . strtolower(join(';', $identity['emails'])));
	}

	return $settings;
	}

	/**
	* 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['valarms']) {
	$event['alarms_text'] = libcalendaring::alarms_text($event['valarms']);
	$event['valarms'] = libcalendaring::to_client_alarms($event['valarms']);
	}
	if ($event['recurrence']) {
	$event['recurrence_text'] = $this->_recurrence_text($event['recurrence']);
	if ($event['recurrence']['UNTIL'])
	$event['recurrence']['UNTIL'] = $this->lib->adjust_timezone($event['recurrence']['UNTIL'], $event['allday'])->format('c');
	unset($event['recurrence']['EXCEPTIONS']);

	// format RDATE values
	if (is_array($event['recurrence']['RDATE'])) {
	$libcal = $this->lib;
	$event['recurrence']['RDATE'] = array_map(function($rdate) use ($libcal) {
	return $libcal->adjust_timezone($rdate, true)->format('c');
	}, $event['recurrence']['RDATE']);
	}
	}

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

	// check for organizer in attendees list
	$organizer = null;
	foreach ((array)$event['attendees'] as $i => $attendee) {
	if ($attendee['role'] == 'ORGANIZER') {
	$organizer = $attendee;
	break;
	}
	}

	if ($organizer === null && !empty($event['organizer'])) {
	$organizer = $event['organizer'];
	$organizer['role'] = 'ORGANIZER';
	if (!is_array($event['attendees']))
	$event['attendees'] = array();
	array_unshift($event['attendees'], $organizer);
	}

	// mapping url => vurl because of the fullcalendar client script
	$event['vurl'] = $event['url'];
	unset($event['url']);

	return array(
	'_id' => $event['calendar'] . ':' . $event['id'], // unique identifier for fullcalendar
	'start' => $this->lib->adjust_timezone($event['start'], $event['allday'])->format('c'),
	'end' => $this->lib->adjust_timezone($event['end'], $event['allday'])->format('c'),
	// 'changed' might be empty for event recurrences (Bug #2185)
	'changed' => $event['changed'] ? $this->lib->adjust_timezone($event['changed'])->format('c') : null,
	'created' => $event['created'] ? $this->lib->adjust_timezone($event['created'])->format('c') : null,
	'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(join('-', (array)$event['categories'])), true),
	'allDay' => ($event['allday'] == 1),
	) + $event;
	}


	/**
	* Render localized text describing the recurrence rule of an event
	*/
	private function _recurrence_text($rrule)
	{
	// derive missing FREQ and INTERVAL from RDATE list
	if (empty($rrule['FREQ']) && !empty($rrule['RDATE'])) {
	$first = $rrule['RDATE'][0];
	$second = $rrule['RDATE'][1];
	$third = $rrule['RDATE'][2];
	if (is_a($first, 'DateTime') && is_a($second, 'DateTime')) {
	$diff = $first->diff($second);
	foreach (array('y' => 'YEARLY', 'm' => 'MONTHLY', 'd' => 'DAILY') as $k => $freq) {
	if ($diff->$k != 0) {
	$rrule['FREQ'] = $freq;
	$rrule['INTERVAL'] = $diff->$k;

	// verify interval with next item
	if (is_a($third, 'DateTime')) {
	$diff2 = $second->diff($third);
	if ($diff2->$k != $diff->$k) {
	unset($rrule['INTERVAL']);
	}
	}
	break;
	}
	}
	}
	if (!$rrule['INTERVAL'])
	$rrule['FREQ'] = 'RDATE';
	$rrule['UNTIL'] = end($rrule['RDATE']);
	}

	// 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 'YEARLY':
	$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'], libcalendaring::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));
	}


	/**
	* 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 = $this->driver->list_calendars(true);
	$count = 0;

	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' => new DateTime('@'.$start),
	'end' => new DateTime('@'.($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()
	{
	$this->lib->attachment_upload(self::SESSION_KEY, 'cal:');
	}

	/**
	* Handler for attachments download/displaying
	*/
	public function attachment_get()
	{
	// show loading page
	if (!empty($_GET['_preload'])) {
	return $this->lib->attachment_loading_page();
	}

	$event_id = 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_id, 'calendar' => $calendar);
	$attachment = $this->driver->get_attachment($id, $event);

	// show part page
	if (!empty($_GET['_frame'])) {
	$this->lib->attachment = $attachment;
	$this->register_handler('plugin.attachmentframe', array($this->lib, 'attachment_frame'));
	$this->register_handler('plugin.attachmentcontrols', array($this->lib, 'attachment_header'));
	$this->rc->output->send('calendar.attachment');
	}
	// deliver attachment content
	else if ($attachment) {
	$attachment['body'] = $this->driver->get_attachment_body($id, $event);
	$this->lib->attachment_get($attachment);
	}

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


	/**
	* Prepares new/edited event properties before save
	*/
	private function write_preprocess(&$event, $action)
	{
	// convert dates into DateTime objects in user's current timezone
	$event['start'] = new DateTime($event['start'], $this->timezone);
	$event['end'] = new DateTime($event['end'], $this->timezone);

	// start/end is all we need for 'move' action (#1480)
	if ($action == 'move') {
	return;
	}

	if (is_array($event['recurrence']) && !empty($event['recurrence']['UNTIL']))
	$event['recurrence']['UNTIL'] = new DateTime($event['recurrence']['UNTIL'], $this->timezone);

	if (is_array($event['recurrence']) && is_array($event['recurrence']['RDATE'])) {
	$tz = $this->timezone;
	$start = $event['start'];
	$event['recurrence']['RDATE'] = array_map(function($rdate) use ($tz, $start) {
	try {
	$dt = new DateTime($rdate, $tz);
	$dt->setTime($start->format('G'), $start->format('i'));
	return $dt;
	}
	catch (Exception $e) {
	return null;
	}
	}, $event['recurrence']['RDATE']);
	}

	// convert the submitted alarm values
	if ($event['valarms']) {
	$event['valarms'] = libcalendaring::from_client_alarms($event['valarms']);
	}

	$attachments = array();
	$eventid = 'cal:'.$event['id'];
	if (is_array($_SESSION[self::SESSION_KEY]) && $_SESSION[self::SESSION_KEY]['id'] == $eventid) {
	if (!empty($_SESSION[self::SESSION_KEY]['attachments'])) {
	foreach ($_SESSION[self::SESSION_KEY]['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 ($action == 'new' \|\| $action == 'edit') {
	if (!$event['attendees'])
	$event['attendees'] = array();

	$emails = $this->get_user_emails();
	$organizer = $owner = false;
	foreach ((array)$event['attendees'] as $i => $attendee) {
	if ($attendee['role'] == 'ORGANIZER')
	$organizer = $i;
	if ($attendee['email'] == in_array(strtolower($attendee['email']), $emails))
	$owner = $i;
	else if (!isset($attendee['rsvp']))
	$event['attendees'][$i]['rsvp'] = true;
	}

	// set new organizer identity
	if ($organizer !== false && !empty($event['_identity']) && ($identity = $this->rc->user->get_identity($event['_identity']))) {
	$event['attendees'][$organizer]['name'] = $identity['name'];
	$event['attendees'][$organizer]['email'] = $identity['email'];
	}

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

	// mapping url => vurl because of the fullcalendar client script
	if (array_key_exists('vurl', $event)) {
	$event['url'] = $event['vurl'];
	unset($event['vurl']);
	}
	}

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

	/**
	* Send out an invitation/notification to all event attendees
	*/
	private function notify_attendees($event, $old, $action = 'edit')
	{
	if ($action == 'remove' \|\| ($event['status'] == 'CANCELLED' && $old['status'] != $event['status'])) {
	$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; $current = array();
	foreach ((array)$event['attendees'] as $attendee) {
	$current[] = strtolower($attendee['email']);

	// skip myself for obvious reasons
	if (!$attendee['email'] \|\| in_array(strtolower($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;
	}

	// send CANCEL message to removed attendees
	foreach ((array)$old['attendees'] as $attendee) {
	if ($attendee['ROLE'] == 'ORGANIZER' \|\| !$attendee['email'] \|\| in_array(strtolower($attendee['email']), $current))
	continue;

	$vevent = $old;
	$vevent['cancelled'] = $is_cancelled;
	$vevent['attendees'] = array($attendee);
	if ($itip->send_itip_message($vevent, 'CANCEL', $attendee, 'eventcancelsubject', 'eventcancelmailbody'))
	$sent++;
	else
	$sent = -100;
	}

	return $sent;
	}

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

	// convert dates into unix timestamps
	if (!empty($start) && !is_numeric($start)) {
	$dts = new DateTime($start, $this->timezone);
	$start = $dts->format('U');
	}
	if (!empty($end) && !is_numeric($end)) {
	$dte = new DateTime($end, $this->timezone);
	$end = $dte->format('U');
	}

	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));
	$strformat = $interval > 60 ? 'Ymd' : 'YmdHis';

	// convert dates into unix timestamps
	if (!empty($start) && !is_numeric($start)) {
	$dts = new DateTime($start, $this->timezone);
	$start = $dts->format('U');
	}
	if (!empty($end) && !is_numeric($end)) {
	$dte = new DateTime($end, $this->timezone);
	$end = $dte->format('U');
	}

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

	if (!$dte) {
	$dts = new DateTime('@'.$start);
	$dts->setTimezone($this->timezone);
	}

	$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;
	$dt = new DateTime('@'.$t);
	$dt->setTimezone($this->timezone);

	// 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;
	$times[$s] = intval($dt->format($strformat));
	$t = $t_end;
	}

	$dte = new DateTime('@'.$t_end);
	$dte->setTimezone($this->timezone);

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

	echo json_encode(array(
	'email' => $email,
	'start' => $dts->format('c'),
	'end' => $dte->format('c'),
	'interval' => $interval,
	'slots' => $slots,
	'times' => $times,
	));
	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_path = $this->local_skin_path();
	$this->include_stylesheet($skin_path . '/fullcalendar.css');
	$this->include_stylesheet($skin_path . '/print.css');

	// Add JS files to the page header
	$this->include_script('print.js');
	$this->include_script('lib/js/fullcalendar.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.gui_object('attachmentlist', '" . $this->ui->attachmentlist_id . "');\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;
	}


	/** Resource management functions **/

	/**
	* Getter for the configured implementation of the resource directory interface
	*/
	private function resources_directory()
	{
	if (is_object($this->resources_dir)) {
	return $this->resources_dir;
	}

	if ($driver_name = $this->rc->config->get('calendar_resources_driver')) {
	$driver_class = 'resources_driver_' . $driver_name;

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

	$this->resources_dir = new $driver_class($this);
	}

	return $this->resources_dir;
	}

	/**
	* Handler for resoruce autocompletion requests
	*/
	public function resources_autocomplete()
	{
	$search = rcube_utils::get_input_value('_search', rcube_utils::INPUT_GPC, true);
	$sid = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
	$maxnum = (int)$this->rc->config->get('autocomplete_max', 15);
	$results = array();

	if ($directory = $this->resources_directory()) {
	foreach ($directory->load_resources($search, $maxnum) as $rec) {
	$results[] = array(
	'name' => $rec['name'],
	'email' => $rec['email'],
	'type' => $rec['_type'],
	);
	}
	}

	$this->rc->output->command('ksearch_query_results', $results, $search, $sid);
	$this->rc->output->send();
	}

	/**
	* Handler for load-requests for resource data
	*/
	function resources_list()
	{
	$data = array();

	if ($directory = $this->resources_directory()) {
	foreach ($directory->load_resources() as $rec) {
	$data[] = $rec;
	}
	}

	$this->rc->output->command('plugin.resource_data', $data);
	$this->rc->output->send();
	}

	/**
	* Handler for requests loading resource owner information
	*/
	function resources_owner()
	{
	if ($directory = $this->resources_directory()) {
	$id = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
	$data = $directory->get_resource_owner($id);
	}

	$this->rc->output->command('plugin.resource_owner', $data);
	$this->rc->output->send();
	}

	/**
	* Deliver event data for a resource's calendar
	*/
	function resources_calendar()
	{
	$events = array();

	if ($directory = $this->resources_directory()) {
	$events = $directory->get_resource_calendar(
	rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC),
	rcube_utils::get_input_value('start', RCUBE_INPUT_GET),
	rcube_utils::get_input_value('end', RCUBE_INPUT_GET));
	}

	echo $this->encode($events);
	exit;
	}


	/** Event invitation plugin hooks **/

	/**
	* Handler for calendar/itip-status requests
	*/
	function event_itip_status()
	{
	$data = get_input_value('data', RCUBE_INPUT_POST, true);

	// find local copy of the referenced event
	$this->load_driver();
	$existing = $this->driver->get_event($data, true, false, true);

	$itip = $this->load_itip();
	$response = $itip->get_itip_status($data, $existing);

	// get a list of writeable calendars to save new events to
	if (!$existing && $response['action'] == 'rsvp' \|\| $response['action'] == 'import') {
	$calendars = $this->driver->list_calendars(false, true);
	$calendar_select = new html_select(array('name' => 'calendar', 'id' => 'itip-saveto', 'is_escaped' => true));
	$numcals = 0;
	foreach ($calendars as $calendar) {
	if (!$calendar['readonly']) {
	$calendar_select->add($calendar['name'], $calendar['id']);
	$numcals++;
	}
	}
	if ($numcals <= 1)
	$calendar_select = null;
	}

	if ($calendar_select) {
	$default_calendar = $this->get_default_calendar(true);
	$response['select'] = html::span('folder-select', $this->gettext('saveincalendar') . ' ' .
	$calendar_select->show($this->rc->config->get('calendar_default_calendar', $default_calendar['id'])));
	}

	$this->rc->output->command('plugin.update_itip_object_status', $response);
	}

	/**
	* Handler for calendar/itip-remove requests
	*/
	function event_itip_remove()
	{
	$success = false;

	// search for event if only UID is given
	if ($event = $this->driver->get_event(array('uid' => get_input_value('uid', RCUBE_INPUT_POST)), true)) {
	$success = $this->driver->remove_event($event, true);
	}

	if ($success) {
	$this->rc->output->show_message('calendar.successremoval', 'confirmation');
	}
	else {
	$this->rc->output->show_message('calendar.errorsaving', 'error');
	}
	}

	/**
	* Handler for URLs that allow an invitee to respond on his invitation mail
	*/
	public function itip_attend_response($p)
	{
	if ($p['action'] == 'attend') {
	$this->ui->init();

	$this->rc->output->set_env('task', 'calendar'); // override some env vars
	$this->rc->output->set_env('refresh_interval', 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', $itip->gettext('eventcancelled'));
	}
	// save submitted RSVP status
	else if (!empty($_POST['rsvp'])) {
	$status = null;
	foreach (array('accepted','tentative','declined') as $method) {
	if ($_POST['rsvp'] == $itip->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), $itip->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($itip->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();
	}

	/**
	*
	*/
	public function mail_messages_list($p)
	{
	if (in_array('attachment', (array)$p['cols'])) {
	foreach ($p['messages'] as $i => $header) {
	$part = new StdClass;
	$part->mimetype = $header->ctype;
	if ($this->is_vcalendar($part)) {
	$header->list_flags['attachmentClass'] = 'ical';
	}
	else if (in_array($header->ctype, array('multipart/alternative', 'multipart/mixed'))) {
	// TODO: fetch bodystructure and search for ical parts. Maybe too expensive?

	if (!empty($header->structure) && is_array($header->structure->parts)) {
	foreach ($header->structure->parts as $part) {
	if ($this->is_vcalendar($part) && !empty($part->ctype_parameters['method'])) {
	$header->list_flags['attachmentClass'] = 'ical';
	break;
	}
	}
	}
	}
	}
	}
	}

	/**
	* 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 $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();
	$this->load_itip();
	}

	$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) {
	if ($event['_type'] != 'event') // skip non-event objects (#2928)
	continue;

	// get prepared inline UI for this event object
	$html .= html::div('calendar-invitebox',
	$this->itip->mail_itip_inline_ui(
	$event,
	$this->ical->method,
	$mime_id.':'.$idx,
	'calendar',
	rcube_utils::anytodatetime($this->message->headers->date)
	)
	);

	// 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','calendar.declinedeleteconfirm');
	}

	// add "Save to calendar" button into attachment menu
	if (!empty($this->ics_parts)) {
	$this->add_button(array(
	'id' => 'attachmentsavecal',
	'name' => 'attachmentsavecal',
	'type' => 'link',
	'wrapper' => 'li',
	'command' => 'attachment-save-calendar',
	'class' => 'icon calendarlink',
	'classact' => 'icon calendarlink active',
	'innerclass' => 'icon calendar',
	'label' => 'calendar.savetocalendar',
	), 'attachmentmenu');
	}

	return $p;
	}

	/**
	* Read the given mime message from IMAP and parse ical data
	*/
	private function mail_get_itip_event($mbox, $uid, $mime_id)
	{
	$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);

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

	// successfully parsed events?
	if (!empty($events) && ($event = $events[$index])) {
	// store the message's sender address for comparisons
	$event['_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] : '';
	$event['_sender_utf'] = rcube_idn_to_utf8($event['_sender']);

	return $event;
	}

	return null;
	}

	/**
	* Handler for POST request to import an event attached to a mail message
	*/
	public function mail_import_itip()
	{
	$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);
	$delete = intval(get_input_value('_del', RCUBE_INPUT_POST));

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

	// successfully parsed events?
	if ($event = $this->mail_get_itip_event($mbox, $uid, $mime_id)) {
	// find writeable calendar to store event
	$cal_id = !empty($_REQUEST['_folder']) ? get_input_value('_folder', RCUBE_INPUT_POST) : null;
	$calendars = $this->driver->list_calendars(false, true);
	$calendar = $calendars[$cal_id] ?: $this->get_default_calendar(true);

	$metadata = array(
	'uid' => $event['uid'],
	'changed' => is_object($event['changed']) ? $event['changed']->format('U') : 0,
	'sequence' => intval($event['sequence']),
	'fallback' => strtoupper($status),
	'method' => $this->ical->method,
	'task' => 'calendar',
	);

	// 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(strtolower($attendee['email']), $emails)) {
	$event['attendees'][$i]['status'] = strtoupper($status);
	$metadata['attendee'] = $attendee['email'];
	$metadata['rsvp'] = $attendee['rsvp'] \|\| $attendee['role'] != 'NON-PARTICIPANT';
	$reply_sender = $attendee['email'];
	}
	}

	// add attendee with this user's default identity if not listed
	if (!$reply_sender) {
	$sender_identity = $this->rc->user->get_identity();
	$event['attendees'][] = array(
	'name' => $sender_identity['name'],
	'email' => $sender_identity['email'],
	'role' => 'OPT-PARTICIPANT',
	'status' => strtoupper($status),
	'rsvp' => true,
	);
	$metadata['attendee'] = $sender_identity['email'];
	}
	}

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

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

	if ($existing) {
	// only update attendee status
	if ($this->ical->method == 'REPLY') {
	// try to identify the attendee using the email sender address
	$existing_attendee = -1;
	foreach ($existing['attendees'] as $i => $attendee) {
	if ($event['_sender'] && ($attendee['email'] == $event['_sender'] \|\| $attendee['email'] == $event['_sender_utf'])) {
	$existing_attendee = $i;
	break;
	}
	}
	$event_attendee = null;
	foreach ($event['attendees'] as $attendee) {
	if ($event['_sender'] && ($attendee['email'] == $event['_sender'] \|\| $attendee['email'] == $event['_sender_utf'])) {
	$event_attendee = $attendee;
	$metadata['fallback'] = $attendee['status'];
	$metadata['attendee'] = $attendee['email'];
	$metadata['rsvp'] = $attendee['rsvp'] \|\| $attendee['role'] != 'NON-PARTICIPANT';
	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['sequence'] >= $existing['sequence'] \|\| $event['changed'] >= $existing['changed']) && $event_attendee) {
	$existing['attendees'][] = $event_attendee;
	$success = $this->driver->edit_event($existing);
	}
	else {
	$error_msg = $this->gettext('newerversionexists');
	}
	}
	// delete the event when declined (#1670)
	else if ($status == 'declined' && $delete) {
	$deleted = $this->driver->remove_event($existing, true);
	$success = true;
	}
	// import the (newer) event
	else if ($event['sequence'] >= $existing['sequence'] \|\| $event['changed'] >= $existing['changed']) {
	$event['id'] = $existing['id'];
	$event['calendar'] = $existing['calendar'];

	// set status=CANCELLED on CANCEL messages
	if ($this->ical->method == 'CANCEL')
	$event['status'] = 'CANCELLED';
	// show me as free when declined (#1670)
	if ($status == 'declined' \|\| $event['status'] == 'CANCELLED')
	$event['free_busy'] = 'free';

	$success = $this->driver->edit_event($event);
	}
	else if (!empty($status)) {
	$existing['attendees'] = $event['attendees'];
	if ($status == 'declined') // show me as free when declined (#1670)
	$existing['free_busy'] = 'free';
	$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' : ($deleted ? 'successremoval' : ($existing ? 'updatedsuccessfully' : 'importedsuccessfully'));
	$this->rc->output->command('display_message', $this->gettext(array('name' => $message, 'vars' => array('calendar' => $calendar['name']))), 'confirmation');

	$metadata['rsvp'] = intval($metadata['rsvp']);
	$this->rc->output->command('plugin.fetch_itip_object_status', $metadata);
	$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(strtolower($organizer['email']), $emails) && !$error_msg) {
	$event['comment'] = get_input_value('_comment', RCUBE_INPUT_POST);
	$itip = $this->load_itip();
	$itip->set_sender_email($reply_sender);
	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();
	}


	/**
	* Handler for calendar/itip-remove requests
	*/
	function mail_itip_decline_reply()
	{
	$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);

	if (($event = $this->mail_get_itip_event($mbox, $uid, $mime_id)) && $this->ical->method == 'REPLY') {
	$event['comment'] = get_input_value('_comment', RCUBE_INPUT_POST);

	foreach ($event['attendees'] as $_attendee) {
	if ($_attendee['role'] != 'ORGANIZER') {
	$attendee = $_attendee;
	break;
	}
	}

	$itip = $this->load_itip();
	if ($itip->send_itip_message($event, 'CANCEL', $attendee, 'itipsubjectcancel', 'itipmailbodycancel'))
	$this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $attendee['name'] ? $attendee['name'] : $attendee['email']))), 'confirmation');
	else
	$this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
	}
	else {
	$this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
	}
	}

	/**
	* Import the full payload from a mail message attachment
	*/
	public function mail_import_attachment()
	{
	$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);
	$charset = RCMAIL_CHARSET;

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

	if ($uid && $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);

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

	$success = $existing = 0;
	if (!empty($events)) {
	// find writeable calendar to store event
	$cal_id = !empty($_REQUEST['_calendar']) ? get_input_value('_calendar', RCUBE_INPUT_POST) : null;
	$calendars = $this->driver->list_calendars(false, true);
	$calendar = $calendars[$cal_id] ?: $this->get_default_calendar(true);

	foreach ($events as $event) {
	// save to calendar
	if ($calendar && !$calendar['readonly'] && $event['_type'] == 'event') {
	$event['calendar'] = $calendar['id'];

	if (!$this->driver->get_event($event['uid'], true, false)) {
	$success += (bool)$this->driver->new_event($event);
	}
	else {
	$existing++;
	}
	}
	}
	}

	if ($success) {
	$this->rc->output->command('display_message', $this->gettext(array(
	'name' => 'importsuccess',
	'vars' => array('nr' => $success),
	)), 'confirmation');
	}
	else if ($existing) {
	$this->rc->output->command('display_message', $this->gettext('importwarningexists'), 'warning');
	}
	else {
	$this->rc->output->command('display_message', $this->gettext('errorimportingevent'), 'error');
	}
	}

	/**
	* 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[self::SESSION_KEY]) \|\| $_SESSION[self::SESSION_KEY]['id'] != $eventid) {
	$_SESSION[self::SESSION_KEY] = array();
	$_SESSION[self::SESSION_KEY]['id'] = $eventid;
	$_SESSION[self::SESSION_KEY]['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'];
	$attachment['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);

	// store new attachment in session
	unset($attachment['status'], $attachment['abort'], $attachment['data']);
	$_SESSION[self::SESSION_KEY]['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()
	{
	return $this->lib->get_user_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 . '://' . preg_replace('/:\d+$/', '', $_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);
	}

	+ /**
	+ * Handler for user_delete plugin hook
	+ */
	+ public function user_delete($args)
	+ {
	+ $this->load_driver();
	+ return $this->driver->user_delete($args);
	+ }
	+
	/**
	* Magic getter for public access to protected members
	*/
	public function __get($name)
	{
	switch ($name) {
	case 'ical':
	return $this->get_ical();

	case 'itip':
	return $this->load_itip();

	case 'driver':
	$this->load_driver();
	return $this->driver;
	}

	return null;
	}

	}
	diff --git a/plugins/calendar/drivers/calendar_driver.php b/plugins/calendar/drivers/calendar_driver.php
	index 6769cfdc..c5eff9d6 100644
	--- a/plugins/calendar/drivers/calendar_driver.php
	+++ b/plugins/calendar/drivers/calendar_driver.php
	@@ -1,534 +1,545 @@
	<?php

	/**
	* Driver interface for the Calendar plugin
	*
	* @version @package_version@
	* @author Lazlo Westerhof <hello@lazlo.me>
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2010, Lazlo Westerhof <hello@lazlo.me>
	* Copyright (C) 2012-2014, 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/>.
	*/


	/**
	* Struct of an internal event object how it is passed from/to the driver classes:
	*
	* $event = array(
	* 'id' => 'Event ID used for editing',
	* 'uid' => 'Unique identifier of this event',
	* 'calendar' => 'Calendar identifier to add event to or where the event is stored',
	* 'start' => DateTime, // Event start date/time as DateTime object
	* 'end' => DateTime, // Event end date/time as DateTime object
	* 'allday' => true\|false, // Boolean flag if this is an all-day event
	* 'changed' => DateTime, // Last modification date of event
	* 'title' => 'Event title/summary',
	* 'location' => 'Location string',
	* 'description' => 'Event description',
	* 'url' => 'URL to more information',
	* 'recurrence' => array( // Recurrence definition according to iCalendar (RFC 2445) specification as list of key-value pairs
	* 'FREQ' => 'DAILY\|WEEKLY\|MONTHLY\|YEARLY',
	* 'INTERVAL' => 1...n,
	* 'UNTIL' => DateTime,
	* 'COUNT' => 1..n, // number of times
	* // + more properties (see http://www.kanzaki.com/docs/ical/recur.html)
	* 'EXDATE' => array(), // list of DateTime objects of exception Dates/Times
	* 'EXCEPTIONS' => array(<event>), list of event objects which denote exceptions in the recurrence chain
	* ),
	* 'recurrence_id' => 'ID of the recurrence group', // usually the ID of the starting event
	* 'categories' => 'Event category',
	* 'free_busy' => 'free\|busy\|outofoffice\|tentative', // Show time as
	* 'status' => 'TENTATIVE\|CONFIRMED\|CANCELLED', // event status according to RFC 2445
	* 'priority' => 0-9, // Event priority (0=undefined, 1=highest, 9=lowest)
	* 'sensitivity' => 'public\|private\|confidential', // Event sensitivity
	* 'alarms' => '-15M:DISPLAY', // DEPRECATED Reminder settings inspired by valarm definition (e.g. display alert 15 minutes before event)
	* 'valarms' => array( // List of reminders (new format), each represented as a hash array:
	* array(
	* 'trigger' => '-PT90M', // ISO 8601 period string prefixed with '+' or '-', or DateTime object
	* 'action' => 'DISPLAY\|EMAIL\|AUDIO',
	* 'duration' => 'PT15M', // ISO 8601 period string
	* 'repeat' => 0, // number of repetitions
	* 'description' => '', // text to display for DISPLAY actions
	* 'summary' => '', // message text for EMAIL actions
	* 'attendees' => array(), // list of email addresses to receive alarm messages
	* ),
	* ),
	* 'attachments' => array( // List of attachments
	* 'name' => 'File name',
	* 'mimetype' => 'Content type',
	* 'size' => 1..n, // in bytes
	* 'id' => 'Attachment identifier'
	* ),
	* 'deleted_attachments' => array(), // array of attachment identifiers to delete when event is updated
	* 'attendees' => array( // List of event participants
	* 'name' => 'Participant name',
	* 'email' => 'Participant e-mail address', // used as identifier
	* 'role' => 'ORGANIZER\|REQ-PARTICIPANT\|OPT-PARTICIPANT\|CHAIR',
	* 'status' => 'NEEDS-ACTION\|UNKNOWN\|ACCEPTED\|TENTATIVE\|DECLINED'
	* 'rsvp' => true\|false,
	* ),
	*
	* '_savemode' => 'all\|future\|current\|new', // How changes on recurring event should be handled
	* '_notify' => true\|false, // whether to notify event attendees about changes
	* '_fromcalendar' => 'Calendar identifier where the event was stored before',
	* );
	*/

	/**
	* Interface definition for calendar driver classes
	*/
	abstract class calendar_driver
	{
	const BIRTHDAY_CALENDAR_ID = '__bdays__';

	// features supported by backend
	public $alarms = false;
	public $attendees = false;
	public $freebusy = false;
	public $attachments = false;
	public $undelete = false; // event undelete action
	public $categoriesimmutable = false;
	public $alarm_types = array('DISPLAY');
	public $alarm_absolute = true;
	public $last_error;

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

	/**
	* Get a list of available calendars from this source
	*
	* @param bool $active Return only active calendars
	* @param bool $personal Return only personal calendars
	*
	* @return array List of calendars
	*/
	abstract function list_calendars($active = false, $personal = false);

	/**
	* Create a new calendar assigned to the current user
	*
	* @param array Hash array with calendar properties
	* name: Calendar name
	* color: The color of the calendar
	* showalarms: True if alarms are enabled
	* @return mixed ID of the calendar on success, False on error
	*/
	abstract function create_calendar($prop);

	/**
	* Update properties of an existing calendar
	*
	* @param array Hash array with calendar properties
	* id: Calendar Identifier
	* name: Calendar name
	* color: The color of the calendar
	* showalarms: True if alarms are enabled (if supported)
	* @return boolean True on success, Fales on failure
	*/
	abstract function edit_calendar($prop);

	/**
	* Set active/subscribed state of a calendar
	*
	* @param array Hash array with calendar properties
	* id: Calendar Identifier
	* active: True if calendar is active, false if not
	* @return boolean True on success, Fales on failure
	*/
	abstract function subscribe_calendar($prop);

	/**
	* Delete the given calendar with all its contents
	*
	* @param array Hash array with calendar properties
	* id: Calendar Identifier
	* @return boolean True on success, Fales on failure
	*/
	abstract function remove_calendar($prop);

	/**
	* Add a single event to the database
	*
	* @param array Hash array with event properties (see header of this file)
	* @return mixed New event ID on success, False on error
	*/
	abstract function new_event($event);

	/**
	* Update an event entry with the given data
	*
	* @param array Hash array with event properties (see header of this file)
	* @return boolean True on success, False on error
	*/
	abstract function edit_event($event);

	/**
	* Move a single event
	*
	* @param array Hash array with event properties:
	* id: Event identifier
	* start: Event start date/time as DateTime object
	* end: Event end date/time as DateTime object
	* allday: Boolean flag if this is an all-day event
	* @return boolean True on success, False on error
	*/
	abstract function move_event($event);

	/**
	* Resize a single event
	*
	* @param array Hash array with event properties:
	* id: Event identifier
	* start: Event start date/time as DateTime object with timezone
	* end: Event end date/time as DateTime object with timezone
	* @return boolean True on success, False on error
	*/
	abstract function resize_event($event);

	/**
	* Remove a single event from the database
	*
	* @param array Hash array with event properties:
	* id: Event identifier
	* @param boolean Remove event irreversible (mark as deleted otherwise,
	* if supported by the backend)
	*
	* @return boolean True on success, False on error
	*/
	abstract function remove_event($event, $force = true);

	/**
	* Restores a single deleted event (if supported)
	*
	* @param array Hash array with event properties:
	* id: Event identifier
	*
	* @return boolean True on success, False on error
	*/
	public function restore_event($event)
	{
	return false;
	}

	/**
	* Return data of a single event
	*
	* @param mixed UID string or hash array with event properties:
	* id: Event identifier
	* calendar: Calendar identifier (optional)
	* @param boolean If true, only writeable calendars shall be searched
	* @param boolean If true, only active calendars shall be searched
	* @param boolean If true, only personal calendars shall be searched
	*
	* @return array Event object as hash array
	*/
	abstract function get_event($event, $writeable = false, $active = false, $personal = false);

	/**
	* Get events from source.
	*
	* @param integer Event's new start (unix timestamp)
	* @param integer Event's new end (unix timestamp)
	* @param string Search query (optional)
	* @param mixed List of calendar IDs to load events from (either as array or comma-separated string)
	* @param boolean Include virtual/recurring events (optional)
	* @param integer Only list events modified since this time (unix timestamp)
	* @return array A list of event objects (see header of this file for struct of an event)
	*/
	abstract function load_events($start, $end, $query = null, $calendars = null, $virtual = 1, $modifiedsince = null);

	/**
	* Get a list of pending alarms to be displayed to the user
	*
	* @param integer Current time (unix timestamp)
	* @param mixed List of calendar IDs to show alarms for (either as array or comma-separated string)
	* @return array A list of alarms, each encoded as hash array:
	* id: Event identifier
	* uid: Unique identifier of this event
	* start: Event start date/time as DateTime object
	* end: Event end date/time as DateTime object
	* allday: Boolean flag if this is an all-day event
	* title: Event title/summary
	* location: Location string
	*/
	abstract function pending_alarms($time, $calendars = null);

	/**
	* (User) feedback after showing an alarm notification
	* This should mark the alarm as 'shown' or snooze it for the given amount of time
	*
	* @param string Event identifier
	* @param integer Suspend the alarm for this number of seconds
	*/
	abstract function dismiss_alarm($event_id, $snooze = 0);

	/**
	* Check the given event object for validity
	*
	* @param array Event object as hash array
	* @return boolean True if valid, false if not
	*/
	public function validate($event)
	{
	$valid = true;

	if (!is_object($event['start']) \|\| !is_a($event['start'], 'DateTime'))
	$valid = false;
	if (!is_object($event['end']) \|\| !is_a($event['end'], 'DateTime'))
	$valid = false;

	return $valid;
	}


	/**
	* Get list of event's attachments.
	* Drivers can return list of attachments as event property.
	* If they will do not do this list_attachments() method will be used.
	*
	* @param array $event Hash array with event properties:
	* id: Event identifier
	* calendar: Calendar identifier
	*
	* @return array List of attachments, each as hash array:
	* id: Attachment identifier
	* name: Attachment name
	* mimetype: MIME content type of the attachment
	* size: Attachment size
	*/
	public function list_attachments($event) { }

	/**
	* Get attachment properties
	*
	* @param string $id Attachment identifier
	* @param array $event Hash array with event properties:
	* id: Event identifier
	* calendar: Calendar identifier
	*
	* @return array Hash array with attachment properties:
	* id: Attachment identifier
	* name: Attachment name
	* mimetype: MIME content type of the attachment
	* size: Attachment size
	*/
	public function get_attachment($id, $event) { }

	/**
	* Get attachment body
	*
	* @param string $id Attachment identifier
	* @param array $event Hash array with event properties:
	* id: Event identifier
	* calendar: Calendar identifier
	*
	* @return string Attachment body
	*/
	public function get_attachment_body($id, $event) { }

	/**
	* List availabale categories
	* The default implementation reads them from config/user prefs
	*/
	public function list_categories()
	{
	$rcmail = rcube::get_instance();
	return $rcmail->config->get('calendar_categories', $this->default_categories);
	}

	/**
	* Create a new category
	*/
	public function add_category($name, $color) { }

	/**
	* Remove the given category
	*/
	public function remove_category($name) { }

	/**
	* Update/replace a category
	*/
	public function replace_category($oldname, $name, $color) { }

	/**
	* Fetch free/busy information from a person within the given range
	*
	* @param string E-mail address of attendee
	* @param integer Requested period start date/time as unix timestamp
	* @param integer Requested period end date/time as unix timestamp
	*
	* @return array List of busy timeslots within the requested range
	*/
	public function get_freebusy_list($email, $start, $end)
	{
	return false;
	}

	/**
	* Callback function to produce driver-specific calendar create/edit form
	*
	* @param string Request action 'form-edit\|form-new'
	* @param array Calendar properties (e.g. id, color)
	* @param array Edit form fields
	*
	* @return string HTML content of the form
	*/
	public function calendar_form($action, $calendar, $formfields)
	{
	$html = '';
	foreach ($formfields as $field) {
	$html .= html::div('form-section',
	html::label($field['id'], $field['label']) .
	$field['value']);
	}

	return $html;
	}

	/**
	* Compose a list of birthday events from the contact records in the user's address books.
	*
	* This is a default implementation using Roundcube's address book API.
	* It can be overriden with a more optimized version by the individual drivers.
	*
	* @param integer Event's new start (unix timestamp)
	* @param integer Event's new end (unix timestamp)
	* @param string Search query (optional)
	* @param integer Only list events modified since this time (unix timestamp)
	* @return array A list of event records
	*/
	public function load_birthday_events($start, $end, $search = null, $modifiedsince = null)
	{
	// ignore update requests for simplicity reasons
	if (!empty($modifiedsince)) {
	return array();
	}

	// convert to DateTime for comparisons
	$start = new DateTime('@'.$start);
	$end = new DateTime('@'.$end);
	// extract the current year
	$year = $start->format('Y');
	$year2 = $end->format('Y');

	$events = array();
	$search = mb_strtolower($search);
	$rcmail = rcmail::get_instance();
	$cache = $rcmail->get_cache('calendar.birthdays', 'db', 3600);
	$cache->expunge();

	$alarm_type = $rcmail->config->get('calendar_birthdays_alarm_type', '');
	$alarm_offset = $rcmail->config->get('calendar_birthdays_alarm_offset', '-1D');
	$alarms = $alarm_type ? $alarm_offset . ':' . $alarm_type : null;

	// let the user select the address books to consider in prefs
	$selected_sources = $rcmail->config->get('calendar_birthday_adressbooks');
	$sources = $selected_sources ?: array_keys($rcmail->get_address_sources(false, true));
	foreach ($sources as $source) {
	$abook = $rcmail->get_address_book($source);

	// skip LDAP address books unless selected by the user
	if (!$abook \|\| ($abook instanceof rcube_ldap && empty($selected_sources))) {
	continue;
	}

	$abook->set_pagesize(10000);

	// check for cached results
	$cache_records = array();
	$cached = $cache->get($source);

	// iterate over (cached) contacts
	foreach (($cached ?: $abook->search('*', '', 2, true, true, array('birthday'))) as $contact) {
	if (is_array($contact) && !empty($contact['birthday'])) {
	try {
	if (is_array($contact['birthday']))
	$contact['birthday'] = reset($contact['birthday']);

	$bday = $contact['birthday'] instanceof DateTime ? $contact['birthday'] :
	new DateTime($contact['birthday'], new DateTimezone('UTC'));
	$birthyear = $bday->format('Y');
	}
	catch (Exception $e) {
	console('BIRTHDAY PARSE ERROR: ' . $e);
	continue;
	}

	$display_name = rcube_addressbook::compose_display_name($contact);
	$event_title = $rcmail->gettext(array('name' => 'birthdayeventtitle', 'vars' => array('name' => $display_name)), 'calendar');

	// add stripped record to cache
	if (empty($cached)) {
	$cache_records[] = array(
	'ID' => $contact['ID'],
	'name' => $display_name,
	'birthday' => $bday->format('Y-m-d'),
	);
	}

	// filter by search term (only name is involved here)
	if (!empty($search) && strpos(mb_strtolower($event_title), $search) === false) {
	continue;
	}

	// quick-and-dirty recurrence computation: just replace the year
	$bday->setDate($year, $bday->format('n'), $bday->format('j'));
	$bday->setTime(12, 0, 0);

	// date range reaches over multiple years: use end year if not in range
	if (($bday > $end \|\| $bday < $start) && $year2 != $year) {
	$bday->setDate($year2, $bday->format('n'), $bday->format('j'));
	$year = $year2;
	}

	// birthday is within requested range
	if ($bday <= $end && $bday >= $start) {
	$age = $year - $birthyear;
	$event = array(
	'id' => md5('bday_' . $contact['ID'] . $year),
	'calendar' => self::BIRTHDAY_CALENDAR_ID,
	'title' => $event_title,
	'description' => $rcmail->gettext(array('name' => 'birthdayage', 'vars' => array('age' => $age)), 'calendar'),
	// Add more contact information to description block?
	'allday' => true,
	'start' => $bday,
	'alarms' => $alarms,
	);
	$event['end'] = clone $bday;
	$event['end']->add(new DateInterval('PT1H'));

	$events[] = $event;
	}
	}
	}

	// store collected contacts in cache
	if (empty($cached)) {
	$cache->write($source, $cache_records);
	}
	}

	return $events;
	}

	+ /**
	+ * Handler for user_delete plugin hook
	+ *
	+ * @param array Hash array with hook arguments
	+ * @return array Return arguments for plugin hooks
	+ */
	+ public function user_delete($args)
	+ {
	+ // TO BE OVERRIDDEN
	+ return $args;
	+ }
	}
	diff --git a/plugins/calendar/drivers/database/database_driver.php b/plugins/calendar/drivers/database/database_driver.php
	index b4de23bb..9b04bf1d 100644
	--- a/plugins/calendar/drivers/database/database_driver.php
	+++ b/plugins/calendar/drivers/database/database_driver.php
	@@ -1,1144 +1,1174 @@
	<?php

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


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

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

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

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


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

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

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

	$this->_read_calendars();
	}

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

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

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

	$calendars = $this->calendars;

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

	// 'personal' is unsupported in this driver

	// append the virtual birthdays calendar
	if ($this->rc->config->get('calendar_contact_birthdays', false)) {
	$prefs = $this->rc->config->get('birthday_calendar', array('color' => '87CEFA'));
	$hidden = array_filter(explode(',', $this->rc->config->get('hidden_calendars', '')));

	$id = self::BIRTHDAY_CALENDAR_ID;
	if (!$active \|\| !in_array($id, $hidden)) {
	$calendars[$id] = array(
	'id' => $id,
	'name' => $this->cal->gettext('birthdays'),
	'listname' => $this->cal->gettext('birthdays'),
	'color' => $prefs['color'],
	'showalarms' => (bool)$this->rc->config->get('calendar_birthdays_alarm_type'),
	'active' => !in_array($id, $hidden),
	'class_name' => 'birthdays',
	'readonly' => true,
	'default' => false,
	'children' => false,
	);
	}
	}

	return $calendars;
	}

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

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

	return false;
	}

	/**
	* Update properties of an existing calendar
	*
	* @see calendar_driver::edit_calendar()
	*/
	public function edit_calendar($prop)
	{
	// birthday calendar properties are saved in user prefs
	if ($prop['id'] == self::BIRTHDAY_CALENDAR_ID) {
	$prefs['birthday_calendar'] = $this->rc->config->get('birthday_calendar', array('color' => '87CEFA'));
	if (isset($prop['color']))
	$prefs['birthday_calendar']['color'] = $prop['color'];
	if (isset($prop['showalarms']))
	$prefs['calendar_birthdays_alarm_type'] = $prop['showalarms'] ? $this->alarm_types[0] : '';
	$this->rc->user->save_prefs($prefs);
	return true;
	}

	$query = $this->rc->db->query(
	"UPDATE " . $this->db_calendars . "
	SET name=?, color=?, showalarms=?
	WHERE calendar_id=?
	AND user_id=?",
	$prop['name'],
	$prop['color'],
	$prop['showalarms']?1:0,
	$prop['id'],
	$this->rc->user->ID
	);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$this->_update_recurring($event);
	}

	return $event_id;
	}

	return false;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// shifted or resized
	if ($diff && ($old_start_date == $new_start_date \|\| $old_duration == $new_duration)) {
	$event['start'] = $master['start']->add($old['start']->diff($event['start']));
	$event['end'] = clone $event['start'];
	$event['end']->add(new DateInterval('PT'.$new_duration.'S'));
	}
	// dates did not change, use the ones from master
	else if ($event['start'] == $old['start'] && $event['end'] == $old['end']) {
	$event['start'] = $master['start'];
	$event['end'] = $master['end'];
	}
	break;
	}
	}

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

	return $success;
	}

	return false;
	}

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

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

	if ($event['free_busy'] == 'tentative') {
	$event['status'] = 'TENTATIVE';
	}

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

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

	if (is_array($event['valarms'])) {
	$event['alarms'] = $this->serialize_alarms($event['valarms']);
	}

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

	return $event;
	}

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

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

	return null;
	}

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

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

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

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

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

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

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

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

	return $success;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return $success;
	}

	return false;
	}

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

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

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

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

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

	return false;
	}

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

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

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

	if (!$virtual)
	$sql_add .= ' AND e.recurrence_id = 0';

	if ($modifiedsince)
	$sql_add .= ' AND e.changed >= ' . $this->rc->db->quote(date('Y-m-d H:i:s', $modifiedsince));

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

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

	// add events from the address books birthday calendar
	if (in_array(self::BIRTHDAY_CALENDAR_ID, $calendars)) {
	$events = array_merge($events, $this->load_birthday_events($start, $end, $search, $modifiedsince));
	}

	return $events;
	}

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

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

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

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

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

	// decode serialized alarms
	if ($event['alarms']) {
	$event['valarms'] = $this->unserialize_alarms($event['alarms']);
	}

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

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

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

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

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

	return $alarms;
	}

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

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

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

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

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

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

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

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

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

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

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

	return $attachments;
	}

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

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

	return null;
	}

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

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

	return null;
	}

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

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

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

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

	/**
	* Helper method to serialize the list of alarms into a string
	*/
	private function serialize_alarms($valarms)
	{
	foreach ((array)$valarms as $i => $alarm) {
	if ($alarm['trigger'] instanceof DateTime) {
	$valarms[$i]['trigger'] = '@' . $alarm['trigger']->format('c');
	}
	}

	return $valarms ? json_encode($valarms) : null;
	}

	/**
	* Helper method to decode a serialized list of alarms
	*/
	private function unserialize_alarms($alarms)
	{
	// decode json serialized alarms
	if ($alarms && $alarms[0] == '[') {
	$valarms = json_decode($alarms, true);
	foreach ($valarms as $i => $alarm) {
	if ($alarm['trigger'][0] == '@') {
	try {
	$valarms[$i]['trigger'] = new DateTime(substr($alarm['trigger'], 1));
	}
	catch (Exception $e) {
	unset($valarms[$i]);
	}
	}
	}
	}
	// convert legacy alarms data
	else if (strlen($alarms)) {
	list($trigger, $action) = explode(':', $alarms, 2);
	if ($trigger = libcalendaring::parse_alaram_value($trigger)) {
	$valarms = array(array('action' => $action, 'trigger' => $trigger[3] ?: $trigger[0]));
	}
	}

	return $valarms;
	}

	+ /**
	+ * Handler for user_delete plugin hook
	+ */
	+ public function user_delete($args)
	+ {
	+ $db = $this->rc->db;
	+ $user = $args['user'];
	+ $event_ids = array();
	+
	+ $events = $db->query(
	+ "SELECT event_id FROM " . $this->db_events . " AS ev" .
	+ " LEFT JOIN " . $this->db_calendars . " cal ON (ev.calendar_id = cal.calendar_id)".
	+ " WHERE user_id=?",
	+ $user->ID);
	+
	+ while ($row = $db->fetch_assoc($calendars)) {
	+ $event_ids[] = $row['event_id'];
	+ }
	+
	+ if (!empty($event_ids)) {
	+ foreach (array($this->db_attachments, $this->db_events) as $table) {
	+ $db->query(sprintf("DELETE FROM $table WHERE event_id IN (%s)", join(',', $event_ids)));
	+ }
	+ }
	+
	+ foreach (array($this->db_calendars, 'itipinvitations') as $table) {
	+ $db->query("DELETE FROM $table WHERE user_id=?", $user->ID);
	+ }
	+ }
	+
	}
	diff --git a/plugins/calendar/drivers/kolab/kolab_driver.php b/plugins/calendar/drivers/kolab/kolab_driver.php
	index 6058dfb8..28eb8ba5 100644
	--- a/plugins/calendar/drivers/kolab/kolab_driver.php
	+++ b/plugins/calendar/drivers/kolab/kolab_driver.php
	@@ -1,1302 +1,1313 @@
	<?php

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

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

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

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

	/**
	* Default constructor
	*/
	public function __construct($cal)
	{
	$cal->require_plugin('libkolab');

	$this->cal = $cal;
	$this->rc = $cal->rc;
	$this->_read_calendars();

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

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

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


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

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

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

	return $this->calendars;
	}


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

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

	// include virtual folders for a full folder tree
	if (!$active && !$personal && !$this->rc->output->ajax_call && in_array($this->rc->action, array('index','')))
	$folders = kolab_storage::folder_hierarchy($folders);

	foreach ($folders as $id => $cal) {
	$fullname = $cal->get_name();
	$listname = kolab_storage::folder_displayname($fullname, $names);

	// special handling for virtual folders
	if ($cal->virtual) {
	$calendars[$cal->id] = array(
	'id' => $cal->id,
	'name' => $fullname,
	'listname' => $listname,
	'virtual' => true,
	'readonly' => true,
	);
	}
	else {
	$calendars[$cal->id] = array(
	'id' => $cal->id,
	'name' => $fullname,
	'listname' => $listname,
	'editname' => $cal->get_foldername(),
	'color' => $cal->get_color(),
	'readonly' => $cal->readonly,
	'showalarms' => $cal->alarms,
	'class_name' => $cal->get_namespace(),
	'default' => $cal->storage->default,
	'active' => $cal->storage->is_active(),
	'owner' => $cal->get_owner(),
	'children' => true, // TODO: determine if that folder indeed has child folders
	'caldavurl' => $cal->get_caldav_url(),
	);
	}
	}

	// append the virtual birthdays calendar
	if ($this->rc->config->get('calendar_contact_birthdays', false)) {
	$id = self::BIRTHDAY_CALENDAR_ID;
	$prefs = $this->rc->config->get('kolab_calendars', array()); // read local prefs
	if (!$active \|\| $prefs[$id]['active']) {
	$calendars[$id] = array(
	'id' => $id,
	'name' => $this->cal->gettext('birthdays'),
	'listname' => $this->cal->gettext('birthdays'),
	'color' => $prefs[$id]['color'],
	'active' => $prefs[$id]['active'],
	'showalarms' => (bool)$this->rc->config->get('calendar_birthdays_alarm_type'),
	'class_name' => 'birthdays',
	'readonly' => true,
	'default' => false,
	'children' => false,
	);
	}
	}

	return $calendars;
	}

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

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

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

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

	return $calendars;
	}

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

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

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

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

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

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

	return $id;
	}


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

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

	// create ID
	$id = kolab_storage::folder_id($newfolder);
	}
	else {
	$id = $prop['id'];
	}

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

	if (isset($prop['color']))
	$prefs['kolab_calendars'][$id]['color'] = $prop['color'];

	if (isset($prop['showalarms']) && $id == self::BIRTHDAY_CALENDAR_ID)
	$prefs['calendar_birthdays_alarm_type'] = $prop['showalarms'] ? $this->alarm_types[0] : '';
	else if (isset($prop['showalarms']))
	$prefs['kolab_calendars'][$id]['showalarms'] = $prop['showalarms'] ? true : false;

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

	return true;
	}


	/**
	* Set active/subscribed state of a calendar
	*
	* @see calendar_driver::subscribe_calendar()
	*/
	public function subscribe_calendar($prop)
	{
	if ($prop['id'] && ($cal = $this->calendars[$prop['id']])) {
	return $cal->storage->activate($prop['active']);
	}
	else {
	// save state in local prefs
	$prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());
	$prefs['kolab_calendars'][$prop['id']]['active'] = (bool)$prop['active'];
	$this->rc->user->save_prefs($prefs);
	return true;
	}

	return false;
	}


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

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

	return false;
	}


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

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

	return false;
	}

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

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

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

	if ($success && $this->freebusy_trigger) {
	$this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));
	$this->freebusy_trigger = false; // disable after first execution (#2355)
	}

	return $success;
	}

	return false;
	}

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

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

	return false;
	}

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

	return false;
	}

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

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

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

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

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

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

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

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

	$master['start'] = $recurring['start'];
	$master['end'] = $recurring['end'];
	if ($master['recurrence']['COUNT'])
	$master['recurrence']['COUNT']--;
	}
	// remove the matching RDATE entry
	else if ($master['recurrence']['RDATE']) {
	foreach ($master['recurrence']['RDATE'] as $j => $rdate) {
	if ($rdate->format('Ymd') == $event['start']->format('Ymd')) {
	unset($master['recurrence']['RDATE'][$j]);
	break;
	}
	}
	}
	else { // add exception to master event
	$master['recurrence']['EXDATE'][] = $event['start'];
	}
	$success = $storage->update_event($master);
	break;

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

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

	// if all future instances are deleted, remove recurrence rule entirely (bug #1677)
	if ($master['recurrence']['UNTIL']->format('Ymd') == $master['start']->format('Ymd')) {
	$master['recurrence'] = array();
	}
	// remove matching RDATE entries
	else if ($master['recurrence']['RDATE']) {
	foreach ($master['recurrence']['RDATE'] as $j => $rdate) {
	if ($rdate->format('Ymd') == $event['start']->format('Ymd')) {
	$master['recurrence']['RDATE'] = array_slice($master['recurrence']['RDATE'], 0, $j);
	break;
	}
	}
	}

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

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

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

	return $success;
	}

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

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

	return $success;
	}

	return false;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$add_exception = true;

	// adjust matching RDATE entry if dates changed
	if ($savemode == 'current' && $master['recurrence']['RDATE'] && ($old_date = $old['start']->format('Ymd')) != $event['start']->format('Ymd')) {
	foreach ($master['recurrence']['RDATE'] as $j => $rdate) {
	if ($rdate->format('Ymd') == $old_date) {
	$master['recurrence']['RDATE'][$j] = $event['start'];
	sort($master['recurrence']['RDATE']);
	$add_exception = false;
	break;
	}
	}
	}

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

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

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

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

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

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

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

	// unset _dateonly flags in (cached) date objects
	unset($event['start']->_dateonly, $event['end']->_dateonly);

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

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

	return $success;
	}

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

	$query = array();
	if ($modifiedsince)
	$query[] = array('changed', '>=', $modifiedsince);

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

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

	// add events from the address books birthday calendar
	if (in_array(self::BIRTHDAY_CALENDAR_ID, $calendars)) {
	$events = array_merge($events, $this->load_birthday_events($start, $end, $search, $modifiedsince));
	}

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

	return $events;
	}

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

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

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

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

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

	$time = $slot + $interval;

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

	foreach ($calendar->list_events($time, $time + 86400 * 365, null, 1, $query) as $e) {
	// add to list if alarm is set
	$alarm = libcalendaring::get_next_alarm($e);
	if ($alarm && $alarm['time'] && $alarm['time'] <= $time && in_array($alarm['action'], $this->alarm_types)) {
	$id = $alarm['id']; // use alarm-id as primary identifier
	$candidates[$id] = array(
	'id' => $id,
	'title' => $e['title'],
	'location' => $e['location'],
	'start' => $e['start'],
	'end' => $e['end'],
	'notifyat' => $alarm['time'],
	'action' => $alarm['action'],
	);
	}
	}
	}

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

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

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

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

	return $alarms;
	}

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

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

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

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

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

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

	return $event['attachments'];
	}

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

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

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

	return null;
	}

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

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

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

	/**
	* Fetch free/busy information from a person within the given range
	*/
	public function get_freebusy_list($email, $start, $end)
	{
	if (empty($email)/* \|\| $end < time()*/)
	return false;

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

	// ask kolab server first
	try {
	$request_config = array(
	'store_body' => true,
	'follow_redirects' => true,
	);
	$request = libkolab::http_request(kolab_storage::get_freebusy_url($email), 'GET', $request_config);
	$response = $request->send();

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

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

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

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

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

	if ($fbdata)
	break;
	}
	}

	// parse free-busy information using Horde classes
	if ($fbdata) {
	$ical = $this->cal->get_ical();
	$ical->import($fbdata);
	if ($fb = $ical->freebusy) {
	$result = array();
	foreach ($fb['periods'] as $tuple) {
	list($from, $to, $type) = $tuple;
	$result[] = array($from->format('U'), $to->format('U'), isset($fbtypemap[$type]) ? $fbtypemap[$type] : calendar::FREEBUSY_BUSY);
	}

	// we take 'dummy' free-busy lists as "unknown"
	if (empty($result) && !empty($fb['comment']) && stripos($fb['comment'], 'dummy'))
	return false;

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

	return $result;
	}
	}

	return false;
	}

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

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

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

	exit;
	}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

	return $content;
	}


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

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

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

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

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

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

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

	return $plugin['form']['sharing']['content'];
	}
	+
	+ /**
	+ * Handler for user_delete plugin hook
	+ */
	+ public function user_delete($args)
	+ {
	+ $db = $this->rc->get_dbh();
	+ foreach (array('kolab_alarms', 'itipinvitations') as $table) {
	+ $db->query("DELETE FROM $table WHERE user_id=?", $args['user']->ID);
	+ }
	+ }
	}
	diff --git a/plugins/tasklist/drivers/database/tasklist_database_driver.php b/plugins/tasklist/drivers/database/tasklist_database_driver.php
	index f40d5048..cf1885b7 100644
	--- a/plugins/tasklist/drivers/database/tasklist_database_driver.php
	+++ b/plugins/tasklist/drivers/database/tasklist_database_driver.php
	@@ -1,726 +1,745 @@
	<?php

	/**
	* Database driver for the Tasklist plugin
	*
	* @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 tasklist_database_driver extends tasklist_driver
	{
	public $undelete = true; // yes, we can
	public $sortable = false;
	public $alarm_types = array('DISPLAY');

	private $rc;
	private $plugin;
	private $lists = array();
	private $list_ids = '';

	private $db_tasks = 'tasks';
	private $db_lists = 'tasklists';


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

	// read database config
	$db = $this->rc->get_dbh();
	$this->db_lists = $this->rc->config->get('db_table_lists', $db->table_name($this->db_lists));
	$this->db_tasks = $this->rc->config->get('db_table_tasks', $db->table_name($this->db_tasks));

	$this->_read_lists();
	}

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

	if (!empty($this->rc->user->ID)) {
	$list_ids = array();
	$result = $this->rc->db->query(
	"SELECT *, tasklist_id AS id FROM " . $this->db_lists . "
	WHERE user_id=?
	ORDER BY CASE WHEN name='INBOX' THEN 0 ELSE 1 END, name",
	$this->rc->user->ID
	);

	while ($result && ($arr = $this->rc->db->fetch_assoc($result))) {
	$arr['showalarms'] = intval($arr['showalarms']);
	$arr['active'] = !in_array($arr['id'], $hidden);
	$arr['name'] = html::quote($arr['name']);
	$arr['listname'] = html::quote($arr['name']);
	$arr['editable'] = true;
	$this->lists[$arr['id']] = $arr;
	$list_ids[] = $this->rc->db->quote($arr['id']);
	}
	$this->list_ids = join(',', $list_ids);
	}
	}

	/**
	* Get a list of available tasks lists from this source
	*/
	public function get_lists()
	{
	// attempt to create a default list for this user
	if (empty($this->lists)) {
	- if ($this->create_list(array('name' => 'Default', 'color' => '000000')))
	+ $prop = array('name' => 'Default', 'color' => '000000');
	+ if ($this->create_list($prop))
	$this->_read_lists();
	}

	return $this->lists;
	}

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

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

	return false;
	}

	/**
	* Update properties of an existing tasklist
	*
	* @param array Hash array with list properties
	* @return boolean True on success, Fales on failure
	* @see tasklist_driver::edit_list()
	*/
	public function edit_list(&$prop)
	{
	$query = $this->rc->db->query(
	"UPDATE " . $this->db_lists . "
	SET name=?, color=?, showalarms=?
	WHERE tasklist_id=?
	AND user_id=?",
	$prop['name'],
	$prop['color'],
	$prop['showalarms']?1:0,
	$prop['id'],
	$this->rc->user->ID
	);

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

	/**
	* Set active/subscribed state of a list
	*
	* @param array Hash array with list properties
	* @return boolean True on success, Fales on failure
	* @see tasklist_driver::subscribe_list()
	*/
	public function subscribe_list($prop)
	{
	$hidden = array_flip(explode(',', $this->rc->config->get('hidden_tasklists', '')));

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

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

	/**
	* Delete the given list with all its contents
	*
	* @param array Hash array with list properties
	* @return boolean True on success, Fales on failure
	* @see tasklist_driver::remove_list()
	*/
	public function remove_list($prop)
	{
	$list_id = $prop['id'];

	if ($this->lists[$list_id]) {
	// delete all tasks linked with this list
	$this->rc->db->query(
	"DELETE FROM " . $this->db_tasks . "
	WHERE tasklist_id=?",
	$list_id
	);

	// delete list record
	$query = $this->rc->db->query(
	"DELETE FROM " . $this->db_lists . "
	WHERE tasklist_id=?
	AND user_id=?",
	$list_id,
	$this->rc->user->ID
	);

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

	return false;
	}

	/**
	* Get number of tasks matching the given filter
	*
	* @param array List of lists to count tasks of
	* @return array Hash array with counts grouped by status (all\|flagged\|today\|tomorrow\|overdue\|nodate)
	* @see tasklist_driver::count_tasks()
	*/
	function count_tasks($lists = null)
	{
	if (empty($lists))
	$lists = array_keys($this->lists);
	else if (is_string($lists))
	$lists = explode(',', $lists);

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

	$today_date = new DateTime('now', $this->plugin->timezone);
	$today = $today_date->format('Y-m-d');
	$tomorrow_date = new DateTime('now + 1 day', $this->plugin->timezone);
	$tomorrow = $tomorrow_date->format('Y-m-d');

	$result = $this->rc->db->query(sprintf(
	"SELECT task_id, flagged, date FROM " . $this->db_tasks . "
	WHERE tasklist_id IN (%s)
	AND del=0 AND complete<1",
	join(',', $list_ids)
	));

	$counts = array('all' => 0, 'flagged' => 0, 'today' => 0, 'tomorrow' => 0, 'overdue' => 0, 'nodate' => 0);
	while ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
	$counts['all']++;
	if ($rec['flagged'])
	$counts['flagged']++;
	if (empty($rec['date']))
	$counts['nodate']++;
	else if ($rec['date'] == $today)
	$counts['today']++;
	else if ($rec['date'] == $tomorrow)
	$counts['tomorrow']++;
	else if ($rec['date'] < $today)
	$counts['overdue']++;
	}

	return $counts;
	}

	/**
	* Get all taks records matching the given filter
	*
	* @param array Hash array wiht filter criterias
	* @param array List of lists to get tasks from
	* @return array List of tasks records matchin the criteria
	* @see tasklist_driver::list_tasks()
	*/
	function list_tasks($filter, $lists = null)
	{
	if (empty($lists))
	$lists = array_keys($this->lists);
	else if (is_string($lists))
	$lists = explode(',', $lists);

	// only allow to select from lists of this user
	$list_ids = array_map(array($this->rc->db, 'quote'), array_intersect($lists, array_keys($this->lists)));
	$sql_add = '';

	// add filter criteria
	if ($filter['from'] \|\| ($filter['mask'] & tasklist::FILTER_MASK_TODAY)) {
	$sql_add .= ' AND (date IS NULL OR date >= ?)';
	$datefrom = $filter['from'];
	}
	if ($filter['to']) {
	if ($filter['mask'] & tasklist::FILTER_MASK_OVERDUE)
	$sql_add .= ' AND (date IS NOT NULL AND date <= ' . $this->rc->db->quote($filter['to']) . ')';
	else
	$sql_add .= ' AND (date IS NULL OR date <= ' . $this->rc->db->quote($filter['to']) . ')';
	}

	// special case 'today': also show all events with date before today
	if ($filter['mask'] & tasklist::FILTER_MASK_TODAY) {
	$datefrom = date('Y-m-d', 0);
	}

	if ($filter['mask'] & tasklist::FILTER_MASK_NODATE)
	$sql_add = ' AND date IS NULL';

	if ($filter['mask'] & tasklist::FILTER_MASK_COMPLETE)
	$sql_add .= ' AND complete=1';
	else if (empty($filter['since'])) // don't show complete tasks by default
	$sql_add .= ' AND complete<1';

	if ($filter['mask'] & tasklist::FILTER_MASK_FLAGGED)
	$sql_add .= ' AND flagged=1';

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

	if ($filter['since'] && is_numeric($filter['since'])) {
	$sql_add .= ' AND changed >= ' . $this->rc->db->quote(date('Y-m-d H:i:s', $filter['since']));
	}

	$tasks = array();
	if (!empty($list_ids)) {
	$result = $this->rc->db->query(sprintf(
	"SELECT * FROM " . $this->db_tasks . "
	WHERE tasklist_id IN (%s)
	AND del=0
	%s
	ORDER BY parent_id, task_id ASC",
	join(',', $list_ids),
	$sql_add
	),
	$datefrom
	);

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

	return $tasks;
	}

	/**
	* Return data of a specific task
	*
	* @param mixed Hash array with task properties or task UID
	* @return array Hash array with task properties or false if not found
	*/
	public function get_task($prop)
	{
	if (is_string($prop))
	$prop['uid'] = $prop;

	$query_col = $prop['id'] ? 'task_id' : 'uid';

	$result = $this->rc->db->query(sprintf(
	"SELECT * FROM " . $this->db_tasks . "
	WHERE tasklist_id IN (%s)
	AND %s=?
	AND del=0",
	$this->list_ids,
	$query_col
	),
	$prop['id'] ? $prop['id'] : $prop['uid']
	);

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

	return false;
	}

	/**
	* Get all decendents of the given task record
	*
	* @param mixed Hash array with task properties or task UID
	* @param boolean True if all childrens children should be fetched
	* @return array List of all child task IDs
	*/
	public function get_childs($prop, $recursive = false)
	{
	// resolve UID first
	if (is_string($prop)) {
	$result = $this->rc->db->query(sprintf(
	"SELECT task_id AS id, tasklist_id AS list FROM " . $this->db_tasks . "
	WHERE tasklist_id IN (%s)
	AND uid=?",
	$this->list_ids
	),
	$prop);
	$prop = $this->rc->db->fetch_assoc($result);
	}

	$childs = array();
	$task_ids = array($prop['id']);

	// query for childs (recursively)
	while (!empty($task_ids)) {
	$result = $this->rc->db->query(sprintf(
	"SELECT task_id AS id FROM " . $this->db_tasks . "
	WHERE tasklist_id IN (%s)
	AND parent_id IN (%s)
	AND del=0",
	$this->list_ids,
	join(',', array_map(array($this->rc->db, 'quote'), $task_ids))
	));

	$task_ids = array();
	while ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
	$childs[] = $rec['id'];
	$task_ids[] = $rec['id'];
	}

	if (!$recursive)
	break;
	}

	return $childs;
	}

	/**
	* Get a list of pending alarms to be displayed to the user
	*
	* @param integer Current time (unix timestamp)
	* @param mixed List of list IDs to show alarms for (either as array or comma-separated string)
	* @return array A list of alarms, each encoded as hash array with task properties
	* @see tasklist_driver::pending_alarms()
	*/
	public function pending_alarms($time, $lists = null)
	{
	if (empty($lists))
	$lists = array_keys($this->lists);
	else if (is_string($lists))
	$lists = explode(',', $lists);

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

	$alarms = array();
	if (!empty($list_ids)) {
	$result = $this->rc->db->query(sprintf(
	"SELECT * FROM " . $this->db_tasks . "
	WHERE tasklist_id IN (%s)
	AND notify <= %s AND complete < 1",
	join(',', $list_ids),
	$this->rc->db->fromunixtime($time)
	));

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

	return $alarms;
	}

	/**
	* Feedback after showing/sending an alarm notification
	*
	* @see tasklist_driver::dismiss_alarm()
	*/
	public function dismiss_alarm($task_id, $snooze = 0)
	{
	// set new notifyat time or unset if not snoozed
	$notify_at = $snooze > 0 ? date('Y-m-d H:i:s', time() + $snooze) : null;

	$query = $this->rc->db->query(sprintf(
	"UPDATE " . $this->db_tasks . "
	SET changed=%s, notify=?
	WHERE task_id=?
	AND tasklist_id IN (" . $this->list_ids . ")",
	$this->rc->db->now()),
	$notify_at,
	$task_id
	);

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

	/**
	* Map some internal database values to match the generic "API"
	*/
	private function _read_postprocess($rec)
	{
	$rec['id'] = $rec['task_id'];
	$rec['list'] = $rec['tasklist_id'];
	$rec['changed'] = new DateTime($rec['changed']);
	$rec['tags'] = array_filter(explode(',', $rec['tags']));

	if (!$rec['parent_id'])
	unset($rec['parent_id']);

	// decode serialized alarms
	if ($rec['alarms']) {
	$rec['valarms'] = $this->unserialize_alarms($rec['alarms']);
	unset($rec['alarms']);
	}

	unset($rec['task_id'], $rec['tasklist_id'], $rec['created']);
	return $rec;
	}

	/**
	* Add a single task to the database
	*
	* @param array Hash array with task properties (see header of this file)
	* @return mixed New event ID on success, False on error
	* @see tasklist_driver::create_task()
	*/
	public function create_task($prop)
	{
	// check list permissions
	$list_id = $prop['list'] ? $prop['list'] : reset(array_keys($this->lists));
	if (!$this->lists[$list_id] \|\| $this->lists[$list_id]['readonly'])
	return false;

	if (is_array($prop['valarms'])) {
	$prop['alarms'] = $this->serialize_alarms($prop['valarms']);
	}

	foreach (array('parent_id', 'date', 'time', 'startdate', 'starttime', 'alarms') as $col) {
	if (empty($prop[$col]))
	$prop[$col] = null;
	}

	$notify_at = $this->_get_notification($prop);
	$result = $this->rc->db->query(sprintf(
	"INSERT INTO " . $this->db_tasks . "
	(tasklist_id, uid, parent_id, created, changed, title, date, time, startdate, starttime, description, tags, alarms, notify)
	VALUES (?, ?, ?, %s, %s, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
	$this->rc->db->now(),
	$this->rc->db->now()
	),
	$list_id,
	$prop['uid'],
	$prop['parent_id'],
	$prop['title'],
	$prop['date'],
	$prop['time'],
	$prop['startdate'],
	$prop['starttime'],
	strval($prop['description']),
	join(',', (array)$prop['tags']),
	$prop['alarms'],
	$notify_at
	);

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

	return false;
	}

	/**
	* Update an task entry with the given data
	*
	* @param array Hash array with task properties
	* @return boolean True on success, False on error
	* @see tasklist_driver::edit_task()
	*/
	public function edit_task($prop)
	{
	if (is_array($prop['valarms'])) {
	$prop['alarms'] = $this->serialize_alarms($prop['valarms']);
	}

	$sql_set = array();
	foreach (array('title', 'description', 'flagged', 'complete') as $col) {
	if (isset($prop[$col]))
	$sql_set[] = $this->rc->db->quote_identifier($col) . '=' . $this->rc->db->quote($prop[$col]);
	}
	foreach (array('parent_id', 'date', 'time', 'startdate', 'starttime', 'alarms') as $col) {
	if (isset($prop[$col]))
	$sql_set[] = $this->rc->db->quote_identifier($col) . '=' . (empty($prop[$col]) ? 'NULL' : $this->rc->db->quote($prop[$col]));
	}
	if (isset($prop['tags']))
	$sql_set[] = $this->rc->db->quote_identifier('tags') . '=' . $this->rc->db->quote(join(',', (array)$prop['tags']));

	if (isset($prop['date']) \|\| isset($prop['time']) \|\| isset($prop['alarms'])) {
	$notify_at = $this->_get_notification($prop);
	$sql_set[] = $this->rc->db->quote_identifier('notify') . '=' . (empty($notify_at) ? 'NULL' : $this->rc->db->quote($notify_at));
	}

	// moved from another list
	if ($prop['_fromlist'] && ($newlist = $prop['list'])) {
	$sql_set[] = 'tasklist_id=' . $this->rc->db->quote($newlist);
	}

	$query = $this->rc->db->query(sprintf(
	"UPDATE " . $this->db_tasks . "
	SET changed=%s %s
	WHERE task_id=?
	AND tasklist_id IN (%s)",
	$this->rc->db->now(),
	($sql_set ? ', ' . join(', ', $sql_set) : ''),
	$this->list_ids
	),
	$prop['id']
	);

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

	/**
	* Move a single task to another list
	*
	* @param array Hash array with task properties:
	* @return boolean True on success, False on error
	* @see tasklist_driver::move_task()
	*/
	public function move_task($prop)
	{
	return $this->edit_task($prop);
	}

	/**
	* Remove a single task from the database
	*
	* @param array Hash array with task properties
	* @param boolean Remove record irreversible
	* @return boolean True on success, False on error
	* @see tasklist_driver::delete_task()
	*/
	public function delete_task($prop, $force = true)
	{
	$task_id = $prop['id'];

	if ($task_id && $force) {
	$query = $this->rc->db->query(
	"DELETE FROM " . $this->db_tasks . "
	WHERE task_id=?
	AND tasklist_id IN (" . $this->list_ids . ")",
	$task_id
	);
	}
	else if ($task_id) {
	$query = $this->rc->db->query(sprintf(
	"UPDATE " . $this->db_tasks . "
	SET changed=%s, del=1
	WHERE task_id=?
	AND tasklist_id IN (%s)",
	$this->rc->db->now(),
	$this->list_ids
	),
	$task_id
	);
	}

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

	/**
	* Restores a single deleted task (if supported)
	*
	* @param array Hash array with task properties
	* @return boolean True on success, False on error
	* @see tasklist_driver::undelete_task()
	*/
	public function undelete_task($prop)
	{
	$query = $this->rc->db->query(sprintf(
	"UPDATE " . $this->db_tasks . "
	SET changed=%s, del=0
	WHERE task_id=?
	AND tasklist_id IN (%s)",
	$this->rc->db->now(),
	$this->list_ids
	),
	$prop['id']
	);

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

	/**
	* Compute absolute time to notify the user
	*/
	private function _get_notification($task)
	{
	if ($task['valarms'] && $task['complete'] < 1) {
	$alarm = libcalendaring::get_next_alarm($task, 'task');

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

	return null;
	}

	/**
	* Helper method to serialize the list of alarms into a string
	*/
	private function serialize_alarms($valarms)
	{
	foreach ((array)$valarms as $i => $alarm) {
	if ($alarm['trigger'] instanceof DateTime) {
	$valarms[$i]['trigger'] = '@' . $alarm['trigger']->format('c');
	}
	}

	return $valarms ? json_encode($valarms) : null;
	}

	/**
	* Helper method to decode a serialized list of alarms
	*/
	private function unserialize_alarms($alarms)
	{
	// decode json serialized alarms
	if ($alarms && $alarms[0] == '[') {
	$valarms = json_decode($alarms, true);
	foreach ($valarms as $i => $alarm) {
	if ($alarm['trigger'][0] == '@') {
	try {
	$valarms[$i]['trigger'] = new DateTime(substr($alarm['trigger'], 1));
	}
	catch (Exception $e) {
	unset($valarms[$i]);
	}
	}
	}
	}
	// convert legacy alarms data
	else if (strlen($alarms)) {
	list($trigger, $action) = explode(':', $alarms, 2);
	if ($trigger = libcalendaring::parse_alaram_value($trigger)) {
	$valarms = array(array('action' => $action, 'trigger' => $trigger[3] ?: $trigger[0]));
	}
	}

	return $valarms;
	}

	+ /**
	+ * Handler for user_delete plugin hook
	+ */
	+ public function user_delete($args)
	+ {
	+ $db = $this->rc->db;
	+ $list_ids = array();
	+ $lists = $db->query("SELECT tasklist_id FROM " . $this->db_lists . " WHERE user_id=?", $args['user']->ID);
	+ while ($row = $db->fetch_assoc($lists)) {
	+ $list_ids[] = $row['tasklist_id'];
	+ }
	+
	+ if (!empty($list_ids)) {
	+ foreach (array($this->db_tasks, $this->db_lists) as $table) {
	+ $db->query(sprintf("DELETE FROM $table WHERE tasklist_id IN (%s)", join(',', $list_ids)));
	+ }
	+ }
	+ }
	}
	diff --git a/plugins/tasklist/drivers/tasklist_driver.php b/plugins/tasklist/drivers/tasklist_driver.php
	index ee5a161d..382a9106 100644
	--- a/plugins/tasklist/drivers/tasklist_driver.php
	+++ b/plugins/tasklist/drivers/tasklist_driver.php
	@@ -1,280 +1,291 @@
	<?php

	/**
	* Driver interface for the Tasklist plugin
	*
	* @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/>.
	*/

	/**
	* Struct of an internal task object how it is passed from/to the driver classes:
	*
	* $task = array(
	* 'id' => 'Task ID used for editing', // must be unique for the current user
	* 'parent_id' => 'ID of parent task', // null if top-level task
	* 'uid' => 'Unique identifier of this task',
	* 'list' => 'Task list identifier to add the task to or where the task is stored',
	* 'changed' => <DateTime>, // Last modification date/time of the record
	* 'title' => 'Event title/summary',
	* 'description' => 'Event description',
	* 'tags' => array(), // List of tags for this task
	* 'date' => 'Due date', // as string of format YYYY-MM-DD or null if no date is set
	* 'time' => 'Due time', // as string of format hh::ii or null if no due time is set
	* 'startdate' => 'Start date' // Delay start of the task until that date
	* 'starttime' => 'Start time' // ...and time
	* 'categories' => 'Task category',
	* 'flagged' => 'Boolean value whether this record is flagged',
	* 'complete' => 'Float value representing the completeness state (range 0..1)',
	* 'sensitivity' => 0\|1\|2, // Event sensitivity (0=public, 1=private, 2=confidential)
	* 'alarms' => '-15M:DISPLAY', // Reminder settings inspired by valarm definition (e.g. display alert 15 minutes before due time)
	* '_fromlist' => 'List identifier where the task was stored before',
	* );
	*/

	/**
	* Driver interface for the Tasklist plugin
	*/
	abstract class tasklist_driver
	{
	// features supported by the backend
	public $alarms = false;
	public $attachments = false;
	public $undelete = false; // task undelete action
	public $sortable = false;
	public $alarm_types = array('DISPLAY');
	public $alarm_absolute = true;
	public $last_error;

	/**
	* Get a list of available task lists from this source
	*/
	abstract function get_lists();

	/**
	* Create a new list assigned to the current user
	*
	* @param array Hash array with list properties
	* name: List name
	* color: The color of the list
	* showalarms: True if alarms are enabled
	* @return mixed ID of the new list on success, False on error
	*/
	abstract function create_list(&$prop);

	/**
	* Update properties of an existing tasklist
	*
	* @param array Hash array with list properties
	* id: List Identifier
	* name: List name
	* color: The color of the list
	* showalarms: True if alarms are enabled (if supported)
	* @return boolean True on success, Fales on failure
	*/
	abstract function edit_list(&$prop);

	/**
	* Set active/subscribed state of a list
	*
	* @param array Hash array with list properties
	* id: List Identifier
	* active: True if list is active, false if not
	* @return boolean True on success, Fales on failure
	*/
	abstract function subscribe_list($prop);

	/**
	* Delete the given list with all its contents
	*
	* @param array Hash array with list properties
	* id: list Identifier
	* @return boolean True on success, Fales on failure
	*/
	abstract function remove_list($prop);

	/**
	* Get number of tasks matching the given filter
	*
	* @param array List of lists to count tasks of
	* @return array Hash array with counts grouped by status (all\|flagged\|completed\|today\|tomorrow\|nodate)
	*/
	abstract function count_tasks($lists = null);

	/**
	* Get all taks records matching the given filter
	*
	* @param array Hash array with filter criterias:
	* - mask: Bitmask representing the filter selection (check against tasklist::FILTER_MASK_* constants)
	* - from: Date range start as string (Y-m-d)
	* - to: Date range end as string (Y-m-d)
	* - search: Search query string
	* @param array List of lists to get tasks from
	* @return array List of tasks records matchin the criteria
	*/
	abstract function list_tasks($filter, $lists = null);

	/**
	* Get a list of pending alarms to be displayed to the user
	*
	* @param integer Current time (unix timestamp)
	* @param mixed List of list IDs to show alarms for (either as array or comma-separated string)
	* @return array A list of alarms, each encoded as hash array with task properties
	* id: Task identifier
	* uid: Unique identifier of this task
	* date: Task due date
	* time: Task due time
	* title: Task title/summary
	*/
	abstract function pending_alarms($time, $lists = null);

	/**
	* (User) feedback after showing an alarm notification
	* This should mark the alarm as 'shown' or snooze it for the given amount of time
	*
	* @param string Task identifier
	* @param integer Suspend the alarm for this number of seconds
	*/
	abstract function dismiss_alarm($id, $snooze = 0);

	/**
	* Return data of a specific task
	*
	* @param mixed Hash array with task properties or task UID
	* @return array Hash array with task properties or false if not found
	*/
	abstract public function get_task($prop);

	/**
	* Get decendents of the given task record
	*
	* @param mixed Hash array with task properties or task UID
	* @param boolean True if all childrens children should be fetched
	* @return array List of all child task IDs
	*/
	abstract public function get_childs($prop, $recursive = false);

	/**
	* Add a single task to the database
	*
	* @param array Hash array with task properties (see header of this file)
	* @return mixed New event ID on success, False on error
	*/
	abstract function create_task($prop);

	/**
	* Update an task entry with the given data
	*
	* @param array Hash array with task properties (see header of this file)
	* @return boolean True on success, False on error
	*/
	abstract function edit_task($prop);

	/**
	* Move a single task to another list
	*
	* @param array Hash array with task properties:
	* id: Task identifier
	* list: New list identifier to move to
	* _fromlist: Previous list identifier
	* @return boolean True on success, False on error
	*/
	abstract function move_task($prop);

	/**
	* Remove a single task from the database
	*
	* @param array Hash array with task properties:
	* id: Task identifier
	* @param boolean Remove record irreversible (mark as deleted otherwise, if supported by the backend)
	* @return boolean True on success, False on error
	*/
	abstract function delete_task($prop, $force = true);

	/**
	* Restores a single deleted task (if supported)
	*
	* @param array Hash array with task properties:
	* id: Task identifier
	* @return boolean True on success, False on error
	*/
	public function undelete_task($prop)
	{
	return false;
	}

	/**
	* Get attachment properties
	*
	* @param string $id Attachment identifier
	* @param array $task Hash array with event properties:
	* id: Task identifier
	* list: List identifier
	*
	* @return array Hash array with attachment properties:
	* id: Attachment identifier
	* name: Attachment name
	* mimetype: MIME content type of the attachment
	* size: Attachment size
	*/
	public function get_attachment($id, $task) { }

	/**
	* Get attachment body
	*
	* @param string $id Attachment identifier
	* @param array $task Hash array with event properties:
	* id: Task identifier
	* list: List identifier
	*
	* @return string Attachment body
	*/
	public function get_attachment_body($id, $task) { }

	/**
	* List availabale categories
	* The default implementation reads them from config/user prefs
	*/
	public function list_categories()
	{
	$rcmail = rcube::get_instance();
	return $rcmail->config->get('tasklist_categories', array());
	}

	/**
	* Build the edit/create form for lists.
	* This gives the drivers the opportunity to add more list properties
	*
	* @param string The action called this form
	* @param array Tasklist properties
	* @param array List with form fields to be rendered
	* @return string HTML content of the form
	*/
	public function tasklist_edit_form($action, $list, $formfields)
	{
	$html = '';
	foreach ($formfields as $field) {
	$html .= html::div('form-section',
	html::label($field['id'], $field['label']) .
	$field['value']);
	}

	return $html;
	}

	+ /**
	+ * Handler for user_delete plugin hook
	+ *
	+ * @param array Hash array with hook arguments
	+ * @return array Return arguments for plugin hooks
	+ */
	+ public function user_delete($args)
	+ {
	+ // TO BE OVERRIDDEN
	+ return $args;
	+ }
	}
	diff --git a/plugins/tasklist/tasklist.php b/plugins/tasklist/tasklist.php
	index 9532c619..ace7e452 100644
	--- a/plugins/tasklist/tasklist.php
	+++ b/plugins/tasklist/tasklist.php
	@@ -1,988 +1,998 @@
	<?php

	/**
	* Tasks plugin for Roundcube webmail
	*
	* @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 tasklist extends rcube_plugin
	{
	const FILTER_MASK_TODAY = 1;
	const FILTER_MASK_TOMORROW = 2;
	const FILTER_MASK_WEEK = 4;
	const FILTER_MASK_LATER = 8;
	const FILTER_MASK_NODATE = 16;
	const FILTER_MASK_OVERDUE = 32;
	const FILTER_MASK_FLAGGED = 64;
	const FILTER_MASK_COMPLETE = 128;

	const SESSION_KEY = 'tasklist_temp';

	public static $filter_masks = array(
	'today' => self::FILTER_MASK_TODAY,
	'tomorrow' => self::FILTER_MASK_TOMORROW,
	'week' => self::FILTER_MASK_WEEK,
	'later' => self::FILTER_MASK_LATER,
	'nodate' => self::FILTER_MASK_NODATE,
	'overdue' => self::FILTER_MASK_OVERDUE,
	'flagged' => self::FILTER_MASK_FLAGGED,
	'complete' => self::FILTER_MASK_COMPLETE,
	);

	public $task = '?(?!login\|logout).*';
	public $rc;
	public $lib;
	public $driver;
	public $timezone;
	public $ui;

	private $collapsed_tasks = array();


	/**
	* Plugin initialization.
	*/
	function init()
	{
	$this->require_plugin('libcalendaring');

	$this->rc = rcube::get_instance();
	$this->lib = libcalendaring::get_instance();

	$this->register_task('tasks', 'tasklist');

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

	$this->timezone = $this->lib->timezone;

	// proceed initialization in startup hook
	$this->add_hook('startup', array($this, 'startup'));
	+
	+ $this->add_hook('user_delete', array($this, 'user_delete'));
	}

	/**
	* Startup hook
	*/
	public function startup($args)
	{
	// the tasks module can be enabled/disabled by the kolab_auth plugin
	if ($this->rc->config->get('tasklist_disabled', false) \|\| !$this->rc->config->get('tasklist_enabled', true))
	return;

	// load localizations
	$this->add_texts('localization/', $args['task'] == 'tasks' && (!$args['action'] \|\| $args['action'] == 'print'));
	$this->rc->load_language($_SESSION['language'], array('tasks.tasks' => $this->gettext('navtitle'))); // add label for task title

	if ($args['task'] == 'tasks' && $args['action'] != 'save-pref') {
	$this->load_driver();

	// register calendar actions
	$this->register_action('index', array($this, 'tasklist_view'));
	$this->register_action('task', array($this, 'task_action'));
	$this->register_action('tasklist', array($this, 'tasklist_action'));
	$this->register_action('counts', array($this, 'fetch_counts'));
	$this->register_action('fetch', array($this, 'fetch_tasks'));
	$this->register_action('inlineui', array($this, 'get_inline_ui'));
	$this->register_action('mail2task', array($this, 'mail_message2task'));
	$this->register_action('get-attachment', array($this, 'attachment_get'));
	$this->register_action('upload', array($this, 'attachment_upload'));
	$this->add_hook('refresh', array($this, 'refresh'));

	$this->collapsed_tasks = array_filter(explode(',', $this->rc->config->get('tasklist_collapsed_tasks', '')));
	}
	else if ($args['task'] == 'mail') {
	// TODO: register hooks to catch ical/vtodo email attachments
	if ($args['action'] == 'show' \|\| $args['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' => 'tasklist-create-from-mail',
	'label' => 'tasklist.createfrommail',
	'type' => 'link',
	'classact' => 'icon taskaddlink active',
	'class' => 'icon taskaddlink',
	'innerclass' => 'icon taskadd',
	))),
	'messagemenu');

	$this->api->output->add_label('tasklist.createfrommail');
	}
	}

	if (!$this->rc->output->ajax_call && !$this->rc->output->env['framed']) {
	require_once($this->home . '/tasklist_ui.php');
	$this->ui = new tasklist_ui($this);
	$this->ui->init();
	}

	// add hooks for alarms handling
	$this->add_hook('pending_alarms', array($this, 'pending_alarms'));
	$this->add_hook('dismiss_alarms', array($this, 'dismiss_alarms'));
	}


	/**
	* 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('tasklist_driver', 'database');
	$driver_class = 'tasklist_' . $driver_name . '_driver';

	require_once($this->home . '/drivers/tasklist_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;
	}

	$this->rc->output->set_env('tasklist_driver', $driver_name);
	}


	/**
	* Dispatcher for task-related actions initiated by the client
	*/
	public function task_action()
	{
	$filter = intval(get_input_value('filter', RCUBE_INPUT_GPC));
	$action = get_input_value('action', RCUBE_INPUT_GPC);
	$rec = get_input_value('t', RCUBE_INPUT_POST, true);
	$oldrec = $rec;
	$success = $refresh = false;

	switch ($action) {
	case 'new':
	$oldrec = null;
	$rec = $this->prepare_task($rec);
	$rec['uid'] = $this->generate_uid();
	$temp_id = $rec['tempid'];
	if ($success = $this->driver->create_task($rec)) {
	$refresh = $this->driver->get_task($rec);
	if ($temp_id) $refresh['tempid'] = $temp_id;
	$this->cleanup_task($rec);
	}
	break;

	case 'edit':
	$rec = $this->prepare_task($rec);
	if ($success = $this->driver->edit_task($rec)) {
	$refresh[] = $this->driver->get_task($rec);
	$this->cleanup_task($rec);

	// move all childs if list assignment was changed
	if (!empty($rec['_fromlist']) && !empty($rec['list']) && $rec['_fromlist'] != $rec['list']) {
	foreach ($this->driver->get_childs(array('id' => $rec['id'], 'list' => $rec['_fromlist']), true) as $cid) {
	$child = array('id' => $cid, 'list' => $rec['list'], '_fromlist' => $rec['_fromlist']);
	if ($this->driver->move_task($child)) {
	$r = $this->driver->get_task($child);
	if ((bool)($filter & self::FILTER_MASK_COMPLETE) == ($r['complete'] == 1.0)) {
	$refresh[] = $r;
	}
	}
	}
	}
	}
	break;

	case 'move':
	foreach ((array)$rec['id'] as $id) {
	$r = $rec;
	$r['id'] = $id;
	if ($this->driver->move_task($r)) {
	$refresh[] = $this->driver->get_task($r);
	$success = true;

	// move all childs, too
	foreach ($this->driver->get_childs(array('id' => $rec['id'], 'list' => $rec['_fromlist']), true) as $cid) {
	$child = $rec;
	$child['id'] = $cid;
	if ($this->driver->move_task($child)) {
	$r = $this->driver->get_task($child);
	if ((bool)($filter & self::FILTER_MASK_COMPLETE) == ($r['complete'] == 1.0)) {
	$refresh[] = $r;
	}
	}
	}
	}
	}
	break;

	case 'delete':
	$mode = intval(get_input_value('mode', RCUBE_INPUT_POST));
	$oldrec = $this->driver->get_task($rec);
	if ($success = $this->driver->delete_task($rec, false)) {
	// delete/modify all childs
	foreach ($this->driver->get_childs($rec, $mode) as $cid) {
	$child = array('id' => $cid, 'list' => $rec['list']);

	if ($mode == 1) { // delete all childs
	if ($this->driver->delete_task($child, false)) {
	if ($this->driver->undelete)
	$_SESSION['tasklist_undelete'][$rec['id']][] = $cid;
	}
	else
	$success = false;
	}
	else {
	$child['parent_id'] = strval($oldrec['parent_id']);
	$this->driver->edit_task($child);
	}
	}
	// update parent task to adjust list of children
	if (!empty($oldrec['parent_id'])) {
	$refresh[] = $this->driver->get_task(array('id' => $oldrec['parent_id'], 'list' => $rec['list']));
	}
	}

	if (!$success)
	$this->rc->output->command('plugin.reload_data');
	break;

	case 'undelete':
	if ($success = $this->driver->undelete_task($rec)) {
	$refresh[] = $this->driver->get_task($rec);
	foreach ((array)$_SESSION['tasklist_undelete'][$rec['id']] as $cid) {
	if ($this->driver->undelete_task($rec)) {
	$refresh[] = $this->driver->get_task($rec);
	}
	}
	}
	break;

	case 'collapse':
	foreach (explode(',', $rec['id']) as $rec_id) {
	if (intval(get_input_value('collapsed', RCUBE_INPUT_GPC))) {
	$this->collapsed_tasks[] = $rec_id;
	}
	else {
	$i = array_search($rec_id, $this->collapsed_tasks);
	if ($i !== false)
	unset($this->collapsed_tasks[$i]);
	}
	}

	$this->rc->user->save_prefs(array('tasklist_collapsed_tasks' => join(',', array_unique($this->collapsed_tasks))));
	return; // avoid further actions
	}

	if ($success) {
	$this->rc->output->show_message('successfullysaved', 'confirmation');
	$this->update_counts($oldrec, $refresh);
	}
	else
	$this->rc->output->show_message('tasklist.errorsaving', 'error');

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

	if ($refresh) {
	if ($refresh['id']) {
	$this->encode_task($refresh);
	}
	else if (is_array($refresh)) {
	foreach ($refresh as $i => $r)
	$this->encode_task($refresh[$i]);
	}
	$this->rc->output->command('plugin.update_task', $refresh);
	}
	}

	/**
	* repares new/edited task properties before save
	*/
	private function prepare_task($rec)
	{
	// try to be smart and extract date from raw input
	if ($rec['raw']) {
	foreach (array('today','tomorrow','sunday','monday','tuesday','wednesday','thursday','friday','saturday','sun','mon','tue','wed','thu','fri','sat') as $word) {
	$locwords[] = '/^' . preg_quote(mb_strtolower($this->gettext($word))) . '\b/i';
	$normwords[] = $word;
	$datewords[] = $word;
	}
	foreach (array('jan','feb','mar','apr','may','jun','jul','aug','sep','oct','now','dec') as $month) {
	$locwords[] = '/(' . preg_quote(mb_strtolower($this->gettext('long'.$month))) . '\|' . preg_quote(mb_strtolower($this->gettext($month))) . ')\b/i';
	$normwords[] = $month;
	$datewords[] = $month;
	}
	foreach (array('on','this','next','at') as $word) {
	$fillwords[] = preg_quote(mb_strtolower($this->gettext($word)));
	$fillwords[] = $word;
	}

	$raw = trim($rec['raw']);
	$date_str = '';

	// translate localized keywords
	$raw = preg_replace('/^(' . join('\|', $fillwords) . ')\s*/i', '', $raw);
	$raw = preg_replace($locwords, $normwords, $raw);

	// find date pattern
	$date_pattern = '!^(\d+[./-]\s*)?((?:\d+[./-])\|' . join('\|', $datewords) . ')\.?(\s+\d{4})?[:;,]?\s+!i';
	if (preg_match($date_pattern, $raw, $m)) {
	$date_str .= $m[1] . $m[2] . $m[3];
	$raw = preg_replace(array($date_pattern, '/^(' . join('\|', $fillwords) . ')\s*/i'), '', $raw);
	// add year to date string
	if ($m[1] && !$m[3])
	$date_str .= date('Y');
	}

	// find time pattern
	$time_pattern = '/^(\d+([:.]\d+)?(\s*[hapm.]+)?),?\s+/i';
	if (preg_match($time_pattern, $raw, $m)) {
	$has_time = true;
	$date_str .= ($date_str ? ' ' : 'today ') . $m[1];
	$raw = preg_replace($time_pattern, '', $raw);
	}

	// yes, raw input matched a (valid) date
	if (strlen($date_str) && strtotime($date_str) && ($date = new DateTime($date_str, $this->timezone))) {
	$rec['date'] = $date->format('Y-m-d');
	if ($has_time)
	$rec['time'] = $date->format('H:i');
	$rec['title'] = $raw;
	}
	else
	$rec['title'] = $rec['raw'];
	}

	// normalize input from client
	if (isset($rec['complete'])) {
	$rec['complete'] = floatval($rec['complete']);
	if ($rec['complete'] > 1)
	$rec['complete'] /= 100;
	}
	if (isset($rec['flagged']))
	$rec['flagged'] = intval($rec['flagged']);

	// fix for garbage input
	if ($rec['description'] == 'null')
	$rec['description'] = '';

	foreach ($rec as $key => $val) {
	if ($val === 'null')
	$rec[$key] = null;
	}

	if (!empty($rec['date'])) {
	$this->normalize_dates($rec, 'date', 'time');
	}

	if (!empty($rec['startdate'])) {
	$this->normalize_dates($rec, 'startdate', 'starttime');
	}

	// convert tags to array, filter out empty entries
	if (isset($rec['tags']) && !is_array($rec['tags'])) {
	$rec['tags'] = array_filter((array)$rec['tags']);
	}

	// convert the submitted alarm values
	if ($rec['valarms']) {
	$valarms = array();
	foreach (libcalendaring::from_client_alarms($rec['valarms']) as $alarm) {
	// alarms can only work with a date (either task start, due or absolute alarm date)
	if (is_a($alarm['trigger'], 'DateTime') \|\| $rec['date'] \|\| $rec['startdate'])
	$valarms[] = $alarm;
	}
	$rec['valarms'] = $valarms;
	}

	$attachments = array();
	$taskid = $rec['id'];
	if (is_array($_SESSION[self::SESSION_KEY]) && $_SESSION[self::SESSION_KEY]['id'] == $taskid) {
	if (!empty($_SESSION[self::SESSION_KEY]['attachments'])) {
	foreach ($_SESSION[self::SESSION_KEY]['attachments'] as $id => $attachment) {
	if (is_array($rec['attachments']) && in_array($id, $rec['attachments'])) {
	$attachments[$id] = $this->rc->plugins->exec_hook('attachment_get', $attachment);
	unset($attachments[$id]['abort'], $attachments[$id]['group']);
	}
	}
	}
	}

	$rec['attachments'] = $attachments;

	if (is_numeric($rec['id']) && $rec['id'] < 0)
	unset($rec['id']);

	return $rec;
	}

	/**
	* Utility method to convert a tasks date/time values into a normalized format
	*/
	private function normalize_dates(&$rec, $date_key, $time_key)
	{
	try {
	// parse date from user format (#2801)
	$date_format = $this->rc->config->get(empty($rec[$time_key]) ? 'date_format' : 'date_long', 'Y-m-d');
	$date = DateTime::createFromFormat($date_format, trim($rec[$date_key] . ' ' . $rec[$time_key]), $this->timezone);

	// fall back to default strtotime logic
	if (empty($date)) {
	$date = new DateTime($rec[$date_key] . ' ' . $rec[$time_key], $this->timezone);
	}

	$rec[$date_key] = $date->format('Y-m-d');
	if (!empty($rec[$time_key]))
	$rec[$time_key] = $date->format('H:i');

	return true;
	}
	catch (Exception $e) {
	$rec[$date_key] = $rec[$time_key] = null;
	}

	return false;
	}

	/**
	* Releases some resources after successful save
	*/
	private function cleanup_task(&$rec)
	{
	// remove temp. attachment files
	if (!empty($_SESSION[self::SESSION_KEY]) && ($taskid = $_SESSION[self::SESSION_KEY]['id'])) {
	$this->rc->plugins->exec_hook('attachments_cleanup', array('group' => $taskid));
	$this->rc->session->remove(self::SESSION_KEY);
	}
	}


	/**
	* Dispatcher for tasklist actions initiated by the client
	*/
	public function tasklist_action()
	{
	$action = get_input_value('action', RCUBE_INPUT_GPC);
	$list = get_input_value('l', RCUBE_INPUT_GPC, true);
	$success = false;

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

	switch ($action) {
	case 'form-new':
	case 'form-edit':
	echo $this->ui->tasklist_editform($action, $list);
	exit;

	case 'new':
	$list += array('showalarms' => true, 'active' => true, 'editable' => true);
	if ($insert_id = $this->driver->create_list($list)) {
	$list['id'] = $insert_id;
	$this->rc->output->command('plugin.insert_tasklist', $list);
	$success = true;
	}
	break;

	case 'edit':
	if ($newid = $this->driver->edit_list($list)) {
	$list['oldid'] = $list['id'];
	$list['id'] = $newid;
	$this->rc->output->command('plugin.update_tasklist', $list);
	$success = true;
	}
	break;

	case 'subscribe':
	$success = $this->driver->subscribe_list($list);
	break;

	case 'remove':
	if (($success = $this->driver->remove_list($list)))
	$this->rc->output->command('plugin.destroy_tasklist', $list);
	break;
	}

	if ($success)
	$this->rc->output->show_message('successfullysaved', 'confirmation');
	else
	$this->rc->output->show_message('tasklist.errorsaving', 'error');

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

	/**
	* Get counts for active tasks divided into different selectors
	*/
	public function fetch_counts()
	{
	if (isset($_REQUEST['lists'])) {
	$lists = get_input_value('lists', RCUBE_INPUT_GPC);
	}
	else {
	foreach ($this->driver->get_lists() as $list) {
	if ($list['active'])
	$lists[] = $list['id'];
	}
	}
	$counts = $this->driver->count_tasks($lists);
	$this->rc->output->command('plugin.update_counts', $counts);
	}

	/**
	* Adjust the cached counts after changing a task
	*/
	public function update_counts($oldrec, $newrec)
	{
	// rebuild counts until this function is finally implemented
	$this->fetch_counts();

	// $this->rc->output->command('plugin.update_counts', $counts);
	}

	/**
	*
	*/
	public function fetch_tasks()
	{
	$f = intval(get_input_value('filter', RCUBE_INPUT_GPC));
	$search = get_input_value('q', RCUBE_INPUT_GPC);
	$filter = array('mask' => $f, 'search' => $search);
	$lists = get_input_value('lists', RCUBE_INPUT_GPC);;
	/*
	// convert magic date filters into a real date range
	switch ($f) {
	case self::FILTER_MASK_TODAY:
	$today = new DateTime('now', $this->timezone);
	$filter['from'] = $filter['to'] = $today->format('Y-m-d');
	break;

	case self::FILTER_MASK_TOMORROW:
	$tomorrow = new DateTime('now + 1 day', $this->timezone);
	$filter['from'] = $filter['to'] = $tomorrow->format('Y-m-d');
	break;

	case self::FILTER_MASK_OVERDUE:
	$yesterday = new DateTime('yesterday', $this->timezone);
	$filter['to'] = $yesterday->format('Y-m-d');
	break;

	case self::FILTER_MASK_WEEK:
	$today = new DateTime('now', $this->timezone);
	$filter['from'] = $today->format('Y-m-d');
	$weekend = new DateTime('now + 7 days', $this->timezone);
	$filter['to'] = $weekend->format('Y-m-d');
	break;

	case self::FILTER_MASK_LATER:
	$date = new DateTime('now + 8 days', $this->timezone);
	$filter['from'] = $date->format('Y-m-d');
	break;

	}
	*/
	$data = $this->tasks_data($this->driver->list_tasks($filter, $lists), $f, $tags);
	$this->rc->output->command('plugin.data_ready', array('filter' => $f, 'lists' => $lists, 'search' => $search, 'data' => $data, 'tags' => array_values(array_unique($tags))));
	}

	/**
	* Prepare and sort the given task records to be sent to the client
	*/
	private function tasks_data($records, $f, &$tags)
	{
	$data = $tags = $this->task_tree = $this->task_titles = array();
	foreach ($records as $rec) {
	if ($rec['parent_id']) {
	$this->task_tree[$rec['id']] = $rec['parent_id'];
	}
	$this->encode_task($rec);
	if (!empty($rec['tags']))
	$tags = array_merge($tags, (array)$rec['tags']);

	// apply filter; don't trust the driver on this :-)
	if ((!$f && $rec['complete'] < 1.0) \|\| ($rec['mask'] & $f))
	$data[] = $rec;
	}

	// sort tasks according to their hierarchy level and due date
	array_walk($data, array($this, 'task_walk_tree'));
	usort($data, array($this, 'task_sort_cmp'));

	return $data;
	}

	/**
	* Prepare the given task record before sending it to the client
	*/
	private function encode_task(&$rec)
	{
	$rec['mask'] = $this->filter_mask($rec);
	$rec['flagged'] = intval($rec['flagged']);
	$rec['complete'] = floatval($rec['complete']);
	$rec['changed'] = is_object($rec['changed']) ? $rec['changed']->format('U') : null;

	if ($rec['date']) {
	try {
	$date = new DateTime($rec['date'] . ' ' . $rec['time'], $this->timezone);
	$rec['datetime'] = intval($date->format('U'));
	$rec['date'] = $date->format($this->rc->config->get('date_format', 'Y-m-d'));
	$rec['_hasdate'] = 1;
	}
	catch (Exception $e) {
	$rec['date'] = $rec['datetime'] = null;
	}
	}
	else {
	$rec['date'] = $rec['datetime'] = null;
	$rec['_hasdate'] = 0;
	}

	if ($rec['startdate']) {
	try {
	$date = new DateTime($rec['startdate'] . ' ' . $rec['starttime'], $this->timezone);
	$rec['startdatetime'] = intval($date->format('U'));
	$rec['startdate'] = $date->format($this->rc->config->get('date_format', 'Y-m-d'));
	}
	catch (Exception $e) {
	$rec['startdate'] = $rec['startdatetime'] = null;
	}
	}

	if ($rec['valarms']) {
	$rec['alarms_text'] = libcalendaring::alarms_text($rec['valarms']);
	$rec['valarms'] = libcalendaring::to_client_alarms($rec['valarms']);
	}

	foreach ((array)$rec['attachments'] as $k => $attachment) {
	$rec['attachments'][$k]['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
	}

	if (!is_array($rec['tags']))
	$rec['tags'] = (array)$rec['tags'];
	sort($rec['tags'], SORT_LOCALE_STRING);

	if (in_array($rec['id'], $this->collapsed_tasks))
	$rec['collapsed'] = true;

	if (empty($rec['parent_id']))
	$rec['parent_id'] = null;

	$this->task_titles[$rec['id']] = $rec['title'];
	}

	/**
	* Callback function for array_walk over all tasks.
	* Sets tree depth and parent titles
	*/
	private function task_walk_tree(&$rec)
	{
	$rec['_depth'] = 0;
	$parent_id = $this->task_tree[$rec['id']];
	while ($parent_id) {
	$rec['_depth']++;
	$rec['parent_title'] = $this->task_titles[$parent_id];
	$parent_id = $this->task_tree[$parent_id];
	}
	}

	/**
	* Compare function for task list sorting.
	* Nested tasks need to be sorted to the end.
	*/
	private function task_sort_cmp($a, $b)
	{
	$d = $a['_depth'] - $b['_depth'];
	if (!$d) $d = $b['_hasdate'] - $a['_hasdate'];
	if (!$d) $d = $a['datetime'] - $b['datetime'];
	return $d;
	}

	/**
	* Compute the filter mask of the given task
	*
	* @param array Hash array with Task record properties
	* @return int Filter mask
	*/
	public function filter_mask($rec)
	{
	static $today, $tomorrow, $weeklimit;

	if (!$today) {
	$today_date = new DateTime('now', $this->timezone);
	$today = $today_date->format('Y-m-d');
	$tomorrow_date = new DateTime('now + 1 day', $this->timezone);
	$tomorrow = $tomorrow_date->format('Y-m-d');
	$week_date = new DateTime('now + 7 days', $this->timezone);
	$weeklimit = $week_date->format('Y-m-d');
	}

	$mask = 0;
	$start = $rec['startdate'] ?: '1900-00-00';
	$duedate = $rec['date'] ?: '3000-00-00';

	if ($rec['flagged'])
	$mask \|= self::FILTER_MASK_FLAGGED;
	if ($rec['complete'] == 1.0)
	$mask \|= self::FILTER_MASK_COMPLETE;

	if (empty($rec['date']))
	$mask \|= self::FILTER_MASK_NODATE;
	else if ($rec['date'] < $today)
	$mask \|= self::FILTER_MASK_OVERDUE;

	if ($duedate <= $today \|\| ($rec['startdate'] && $start <= $today))
	$mask \|= self::FILTER_MASK_TODAY;
	if ($duedate <= $tomorrow \|\| ($rec['startdate'] && $start <= $tomorrow))
	$mask \|= self::FILTER_MASK_TOMORROW;
	if (($start > $tomorrow && $start <= $weeklimit) \|\| ($duedate > $tomorrow && $duedate <= $weeklimit))
	$mask \|= self::FILTER_MASK_WEEK;
	else if ($start > $weeklimit \|\| ($rec['date'] && $duedate > $weeklimit))
	$mask \|= self::FILTER_MASK_LATER;

	return $mask;
	}


	/***** UI functions ******/

	/**
	* Render main view of the tasklist task
	*/
	public function tasklist_view()
	{
	$this->ui->init();
	$this->ui->init_templates();
	$this->rc->output->set_pagetitle($this->gettext('navtitle'));
	$this->rc->output->send('tasklist.mainview');
	}


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

	$texts['tasklist.newtask'] = $this->gettext('createfrommail');

	$this->ui->init_templates();
	echo $this->api->output->parse('tasklist.taskedit', false, false);
	echo html::tag('link', array('rel' => 'stylesheet', 'type' => 'text/css', 'href' => $this->url($this->local_skin_path() . '/tagedit.css'), 'nl' => true));
	echo html::tag('script', array('type' => 'text/javascript'),
	"rcmail.set_env('tasklists', " . json_encode($this->api->output->env['tasklists']) . ");\n".
	"rcmail.add_label(" . json_encode($texts) . ");\n"
	);
	exit;
	}

	/**
	* Handler for keep-alive requests
	* This will check for updated data in active lists and sync them to the client
	*/
	public function refresh($attr)
	{
	// refresh the entire list every 10th time to also sync deleted items
	if (rand(0,10) == 10) {
	$this->rc->output->command('plugin.reload_data');
	return;
	}

	$filter = array(
	'since' => $attr['last'],
	'search' => get_input_value('q', RCUBE_INPUT_GPC),
	'mask' => intval(get_input_value('filter', RCUBE_INPUT_GPC)) & self::FILTER_MASK_COMPLETE,
	);
	$lists = get_input_value('lists', RCUBE_INPUT_GPC);;

	$updates = $this->driver->list_tasks($filter, $lists);
	if (!empty($updates)) {
	$this->rc->output->command('plugin.refresh_tasks', $this->tasks_data($updates, 255, $tags), true);

	// update counts
	$counts = $this->driver->count_tasks($lists);
	$this->rc->output->command('plugin.update_counts', $counts);
	}
	}

	/**
	* Handler for pending_alarms plugin hook triggered by the calendar module on keep-alive requests.
	* This will check for pending notifications and pass them to the client
	*/
	public function pending_alarms($p)
	{
	$this->load_driver();
	if ($alarms = $this->driver->pending_alarms($p['time'] ?: time())) {
	foreach ($alarms as $alarm) {
	// encode alarm object to suit the expectations of the calendaring code
	if ($alarm['date'])
	$alarm['start'] = new DateTime($alarm['date'].' '.$alarm['time'], $this->timezone);

	$alarm['id'] = 'task:' . $alarm['id']; // prefix ID with task:
	$alarm['allday'] = empty($alarm['time']) ? 1 : 0;
	$p['alarms'][] = $alarm;
	}
	}

	return $p;
	}

	/**
	* Handler for alarm dismiss hook triggered by the calendar module
	*/
	public function dismiss_alarms($p)
	{
	$this->load_driver();
	foreach ((array)$p['ids'] as $id) {
	if (strpos($id, 'task:') === 0)
	$p['success'] \|= $this->driver->dismiss_alarm(substr($id, 5), $p['snooze']);
	}

	return $p;
	}


	/***** Attachment handling *****/

	/**
	* Handler for attachments upload
	*/
	public function attachment_upload()
	{
	$this->lib->attachment_upload(self::SESSION_KEY);
	}

	/**
	* Handler for attachments download/displaying
	*/
	public function attachment_get()
	{
	// show loading page
	if (!empty($_GET['_preload'])) {
	return $this->lib->attachment_loading_page();
	}

	$task = get_input_value('_t', RCUBE_INPUT_GPC);
	$list = get_input_value('_list', RCUBE_INPUT_GPC);
	$id = get_input_value('_id', RCUBE_INPUT_GPC);

	$task = array('id' => $task, 'list' => $list);
	$attachment = $this->driver->get_attachment($id, $task);

	// show part page
	if (!empty($_GET['_frame'])) {
	$this->lib->attachment = $attachment;
	$this->register_handler('plugin.attachmentframe', array($this->lib, 'attachment_frame'));
	$this->register_handler('plugin.attachmentcontrols', array($this->lib, 'attachment_header'));
	$this->rc->output->send('tasklist.attachment');
	}
	// deliver attachment content
	else if ($attachment) {
	$attachment['body'] = $this->driver->get_attachment_body($id, $task);
	$this->lib->attachment_get($attachment);
	}

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


	/***** Email related function *****/

	public function mail_message2task()
	{
	$uid = get_input_value('_uid', RCUBE_INPUT_POST);
	$mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
	$task = array();

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

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

	$this->load_driver();

	// copy mail attachments to task
	if ($message->attachments && $this->driver->attachments) {
	if (!is_array($_SESSION[self::SESSION_KEY]) \|\| $_SESSION[self::SESSION_KEY]['id'] != $task['id']) {
	$_SESSION[self::SESSION_KEY] = array();
	$_SESSION[self::SESSION_KEY]['id'] = $task['id'];
	$_SESSION[self::SESSION_KEY]['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' => $task['id'],
	);

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

	if ($attachment['status'] && !$attachment['abort']) {
	$id = $attachment['id'];
	$attachment['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);

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

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

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

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


	/***** Utility functions *****/

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

	+ /**
	+ * Handler for user_delete plugin hook
	+ */
	+ public function user_delete($args)
	+ {
	+ $this->load_driver();
	+ return $this->driver->user_delete($args);
	+ }
	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, May 1, 3:39 PM (35 m, 36 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 661868
Default Alt Text: (276 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions