No OneTemporary
Actions

Size

179 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/plugins/calendar/drivers/kolab/kolab_calendar.php b/plugins/calendar/drivers/kolab/kolab_calendar.php
	index 9d573eec..2b50ac8a 100644
	--- a/plugins/calendar/drivers/kolab/kolab_calendar.php
	+++ b/plugins/calendar/drivers/kolab/kolab_calendar.php
	@@ -1,817 +1,827 @@
	<?php

	/**
	* Kolab calendar storage class
	*
	* @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/>.
	*/


	class kolab_calendar extends kolab_storage_folder_api
	{
	public $ready = false;
	public $readonly = true;
	public $attachments = true;
	public $alarms = false;
	public $history = false;
	public $subscriptions = true;
	public $categories = array();
	public $storage;

	public $type = 'event';

	protected $cal;
	protected $events = array();
	protected $search_fields = array('title', 'description', 'location', 'attendees');

	/**
	* Factory method to instantiate a kolab_calendar object
	*
	* @param string Calendar ID (encoded IMAP folder name)
	* @param object calendar plugin object
	* @return object kolab_calendar instance
	*/
	public static function factory($id, $calendar)
	{
	$imap = $calendar->rc->get_storage();
	$imap_folder = kolab_storage::id_decode($id);
	$info = $imap->folder_info($imap_folder, true);
	if (empty($info) \|\| $info['noselect'] \|\| strpos(kolab_storage::folder_type($imap_folder), 'event') !== 0) {
	return new kolab_user_calendar($imap_folder, $calendar);
	}
	else {
	return new kolab_calendar($imap_folder, $calendar);
	}
	}

	/**
	* Default constructor
	*/
	public function __construct($imap_folder, $calendar)
	{
	$this->cal = $calendar;
	$this->imap = $calendar->rc->get_storage();
	$this->name = $imap_folder;

	// ID is derrived from folder name
	$this->id = kolab_storage::folder_id($this->name, true);
	$old_id = kolab_storage::folder_id($this->name, false);

	// fetch objects from the given IMAP folder
	$this->storage = kolab_storage::get_folder($this->name);
	$this->ready = $this->storage && $this->storage->valid;

	// Set readonly and alarms flags according to folder permissions
	if ($this->ready) {
	if ($this->storage->get_namespace() == 'personal') {
	$this->readonly = false;
	$this->alarms = true;
	}
	else {
	$rights = $this->storage->get_myrights();
	if ($rights && !PEAR::isError($rights)) {
	if (strpos($rights, 'i') !== false)
	$this->readonly = false;
	}
	}

	// user-specific alarms settings win
	$prefs = $this->cal->rc->config->get('kolab_calendars', array());
	if (isset($prefs[$this->id]['showalarms']))
	$this->alarms = $prefs[$this->id]['showalarms'];
	else if (isset($prefs[$old_id]['showalarms']))
	$this->alarms = $prefs[$old_id]['showalarms'];
	}

	$this->default = $this->storage->default;
	$this->subtype = $this->storage->subtype;
	}


	/**
	* Getter for the IMAP folder name
	*
	* @return string Name of the IMAP folder
	*/
	public function get_realname()
	{
	return $this->name;
	}

	/**
	*
	*/
	public function get_title()
	{
	return null;
	}


	/**
	* Return color to display this calendar
	*/
	public function get_color()
	{
	// color is defined in folder METADATA
	if ($color = $this->storage->get_color()) {
	return $color;
	}

	// calendar color is stored in user prefs (temporary solution)
	$prefs = $this->cal->rc->config->get('kolab_calendars', array());

	if (!empty($prefs[$this->id]) && !empty($prefs[$this->id]['color']))
	return $prefs[$this->id]['color'];

	return 'cc0000';
	}

	/**
	* Compose an URL for CalDAV access to this calendar (if configured)
	*/
	public function get_caldav_url()
	{
	if ($template = $this->cal->rc->config->get('calendar_caldav_url', null)) {
	return strtr($template, array(
	'%h' => $_SERVER['HTTP_HOST'],
	'%u' => urlencode($this->cal->rc->get_user_name()),
	'%i' => urlencode($this->storage->get_uid()),
	'%n' => urlencode($this->name),
	));
	}

	return false;
	}


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

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

	// create ID
	return kolab_storage::folder_id($newfolder);
	}

	/**
	* Getter for a single event object
	*/
	public function get_event($id)
	{
	// directly access storage object
	if (!$this->events[$id] && ($record = $this->storage->get_object($id)))
	$this->events[$id] = $this->_to_rcube_event($record);

	// event not found, maybe a recurring instance is requested
	if (!$this->events[$id]) {
	- $master_id = preg_replace('/-\d+$/', '', $id);
	+ $master_id = preg_replace('/-\d+(T\d{6})?$/', '', $id);
	if ($master_id != $id && ($record = $this->storage->get_object($master_id)))
	$this->events[$master_id] = $this->_to_rcube_event($record);

	if (($master = $this->events[$master_id]) && $master['recurrence']) {
	$this->get_recurring_events($record, $master['start'], null, $id);
	}
	}

	return $this->events[$id];
	}


	/**
	* @param integer Event's new start (unix timestamp)
	* @param integer Event's new end (unix timestamp)
	* @param string Search query (optional)
	* @param boolean Include virtual events (optional)
	* @param array Additional parameters to query storage
	* @param array Additional query to filter events
	* @return array A list of event records
	*/
	public function list_events($start, $end, $search = null, $virtual = 1, $query = array(), $filter_query = null)
	{
	// convert to DateTime for comparisons
	try {
	$start = new DateTime('@'.$start);
	}
	catch (Exception $e) {
	$start = new DateTime('@0');
	}
	try {
	$end = new DateTime('@'.$end);
	}
	catch (Exception $e) {
	$end = new DateTime('today +10 years');
	}

	// get email addresses of the current user
	$user_emails = $this->cal->get_user_emails();

	// query Kolab storage
	$query[] = array('dtstart', '<=', $end);
	$query[] = array('dtend', '>=', $start);

	// add query to exclude pending/declined invitations
	if (empty($filter_query) && $this->get_namespace() != 'other') {
	foreach ($user_emails as $email) {
	$query[] = array('tags', '!=', 'x-partstat:' . $email . ':needs-action');
	$query[] = array('tags', '!=', 'x-partstat:' . $email . ':declined');
	}
	}
	else if (is_array($filter_query)) {
	$query = array_merge($query, $filter_query);
	}

	if (!empty($search)) {
	$search = mb_strtolower($search);
	foreach (rcube_utils::normalize_string($search, true) as $word) {
	$query[] = array('words', 'LIKE', $word);
	}
	}

	$events = array();
	foreach ($this->storage->select($query) as $record) {
	// post-filter events to skip pending and declined invitations
	if (empty($filter_query) && is_array($record['attendees']) && $this->get_namespace() != 'other') {
	foreach ($record['attendees'] as $attendee) {
	if (in_array($attendee['email'], $user_emails) && in_array($attendee['status'], array('NEEDS-ACTION','DECLINED'))) {
	continue 2;
	}
	}
	}

	$event = $this->_to_rcube_event($record);
	$this->events[$event['id']] = $event;

	// remember seen categories
	if ($event['categories'])
	$this->categories[$event['categories']]++;

	// filter events by search query
	if (!empty($search)) {
	$hits = 0;
	$words = rcube_utils::tokenize_string($search, 1);
	foreach ($words as $word) {
	$hits += $this->_fulltext_match($event, $word);
	}

	if ($hits < count($words)) // skip this event if not match with search term
	continue;
	}

	// list events in requested time window
	if ($event['start'] <= $end && $event['end'] >= $start) {
	unset($event['_attendees']);
	$add = true;

	// skip the first instance of a recurring event if listed in exdate
	if ($virtual && (!empty($event['recurrence']['EXDATE']) \|\| !empty($event['recurrence']['EXCEPTIONS']))) {
	$event_date = $event['start']->format('Ymd');
	$exdates = (array)$event['recurrence']['EXDATE'];

	// add dates from exceptions to list
	if (is_array($event['recurrence']['EXCEPTIONS'])) {
	foreach ($event['recurrence']['EXCEPTIONS'] as $exception) {
	$exdates[] = clone $exception['start'];
	}
	}

	foreach ($exdates as $exdate) {
	if ($exdate->format('Ymd') == $event_date) {
	$add = false;
	break;
	}
	}
	}

	if ($add)
	$events[] = $event;
	}

	// resolve recurring events
	if ($record['recurrence'] && $virtual == 1) {
	$events = array_merge($events, $this->get_recurring_events($record, $start, $end));

	// when searching, only recurrence exceptions may match the query so post-filter the results again
	if (!empty($search) && $record['recurrence']['EXCEPTIONS']) {
	$me = $this;
	$events = array_filter($events, function($event) use ($words, $me) {
	$hits = 0;
	foreach ($words as $word) {
	$hits += $me->_fulltext_match($event, $word, false);
	}
	return $hits >= count($words);
	});
	}
	}
	}

	// avoid session race conditions that will loose temporary subscriptions
	$this->cal->rc->session->nowrite = true;

	return $events;
	}

	/**
	*
	* @param integer Date range start (unix timestamp)
	* @param integer Date range end (unix timestamp)
	* @param array Additional query to filter events
	* @return integer Count
	*/
	public function count_events($start, $end = null, $filter_query = null)
	{
	// convert to DateTime for comparisons
	try {
	$start = new DateTime('@'.$start);
	}
	catch (Exception $e) {
	$start = new DateTime('@0');
	}
	if ($end) {
	try {
	$end = new DateTime('@'.$end);
	}
	catch (Exception $e) {
	$end = null;
	}
	}

	// query Kolab storage
	$query[] = array('dtend', '>=', $start);

	if ($end)
	$query[] = array('dtstart', '<=', $end);

	// add query to exclude pending/declined invitations
	if (empty($filter_query)) {
	foreach ($this->cal->get_user_emails() as $email) {
	$query[] = array('tags', '!=', 'x-partstat:' . $email . ':needs-action');
	$query[] = array('tags', '!=', 'x-partstat:' . $email . ':declined');
	}
	}
	else if (is_array($filter_query)) {
	$query = array_merge($query, $filter_query);
	}

	// we rely the Kolab storage query (no post-filtering)
	return $this->storage->count($query);
	}

	/**
	* Create a new event record
	*
	* @see calendar_driver::new_event()
	*
	* @return mixed The created record ID on success, False on error
	*/
	public function insert_event($event)
	{
	if (!is_array($event))
	return false;

	// email links are stored separately
	$links = $event['links'];
	unset($event['links']);

	//generate new event from RC input
	$object = $this->_from_rcube_event($event);
	$saved = $this->storage->save($object, 'event');

	if (!$saved) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error saving event object to Kolab server"),
	true, false);
	$saved = false;
	}
	else {
	// save links in configuration.relation object
	$this->save_links($event['uid'], $links);

	$event['id'] = $event['uid'];
	$this->events = array($event['uid'] => $this->_to_rcube_event($object));
	}

	return $saved;
	}

	/**
	* Update a specific event record
	*
	* @see calendar_driver::new_event()
	* @return boolean True on success, False on error
	*/

	public function update_event($event, $exception_id = null)
	{
	$updated = false;
	$old = $this->storage->get_object($event['id']);
	if (!$old \|\| PEAR::isError($old))
	return false;

	// email links are stored separately
	$links = $event['links'];
	unset($event['links']);

	$object = $this->_from_rcube_event($event, $old);
	$saved = $this->storage->save($object, 'event', $event['id']);

	if (!$saved) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error saving event object to Kolab server"),
	true, false);
	}
	else {
	// save links in configuration.relation object
	$this->save_links($event['uid'], $links);

	$updated = true;
	- $this->events[$event['id']] = $this->_to_rcube_event($object);
	+ $this->events = array($event['id'] => $this->_to_rcube_event($object));

	// refresh local cache with recurring instances
	if ($exception_id) {
	$this->get_recurring_events($object, $event['start'], $event['end'], $exception_id);
	}
	}

	return $updated;
	}

	/**
	* Delete an event record
	*
	* @see calendar_driver::remove_event()
	* @return boolean True on success, False on error
	*/
	public function delete_event($event, $force = true)
	{
	$deleted = $this->storage->delete($event['id'], $force);

	if (!$deleted) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error deleting event object from Kolab server"),
	true, false);
	}

	return $deleted;
	}

	/**
	* Restore deleted event record
	*
	* @see calendar_driver::undelete_event()
	* @return boolean True on success, False on error
	*/
	public function restore_event($event)
	{
	if ($this->storage->undelete($event['id'])) {
	return true;
	}
	else {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error undeleting the event object $event[id] from the Kolab server"),
	true, false);
	}

	return false;
	}

	/**
	* Find messages linked with an event
	*/
	protected function get_links($uid)
	{
	$storage = kolab_storage_config::get_instance();
	return $storage->get_object_links($uid);
	}

	/**
	*
	*/
	protected function save_links($uid, $links)
	{
	// make sure we have a valid array
	if (empty($links)) {
	$links = array();
	}

	$storage = kolab_storage_config::get_instance();
	$remove = array_diff($storage->get_object_links($uid), $links);
	return $storage->save_object_links($uid, $links, $remove);
	}

	/**
	* Create instances of a recurring event
	*
	* @param array Hash array with event properties
	* @param object DateTime Start date of the recurrence window
	* @param object DateTime End date of the recurrence window
	* @param string ID of a specific recurring event instance
	* @return array List of recurring event instances
	*/
	public function get_recurring_events($event, $start, $end = null, $event_id = null)
	{
	$object = $event['_formatobj'];
	if (!$object) {
	$rec = $this->storage->get_object($event['id']);
	$object = $rec['_formatobj'];
	}
	if (!is_object($object))
	return array();

	// determine a reasonable end date if none given
	if (!$end) {
	switch ($event['recurrence']['FREQ']) {
	case 'YEARLY': $intvl = 'P100Y'; break;
	case 'MONTHLY': $intvl = 'P20Y'; break;
	default: $intvl = 'P10Y'; break;
	}

	$end = clone $event['start'];
	$end->add(new DateInterval($intvl));
	}

	- // add recurrence exceptions to output
	- $i = 0;
	+ // copy the recurrence rule from the master event (to be used in the UI)
	+ $recurrence_rule = $event['recurrence'];
	+ unset($recurrence_rule['EXCEPTIONS'], $recurrence_rule['EXDATE']);
	+
	+ // read recurrence exceptions first
	$events = array();
	- $exdates = array();
	+ $exdata = array();
	$futuredata = array();
	- if (is_array($event['recurrence']['EXCEPTIONS'])) {
	- // copy the recurrence rule from the master event (to be used in the UI)
	- $recurrence_rule = $event['recurrence'];
	- unset($recurrence_rule['EXCEPTIONS'], $recurrence_rule['EXDATE']);
	+ $recurrence_id_format = $event['allday'] ? 'Ymd' : 'Ymd\THis';

	+ if (is_array($event['recurrence']['EXCEPTIONS'])) {
	foreach ($event['recurrence']['EXCEPTIONS'] as $exception) {
	+ if (!$exception['_instance'] && is_a($exception['recurrence_date'], 'DateTime'))
	+ $exception['_instance'] = $exception['recurrence_date']->format($recurrence_id_format);
	+ else if (!$exception['_instance'] && is_a($exception['start'], 'DateTime'))
	+ $exception['_instance'] = $exception['start']->format($recurrence_id_format);
	+
	$rec_event = $this->_to_rcube_event($exception);
	- $rec_event['id'] = $event['uid'] . '-' . ++$i;
	- $rec_event['recurrence_id'] = $event['uid'];
	- $rec_event['recurrence'] = $recurrence_rule;
	- $rec_event['_instance'] = $i;
	+ $rec_event['id'] = $event['uid'] . '-' . $exception['_instance'];
	$rec_event['isexception'] = 1;
	- $events[] = $rec_event;

	// found the specifically requested instance, exiting...
	if ($rec_event['id'] == $event_id) {
	+ $rec_event['recurrence'] = $recurrence_rule;
	+ $rec_event['recurrence_id'] = $event['uid'];
	+ $events[] = $rec_event;
	$this->events[$rec_event['id']] = $rec_event;
	return $events;
	}

	// remember this exception's date
	- $exdate = $rec_event['start']->format('Y-m-d');
	- $exdates[$exdate] = $rec_event['id'];
	+ $exdate = substr($exception['_instance'], 0, 8);
	+ $exdata[$exdate] = $rec_event;
	if ($rec_event['thisandfuture']) {
	$futuredata[$exdate] = $rec_event;
	}
	}
	}

	// use libkolab to compute recurring events
	if (class_exists('kolabcalendaring')) {
	$recurrence = new kolab_date_recurrence($object);
	}
	else {
	// fallback to local recurrence implementation
	require_once($this->cal->home . '/lib/calendar_recurrence.php');
	$recurrence = new calendar_recurrence($this->cal, $event);
	}

	+ $i = 0;
	while ($next_event = $recurrence->next_instance()) {
	- // skip if there's an exception at this date
	- $datestr = $next_event['start']->format('Y-m-d');
	- if ($exdates[$datestr]) {
	- // use this event data for future recurring instances
	- if ($futuredata[$datestr])
	- $overlay_data = $futuredata[$datestr];
	- continue;
	- }
	+ $datestr = $next_event['start']->format('Ymd');
	+ $instance_id = $next_event['start']->format($recurrence_id_format);
	+
	+ // use this event data for future recurring instances
	+ if ($futuredata[$datestr])
	+ $overlay_data = $futuredata[$datestr];

	// add to output if in range
	- $rec_id = $event['uid'] . '-' . ++$i;
	+ $rec_id = $event['uid'] . '-' . $instance_id;
	if (($next_event['start'] <= $end && $next_event['end'] >= $start) \|\| ($event_id && $rec_id == $event_id)) {
	$rec_event = $this->_to_rcube_event($next_event);
	+ $rec_event['_instance'] = $instance_id;

	- if ($overlay_data) // copy data from a 'this-and-future' exception
	- $this->_merge_event_data($rec_event, $overlay_data);
	+ if ($overlay_data \|\| $exdata[$datestr]) // copy data from exception
	+ $this->_merge_event_data($rec_event, $exdata[$datestr] ?: $overlay_data);

	$rec_event['id'] = $rec_id;
	$rec_event['recurrence_id'] = $event['uid'];
	- $rec_event['_instance'] = $i;
	+ $rec_event['recurrence'] = $recurrence_rule;
	unset($rec_event['_attendees']);
	$events[] = $rec_event;

	if ($rec_id == $event_id) {
	$this->events[$rec_id] = $rec_event;
	break;
	}
	}
	else if ($next_event['start'] > $end) // stop loop if out of range
	break;

	// avoid endless recursion loops
	- if ($i > 1000)
	+ if (++$i > 1000)
	break;
	}

	return $events;
	}

	/**
	* Merge certain properties from the overlay event to the base event object
	*
	* @param array The event object to be altered
	* @param array The overlay event object to be merged over $event
	*/
	private function _merge_event_data(&$event, $overlay)
	{
	static $forbidden = array('id','uid','created','changed','recurrence','organizer','attendees','sequence');

	foreach ($overlay as $prop => $value) {
	// adjust time of the recurring event instance
	if ($prop == 'start' \|\| $prop == 'end') {
	- if (is_object($event[$prop]) && is_a($event[$prop], 'DateTime'))
	+ if (is_object($event[$prop]) && is_a($event[$prop], 'DateTime')) {
	$event[$prop]->setTime($value->format('G'), intval($value->format('i')), intval($value->format('s')));
	+ // set date value if overlay is an exception of the current instance
	+ if (substr($overlay['_instance'], 0, 8) == substr($event['_instance'], 0, 8)) {
	+ $event[$prop]->setDate(intval($value->format('Y')), intval($value->format('n')), intval($value->format('j')));
	+ }
	+ }
	}
	else if ($prop[0] != '_' && !in_array($prop, $forbidden))
	$event[$prop] = $value;
	}
	}

	/**
	* Convert from Kolab_Format to internal representation
	*/
	private function _to_rcube_event($record)
	{
	$record['id'] = $record['uid'];
	$record['calendar'] = $this->id;
	$record['links'] = $this->get_links($record['uid']);

	if ($this->get_namespace() == 'other') {
	$record['className'] = 'fc-event-ns-other';
	$record = kolab_driver::add_partstat_class($record, array('NEEDS-ACTION','DECLINED'), $this->get_owner());
	}

	return kolab_driver::to_rcube_event($record);
	}

	/**
	* Convert the given event record into a data structure that can be passed to Kolab_Storage backend for saving
	* (opposite of self::_to_rcube_event())
	*/
	private function _from_rcube_event($event, $old = array())
	{
	// in kolab_storage attachments are indexed by content-id
	$event['_attachments'] = array();
	if (is_array($event['attachments'])) {
	foreach ($event['attachments'] as $attachment) {
	$key = null;
	// Roundcube ID has nothing to do with the storage ID, remove it
	if ($attachment['content'] \|\| $attachment['path']) {
	unset($attachment['id']);
	}
	else {
	foreach ((array)$old['_attachments'] as $cid => $oldatt) {
	if ($attachment['id'] == $oldatt['id'])
	$key = $cid;
	}
	}

	// flagged for deletion => set to false
	if ($attachment['_deleted']) {
	$event['_attachments'][$key] = false;
	}
	// replace existing entry
	else if ($key) {
	$event['_attachments'][$key] = $attachment;
	}
	// append as new attachment
	else {
	$event['_attachments'][] = $attachment;
	}
	}

	unset($event['attachments']);
	}

	// set current user as ORGANIZER
	$identity = $this->cal->rc->user->list_emails(true);
	if (empty($event['attendees']) && $identity['email'])
	$event['attendees'] = array(array('role' => 'ORGANIZER', 'name' => $identity['name'], 'email' => $identity['email']));

	$event['_owner'] = $identity['email'];

	// remove EXDATE values if RDATE is given
	if (!empty($event['recurrence']['RDATE'])) {
	$event['recurrence']['EXDATE'] = array();
	}

	// remove recurrence information (e.g. EXDATES and EXCEPTIONS) entirely
	if ($event['recurrence'] && empty($event['recurrence']['FREQ']) && empty($event['recurrence']['RDATE'])) {
	$event['recurrence'] = array();
	}

	// keep 'comment' from initial itip invitation
	if (!empty($old['comment'])) {
	$event['comment'] = $old['comment'];
	}

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

	// copy meta data (starting with _) from old object
	foreach ((array)$old as $key => $val) {
	if (!isset($event[$key]) && $key[0] == '_')
	$event[$key] = $val;
	}

	return $event;
	}

	/**
	* Match the given word in the event contents
	*/
	private function _fulltext_match($event, $word, $recursive = true)
	{
	$hits = 0;
	foreach ($this->search_fields as $col) {
	$sval = is_array($event[$col]) ? self::_complex2string($event[$col]) : $event[$col];
	if (empty($sval))
	continue;

	// do a simple substring matching (to be improved)
	$val = mb_strtolower($sval);
	if (strpos($val, $word) !== false) {
	$hits++;
	break;
	}
	}

	// search in recurrence exceptions
	if (!$hits && $recursive && !empty($event['recurrence']['EXCEPTIONS'])) {
	foreach ($event['recurrence']['EXCEPTIONS'] as $exception) {
	$hits = $this->_fulltext_match($exception, $word, false);
	if ($hits) break;
	}
	}

	return $hits;
	}

	/**
	* Convert a complex event attribute to a string value
	*/
	private static function _complex2string($prop)
	{
	static $ignorekeys = array('role','status','rsvp');

	$out = '';
	if (is_array($prop)) {
	foreach ($prop as $key => $val) {
	if (is_numeric($key)) {
	$out .= self::_complex2string($val);
	}
	else if (!in_array($key, $ignorekeys)) {
	$out .= $val . ' ';
	}
	}
	}
	else if (is_string($prop) \|\| is_numeric($prop)) {
	$out .= $prop . ' ';
	}

	return rtrim($out);
	}

	}
	diff --git a/plugins/calendar/drivers/kolab/kolab_driver.php b/plugins/calendar/drivers/kolab/kolab_driver.php
	index b53ffbf2..0d5b9ab5 100644
	--- a/plugins/calendar/drivers/kolab/kolab_driver.php
	+++ b/plugins/calendar/drivers/kolab/kolab_driver.php
	@@ -1,1892 +1,1920 @@
	<?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/>.
	*/

	class kolab_driver extends calendar_driver
	{
	const INVITATIONS_CALENDAR_PENDING = '--invitation--pending';
	const INVITATIONS_CALENDAR_DECLINED = '--invitation--declined';

	// 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;
	private $bonnie_api = false;

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

	// load helper classes after libkolab has been loaded (#3248)
	require_once(dirname(__FILE__) . '/kolab_calendar.php');
	require_once(dirname(__FILE__) . '/kolab_user_calendar.php');
	require_once(dirname(__FILE__) . '/kolab_invitation_calendar.php');

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

	// get configuration for the Bonnie API
	if ($bonnie_config = $this->cal->rc->config->get('kolab_bonnie_api', false))
	$this->bonnie_api = new kolab_bonnie_api($bonnie_config);

	// calendar uses fully encoded identifiers
	kolab_storage::$encode_ids = true;
	}


	/**
	* 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') + kolab_storage::get_user_folders('event', true));
	$this->calendars = array();

	foreach ($folders as $folder) {
	if ($folder instanceof kolab_storage_folder_user) {
	$calendar = new kolab_user_calendar($folder->name, $this->cal);
	$calendar->subscriptions = count($folder->children) > 0;
	}
	else {
	$calendar = new kolab_calendar($folder->name, $this->cal);
	}

	if ($calendar->ready) {
	$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
	* @param object $tree Reference to hierarchical folder tree object
	*
	* @return array List of calendars
	*/
	public function list_calendars($active = false, $personal = false, &$tree = null)
	{
	// 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();
	}
	}

	$delim = $this->rc->get_storage()->get_hierarchy_delimiter();
	$folders = $this->filter_calendars(false, $active, $personal);
	$calendars = array();

	// include virtual folders for a full folder tree
	if (!is_null($tree))
	$folders = kolab_storage::folder_hierarchy($folders, $tree);

	foreach ($folders as $id => $cal) {
	$fullname = $cal->get_name();
	$listname = $cal->get_foldername();
	$imap_path = explode($delim, $cal->name);

	// find parent
	do {
	array_pop($imap_path);
	$parent_id = kolab_storage::folder_id(join($delim, $imap_path));
	}
	while (count($imap_path) > 1 && !$this->calendars[$parent_id]);

	// restore "real" parent ID
	if ($parent_id && !$this->calendars[$parent_id]) {
	$parent_id = kolab_storage::folder_id($cal->get_parent());
	}

	// turn a kolab_storage_folder object into a kolab_calendar
	if ($cal instanceof kolab_storage_folder) {
	$cal = new kolab_calendar($cal->name, $this->cal);
	$this->calendars[$cal->id] = $cal;
	}

	// special handling for user or virtual folders
	if ($cal instanceof kolab_storage_folder_user) {
	$calendars[$cal->id] = array(
	'id' => $cal->id,
	'name' => kolab_storage::object_name($fullname),
	'listname' => $listname,
	'editname' => $cal->get_foldername(),
	'color' => $cal->get_color(),
	'active' => $cal->is_active(),
	'title' => $cal->get_owner(),
	'owner' => $cal->get_owner(),
	'history' => false,
	'virtual' => false,
	'readonly' => true,
	'group' => 'other',
	'class' => 'user',
	'removable' => true,
	);
	}
	else if ($cal->virtual) {
	$calendars[$cal->id] = array(
	'id' => $cal->id,
	'name' => $fullname,
	'listname' => $listname,
	'editname' => $cal->get_foldername(),
	'virtual' => true,
	'readonly' => true,
	'group' => $cal->get_namespace(),
	'class' => 'folder',
	);
	}
	else {
	$calendars[$cal->id] = array(
	'id' => $cal->id,
	'name' => $fullname,
	'listname' => $listname,
	'editname' => $cal->get_foldername(),
	'title' => $cal->get_title(),
	'color' => $cal->get_color(),
	'readonly' => $cal->readonly,
	'showalarms' => $cal->alarms,
	'history' => !empty($this->bonnie_api),
	'group' => $cal->get_namespace(),
	'default' => $cal->default,
	'active' => $cal->is_active(),
	'owner' => $cal->get_owner(),
	'children' => true, // TODO: determine if that folder indeed has child folders
	'parent' => $parent_id,
	'subtype' => $cal->subtype,
	'caldavurl' => $cal->get_caldav_url(),
	'removable' => !$cal->default,
	);
	}

	if ($cal->subscriptions) {
	$calendars[$cal->id]['subscribed'] = $cal->is_subscribed();
	}
	}

	// list virtual calendars showing invitations
	if ($this->rc->config->get('kolab_invitation_calendars')) {
	foreach (array(self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED) as $id) {
	$cal = new kolab_invitation_calendar($id, $this->cal);
	$this->calendars[$cal->id] = $cal;
	if (!$active \|\| $cal->is_active()) {
	$calendars[$id] = array(
	'id' => $cal->id,
	'name' => $cal->get_name(),
	'listname' => $cal->get_name(),
	'editname' => $cal->get_foldername(),
	'title' => $cal->get_title(),
	'color' => $cal->get_color(),
	'readonly' => $cal->readonly,
	'showalarms' => $cal->alarms,
	'history' => !empty($this->bonnie_api),
	'group' => 'x-invitations',
	'default' => false,
	'active' => $cal->is_active(),
	'owner' => $cal->get_owner(),
	'children' => false,
	);

	if ($id == self::INVITATIONS_CALENDAR_PENDING) {
	$calendars[$id]['counts'] = true;
	}

	if (is_object($tree)) {
	$tree->children[] = $cal;
	}
	}
	}
	}

	// 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'] ?: '87CEFA',
	'active' => (bool)$prefs[$id]['active'],
	'showalarms' => (bool)$this->rc->config->get('calendar_birthdays_alarm_type'),
	'group' => 'x-birthdays',
	'readonly' => true,
	'default' => false,
	'children' => false,
	'history' => 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->is_active()) {
	continue;
	}
	if ($personal && $cal->get_namespace() != 'personal') {
	continue;
	}
	$calendars[$cal->id] = $cal;
	}

	return $calendars;
	}


	/**
	* Get the kolab_calendar instance for the given calendar ID
	*
	* @param string Calendar identifier (encoded imap folder name)
	* @return object kolab_calendar Object nor null if calendar doesn't exist
	*/
	public function get_calendar($id)
	{
	// create calendar object if necesary
	if (!$this->calendars[$id] && in_array($id, array(self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED))) {
	$this->calendars[$id] = new kolab_invitation_calendar($id, $this->cal);
	}
	else if (!$this->calendars[$id] && $id !== self::BIRTHDAY_CALENDAR_ID) {
	$calendar = kolab_calendar::factory($id, $this->cal);
	if ($calendar->ready)
	$this->calendars[$calendar->id] = $calendar;
	}

	return $this->calendars[$id];
	}

	/**
	* 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->get_calendar($prop['id']))) {
	$id = $cal->update($prop);
	}
	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->get_calendar($prop['id'])) && is_object($cal->storage)) {
	$ret = false;
	if (isset($prop['permanent']))
	$ret \|= $cal->storage->subscribe(intval($prop['permanent']));
	if (isset($prop['active']))
	$ret \|= $cal->storage->activate(intval($prop['active']));

	// apply to child folders, too
	if ($prop['recursive']) {
	foreach ((array)kolab_storage::list_folders($cal->storage->name, '*', 'event') as $subfolder) {
	if (isset($prop['permanent']))
	($prop['permanent'] ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
	if (isset($prop['active']))
	($prop['active'] ? kolab_storage::folder_activate($subfolder) : kolab_storage::folder_deactivate($subfolder));
	}
	}
	return $ret;
	}
	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::delete_calendar()
	*/
	public function delete_calendar($prop)
	{
	if ($prop['id'] && ($cal = $this->get_calendar($prop['id']))) {
	$folder = $cal->get_realname();
	// TODO: unsubscribe if no admin rights
	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;
	}


	/**
	* Search for shared or otherwise not listed calendars the user has access
	*
	* @param string Search string
	* @param string Section/source to search
	* @return array List of calendars
	*/
	public function search_calendars($query, $source)
	{
	if (!kolab_storage::setup())
	return array();

	$this->calendars = array();
	$this->search_more_results = false;

	// find unsubscribed IMAP folders that have "event" type
	if ($source == 'folders') {
	foreach ((array)kolab_storage::search_folders('event', $query, array('other')) as $folder) {
	$calendar = new kolab_calendar($folder->name, $this->cal);
	$this->calendars[$calendar->id] = $calendar;
	}
	}
	// find other user's virtual calendars
	else if ($source == 'users') {
	$limit = $this->rc->config->get('autocomplete_max', 15) * 2; // we have slightly more space, so display twice the number
	foreach (kolab_storage::search_users($query, 0, array(), $limit, $count) as $user) {
	$calendar = new kolab_user_calendar($user, $this->cal);
	$this->calendars[$calendar->id] = $calendar;

	// search for calendar folders shared by this user
	foreach (kolab_storage::list_user_folders($user, 'event', false) as $foldername) {
	$cal = new kolab_calendar($foldername, $this->cal);
	$this->calendars[$cal->id] = $cal;
	$calendar->subscriptions = true;
	}
	}

	if ($count > $limit) {
	$this->search_more_results = true;
	}
	}

	// don't list the birthday calendar
	$this->rc->config->set('calendar_contact_birthdays', false);
	$this->rc->config->set('kolab_invitation_calendars', false);

	return $this->list_calendars();
	}


	/**
	* 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->get_calendar($cal)) {
	return $storage->get_event($id);
	}
	// get event from the address books birthday calendar
	else if ($cal == self::BIRTHDAY_CALENDAR_ID) {
	return $this->get_birthday_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->get_calendar($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);
	}

	/**
	* Extended event editing with possible changes to the argument
	*
	* @param array Hash array with event properties
	* @param string New participant status
	* @return boolean True on success, False on error
	*/
	public function edit_rsvp(&$event, $status)
	{
	if (($ret = $this->update_event($event)) && $this->rc->config->get('kolab_invitation_calendars')) {
	// re-assign to the according (virtual) calendar
	if (strtoupper($status) == 'DECLINED')
	$event['calendar'] = self::INVITATIONS_CALENDAR_DECLINED;
	else if (strtoupper($status) == 'NEEDS-ACTION')
	$event['calendar'] = self::INVITATIONS_CALENDAR_PENDING;
	else if ($event['_folder_id'])
	$event['calendar'] = $event['_folder_id'];
	}

	return $ret;
	}


	/**
	* 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->get_calendar($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->get_calendar($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'];
	$decline = $event['decline'];

	if (($storage = $this->get_calendar($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]);
	+ foreach ($master['recurrence']['EXCEPTIONS'] as $i => $exception) {
	+ if ($exception['_instance'] == $event['_instance']) {
	+ unset($master['recurrence']['EXCEPTIONS'][$i]);
	+ // set event date back to the actual occurrence
	+ if ($exception['recurrence_date'])
	+ $event['start'] = $exception['recurrence_date'];
	+ break;
	+ }
	}
	}

	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
	if ($decline && $this->rc->config->get('kolab_invitation_calendars')) {
	// don't delete but set PARTSTAT=DECLINED
	if ($this->cal->lib->set_partstat($master, 'DECLINED')) {
	$success = $storage->update_event($master);
	}
	}

	if (!$success)
	$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->get_calendar($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->get_calendar($event['calendar'])))
	return false;

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

	if ($event['_savemode'] != 'new') {
	if (!$fromcalendar->storage->move($event['id'], $storage->storage))
	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'])
	+ if ($old['recurrence']['EXDATE'] && !isset($event['recurrence']['EXDATE']))
	$event['recurrence']['EXDATE'] = $old['recurrence']['EXDATE'];
	- if ($old['recurrence']['EXCEPTIONS'])
	+ if (isset($event['recurrence']['EXCEPTIONS']))
	+ $with_exceptions = true; // exceptions already provided (e.g. from iCal import)
	+ else 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();
	unset($event['recurrence_id'], $event['id'], $event['_savemode'], $event['_fromcalendar'], $event['_identity'], $event['_notify']);

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

	if ($success = $storage->insert_event($event))
	$success = $event['uid'];
	break;

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

	+ // TODO: increment sequence if scheduling is affected
	+
	// remove some internal properties which should not be saved
	- unset($event['_savemode'], $event['_fromcalendar'], $event['_identity'], $event['_notify']);
	+ unset($event['id'], $event['_savemode'], $event['_fromcalendar'], $event['_identity'], $event['_notify']);

	// 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;
	+ if ($old['recurrence_id'] && is_array($master['recurrence']['EXCEPTIONS'])) {
	+ foreach ($master['recurrence']['EXCEPTIONS'] as $i => $exception) {
	+ if ($exception['_instance'] == $old['_instance']) {
	+ $event['_instance'] = $old['_instance'];
	+ $event['recurrence_date'] = $old['recurrence_date'];
	+ $master['recurrence']['EXCEPTIONS'][$i] = $event;
	+ $success = $storage->update_event($master, $old['id']);
	+ break 2;
	}
	+ }
	}

	$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) {
	+ $event['_instance'] = $old['_instance'];
	$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;
	+ $date_shift = $old['start']->diff($event['start']);

	// 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['start'] = $master['start']->add($date_shift);
	$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'];
	}

	+ // adjust recurrence-id when start changed and therefore the entire recurrence chain changes
	+ if (($old_start_date != $new_start_date \|\| $old_start_time != $new_start_time) && is_array($event['recurrence']['EXCEPTIONS']) && !$with_exceptions) {
	+ $recurrence_id_format = $event['allday'] ? 'Ymd' : 'Ymd\THis';
	+ foreach ($event['recurrence']['EXCEPTIONS'] as $i => $exception) {
	+ $recurrence_id = is_a($exception['recurrence_date'], 'DateTime') ? $exception['recurrence_date'] :
	+ rcube_utils::anytodatetime($exception['_instance'], $old['start']->getTimezone());
	+ if (is_a($recurrence_id, 'DateTime')) {
	+ $recurrence_id->add($date_shift);
	+ $event['recurrence']['EXCEPTIONS'][$i]['recurrence_date'] = $recurrence_id;
	+ $event['recurrence']['EXCEPTIONS'][$i]['_instance'] = $recurrence_id->format($recurrence_id_format);
	+ }
	+ }
	+ }
	+
	// 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);
	else if (!$calendars)
	$calendars = array_keys($this->calendars);

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

	$events = $categories = array();
	foreach ($calendars as $cid) {
	if ($storage = $this->get_calendar($cid)) {
	$events = array_merge($events, $storage->list_events($start, $end, $search, $virtual, $query));
	$categories += $storage->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 number of events in the given calendar
	*
	* @param mixed List of calendar IDs to count events (either as array or comma-separated string)
	* @param integer Date range start (unix timestamp)
	* @param integer Date range end (unix timestamp)
	* @return array Hash array with counts grouped by calendar ID
	*/
	public function count_events($calendars, $start, $end = null)
	{
	$counts = array();

	if ($calendars && is_string($calendars))
	$calendars = explode(',', $calendars);
	else if (!$calendars)
	$calendars = array_keys($this->calendars);

	foreach ($calendars as $cid) {
	if ($storage = $this->get_calendar($cid)) {
	$counts[$cid] = $storage->count_events($start, $end);
	}
	}

	return $counts;
	}

	/**
	* 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'] >= $last && 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("SELECT *"
	. " FROM " . $this->rc->db->table_name('kolab_alarms', true)
	. " WHERE `alarm_id` IN (" . join(',', $alarm_ids) . ")"
	. " AND `user_id` = ?",
	$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)
	{
	$alarms_table = $this->rc->db->table_name('kolab_alarms', true);
	// delete old alarm entry
	$this->rc->db->query("DELETE FROM $alarms_table"
	. " 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 $alarms_table"
	. " (`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->get_calendar($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->get_calendar($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->get_calendar($event['calendar'])))
	return false;

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

	/**
	* Build a struct representing the given message reference
	*
	* @see calendar_driver::get_message_reference()
	*/
	public function get_message_reference($uri_or_headers, $folder = null)
	{
	if (is_object($uri_or_headers)) {
	$uri_or_headers = kolab_storage_config::get_message_uri($uri_or_headers, $folder);
	}

	if (is_string($uri_or_headers)) {
	return kolab_storage_config::get_message_reference($uri_or_headers, 'event');
	}

	return false;
	}

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

	/**
	* Create instances of a recurring event
	*
	* @param array Hash array with event properties
	* @param object DateTime Start date of the recurrence window
	* @param object DateTime End date of the recurrence window
	* @return array List of recurring event instances
	*/
	public function get_recurring_events($event, $start, $end = null)
	{
	// load the given event data into a libkolabxml container
	if (!$event['_formatobj']) {
	$event_xml = new kolab_format_event();
	$event_xml->set($event);
	$event['_formatobj'] = $event_xml;
	}

	$this->_read_calendars();
	$storage = reset($this->calendars);
	return $storage->get_recurring_events($event, $start, $end);
	}

	/**
	* 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 = rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC);
	if (!($cal = $this->get_calendar($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;
	}


	/**
	* Convert from Kolab_Format to internal representation
	*/
	public static function to_rcube_event($record)
	{
	$record['id'] = $record['uid'];

	// all-day events go from 12:00 - 13:00
	if (is_a($record['start'], 'DateTime') && $record['end'] <= $record['start'] && $record['allday']) {
	$record['end'] = clone $record['start'];
	$record['end']->add(new DateInterval('PT1H'));
	}

	if (!empty($record['_attachments'])) {
	foreach ($record['_attachments'] as $key => $attachment) {
	if ($attachment !== false) {
	if (!$attachment['name'])
	$attachment['name'] = $key;

	unset($attachment['path'], $attachment['content']);
	$attachments[] = $attachment;
	}
	}

	$record['attachments'] = $attachments;
	}

	if (!empty($record['attendees'])) {
	foreach ((array)$record['attendees'] as $i => $attendee) {
	if (is_array($attendee['delegated-from'])) {
	$record['attendees'][$i]['delegated-from'] = join(', ', $attendee['delegated-from']);
	}
	if (is_array($attendee['delegated-to'])) {
	$record['attendees'][$i]['delegated-to'] = join(', ', $attendee['delegated-to']);
	}
	}
	}

	// Roundcube only supports one category assignment
	if (is_array($record['categories']))
	$record['categories'] = $record['categories'][0];

	// the cancelled flag transltes into status=CANCELLED
	if ($record['cancelled'])
	$record['status'] = 'CANCELLED';

	// The web client only supports DISPLAY type of alarms
	if (!empty($record['alarms']))
	$record['alarms'] = preg_replace('/:[A-Z]+$/', ':DISPLAY', $record['alarms']);

	// remove empty recurrence array
	if (empty($record['recurrence']))
	unset($record['recurrence']);

	// remove internals
	unset($record['_mailbox'], $record['_msguid'], $record['_formatobj'], $record['_attachments'], $record['x-custom']);

	return $record;
	}

	/**
	* Set CSS class according to the event's attendde partstat
	*/
	public static function add_partstat_class($event, $partstats, $user = null)
	{
	// set classes according to PARTSTAT
	if (is_array($event['attendees'])) {
	$user_emails = libcalendaring::get_instance()->get_user_emails($user);
	$partstat = 'UNKNOWN';
	foreach ($event['attendees'] as $attendee) {
	if (in_array($attendee['email'], $user_emails)) {
	$partstat = $attendee['status'];
	break;
	}
	}

	if (in_array($partstat, $partstats)) {
	$event['className'] = trim($event['className'] . ' fc-invitation-' . strtolower($partstat));
	}
	}

	return $event;
	}

	/**
	* Provide a list of revisions for the given event
	*
	* @param array $event Hash array with event properties
	*
	* @return array List of changes, each as a hash array
	* @see calendar_driver::get_event_changelog()
	*/
	public function get_event_changelog($event)
	{
	if (empty($this->bonnie_api)) {
	return false;
	}

	list($uid, $mailbox) = $this->_resolve_event_identity($event);

	$result = $this->bonnie_api->changelog('event', $uid, $mailbox);
	if (is_array($result) && $result['uid'] == $uid) {
	return $result['changes'];
	}

	return false;
	}

	/**
	* Get a list of property changes beteen two revisions of an event
	*
	* @param array $event Hash array with event properties
	* @param mixed $rev Revisions: "from:to"
	*
	* @return array List of property changes, each as a hash array
	* @see calendar_driver::get_event_diff()
	*/
	public function get_event_diff($event, $rev)
	{
	if (empty($this->bonnie_api)) {
	return false;
	}

	list($uid, $mailbox) = $this->_resolve_event_identity($event);

	// call Bonnie API
	$result = $this->bonnie_api->diff('event', $uid, $rev, $mailbox);
	if (is_array($result) && $result['uid'] == $uid) {
	$result['rev'] = $rev;

	$keymap = array(
	'dtstart' => 'start',
	'dtend' => 'end',
	'dstamp' => 'changed',
	'summary' => 'title',
	'alarm' => 'alarms',
	'attendee' => 'attendees',
	'attach' => 'attachments',
	'rrule' => 'recurrence',
	'transparency' => 'free_busy',
	'classification' => 'sensitivity',
	'lastmodified-date' => 'changed',
	);
	$prop_keymaps = array(
	'attachments' => array('fmttype' => 'mimetype', 'label' => 'name'),
	'attendees' => array('partstat' => 'status'),
	);
	$special_changes = array();

	// map kolab event properties to keys the client expects
	array_walk($result['changes'], function(&$change, $i) use ($keymap, $prop_keymaps, $special_changes) {
	if (array_key_exists($change['property'], $keymap)) {
	$change['property'] = $keymap[$change['property']];
	}
	// translate free_busy values
	if ($change['property'] == 'free_busy') {
	$change['old'] = $old['old'] ? 'free' : 'busy';
	$change['new'] = $old['new'] ? 'free' : 'busy';
	}
	// map alarms trigger value
	if ($change['property'] == 'alarms') {
	if (is_array($change['old']) && is_array($change['old']['trigger']))
	$change['old']['trigger'] = $change['old']['trigger']['value'];
	if (is_array($change['new']) && is_array($change['new']['trigger']))
	$change['new']['trigger'] = $change['new']['trigger']['value'];
	}
	// make all property keys uppercase
	if ($change['property'] == 'recurrence') {
	$special_changes['recurrence'] = $i;
	foreach (array('old','new') as $m) {
	if (is_array($change[$m])) {
	$props = array();
	foreach ($change[$m] as $k => $v)
	$props[strtoupper($k)] = $v;
	$change[$m] = $props;
	}
	}
	}
	// map property keys names
	if (is_array($prop_keymaps[$change['property']])) {
	foreach ($prop_keymaps[$change['property']] as $k => $dest) {
	if (is_array($change['old']) && array_key_exists($k, $change['old'])) {
	$change['old'][$dest] = $change['old'][$k];
	unset($change['old'][$k]);
	}
	if (is_array($change['new']) && array_key_exists($k, $change['new'])) {
	$change['new'][$dest] = $change['new'][$k];
	unset($change['new'][$k]);
	}
	}
	}

	if ($change['property'] == 'exdate') {
	$special_changes['exdate'] = $i;
	}
	else if ($change['property'] == 'rdate') {
	$special_changes['rdate'] = $i;
	}
	});

	// merge some recurrence changes
	foreach (array('exdate','rdate') as $prop) {
	if (array_key_exists($prop, $special_changes)) {
	$exdate = $result['changes'][$special_changes[$prop]];
	if (array_key_exists('recurrence', $special_changes)) {
	$recurrence = &$result['changes'][$special_changes['recurrence']];
	}
	else {
	$i = count($result['changes']);
	$result['changes'][$i] = array('property' => 'recurrence', 'old' => array(), 'new' => array());
	$recurrence = &$result['changes'][$i]['recurrence'];
	}
	$key = strtoupper($prop);
	$recurrence['old'][$key] = $exdate['old'];
	$recurrence['new'][$key] = $exdate['new'];
	unset($result['changes'][$special_changes[$prop]]);
	}
	}

	return $result;
	}

	return false;
	}

	/**
	* Return full data of a specific revision of an event
	*
	* @param array Hash array with event properties
	* @param mixed $rev Revision number
	*
	* @return array Event object as hash array
	* @see calendar_driver::get_event_revison()
	*/
	public function get_event_revison($event, $rev)
	{
	if (empty($this->bonnie_api)) {
	return false;
	}

	$calid = $event['calendar'];
	list($uid, $mailbox) = $this->_resolve_event_identity($event);

	// call Bonnie API
	$result = $this->bonnie_api->get('event', $uid, $rev, $mailbox);
	if (is_array($result) && $result['uid'] == $uid && !empty($result['xml'])) {
	$format = kolab_format::factory('event');
	$format->load($result['xml']);
	$event = $format->to_array();

	if ($format->is_valid()) {
	$event['calendar'] = $calid;
	$event['rev'] = $result['rev'];
	return self::to_rcube_event($event);
	}
	}

	return false;
	}

	/**
	* Helper method to resolved the given event identifier into uid and folder
	*
	* @return array (uid,folder) tuple
	*/
	private function _resolve_event_identity($event)
	{
	$mailbox = null;
	if (is_array($event)) {
	$uid = $event['id'] ?: $event['uid'];
	if (($cal = $this->get_calendar($event['calendar'])) && !($cal instanceof kolab_invitation_calendar)) {
	$mailbox = $cal->get_mailbox_id();
	}
	}
	else {
	$uid = $event;
	}

	return array($uid, $mailbox);
	}

	/**
	* 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)
	{
	// show default dialog for birthday calendar
	if (in_array($calendar['id'], array(self::BIRTHDAY_CALENDAR_ID, self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED))) {
	if ($calendar['id'] != self::BIRTHDAY_CALENDAR_ID)
	unset($formfields['showalarms']);
	return parent::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', 'id' => 'calendar-parent'), $folder);
	$form['props']['fieldsets']['location']['content']['path'] = array(
	'id' => 'calendar-parent',
	'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) {
	$label = !empty($colprop['label']) ? $colprop['label'] : rcube_label($col);

	$table->add('title', html::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 = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
	if ($calid && ($cal = $this->get_calendar($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 " . $this->rc->db->table_name($table, true)
	. " WHERE `user_id` = ?", $args['user']->ID);
	}
	}
	}
	diff --git a/plugins/libcalendaring/libvcalendar.php b/plugins/libcalendaring/libvcalendar.php
	index 127ee36f..4163cfbe 100644
	--- a/plugins/libcalendaring/libvcalendar.php
	+++ b/plugins/libcalendaring/libvcalendar.php
	@@ -1,1336 +1,1339 @@
	<?php

	/**
	* iCalendar functions for the libcalendaring plugin
	*
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2013, 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/>.
	*/

	use \Sabre\VObject;

	// load Sabre\VObject classes
	if (!class_exists('\Sabre\VObject\Reader')) {
	require_once __DIR__ . '/lib/Sabre/VObject/includes.php';
	}

	/**
	* Class to parse and build vCalendar (iCalendar) files
	*
	* Uses the SabreTooth VObject library, version 2.1.
	*
	* Download from https://github.com/fruux/sabre-vobject/archive/2.1.0.zip
	* and place the lib files in this plugin's lib directory
	*
	*/
	class libvcalendar implements Iterator
	{
	private $timezone;
	private $attach_uri = null;
	private $prodid = '-//Roundcube//Roundcube libcalendaring//Sabre//Sabre VObject//EN';
	private $type_component_map = array('event' => 'VEVENT', 'task' => 'VTODO');
	private $attendee_keymap = array('name' => 'CN', 'status' => 'PARTSTAT', 'role' => 'ROLE',
	'cutype' => 'CUTYPE', 'rsvp' => 'RSVP', 'delegated-from' => 'DELEGATED-FROM', 'delegated-to' => 'DELEGATED-TO');
	private $iteratorkey = 0;
	private $charset;
	private $forward_exceptions;
	private $vhead;
	private $fp;
	private $vtimezones = array();

	public $method;
	public $agent = '';
	public $objects = array();
	public $freebusy = array();


	/**
	* Default constructor
	*/
	function __construct($tz = null)
	{
	$this->timezone = $tz;
	$this->prodid = '-//Roundcube//Roundcube libcalendaring ' . RCUBE_VERSION . '//Sabre//Sabre VObject ' . VObject\Version::VERSION . '//EN';
	}

	/**
	* Setter for timezone information
	*/
	public function set_timezone($tz)
	{
	$this->timezone = $tz;
	}

	/**
	* Setter for URI template for attachment links
	*/
	public function set_attach_uri($uri)
	{
	$this->attach_uri = $uri;
	}

	/**
	* Setter for a custom PRODID attribute
	*/
	public function set_prodid($prodid)
	{
	$this->prodid = $prodid;
	}

	/**
	* Setter for a user-agent string to tweak input/output accordingly
	*/
	public function set_agent($agent)
	{
	$this->agent = $agent;
	}

	/**
	* Free resources by clearing member vars
	*/
	public function reset()
	{
	$this->vhead = '';
	$this->method = '';
	$this->objects = array();
	$this->freebusy = array();
	$this->vtimezones = array();
	$this->iteratorkey = 0;

	if ($this->fp) {
	fclose($this->fp);
	$this->fp = null;
	}
	}

	/**
	* Import events from iCalendar format
	*
	* @param string vCalendar input
	* @param string Input charset (from envelope)
	* @param boolean True if parsing exceptions should be forwarded to the caller
	* @return array List of events extracted from the input
	*/
	public function import($vcal, $charset = 'UTF-8', $forward_exceptions = false, $memcheck = true)
	{
	// TODO: convert charset to UTF-8 if other

	try {
	// estimate the memory usage and try to avoid fatal errors when allowed memory gets exhausted
	if ($memcheck) {
	$count = substr_count($vcal, 'BEGIN:VEVENT') + substr_count($vcal, 'BEGIN:VTODO');
	$expected_memory = $count * 70*1024; // assume ~ 70K per event (empirically determined)

	if (!rcube_utils::mem_check($expected_memory)) {
	throw new Exception("iCal file too big");
	}
	}

	$vobject = VObject\Reader::read($vcal, VObject\Reader::OPTION_FORGIVING \| VObject\Reader::OPTION_IGNORE_INVALID_LINES);
	if ($vobject)
	return $this->import_from_vobject($vobject);
	}
	catch (Exception $e) {
	if ($forward_exceptions) {
	throw $e;
	}
	else {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "iCal data parse error: " . $e->getMessage()),
	true, false);
	}
	}

	return array();
	}

	/**
	* Read iCalendar events from a file
	*
	* @param string File path to read from
	* @param string Input charset (from envelope)
	* @param boolean True if parsing exceptions should be forwarded to the caller
	* @return array List of events extracted from the file
	*/
	public function import_from_file($filepath, $charset = 'UTF-8', $forward_exceptions = false)
	{
	if ($this->fopen($filepath, $charset, $forward_exceptions)) {
	while ($this->_parse_next(false)) {
	// nop
	}

	fclose($this->fp);
	$this->fp = null;
	}

	return $this->objects;
	}

	/**
	* Open a file to read iCalendar events sequentially
	*
	* @param string File path to read from
	* @param string Input charset (from envelope)
	* @param boolean True if parsing exceptions should be forwarded to the caller
	* @return boolean True if file contents are considered valid
	*/
	public function fopen($filepath, $charset = 'UTF-8', $forward_exceptions = false)
	{
	$this->reset();

	// just to be sure...
	@ini_set('auto_detect_line_endings', true);

	$this->charset = $charset;
	$this->forward_exceptions = $forward_exceptions;
	$this->fp = fopen($filepath, 'r');

	// check file content first
	$begin = fread($this->fp, 1024);
	if (!preg_match('/BEGIN:VCALENDAR/i', $begin)) {
	return false;
	}

	fseek($this->fp, 0);
	return $this->_parse_next();
	}

	/**
	* Parse the next event/todo/freebusy object from the input file
	*/
	private function _parse_next($reset = true)
	{
	if ($reset) {
	$this->iteratorkey = 0;
	$this->objects = array();
	$this->freebusy = array();
	}

	$next = $this->_next_component();
	$buffer = $next;

	// load the next component(s) too, as they could contain recurrence exceptions
	while (preg_match('/(RRULE\|RECURRENCE-ID)[:;]/i', $next)) {
	$next = $this->_next_component();
	$buffer .= $next;
	}

	// parse the vevent block surrounded with the vcalendar heading
	if (strlen($buffer) && preg_match('/BEGIN:(VEVENT\|VTODO\|VFREEBUSY)/i', $buffer)) {
	try {
	$this->import($this->vhead . $buffer . "END:VCALENDAR", $this->charset, true, false);
	}
	catch (Exception $e) {
	if ($this->forward_exceptions) {
	throw new VObject\ParseException($e->getMessage() . " in\n" . $buffer);
	}
	else {
	// write the failing section to error log
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => $e->getMessage() . " in\n" . $buffer),
	true, false);
	}

	// advance to next
	return $this->_parse_next($reset);
	}

	return count($this->objects) > 0;
	}

	return false;
	}

	/**
	* Helper method to read the next calendar component from the file
	*/
	private function _next_component()
	{
	$buffer = '';
	$vcalendar_head = false;
	while (($line = fgets($this->fp, 1024)) !== false) {
	// ignore END:VCALENDAR lines
	if (preg_match('/END:VCALENDAR/i', $line)) {
	continue;
	}
	// read vcalendar header (with timezone defintion)
	if (preg_match('/BEGIN:VCALENDAR/i', $line)) {
	$this->vhead = '';
	$vcalendar_head = true;
	}

	// end of VCALENDAR header part
	if ($vcalendar_head && preg_match('/BEGIN:(VEVENT\|VTODO\|VFREEBUSY)/i', $line)) {
	$vcalendar_head = false;
	}

	if ($vcalendar_head) {
	$this->vhead .= $line;
	}
	else {
	$buffer .= $line;
	if (preg_match('/END:(VEVENT\|VTODO\|VFREEBUSY)/i', $line)) {
	break;
	}
	}
	}

	return $buffer;
	}

	/**
	* Import objects from an already parsed Sabre\VObject\Component object
	*
	* @param object Sabre\VObject\Component to read from
	* @return array List of events extracted from the file
	*/
	public function import_from_vobject($vobject)
	{
	$seen = array();

	if ($vobject->name == 'VCALENDAR') {
	$this->method = strval($vobject->METHOD);
	$this->agent = strval($vobject->PRODID);

	foreach ($vobject->getBaseComponents() ?: $vobject->getComponents() as $ve) {
	if ($ve->name == 'VEVENT' \|\| $ve->name == 'VTODO') {
	// convert to hash array representation
	$object = $this->_to_array($ve);

	if (!$seen[$object['uid']]++) {
	// parse recurrence exceptions
	if ($object['recurrence']) {
	+ $object['recurrence']['EXCEPTIONS'] = array();
	foreach ($vobject->children as $component) {
	if ($component->name == 'VEVENT' && isset($component->{'RECURRENCE-ID'})) {
	try {
	$object['recurrence']['EXCEPTIONS'][] = $this->_to_array($component);
	}
	catch (Exception $e) {
	console("iCal data parse error: " . $e->getMessage(), $component->serialize());
	}
	}
	}
	}

	$this->objects[] = $object;
	}
	}
	else if ($ve->name == 'VFREEBUSY') {
	$this->objects[] = $this->_parse_freebusy($ve);
	}
	}
	}

	return $this->objects;
	}

	/**
	* Getter for free-busy periods
	*/
	public function get_busy_periods()
	{
	$out = array();
	foreach ((array)$this->freebusy['periods'] as $period) {
	if ($period[2] != 'FREE') {
	$out[] = $period;
	}
	}

	return $out;
	}

	/**
	* Helper method to determine whether the connected client is an Apple device
	*/
	private function is_apple()
	{
	return stripos($this->agent, 'Apple') !== false
	\|\| stripos($this->agent, 'Mac OS X') !== false
	\|\| stripos($this->agent, 'iOS/') !== false;
	}

	/**
	* Convert the given VEvent object to a libkolab compatible array representation
	*
	* @param object Vevent object to convert
	* @return array Hash array with object properties
	*/
	private function _to_array($ve)
	{
	$event = array(
	'uid' => self::convert_string($ve->UID),
	'title' => self::convert_string($ve->SUMMARY),
	'_type' => $ve->name == 'VTODO' ? 'task' : 'event',
	// set defaults
	'priority' => 0,
	'attendees' => array(),
	'x-custom' => array(),
	);

	// Catch possible exceptions when date is invalid (Bug #2144)
	// We can skip these fields, they aren't critical
	foreach (array('CREATED' => 'created', 'LAST-MODIFIED' => 'changed', 'DTSTAMP' => 'changed') as $attr => $field) {
	try {
	if (!$event[$field] && $ve->{$attr}) {
	$event[$field] = $ve->{$attr}->getDateTime();
	}
	} catch (Exception $e) {}
	}

	// map other attributes to internal fields
	foreach ($ve->children as $prop) {
	if (!($prop instanceof VObject\Property))
	continue;

	switch ($prop->name) {
	case 'DTSTART':
	case 'DTEND':
	case 'DUE':
	$propmap = array('DTSTART' => 'start', 'DTEND' => 'end', 'DUE' => 'due');
	$event[$propmap[$prop->name]] = self::convert_datetime($prop);
	break;

	case 'TRANSP':
	$event['free_busy'] = $prop->value == 'TRANSPARENT' ? 'free' : 'busy';
	break;

	case 'STATUS':
	if ($prop->value == 'TENTATIVE')
	$event['free_busy'] = 'tentative';
	else if ($prop->value == 'CANCELLED')
	$event['cancelled'] = true;
	else if ($prop->value == 'COMPLETED')
	$event['complete'] = 100;

	$event['status'] = strval($prop->value);
	break;

	case 'PRIORITY':
	if (is_numeric($prop->value))
	$event['priority'] = $prop->value;
	break;

	case 'RRULE':
	$params = is_array($event['recurrence']) ? $event['recurrence'] : array();
	// parse recurrence rule attributes
	foreach (explode(';', $prop->value) as $par) {
	list($k, $v) = explode('=', $par);
	$params[$k] = $v;
	}
	if ($params['UNTIL'])
	$params['UNTIL'] = date_create($params['UNTIL']);
	if (!$params['INTERVAL'])
	$params['INTERVAL'] = 1;

	$event['recurrence'] = array_filter($params);
	break;

	case 'EXDATE':
	if (!empty($prop->value))
	$event['recurrence']['EXDATE'] = array_merge((array)$event['recurrence']['EXDATE'], self::convert_datetime($prop, true));
	break;

	case 'RDATE':
	if (!empty($prop->value))
	$event['recurrence']['RDATE'] = array_merge((array)$event['recurrence']['RDATE'], self::convert_datetime($prop, true));
	break;

	case 'RECURRENCE-ID':
	$event['recurrence_date'] = self::convert_datetime($prop);
	+ if ($prop->offsetGet('RANGE') == 'THISANDFUTURE' \|\| $prop->offsetGet('THISANDFUTURE') !== null) {
	+ $event['thisandfuture'] = true;
	+ }
	break;

	case 'RELATED-TO':
	$reltype = $prop->offsetGet('RELTYPE');
	if ($reltype == 'PARENT' \|\| $reltype === null) {
	$event['parent_id'] = $prop->value;
	}
	break;

	case 'SEQUENCE':
	$event['sequence'] = intval($prop->value);
	break;

	case 'PERCENT-COMPLETE':
	$event['complete'] = intval($prop->value);
	break;

	case 'LOCATION':
	case 'DESCRIPTION':
	case 'URL':
	case 'COMMENT':
	$event[strtolower($prop->name)] = self::convert_string($prop);
	break;

	case 'CATEGORY':
	case 'CATEGORIES':
	$event['categories'] = array_merge((array)$event['categories'], $prop->getParts());
	break;

	case 'CLASS':
	case 'X-CALENDARSERVER-ACCESS':
	$event['sensitivity'] = strtolower($prop->value);
	break;

	case 'X-MICROSOFT-CDO-BUSYSTATUS':
	if ($prop->value == 'OOF')
	$event['free_busy'] = 'outofoffice';
	else if (in_array($prop->value, array('FREE', 'BUSY', 'TENTATIVE')))
	$event['free_busy'] = strtolower($prop->value);
	break;

	case 'ATTENDEE':
	case 'ORGANIZER':
	$params = array();
	foreach ($prop->parameters as $param) {
	switch ($param->name) {
	case 'RSVP': $params[$param->name] = strtolower($param->value) == 'true'; break;
	default: $params[$param->name] = $param->value; break;
	}
	}
	$attendee = self::map_keys($params, array_flip($this->attendee_keymap));
	$attendee['email'] = preg_replace('/^mailto:/i', '', $prop->value);

	if ($prop->name == 'ORGANIZER') {
	$attendee['role'] = 'ORGANIZER';
	$attendee['status'] = 'ACCEPTED';
	$event['organizer'] = $attendee;
	}
	else if ($attendee['email'] != $event['organizer']['email']) {
	$event['attendees'][] = $attendee;
	}
	break;

	case 'ATTACH':
	$params = self::parameters_array($prop);
	if (substr($prop->value, 0, 4) == 'http' && !strpos($prop->value, ':attachment:')) {
	$event['links'][] = $prop->value;
	}
	else if (strlen($prop->value) && strtoupper($params['VALUE']) == 'BINARY') {
	$attachment = self::map_keys($params, array('FMTTYPE' => 'mimetype', 'X-LABEL' => 'name'));
	$attachment['data'] = base64_decode($prop->value);
	$attachment['size'] = strlen($attachment['data']);
	$event['attachments'][] = $attachment;
	}
	break;

	default:
	if (substr($prop->name, 0, 2) == 'X-')
	$event['x-custom'][] = array($prop->name, strval($prop->value));
	break;
	}
	}

	// check DURATION property if no end date is set
	if (empty($event['end']) && $ve->DURATION) {
	try {
	$duration = new DateInterval(strval($ve->DURATION));
	$end = clone $event['start'];
	$end->add($duration);
	$event['end'] = $end;
	}
	catch (\Exception $e) {
	trigger_error(strval($e), E_USER_WARNING);
	}
	}

	// validate event dates
	if ($event['_type'] == 'event') {
	// check for all-day dates
	if ($event['start']->_dateonly) {
	$event['allday'] = true;
	}

	// all-day events may lack the DTEND property
	if ($event['allday'] && empty($event['end'])) {
	$event['end'] = clone $event['start'];
	}
	// shift end-date by one day (except Thunderbird)
	else if ($event['allday'] && is_object($event['end'])) {
	$event['end']->sub(new \DateInterval('PT23H'));
	}

	// sanity-check and fix end date
	if (!empty($event['end']) && $event['end'] < $event['start']) {
	$event['end'] = clone $event['start'];
	}
	}

	// make organizer part of the attendees list for compatibility reasons
	if (!empty($event['organizer']) && is_array($event['attendees']) && $event['_type'] == 'event') {
	array_unshift($event['attendees'], $event['organizer']);
	}

	// find alarms
	foreach ($ve->select('VALARM') as $valarm) {
	$action = 'DISPLAY';
	$trigger = null;
	$alarm = array();

	foreach ($valarm->children as $prop) {
	switch ($prop->name) {
	case 'TRIGGER':
	foreach ($prop->parameters as $param) {
	if ($param->name == 'VALUE' && $param->value == 'DATE-TIME') {
	$trigger = '@' . $prop->getDateTime()->format('U');
	$alarm['trigger'] = $prop->getDateTime();
	}
	}
	if (!$trigger && ($values = libcalendaring::parse_alarm_value($prop->value))) {
	$trigger = $values[2];
	}

	if (!$alarm['trigger']) {
	$alarm['trigger'] = rtrim(preg_replace('/([A-Z])0[WDHMS]/', '\\1', $prop->value), 'T');
	// if all 0-values have been stripped, assume 'at time'
	if ($alarm['trigger'] == 'P')
	$alarm['trigger'] = 'PT0S';
	}
	break;

	case 'ACTION':
	$action = $alarm['action'] = strtoupper($prop->value);
	break;

	case 'SUMMARY':
	case 'DESCRIPTION':
	case 'DURATION':
	$alarm[strtolower($prop->name)] = self::convert_string($prop);
	break;

	case 'REPEAT':
	$alarm['repeat'] = intval($prop->value);
	break;

	case 'ATTENDEE':
	$alarm['attendees'][] = preg_replace('/^mailto:/i', '', $prop->value);
	break;

	case 'ATTACH':
	$params = self::parameters_array($prop);
	if (strlen($prop->value) && (preg_match('/^[a-z]+:/', $prop->value) \|\| strtoupper($params['VALUE']) == 'URI')) {
	// we only support URI-type of attachments here
	$alarm['uri'] = $prop->value;
	}
	break;
	}
	}

	if ($action != 'NONE') {
	if ($trigger && !$event['alarms']) // store first alarm in legacy property
	$event['alarms'] = $trigger . ':' . $action;

	if ($alarm['trigger'])
	$event['valarms'][] = $alarm;
	}
	}

	// assign current timezone to event start/end
	if ($event['start'] instanceof DateTime) {
	if ($this->timezone)
	$event['start']->setTimezone($this->timezone);
	}
	else {
	unset($event['start']);
	}

	if ($event['end'] instanceof DateTime) {
	if ($this->timezone)
	$event['end']->setTimezone($this->timezone);
	}
	else {
	unset($event['end']);
	}

	// minimal validation
	if (empty($event['uid']) \|\| ($event['_type'] == 'event' && empty($event['start']) != empty($event['end']))) {
	throw new VObject\ParseException('Object validation failed: missing mandatory object properties');
	}

	return $event;
	}

	/**
	* Parse the given vfreebusy component into an array representation
	*/
	private function _parse_freebusy($ve)
	{
	$this->freebusy = array('_type' => 'freebusy', 'periods' => array());
	$seen = array();

	foreach ($ve->children as $prop) {
	if (!($prop instanceof VObject\Property))
	continue;

	switch ($prop->name) {
	case 'CREATED':
	case 'LAST-MODIFIED':
	case 'DTSTAMP':
	case 'DTSTART':
	case 'DTEND':
	$propmap = array('DTSTART' => 'start', 'DTEND' => 'end', 'CREATED' => 'created', 'LAST-MODIFIED' => 'changed', 'DTSTAMP' => 'changed');
	$this->freebusy[$propmap[$prop->name]] = self::convert_datetime($prop);
	break;

	case 'ORGANIZER':
	$this->freebusy['organizer'] = preg_replace('/^mailto:/i', '', $prop->value);
	break;

	case 'FREEBUSY':
	// The freebusy component can hold more than 1 value, separated by commas.
	$periods = explode(',', $prop->value);
	$fbtype = strval($prop['FBTYPE']) ?: 'BUSY';

	// skip dupes
	if ($seen[$prop->value.':'.$fbtype]++)
	continue;

	foreach ($periods as $period) {
	// Every period is formatted as [start]/[end]. The start is an
	// absolute UTC time, the end may be an absolute UTC time, or
	// duration (relative) value.
	list($busyStart, $busyEnd) = explode('/', $period);

	$busyStart = VObject\DateTimeParser::parse($busyStart);
	$busyEnd = VObject\DateTimeParser::parse($busyEnd);
	if ($busyEnd instanceof \DateInterval) {
	$tmp = clone $busyStart;
	$tmp->add($busyEnd);
	$busyEnd = $tmp;
	}

	if ($busyEnd && $busyEnd > $busyStart)
	$this->freebusy['periods'][] = array($busyStart, $busyEnd, $fbtype);
	}
	break;

	case 'COMMENT':
	$this->freebusy['comment'] = $prop->value;
	}
	}

	return $this->freebusy;
	}

	/**
	*
	*/
	public static function convert_string($prop)
	{
	return str_replace('\,', ',', strval($prop->value));
	}

	/**
	* Helper method to correctly interpret an all-day date value
	*/
	public static function convert_datetime($prop, $as_array = false)
	{
	if (empty($prop)) {
	return $as_array ? array() : null;
	}
	else if ($prop instanceof VObject\Property\MultiDateTime) {
	$dt = array();
	$dateonly = ($prop->getDateType() & VObject\Property\DateTime::DATE);
	foreach ($prop->getDateTimes() as $item) {
	$item->_dateonly = $dateonly;
	$dt[] = $item;
	}
	}
	else if ($prop instanceof VObject\Property\DateTime) {
	$dt = $prop->getDateTime();
	if ($prop->getDateType() & VObject\Property\DateTime::DATE) {
	$dt->_dateonly = true;
	}
	}
	else if ($prop instanceof VObject\Property && ($prop['VALUE'] == 'DATE' \|\| $prop['VALUE'] == 'DATE-TIME')) {
	try {
	list($type, $dt) = VObject\Property\DateTime::parseData($prop->value, $prop);
	$dt->_dateonly = ($type & VObject\Property\DateTime::DATE);
	}
	catch (Exception $e) {
	// ignore date parse errors
	}
	}
	else if ($prop instanceof VObject\Property && $prop['VALUE'] == 'PERIOD') {
	$dt = array();
	foreach(explode(',', $prop->value) as $val) {
	try {
	list($start, $end) = explode('/', $val);
	list($type, $item) = VObject\Property\DateTime::parseData($start, $prop);
	$item->_dateonly = ($type & VObject\Property\DateTime::DATE);
	$dt[] = $item;
	}
	catch (Exception $e) {
	// ignore single date parse errors
	}
	}
	}
	else if ($prop instanceof DateTime) {
	$dt = $prop;
	}

	// force return value to array if requested
	if ($as_array && !is_array($dt)) {
	$dt = empty($dt) ? array() : array($dt);
	}

	return $dt;
	}


	/**
	* Create a Sabre\VObject\Property instance from a PHP DateTime object
	*
	* @param string Property name
	* @param object DateTime
	*/
	public function datetime_prop($name, $dt, $utc = false, $dateonly = null)
	{
	$is_utc = $utc \|\| (($tz = $dt->getTimezone()) && in_array($tz->getName(), array('UTC','GMT','Z')));
	$is_dateonly = $dateonly === null ? (bool)$dt->_dateonly : (bool)$dateonly;
	$vdt = new VObject\Property\DateTime($name);
	$vdt->setDateTime($dt, $is_dateonly ? VObject\Property\DateTime::DATE :
	($is_utc ? VObject\Property\DateTime::UTC : VObject\Property\DateTime::LOCALTZ));

	// register timezone for VTIMEZONE block
	if (!$is_utc && !$dateonly && $tz && ($tzname = $tz->getName())) {
	$ts = $dt->format('U');
	if (is_array($this->vtimezones[$tzname])) {
	$this->vtimezones[$tzname][0] = min($this->vtimezones[$tzname][0], $ts);
	$this->vtimezones[$tzname][1] = max($this->vtimezones[$tzname][1], $ts);
	}
	else {
	$this->vtimezones[$tzname] = array($ts, $ts);
	}
	}

	return $vdt;
	}

	/**
	* Copy values from one hash array to another using a key-map
	*/
	public static function map_keys($values, $map)
	{
	$out = array();
	foreach ($map as $from => $to) {
	if (isset($values[$from]))
	$out[$to] = is_array($values[$from]) ? join(',', $values[$from]) : $values[$from];
	}
	return $out;
	}

	/**
	*
	*/
	private static function parameters_array($prop)
	{
	$params = array();
	foreach ($prop->parameters as $param) {
	$params[strtoupper($param->name)] = $param->value;
	}
	return $params;
	}


	/**
	* Export events to iCalendar format
	*
	* @param array Events as array
	* @param string VCalendar method to advertise
	* @param boolean Directly send data to stdout instead of returning
	* @param callable Callback function to fetch attachment contents, false if no attachment export
	* @param boolean Add VTIMEZONE block with timezone definitions for the included events
	* @return string Events in iCalendar format (http://tools.ietf.org/html/rfc5545)
	*/
	public function export($objects, $method = null, $write = false, $get_attachment = false, $with_timezones = true)
	{
	$this->method = $method;

	// encapsulate in VCALENDAR container
	$vcal = VObject\Component::create('VCALENDAR');
	$vcal->version = '2.0';
	$vcal->prodid = $this->prodid;
	$vcal->calscale = 'GREGORIAN';

	if (!empty($method)) {
	$vcal->METHOD = $method;
	}

	// write vcalendar header
	if ($write) {
	echo preg_replace('/END:VCALENDAR[\r\n]*$/m', '', $vcal->serialize());
	}

	foreach ($objects as $object) {
	$this->_to_ical($object, !$write?$vcal:false, $get_attachment);
	}

	// include timezone information
	if ($with_timezones \|\| !empty($method)) {
	foreach ($this->vtimezones as $tzid => $range) {
	$vt = self::get_vtimezone($tzid, $range[0], $range[1]);
	if (empty($vt)) {
	continue; // no timezone information found
	}

	if ($vcal) {
	$vcal->add($vt);
	}
	else {
	echo $vt->serialize();
	}
	}
	}

	if ($write) {
	echo "END:VCALENDAR\r\n";
	return true;
	}
	else {
	return $vcal->serialize();
	}
	}

	/**
	* Build a valid iCal format block from the given event
	*
	* @param array Hash array with event/task properties from libkolab
	* @param object VCalendar object to append event to or false for directly sending data to stdout
	* @param callable Callback function to fetch attachment contents, false if no attachment export
	* @param object RECURRENCE-ID property when serializing a recurrence exception
	*/
	private function _to_ical($event, $vcal, $get_attachment, $recurrence_id = null)
	{
	$type = $event['_type'] ?: 'event';
	$ve = VObject\Component::create($this->type_component_map[$type]);
	$ve->add('UID', $event['uid']);

	// set DTSTAMP according to RFC 5545, 3.8.7.2.
	$dtstamp = !empty($event['changed']) && !empty($this->method) ? $event['changed'] : new DateTime();
	$ve->add($this->datetime_prop('DTSTAMP', $dtstamp, true));

	// all-day events end the next day
	if ($event['allday'] && !empty($event['end'])) {
	$event['end'] = clone $event['end'];
	$event['end']->add(new \DateInterval('P1D'));
	$event['end']->_dateonly = true;
	}
	if (!empty($event['created']))
	$ve->add($this->datetime_prop('CREATED', $event['created'], true));
	if (!empty($event['changed']))
	$ve->add($this->datetime_prop('LAST-MODIFIED', $event['changed'], true));
	if (!empty($event['start']))
	$ve->add($this->datetime_prop('DTSTART', $event['start'], false, (bool)$event['allday']));
	if (!empty($event['end']))
	$ve->add($this->datetime_prop('DTEND', $event['end'], false, (bool)$event['allday']));
	if (!empty($event['due']))
	$ve->add($this->datetime_prop('DUE', $event['due'], false));

	if ($recurrence_id)
	$ve->add($recurrence_id);

	$ve->add('SUMMARY', $event['title']);

	if ($event['location'])
	$ve->add($this->is_apple() ? new vobject_location_property('LOCATION', $event['location']) : new VObject\Property('LOCATION', $event['location']));
	if ($event['description'])
	$ve->add('DESCRIPTION', strtr($event['description'], array("\r\n" => "\n", "\r" => "\n"))); // normalize line endings

	if (isset($event['sequence']))
	$ve->add('SEQUENCE', $event['sequence']);

	if ($event['recurrence'] && !$recurrence_id) {
	if ($exdates = $event['recurrence']['EXDATE']) {
	unset($event['recurrence']['EXDATE']); // don't serialize EXDATEs into RRULE value
	}
	if ($rdates = $event['recurrence']['RDATE']) {
	unset($event['recurrence']['RDATE']); // don't serialize RDATEs into RRULE value
	}

	if ($event['recurrence']['FREQ']) {
	$ve->add('RRULE', libcalendaring::to_rrule($event['recurrence']));
	}

	// add EXDATEs each one per line (for Thunderbird Lightning)
	if ($exdates) {
	foreach ($exdates as $ex) {
	if ($ex instanceof \DateTime) {
	$exd = clone $event['start'];
	$exd->setDate($ex->format('Y'), $ex->format('n'), $ex->format('j'));
	$exd->setTimeZone(new \DateTimeZone('UTC'));
	$ve->add(new VObject\Property('EXDATE', $exd->format('Ymd\\THis\\Z')));
	}
	}
	}
	// add RDATEs
	if (!empty($rdates)) {
	$sample = $this->datetime_prop('RDATE', $rdates[0]);
	$rdprop = new VObject\Property\MultiDateTime('RDATE', null);
	$rdprop->setDateTimes($rdates, $sample->getDateType());
	$ve->add($rdprop);
	}
	}

	if ($event['categories']) {
	$cat = VObject\Property::create('CATEGORIES');
	$cat->setParts((array)$event['categories']);
	$ve->add($cat);
	}

	if (!empty($event['free_busy'])) {
	$ve->add('TRANSP', $event['free_busy'] == 'free' ? 'TRANSPARENT' : 'OPAQUE');

	// for Outlook clients we provide the X-MICROSOFT-CDO-BUSYSTATUS property
	if (stripos($this->agent, 'outlook') !== false) {
	$ve->add('X-MICROSOFT-CDO-BUSYSTATUS', $event['free_busy'] == 'outofoffice' ? 'OOF' : strtoupper($event['free_busy']));
	}
	}

	if ($event['priority'])
	$ve->add('PRIORITY', $event['priority']);

	if ($event['cancelled'])
	$ve->add('STATUS', 'CANCELLED');
	else if ($event['free_busy'] == 'tentative')
	$ve->add('STATUS', 'TENTATIVE');
	else if ($event['complete'] == 100)
	$ve->add('STATUS', 'COMPLETED');
	else if (!empty($event['status']))
	$ve->add('STATUS', $event['status']);

	if (!empty($event['sensitivity']))
	$ve->add('CLASS', strtoupper($event['sensitivity']));

	if (!empty($event['complete'])) {
	$ve->add('PERCENT-COMPLETE', intval($event['complete']));
	// Apple iCal required the COMPLETED date to be set in order to consider a task complete
	if ($event['complete'] == 100)
	$ve->add($this->datetime_prop('COMPLETED', $event['changed'] ?: new DateTime('now - 1 hour'), true));
	}

	if ($event['valarms']) {
	foreach ($event['valarms'] as $alarm) {
	$va = VObject\Component::create('VALARM');
	$va->action = $alarm['action'];
	if ($alarm['trigger'] instanceof DateTime) {
	$va->add($this->datetime_prop('TRIGGER', $alarm['trigger'], true));
	}
	else {
	$va->add('TRIGGER', $alarm['trigger']);
	}

	if ($alarm['action'] == 'EMAIL') {
	foreach ((array)$alarm['attendees'] as $attendee) {
	$va->add('ATTENDEE', 'mailto:' . $attendee);
	}
	}
	if ($alarm['description']) {
	$va->add('DESCRIPTION', $alarm['description'] ?: $event['title']);
	}
	if ($alarm['summary']) {
	$va->add('SUMMARY', $alarm['summary']);
	}
	if ($alarm['duration']) {
	$va->add('DURATION', $alarm['duration']);
	$va->add('REPEAT', intval($alarm['repeat']));
	}
	if ($alarm['uri']) {
	$va->add('ATTACH', $alarm['uri'], array('VALUE' => 'URI'));
	}
	$ve->add($va);
	}
	}
	// legacy support
	else if ($event['alarms']) {
	$va = VObject\Component::create('VALARM');
	list($trigger, $va->action) = explode(':', $event['alarms']);
	$val = libcalendaring::parse_alarm_value($trigger);
	if ($val[3])
	$va->add('TRIGGER', $val[3]);
	else if ($val[0] instanceof DateTime)
	$va->add($this->datetime_prop('TRIGGER', $val[0]));
	$ve->add($va);
	}

	foreach ((array)$event['attendees'] as $attendee) {
	if ($attendee['role'] == 'ORGANIZER') {
	if (empty($event['organizer']))
	$event['organizer'] = $attendee;
	}
	else if (!empty($attendee['email'])) {
	if (isset($attendee['rsvp']))
	$attendee['rsvp'] = $attendee['rsvp'] ? 'TRUE' : 'FALSE';
	$ve->add('ATTENDEE', 'mailto:' . $attendee['email'], array_filter(self::map_keys($attendee, $this->attendee_keymap)));
	}
	}

	if ($event['organizer']) {
	$ve->add('ORGANIZER', 'mailto:' . $event['organizer']['email'], self::map_keys($event['organizer'], array('name' => 'CN')));
	}

	foreach ((array)$event['url'] as $url) {
	if (!empty($url)) {
	$ve->add('URL', $url);
	}
	}

	if (!empty($event['parent_id'])) {
	$ve->add('RELATED-TO', $event['parent_id'], array('RELTYPE' => 'PARENT'));
	}

	if ($event['comment'])
	$ve->add('COMMENT', $event['comment']);

	$memory_limit = parse_bytes(ini_get('memory_limit'));

	// export attachments
	if (!empty($event['attachments'])) {
	foreach ((array)$event['attachments'] as $attach) {
	// check available memory and skip attachment export if we can't buffer it
	// @todo: use rcube_utils::mem_check()
	if (is_callable($get_attachment) && $memory_limit > 0 && ($memory_used = function_exists('memory_get_usage') ? memory_get_usage() : 1610241024)
	&& $attach['size'] && $memory_used + $attach['size'] * 3 > $memory_limit) {
	continue;
	}
	// embed attachments using the given callback function
	if (is_callable($get_attachment) && ($data = call_user_func($get_attachment, $attach['id'], $event))) {
	// embed attachments for iCal
	$ve->add('ATTACH',
	base64_encode($data),
	array_filter(array('VALUE' => 'BINARY', 'ENCODING' => 'BASE64', 'FMTTYPE' => $attach['mimetype'], 'X-LABEL' => $attach['name'])));
	unset($data); // attempt to free memory
	}
	// list attachments as absolute URIs
	else if (!empty($this->attach_uri)) {
	$ve->add('ATTACH',
	strtr($this->attach_uri, array(
	'{{id}}' => urlencode($attach['id']),
	'{{name}}' => urlencode($attach['name']),
	'{{mimetype}}' => urlencode($attach['mimetype']),
	)),
	array('FMTTYPE' => $attach['mimetype'], 'VALUE' => 'URI'));
	}
	}
	}

	foreach ((array)$event['links'] as $uri) {
	$ve->add('ATTACH', $uri);
	}

	// add custom properties
	foreach ((array)$event['x-custom'] as $prop) {
	$ve->add($prop[0], $prop[1]);
	}

	// append to vcalendar container
	if ($vcal) {
	$vcal->add($ve);
	}
	else { // serialize and send to stdout
	echo $ve->serialize();
	}

	// append recurrence exceptions
	if (is_array($event['recurrence']) && $event['recurrence']['EXCEPTIONS']) {
	foreach ($event['recurrence']['EXCEPTIONS'] as $ex) {
	- $exdate = clone $event['start'];
	- $exdate->setDate($ex['start']->format('Y'), $ex['start']->format('n'), $ex['start']->format('j'));
	- $recurrence_id = $this->datetime_prop('RECURRENCE-ID', $exdate, true);
	- // if ($ex['thisandfuture']) // not supported by any client :-(
	- // $recurrence_id->add('RANGE', 'THISANDFUTURE');
	+ $exdate = $ex['recurrence_date'] ?: $ex['start'];
	+ $recurrence_id = $this->datetime_prop('RECURRENCE-ID', $exdate, false, (bool)$event['allday']);
	+ if ($ex['thisandfuture'])
	+ $recurrence_id->add('RANGE', 'THISANDFUTURE');
	$this->_to_ical($ex, $vcal, $get_attachment, $recurrence_id);
	}
	}
	}

	/**
	* Returns a VTIMEZONE component for a Olson timezone identifier
	* with daylight transitions covering the given date range.
	*
	* @param string Timezone ID as used in PHP's Date functions
	* @param integer Unix timestamp with first date/time in this timezone
	* @param integer Unix timestap with last date/time in this timezone
	*
	* @return mixed A Sabre\VObject\Component object representing a VTIMEZONE definition
	* or false if no timezone information is available
	*/
	public static function get_vtimezone($tzid, $from = 0, $to = 0)
	{
	if (!$from) $from = time();
	if (!$to) $to = $from;

	if (is_string($tzid)) {
	try {
	$tz = new \DateTimeZone($tzid);
	}
	catch (\Exception $e) {
	return false;
	}
	}
	else if (is_a($tzid, '\\DateTimeZone')) {
	$tz = $tzid;
	}

	if (!is_a($tz, '\\DateTimeZone')) {
	return false;
	}

	$year = 86400 * 360;
	$transitions = $tz->getTransitions($from - $year, $to + $year);

	$vt = new VObject\Component('VTIMEZONE');
	$vt->TZID = $tz->getName();

	$std = null; $dst = null;
	foreach ($transitions as $i => $trans) {
	$cmp = null;

	if ($i == 0) {
	$tzfrom = $trans['offset'] / 3600;
	continue;
	}

	if ($trans['isdst']) {
	$t_dst = $trans['ts'];
	$dst = new VObject\Component('DAYLIGHT');
	$cmp = $dst;
	}
	else {
	$t_std = $trans['ts'];
	$std = new VObject\Component('STANDARD');
	$cmp = $std;
	}

	if ($cmp) {
	$dt = new DateTime($trans['time']);
	$offset = $trans['offset'] / 3600;

	$cmp->DTSTART = $dt->format('Ymd\THis');
	$cmp->TZOFFSETFROM = sprintf('%s%02d%02d', $tzfrom >= 0 ? '+' : '', floor($tzfrom), ($tzfrom - floor($tzfrom)) * 60);
	$cmp->TZOFFSETTO = sprintf('%s%02d%02d', $offset >= 0 ? '+' : '', floor($offset), ($offset - floor($offset)) * 60);

	if (!empty($trans['abbr'])) {
	$cmp->TZNAME = $trans['abbr'];
	}

	$tzfrom = $offset;
	$vt->add($cmp);
	}

	// we covered the entire date range
	if ($std && $dst && min($t_std, $t_dst) < $from && max($t_std, $t_dst) > $to) {
	break;
	}
	}

	// add X-MICROSOFT-CDO-TZID if available
	$microsoftExchangeMap = array_flip(VObject\TimeZoneUtil::$microsoftExchangeMap);
	if (array_key_exists($tz->getName(), $microsoftExchangeMap)) {
	$vt->add('X-MICROSOFT-CDO-TZID', $microsoftExchangeMap[$tz->getName()]);
	}

	return $vt;
	}


	/* Implement PHP 5 Iterator interface to make foreach work */

	function current()
	{
	return $this->objects[$this->iteratorkey];
	}

	function key()
	{
	return $this->iteratorkey;
	}

	function next()
	{
	$this->iteratorkey++;

	// read next chunk if we're reading from a file
	if (!$this->objects[$this->iteratorkey] && $this->fp) {
	$this->_parse_next(true);
	}

	return $this->valid();
	}

	function rewind()
	{
	$this->iteratorkey = 0;
	}

	function valid()
	{
	return !empty($this->objects[$this->iteratorkey]);
	}

	}


	/**
	* Override Sabre\VObject\Property that quotes commas in the location property
	* because Apple clients treat that property as list.
	*/
	class vobject_location_property extends VObject\Property
	{
	/**
	* Turns the object back into a serialized blob.
	*
	* @return string
	*/
	public function serialize()
	{
	$str = $this->name;

	foreach ($this->parameters as $param) {
	$str.=';' . $param->serialize();
	}

	$src = array(
	'\\',
	"\n",
	',',
	);
	$out = array(
	'\\\\',
	'\n',
	'\,',
	);
	$str.=':' . str_replace($src, $out, $this->value);

	$out = '';
	while (strlen($str) > 0) {
	if (strlen($str) > 75) {
	$out.= mb_strcut($str, 0, 75, 'utf-8') . "\r\n";
	$str = ' ' . mb_strcut($str, 75, strlen($str), 'utf-8');
	} else {
	$out.= $str . "\r\n";
	$str = '';
	break;
	}
	}

	return $out;
	}
	}
	diff --git a/plugins/libcalendaring/tests/libvcalendar.php b/plugins/libcalendaring/tests/libvcalendar.php
	index 9e2f03bf..f8b0d857 100644
	--- a/plugins/libcalendaring/tests/libvcalendar.php
	+++ b/plugins/libcalendaring/tests/libvcalendar.php
	@@ -1,538 +1,539 @@
	<?php

	/**
	* libcalendaring plugin's iCalendar functions tests
	*
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2013, 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 libvcalendar_test extends PHPUnit_Framework_TestCase
	{
	function setUp()
	{
	require_once __DIR__ . '/../libvcalendar.php';
	require_once __DIR__ . '/../libcalendaring.php';
	}

	/**
	* Simple iCal parsing test
	*/
	function test_import()
	{
	$ical = new libvcalendar();
	$ics = file_get_contents(__DIR__ . '/resources/snd.ics');
	$events = $ical->import($ics, 'UTF-8');

	$this->assertEquals(1, count($events));
	$event = $events[0];

	$this->assertInstanceOf('DateTime', $event['created'], "'created' property is DateTime object");
	$this->assertInstanceOf('DateTime', $event['changed'], "'changed' property is DateTime object");
	$this->assertEquals('UTC', $event['created']->getTimezone()->getName(), "'created' date is in UTC");

	$this->assertInstanceOf('DateTime', $event['start'], "'start' property is DateTime object");
	$this->assertInstanceOf('DateTime', $event['end'], "'end' property is DateTime object");
	$this->assertEquals('08-01', $event['start']->format('m-d'), "Start date is August 1st");
	$this->assertTrue($event['allday'], "All-day event flag");

	$this->assertEquals('B968B885-08FB-40E5-B89E-6DA05F26AA79', $event['uid'], "Event UID");
	$this->assertEquals('Swiss National Day', $event['title'], "Event title");
	$this->assertEquals('http://en.wikipedia.org/wiki/Swiss_National_Day', $event['url'], "URL property");
	$this->assertEquals(2, $event['sequence'], "Sequence number");

	$desclines = explode("\n", $event['description']);
	$this->assertEquals(4, count($desclines), "Multiline description");
	$this->assertEquals("French: Fête nationale Suisse", rtrim($desclines[1]), "UTF-8 encoding");
	}

	/**
	* Test parsing from files
	*/
	function test_import_from_file()
	{
	$ical = new libvcalendar();

	$events = $ical->import_from_file(__DIR__ . '/resources/multiple.ics', 'UTF-8');
	$this->assertEquals(2, count($events));

	$events = $ical->import_from_file(__DIR__ . '/resources/invalid.txt', 'UTF-8');
	$this->assertEmpty($events);
	}

	/**
	* Test parsing from files with multiple VCALENDAR blocks (#2884)
	*/
	function test_import_from_file_multiple()
	{
	$ical = new libvcalendar();
	$ical->fopen(__DIR__ . '/resources/multiple-rdate.ics', 'UTF-8');
	$events = array();
	foreach ($ical as $event) {
	$events[] = $event;
	}

	$this->assertEquals(2, count($events));
	$this->assertEquals("AAAA6A8C3CCE4EE2C1257B5C00FFFFFF-Lotus_Notes_Generated", $events[0]['uid']);
	$this->assertEquals("AAAA1C572093EC3FC125799C004AFFFF-Lotus_Notes_Generated", $events[1]['uid']);
	}

	function test_invalid_dates()
	{
	$ical = new libvcalendar();
	$events = $ical->import_from_file(__DIR__ . '/resources/invalid-dates.ics', 'UTF-8');
	$event = $events[0];

	$this->assertEquals(1, count($events), "Import event data");
	$this->assertFalse(array_key_exists('created', $event), "No created date field");
	$this->assertFalse(array_key_exists('changed', $event), "No changed date field");
	}

	function test_invalid_vevent()
	{
	$this->setExpectedException('\Sabre\VObject\ParseException');

	$ical = new libvcalendar();
	$events = $ical->import_from_file(__DIR__ . '/resources/invalid-event.ics', 'UTF-8', true);
	}

	/**
	* Test some extended ical properties such as attendees, recurrence rules, alarms and attachments
	*
	* @depends test_import_from_file
	*/
	function test_extended()
	{
	$ical = new libvcalendar();

	$events = $ical->import_from_file(__DIR__ . '/resources/itip.ics', 'UTF-8');
	$event = $events[0];
	$this->assertEquals('REQUEST', $ical->method, "iTip method");

	// attendees
	$this->assertEquals(2, count($event['attendees']), "Attendees list (including organizer)");
	$organizer = $event['attendees'][0];
	$this->assertEquals('ORGANIZER', $organizer['role'], 'Organizer ROLE');
	$this->assertEquals('Rolf Test', $organizer['name'], 'Organizer name');

	$attendee = $event['attendees'][1];
	$this->assertEquals('REQ-PARTICIPANT', $attendee['role'], 'Attendee ROLE');
	$this->assertEquals('NEEDS-ACTION', $attendee['status'], 'Attendee STATUS');
	$this->assertEquals('rolf2@mykolab.com', $attendee['email'], 'Attendee mailto:');
	$this->assertTrue($attendee['rsvp'], 'Attendee RSVP');

	// attachments
	$this->assertEquals(1, count($event['attachments']), "Embedded attachments");
	$attachment = $event['attachments'][0];
	$this->assertEquals('text/html', $attachment['mimetype'], "Attachment mimetype attribute");
	$this->assertEquals('calendar.html', $attachment['name'], "Attachment filename (X-LABEL) attribute");
	$this->assertContains('<title>Kalender</title>', $attachment['data'], "Attachment content (decoded)");

	// recurrence rules
	$events = $ical->import_from_file(__DIR__ . '/resources/recurring.ics', 'UTF-8');
	$event = $events[0];

	$this->assertTrue(is_array($event['recurrence']), 'Recurrences rule as hash array');
	$rrule = $event['recurrence'];
	$this->assertEquals('MONTHLY', $rrule['FREQ'], "Recurrence frequency");
	$this->assertEquals('1', $rrule['INTERVAL'], "Recurrence interval");
	$this->assertEquals('3WE', $rrule['BYDAY'], "Recurrence frequency");
	$this->assertInstanceOf('DateTime', $rrule['UNTIL'], "Recurrence end date");

	$this->assertEquals(2, count($rrule['EXDATE']), "Recurrence EXDATEs");
	$this->assertInstanceOf('DateTime', $rrule['EXDATE'][0], "Recurrence EXDATE as DateTime");

	// categories, class
	$this->assertEquals('libcalendaring tests', join(',', (array)$event['categories']), "Event categories");
	$this->assertEquals('confidential', $event['sensitivity'], "Class/sensitivity = confidential");

	// parse a reccuence chain instance
	$events = $ical->import_from_file(__DIR__ . '/resources/recurrence-id.ics', 'UTF-8');
	$this->assertEquals(1, count($events), "Fall back to Component::getComponents() when getBaseComponents() is empty");
	$this->assertInstanceOf('DateTime', $events[0]['recurrence_date'], "Recurrence-ID as date");
	+ $this->assertTrue($events[0]['thisandfuture'], "Range=THISANDFUTURE");
	}

	/**
	*
	*/
	function test_alarms()
	{
	$ical = new libvcalendar();

	$events = $ical->import_from_file(__DIR__ . '/resources/recurring.ics', 'UTF-8');
	$event = $events[0];

	$this->assertEquals('-12H:DISPLAY', $event['alarms'], "Serialized alarms string");
	$alarm = libcalendaring::parse_alarm_value($event['alarms']);
	$this->assertEquals('12', $alarm[0], "Alarm value");
	$this->assertEquals('-H', $alarm[1], "Alarm unit");

	$this->assertEquals('DISPLAY', $event['valarms'][0]['action'], "Full alarm item (action)");
	$this->assertEquals('-PT12H', $event['valarms'][0]['trigger'], "Full alarm item (trigger)");

	// alarm trigger with 0 values
	$events = $ical->import_from_file(__DIR__ . '/resources/alarms.ics', 'UTF-8');
	$event = $events[0];

	$this->assertEquals('-30M:DISPLAY', $event['alarms'], "Stripped alarm string");
	$alarm = libcalendaring::parse_alarm_value($event['alarms']);
	$this->assertEquals('30', $alarm[0], "Alarm value");
	$this->assertEquals('-M', $alarm[1], "Alarm unit");
	$this->assertEquals('-30M', $alarm[2], "Alarm string");
	$this->assertEquals('-PT30M', $alarm[3], "Unified alarm string (stripped zero-values)");

	$this->assertEquals('DISPLAY', $event['valarms'][0]['action'], "First alarm action");
	$this->assertEquals('This is the first event reminder', $event['valarms'][0]['description'], "First alarm text");

	$this->assertEquals(2, count($event['valarms']), "List all VALARM blocks");

	$valarm = $event['valarms'][1];
	$this->assertEquals(1, count($valarm['attendees']), "Email alarm attendees");
	$this->assertEquals('EMAIL', $valarm['action'], "Second alarm item (action)");
	$this->assertEquals('-P1D', $valarm['trigger'], "Second alarm item (trigger)");
	$this->assertEquals('This is the reminder message', $valarm['summary'], "Email alarm text");

	// test alarms export
	$ics = $ical->export(array($event));
	$this->assertContains('ACTION:DISPLAY', $ics, "Display alarm block");
	$this->assertContains('ACTION:EMAIL', $ics, "Email alarm block");
	$this->assertContains('DESCRIPTION:This is the first event reminder', $ics, "Alarm description");
	$this->assertContains('SUMMARY:This is the reminder message', $ics, "Email alarm summary");
	$this->assertContains('ATTENDEE:mailto:reminder-recipient@example.org', $ics, "Email alarm recipient");
	}

	/**
	* @depends test_import_from_file
	*/
	function test_attachment()
	{
	$ical = new libvcalendar();

	$events = $ical->import_from_file(__DIR__ . '/resources/attachment.ics', 'UTF-8');
	$event = $events[0];

	$this->assertEquals(2, count($events));
	$this->assertEquals(1, count($event['attachments']));
	$this->assertEquals('image/png', $event['attachments'][0]['mimetype']);
	$this->assertEquals('500px-Opensource.svg.png', $event['attachments'][0]['name']);
	}

	/**
	* @depends test_import
	*/
	function test_apple_alarms()
	{
	$ical = new libvcalendar();
	$events = $ical->import_from_file(__DIR__ . '/resources/apple-alarms.ics', 'UTF-8');
	$event = $events[0];

	// alarms
	$this->assertEquals('-45M:AUDIO', $event['alarms'], "Relative alarm string");
	$alarm = libcalendaring::parse_alarm_value($event['alarms']);
	$this->assertEquals('45', $alarm[0], "Alarm value");
	$this->assertEquals('-M', $alarm[1], "Alarm unit");

	$this->assertEquals(1, count($event['valarms']), "Ignore invalid alarm blocks");
	$this->assertEquals('AUDIO', $event['valarms'][0]['action'], "Full alarm item (action)");
	$this->assertEquals('-PT45M', $event['valarms'][0]['trigger'], "Full alarm item (trigger)");
	$this->assertEquals('Basso', $event['valarms'][0]['uri'], "Full alarm item (attachment)");
	}

	/**
	*
	*/
	function test_escaped_values()
	{
	$ical = new libvcalendar();
	$events = $ical->import_from_file(__DIR__ . '/resources/escaped.ics', 'UTF-8');
	$event = $events[0];

	$this->assertEquals("House, Street, Zip Place", $event['location'], "Decode escaped commas in location value");
	$this->assertEquals("Me, meets Them\nThem, meet Me", $event['description'], "Decode description value");
	$this->assertEquals("Kolab, Thomas", $event['attendees'][3]['name'], "Unescaped");

	$ics = $ical->export($events);
	$this->assertContains('ATTENDEE;CN="Kolab, Thomas";PARTSTAT=', $ics, "Quoted attendee parameters");
	}

	/**
	* Parse RDATE properties (#2885)
	*/
	function test_rdate()
	{
	$ical = new libvcalendar();
	$events = $ical->import_from_file(__DIR__ . '/resources/multiple-rdate.ics', 'UTF-8');
	$event = $events[0];

	$this->assertEquals(9, count($event['recurrence']['RDATE']));
	$this->assertInstanceOf('DateTime', $event['recurrence']['RDATE'][0]);
	}

	/**
	* @depends test_import
	*/
	function test_freebusy()
	{
	$ical = new libvcalendar();
	$ical->import_from_file(__DIR__ . '/resources/freebusy.ifb', 'UTF-8');
	$freebusy = $ical->freebusy;

	$this->assertInstanceOf('DateTime', $freebusy['start'], "'start' property is DateTime object");
	$this->assertInstanceOf('DateTime', $freebusy['end'], "'end' property is DateTime object");
	$this->assertEquals(11, count($freebusy['periods']), "Number of freebusy periods defined");
	$this->assertEquals(9, count($ical->get_busy_periods()), "Number of busy periods found");
	}

	/**
	* @depends test_import
	*/
	function test_freebusy_dummy()
	{
	$ical = new libvcalendar();
	$ical->import_from_file(__DIR__ . '/resources/dummy.ifb', 'UTF-8');
	$freebusy = $ical->freebusy;

	$this->assertEquals(0, count($freebusy['periods']), "Ignore 0-length freebudy periods");
	$this->assertContains('dummy', $freebusy['comment'], "Parse comment");
	}

	function test_vtodo()
	{
	$ical = new libvcalendar();
	$tasks = $ical->import_from_file(__DIR__ . '/resources/vtodo.ics', 'UTF-8', true);
	$task = $tasks[0];

	$this->assertInstanceOf('DateTime', $task['start'], "'start' property is DateTime object");
	$this->assertInstanceOf('DateTime', $task['due'], "'due' property is DateTime object");
	$this->assertEquals('-1D:DISPLAY', $task['alarms'], "Taks alarm value");
	$this->assertEquals('IN-PROCESS', $task['status'], "Task status property");
	$this->assertEquals(1, count($task['x-custom']), "Custom properties");
	$this->assertEquals(4, count($task['categories']));
	$this->assertEquals('1234567890-12345678-PARENT', $task['parent_id'], "Parent Relation");
	}

	/**
	* Test for iCal export from internal hash array representation
	*
	*
	*/
	function test_export()
	{
	$ical = new libvcalendar();

	$events = $ical->import_from_file(__DIR__ . '/resources/itip.ics', 'UTF-8');
	$event = $events[0];
	$events = $ical->import_from_file(__DIR__ . '/resources/recurring.ics', 'UTF-8');
	$event += $events[0];

	$this->attachment_data = $event['attachments'][0]['data'];
	unset($event['attachments'][0]['data']);
	$event['attachments'][0]['id'] = '1';
	$event['description'] = 'Exported by libvcalendar';

	$event['start']->setTimezone(new DateTimezone('Europe/Berlin'));
	$event['end']->setTimezone(new DateTimezone('Europe/Berlin'));

	$ics = $ical->export(array($event), 'REQUEST', false, array($this, 'get_attachment_data'), true);

	$this->assertContains('BEGIN:VCALENDAR', $ics, "VCALENDAR encapsulation BEGIN");

	$this->assertContains('BEGIN:VTIMEZONE', $ics, "VTIMEZONE encapsulation BEGIN");
	$this->assertContains('TZID:Europe/Berlin', $ics, "Timezone ID");
	$this->assertContains('TZOFFSETFROM:+0100', $ics, "Timzone transition FROM");
	$this->assertContains('TZOFFSETTO:+0200', $ics, "Timzone transition TO");
	$this->assertContains('END:VTIMEZONE', $ics, "VTIMEZONE encapsulation END");

	$this->assertContains('BEGIN:VEVENT', $ics, "VEVENT encapsulation BEGIN");
	$this->assertContains('UID:ac6b0aee-2519-4e5c-9a25-48c57064c9f0', $ics, "Event UID");
	$this->assertContains('SEQUENCE:' . $event['sequence'], $ics, "Export Sequence number");
	$this->assertContains('CLASS:CONFIDENTIAL', $ics, "Sensitivity => Class");
	$this->assertContains('DESCRIPTION:*Exported by', $ics, "Export Description");
	$this->assertContains('ORGANIZER;CN=Rolf Test:mailto:rolf@', $ics, "Export organizer");
	$this->assertRegExp('/ATTENDEE.*;ROLE=REQ-PARTICIPANT/', $ics, "Export Attendee ROLE");
	$this->assertRegExp('/ATTENDEE.*;PARTSTAT=NEEDS-ACTION/', $ics, "Export Attendee Status");
	$this->assertRegExp('/ATTENDEE.*;RSVP=TRUE/', $ics, "Export Attendee RSVP");
	$this->assertRegExp('/ATTENDEE.*:mailto:rolf2@/', $ics, "Export Attendee mailto:");

	$rrule = $event['recurrence'];
	$this->assertRegExp('/RRULE:.*FREQ='.$rrule['FREQ'].'/', $ics, "Export Recurrence Frequence");
	$this->assertRegExp('/RRULE:.*INTERVAL='.$rrule['INTERVAL'].'/', $ics, "Export Recurrence Interval");
	$this->assertRegExp('/RRULE:.*UNTIL=20140718T215959Z/', $ics, "Export Recurrence End date");
	$this->assertRegExp('/RRULE:.*BYDAY='.$rrule['BYDAY'].'/', $ics, "Export Recurrence BYDAY");
	$this->assertRegExp('/EXDATE.*:20131218/', $ics, "Export Recurrence EXDATE");

	$this->assertContains('BEGIN:VALARM', $ics, "Export VALARM");
	$this->assertContains('TRIGGER:-PT12H', $ics, "Export Alarm trigger");

	$this->assertRegExp('/ATTACH.*;VALUE=BINARY/', $ics, "Embed attachment");
	$this->assertRegExp('/ATTACH.*;ENCODING=BASE64/', $ics, "Attachment B64 encoding");
	$this->assertRegExp('!ATTACH.*;FMTTYPE=text/html!', $ics, "Attachment mimetype");
	$this->assertRegExp('!ATTACH.*;X-LABEL=calendar.html!', $ics, "Attachment filename with X-LABEL");

	$this->assertContains('END:VEVENT', $ics, "VEVENT encapsulation END");
	$this->assertContains('END:VCALENDAR', $ics, "VCALENDAR encapsulation END");
	}

	/**
	* @depends test_extended
	* @depends test_export
	*/
	function test_export_multiple()
	{
	$ical = new libvcalendar();
	$events = array_merge(
	$ical->import_from_file(__DIR__ . '/resources/snd.ics', 'UTF-8'),
	$ical->import_from_file(__DIR__ . '/resources/multiple.ics', 'UTF-8')
	);

	$num = count($events);
	$ics = $ical->export($events, null, false);

	$this->assertContains('BEGIN:VCALENDAR', $ics, "VCALENDAR encapsulation BEGIN");
	$this->assertContains('END:VCALENDAR', $ics, "VCALENDAR encapsulation END");
	$this->assertEquals($num, substr_count($ics, 'BEGIN:VEVENT'), "VEVENT encapsulation BEGIN");
	$this->assertEquals($num, substr_count($ics, 'END:VEVENT'), "VEVENT encapsulation END");
	}

	/**
	* @depends test_export
	*/
	function test_export_recurrence_exceptions()
	{
	$ical = new libvcalendar();
	$events = $ical->import_from_file(__DIR__ . '/resources/recurring.ics', 'UTF-8');

	// add exceptions
	$event = $events[0];
	$exception1 = $event;
	$exception1['start'] = clone $event['start'];
	$exception1['start']->setDate(2013, 8, 14);
	$exception1['end'] = clone $event['end'];
	$exception1['end']->setDate(2013, 8, 14);

	$exception2 = $event;
	$exception2['start'] = clone $event['start'];
	$exception2['start']->setDate(2013, 11, 13);
	$exception2['end'] = clone $event['end'];
	$exception2['end']->setDate(2013, 11, 13);
	$exception2['title'] = 'Recurring Exception';

	$events[0]['recurrence']['EXCEPTIONS'] = array($exception1, $exception2);

	$ics = $ical->export($events, null, false);

	$num = count($events[0]['recurrence']['EXCEPTIONS']) + 1;
	$this->assertEquals($num, substr_count($ics, 'BEGIN:VEVENT'), "VEVENT encapsulation BEGIN");
	$this->assertEquals($num, substr_count($ics, 'UID:'.$event['uid']), "Recurrence Exceptions with same UID");
	$this->assertEquals($num, substr_count($ics, 'END:VEVENT'), "VEVENT encapsulation END");

	$this->assertContains('RECURRENCE-ID;VALUE=DATE-TIME:20130814', $ics, "Recurrence-ID (1) being the exception date");
	$this->assertContains('RECURRENCE-ID;VALUE=DATE-TIME:20131113', $ics, "Recurrence-ID (2) being the exception date");
	$this->assertContains('SUMMARY:'.$exception2['title'], $ics, "Exception title");
	}

	/**
	*
	*/
	function test_export_rdate()
	{
	$ical = new libvcalendar();
	$events = $ical->import_from_file(__DIR__ . '/resources/multiple-rdate.ics', 'UTF-8');
	$ics = $ical->export($events, null, false);

	$this->assertContains('RDATE;VALUE=DATE-TIME:20140520T020000Z', $ics, "VALUE=PERIOD is translated into single DATE-TIME values");
	}

	/**
	* @depends test_export
	*/
	function test_export_direct()
	{
	$ical = new libvcalendar();
	$events = $ical->import_from_file(__DIR__ . '/resources/multiple.ics', 'UTF-8');
	$num = count($events);

	ob_start();
	$return = $ical->export($events, null, true);
	$output = ob_get_contents();
	ob_end_clean();

	$this->assertTrue($return, "Return true on successful writing");
	$this->assertContains('BEGIN:VCALENDAR', $output, "VCALENDAR encapsulation BEGIN");
	$this->assertContains('END:VCALENDAR', $output, "VCALENDAR encapsulation END");
	$this->assertEquals($num, substr_count($output, 'BEGIN:VEVENT'), "VEVENT encapsulation BEGIN");
	$this->assertEquals($num, substr_count($output, 'END:VEVENT'), "VEVENT encapsulation END");
	}

	function test_datetime()
	{
	$ical = new libvcalendar();
	$localtime = $ical->datetime_prop('DTSTART', new DateTime('2013-09-01 12:00:00', new DateTimeZone('Europe/Berlin')));
	$localdate = $ical->datetime_prop('DTSTART', new DateTime('2013-09-01', new DateTimeZone('Europe/Berlin')), false, true);
	$utctime = $ical->datetime_prop('DTSTART', new DateTime('2013-09-01 12:00:00', new DateTimeZone('UTC')));
	$asutctime = $ical->datetime_prop('DTSTART', new DateTime('2013-09-01 12:00:00', new DateTimeZone('Europe/Berlin')), true);

	$this->assertContains('TZID=Europe/Berlin', $localtime->serialize());
	$this->assertContains('VALUE=DATE', $localdate->serialize());
	$this->assertContains('20130901T120000Z', $utctime->serialize());
	$this->assertContains('20130901T100000Z', $asutctime->serialize());
	}

	function test_get_vtimezone()
	{
	$vtz = libvcalendar::get_vtimezone('Europe/Berlin', strtotime('2014-08-22T15:00:00+02:00'));
	$this->assertInstanceOf('\Sabre\VObject\Component', $vtz, "VTIMEZONE is a Component object");
	$this->assertEquals('Europe/Berlin', $vtz->TZID);
	$this->assertEquals('4', $vtz->{'X-MICROSOFT-CDO-TZID'});

	// check for transition to daylight saving time which is BEFORE the given date
	$dst = reset($vtz->select('DAYLIGHT'));
	$this->assertEquals('DAYLIGHT', $dst->name);
	$this->assertEquals('20140330T010000', $dst->DTSTART);
	$this->assertEquals('+0100', $dst->TZOFFSETFROM);
	$this->assertEquals('+0200', $dst->TZOFFSETTO);
	$this->assertEquals('CEST', $dst->TZNAME);

	// check (last) transition to standard time which is AFTER the given date
	$std = end($vtz->select('STANDARD'));
	$this->assertEquals('STANDARD', $std->name);
	$this->assertEquals('20141026T010000', $std->DTSTART);
	$this->assertEquals('+0200', $std->TZOFFSETFROM);
	$this->assertEquals('+0100', $std->TZOFFSETTO);
	$this->assertEquals('CET', $std->TZNAME);

	// unknown timezone
	$vtz = libvcalendar::get_vtimezone('America/Foo Bar');
	$this->assertEquals(false, $vtz);

	// invalid input data
	$vtz = libvcalendar::get_vtimezone(new DateTime());
	$this->assertEquals(false, $vtz);

	// DateTimezone as input data
	$vtz = libvcalendar::get_vtimezone(new DateTimezone('Pacific/Chatham'));
	$this->assertInstanceOf('\Sabre\VObject\Component', $vtz);
	$this->assertContains('TZOFFSETFROM:+1245', $vtz->serialize());
	$this->assertContains('TZOFFSETTO:+1345', $vtz->serialize());
	}

	function get_attachment_data($id, $event)
	{
	return $this->attachment_data;
	}
	}

	diff --git a/plugins/libcalendaring/tests/resources/recurrence-id.ics b/plugins/libcalendaring/tests/resources/recurrence-id.ics
	index 41485f9d..8229da28 100644
	--- a/plugins/libcalendaring/tests/resources/recurrence-id.ics
	+++ b/plugins/libcalendaring/tests/resources/recurrence-id.ics
	@@ -1,31 +1,31 @@
	BEGIN:VCALENDAR
	VERSION:2.0
	PRODID:-//Lotus Development Corporation//NONSGML Notes 8.5.3//EN_C
	METHOD:REQUEST
	BEGIN:VTIMEZONE
	TZID:W. Europe
	BEGIN:STANDARD
	DTSTART:19501029T020000
	TZOFFSETFROM:+0200
	TZOFFSETTO:+0100
	RRULE:FREQ=YEARLY;BYMINUTE=0;BYHOUR=2;BYDAY=-1SU;BYMONTH=10
	END:STANDARD
	BEGIN:DAYLIGHT
	DTSTART:19500326T020000
	TZOFFSETFROM:+0100
	TZOFFSETTO:+0200
	RRULE:FREQ=YEARLY;BYMINUTE=0;BYHOUR=2;BYDAY=-1SU;BYMONTH=3
	END:DAYLIGHT
	END:VTIMEZONE
	BEGIN:VEVENT
	DTSTART;TZID="W. Europe":20140230T150000
	DTEND;TZID="W. Europe":20140230T163000
	TRANSP:OPAQUE
	RDATE;TZID="W. Europe";VALUE=PERIOD:20140227T140000/20140227T153000
	-RECURRENCE-ID:20140227T130000Z
	+RECURRENCE-ID;RANGE=THISANDFUTURE:20140227T130000Z
	SEQUENCE:0
	UID:7e93e8e8eef16f28aa33b78cd73613ebff
	DTSTAMP:20140120T105609Z
	SUMMARY:Invitation with Recurrence-ID
	END:VEVENT
	END:VCALENDAR
	diff --git a/plugins/libkolab/lib/kolab_format_event.php b/plugins/libkolab/lib/kolab_format_event.php
	index 8cad89a1..03b5dde1 100644
	--- a/plugins/libkolab/lib/kolab_format_event.php
	+++ b/plugins/libkolab/lib/kolab_format_event.php
	@@ -1,244 +1,273 @@
	<?php

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

	class kolab_format_event extends kolab_format_xcal
	{
	public $CTYPEv2 = 'application/x-vnd.kolab.event';

	public $scheduling_properties = array('start', 'end', 'allday', 'location', 'status', 'cancelled');

	protected $objclass = 'Event';
	protected $read_func = 'readEvent';
	protected $write_func = 'writeEvent';

	/**
	* Default constructor
	*/
	function __construct($data = null, $version = 3.0)
	{
	parent::__construct(is_string($data) ? $data : null, $version);

	// got an Event object as argument
	if (is_object($data) && is_a($data, $this->objclass)) {
	$this->obj = $data;
	$this->loaded = true;
	}
	}

	/**
	* Clones into an instance of libcalendaring's extended EventCal class
	*
	* @return mixed EventCal object or false on failure
	*/
	public function to_libcal()
	{
	static $error_logged = false;

	if (class_exists('kolabcalendaring')) {
	return new EventCal($this->obj);
	}
	else if (!$error_logged) {
	$error_logged = true;
	rcube::raise_error(array(
	'code' => 900, 'type' => 'php',
	'message' => "required kolabcalendaring module not found"
	), true);
	}

	return false;
	}

	/**
	* Set event properties to the kolabformat object
	*
	* @param array Event data as hash array
	*/
	public function set(&$object)
	{
	// set common xcal properties
	parent::set($object);

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

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

	// save recurrence exceptions
	- if (is_array($object['recurrence']) && $object['recurrence']['EXCEPTIONS']) {
	+ if (is_array($object['recurrence']) && is_array($object['recurrence']['EXCEPTIONS'])) {
	+ $recurrence_id_format = $object['allday'] ? 'Ymd' : 'Ymd\THis';
	$vexceptions = new vectorevent;
	foreach((array)$object['recurrence']['EXCEPTIONS'] as $i => $exception) {
	$exevent = new kolab_format_event;
	$exevent->set(($compacted = $this->compact_exception($exception, $object))); // only save differing values
	- $exevent->obj->setRecurrenceID(self::get_datetime($exception['start'], null, true), (bool)$exception['thisandfuture']);
	+
	+ // get value for recurrence-id
	+ if (!empty($exception['recurrence_date']) && is_a($exception['recurrence_date'], 'DateTime')) {
	+ $recurrence_id = $exception['recurrence_date'];
	+ $compacted['_instance'] = $recurrence_id->format($recurrence_id_format);
	+ }
	+ else if (!empty($exception['_instance']) && strlen($exception['_instance']) > 4) {
	+ $recurrence_id = rcube_utils::anytodatetime($exception['_instance'], $object['start']->getTimezone());
	+ $compacted['recurrence_date'] = $recurrence_id;
	+ }
	+ $exevent->obj->setRecurrenceID(self::get_datetime($recurrence_id ?: $exception['start'], null, $object['allday']), (bool)$exception['thisandfuture']);
	+
	$vexceptions->push($exevent->obj);
	+
	// write cleaned-up exception data back to memory/cache
	$object['recurrence']['EXCEPTIONS'][$i] = $this->expand_exception($compacted, $object);
	}
	$this->obj->setExceptions($vexceptions);
	}

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

	/**
	*
	*/
	public function is_valid()
	{
	return !$this->formaterror && (($this->data && !empty($this->data['start']) && !empty($this->data['end'])) \|\|
	(is_object($this->obj) && $this->obj->isValid() && $this->obj->uid()));
	}

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

	// read common xcal props
	$object = parent::to_array($data);

	// read object properties
	$object += array(
	'end' => self::php_datetime($this->obj->end()),
	'allday' => $this->obj->start()->isDateOnly(),
	'free_busy' => $this->obj->transparency() ? 'free' : 'busy', // TODO: transparency is only boolean
	'attendees' => array(),
	);

	// derive event end from duration (#1916)
	if (!$object['end'] && $object['start'] && ($duration = $this->obj->duration()) && $duration->isValid()) {
	$interval = new DateInterval('PT0S');
	$interval->d = $duration->weeks() * 7 + $duration->days();
	$interval->h = $duration->hours();
	$interval->i = $duration->minutes();
	$interval->s = $duration->seconds();
	$object['end'] = clone $object['start'];
	$object['end']->add($interval);
	}

	// organizer is part of the attendees list in Roundcube
	if ($object['organizer']) {
	$object['organizer']['role'] = 'ORGANIZER';
	array_unshift($object['attendees'], $object['organizer']);
	}

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

	// this is an exception object
	if ($this->obj->recurrenceID()->isValid()) {
	$object['thisandfuture'] = $this->obj->thisAndFuture();
	+ $object['recurrence_date'] = self::php_datetime($this->obj->recurrenceID());
	}
	// read exception event objects
	else if (($exceptions = $this->obj->exceptions()) && is_object($exceptions) && $exceptions->size()) {
	$recurrence_exceptions = array();
	+ $recurrence_id_format = $object['allday'] ? 'Ymd' : 'Ymd\THis';
	for ($i=0; $i < $exceptions->size(); $i++) {
	if (($exobj = $exceptions->get($i))) {
	$exception = new kolab_format_event($exobj);
	if ($exception->is_valid()) {
	- $recurrence_exceptions[] = $this->expand_exception($exception->to_array(), $object);
	+ $exdata = $exception->to_array();
	+
	+ // fix date-only recurrence ID saved by old versions
	+ if ($exdata['recurrence_date'] && $exdata['recurrence_date']->_dateonly && !$object['allday']) {
	+ $exdata['recurrence_date']->setTimezone($object['start']->getTimezone());
	+ $exdata['recurrence_date']->setTime($object['start']->format('G'), intval($object['start']->format('i')), intval($object['start']->format('s')));
	+ }
	+
	+ $recurrence_id = $exdata['recurrence_date'] ?: $exdata['start'];
	+ $exdata['_instance'] = $recurrence_id->format($recurrence_id_format);
	+ $recurrence_exceptions[] = $this->expand_exception($exdata, $object);
	}
	}
	}
	$object['recurrence']['EXCEPTIONS'] = $recurrence_exceptions;
	}

	return $this->data = $object;
	}

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

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

	return $tags;
	}

	/**
	* Remove some attributes from the exception container
	*/
	private function compact_exception($exception, $master)
	{
	- $forbidden = array('recurrence','organizer','attendees','sequence');
	+ $forbidden = array('recurrence','organizer','_attachments');

	- foreach ($forbidden as $prop) {
	- if (array_key_exists($prop, $exception)) {
	- unset($exception[$prop]);
	+ foreach ($forbidden as $prop) {
	+ if (array_key_exists($prop, $exception)) {
	+ unset($exception[$prop]);
	+ }
	}
	- }

	- foreach ($master as $prop => $value) {
	- if (isset($exception[$prop]) && gettype($exception[$prop]) == gettype($value) && $exception[$prop] == $value) {
	- unset($exception[$prop]);
	+ foreach ($master as $prop => $value) {
	+ if (isset($exception[$prop]) && gettype($exception[$prop]) == gettype($value) && $exception[$prop] == $value) {
	+ unset($exception[$prop]);
	+ }
	}
	- }

	- return $exception;
	+ return $exception;
	}

	/**
	* Copy attributes not specified by the exception from the master event
	*/
	private function expand_exception($exception, $master)
	{
	- foreach ($master as $prop => $value) {
	- if (empty($exception[$prop]) && !empty($value))
	- $exception[$prop] = $value;
	- }
	+ foreach ($master as $prop => $value) {
	+ if (empty($exception[$prop]) && !empty($value)) {
	+ $exception[$prop] = $value;
	+ if ($prop == 'recurrence') {
	+ unset($exception[$prop]['EXCEPTIONS']);
	+ }
	+ }
	+ }

	- return $exception;
	+ return $exception;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Feb 2, 3:00 PM (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 426942
Default Alt Text: (179 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions