No OneTemporary
Actions

Size

202 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/plugins/libcalendaring/libcalendaring.php b/plugins/libcalendaring/libcalendaring.php
	index 6a02b9e3..379bd945 100644
	--- a/plugins/libcalendaring/libcalendaring.php
	+++ b/plugins/libcalendaring/libcalendaring.php
	@@ -1,1532 +1,1551 @@
	<?php

	/**
	* Library providing common functions for calendaring plugins
	*
	* Provides utility functions for calendar-related modules such as
	* - alarms display and dismissal
	* - attachment handling
	* - recurrence computation and UI elements
	* - ical parsing and exporting
	* - itip scheduling protocol
	*
	* @version @package_version@
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2012-2015, 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 libcalendaring extends rcube_plugin
	{
	public $rc;
	public $timezone;
	public $gmt_offset;
	public $dst_active;
	public $timezone_offset;
	public $ical_parts = array();
	public $ical_message;

	public $defaults = array(
	'calendar_date_format' => "Y-m-d",
	'calendar_date_short' => "M-j",
	'calendar_date_long' => "F j Y",
	'calendar_date_agenda' => "l M-d",
	'calendar_time_format' => "H:m",
	'calendar_first_day' => 1,
	'calendar_first_hour' => 6,
	'calendar_date_format_sets' => array(
	'Y-m-d' => array('d M Y', 'm-d', 'l m-d'),
	'Y/m/d' => array('d M Y', 'm/d', 'l m/d'),
	'Y.m.d' => array('d M Y', 'm.d', 'l m.d'),
	'd-m-Y' => array('d M Y', 'd-m', 'l d-m'),
	'd/m/Y' => array('d M Y', 'd/m', 'l d/m'),
	'd.m.Y' => array('d M Y', 'd.m', 'l d.m'),
	'j.n.Y' => array('d M Y', 'd.m', 'l d.m'),
	'm/d/Y' => array('M d Y', 'm/d', 'l m/d'),
	),
	);

	private static $instance;

	private $mail_ical_parser;

	/**
	* Singleton getter to allow direct access from other plugins
	*/
	public static function get_instance()
	{
	if (!self::$instance) {
	self::$instance = new libcalendaring(rcube::get_instance()->plugins);
	self::$instance->init_instance();
	}

	return self::$instance;
	}

	/**
	* Initializes class properties
	*/
	public function init_instance()
	{
	$this->rc = rcube::get_instance();

	// set user's timezone
	try {
	$this->timezone = new DateTimeZone($this->rc->config->get('timezone', 'GMT'));
	}
	catch (Exception $e) {
	$this->timezone = new DateTimeZone('GMT');
	}

	$now = new DateTime('now', $this->timezone);

	$this->gmt_offset = $now->getOffset();
	$this->dst_active = $now->format('I');
	$this->timezone_offset = $this->gmt_offset / 3600 - $this->dst_active;

	$this->add_texts('localization/', false);
	}

	/**
	* Required plugin startup method
	*/
	public function init()
	{
	self::$instance = $this;

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

	// include client scripts and styles
	if ($this->rc->output) {
	// add hook to display alarms
	$this->add_hook('refresh', array($this, 'refresh'));
	$this->register_action('plugin.alarms', array($this, 'alarms_action'));
	$this->register_action('plugin.expand_attendee_group', array($this, 'expand_attendee_group'));
	}

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

	/**
	* Startup hook
	*/
	public function startup($args)
	{
	if ($this->rc->output && $this->rc->output->type == 'html') {
	$this->rc->output->set_env('libcal_settings', $this->load_settings());
	$this->include_script('libcalendaring.js');
	$this->include_stylesheet($this->local_skin_path() . '/libcal.css');

	$this->add_label(
	'itipaccepted', 'itiptentative', 'itipdeclined',
	'itipdelegated', 'expandattendeegroup', 'expandattendeegroupnodata',
	'statusorganizer', 'statusaccepted', 'statusdeclined',
	'statusdelegated', 'statusunknown', 'statusneeds-action',
	'statustentative', 'statuscompleted', 'statusin-process',
	'delegatedto', 'delegatedfrom', 'showmore'
	);
	}

	if ($args['task'] == 'mail') {
	if ($args['action'] == 'show' \|\| $args['action'] == 'preview') {
	$this->add_hook('message_load', array($this, 'mail_message_load'));
	}
	}
	}

	/**
	* Load iCalendar functions
	*/
	public static function get_ical()
	{
	$self = self::get_instance();
	require_once __DIR__ . '/libvcalendar.php';
	return new libvcalendar();
	}

	/**
	* Load iTip functions
	*/
	public static function get_itip($domain = 'libcalendaring')
	{
	$self = self::get_instance();
	require_once __DIR__ . '/lib/libcalendaring_itip.php';
	return new libcalendaring_itip($self, $domain);
	}

	/**
	* Load recurrence computation engine
	*/
	public static function get_recurrence()
	{
	$self = self::get_instance();
	require_once __DIR__ . '/lib/libcalendaring_recurrence.php';
	return new libcalendaring_recurrence($self);
	}

	/**
	* Shift dates into user's current timezone
	*
	* @param mixed Any kind of a date representation (DateTime object, string or unix timestamp)
	* @return object DateTime object in user's timezone
	*/
	public function adjust_timezone($dt, $dateonly = false)
	{
	if (is_numeric($dt))
	$dt = new DateTime('@'.$dt);
	else if (is_string($dt))
	$dt = rcube_utils::anytodatetime($dt);

	if ($dt instanceof DateTime && !($dt->_dateonly \|\| $dateonly)) {
	$dt->setTimezone($this->timezone);
	}

	return $dt;
	}


	/**
	*
	*/
	public function load_settings()
	{
	$this->date_format_defaults();

	$settings = array();
	$keys = array('date_format', 'time_format', 'date_short', 'date_long', 'date_agenda');

	foreach ($keys as $key) {
	$settings[$key] = (string)$this->rc->config->get('calendar_' . $key, $this->defaults['calendar_' . $key]);
	$settings[$key] = self::from_php_date_format($settings[$key]);
	}

	$settings['dates_long'] = $settings['date_long'];
	$settings['first_day'] = (int)$this->rc->config->get('calendar_first_day', $this->defaults['calendar_first_day']);
	$settings['timezone'] = $this->timezone_offset;
	$settings['dst'] = $this->dst_active;

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

	return $settings;
	}


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

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

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

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

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

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

	// handle task objects
	if ($event['_type'] == 'task' && is_object($event['due'])) {
	$date_format = $event['due']->_dateonly ? self::to_php_date_format($this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format'])) : null;
	$fromto = $this->rc->format_date($event['due'], $date_format, false);

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

	return $fromto;
	}

	// abort if no valid event dates are given
	if (!is_object($event['start']) \|\| !is_a($event['start'], 'DateTime') \|\| !is_object($event['end']) \|\| !is_a($event['end'], 'DateTime')) {
	return $fromto;
	}

	$duration = $event['start']->diff($event['end'])->format('s');

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

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

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

	return $fromto;
	}


	/**
	* Render HTML form for alarm configuration
	*/
	public function alarm_select($attrib, $alarm_types, $absolute_time = true)
	{
	unset($attrib['name']);

	$input_value = new html_inputfield(array('name' => 'alarmvalue[]', 'class' => 'edit-alarm-value form-control', 'size' => 3));
	$input_date = new html_inputfield(array('name' => 'alarmdate[]', 'class' => 'edit-alarm-date form-control', 'size' => 10));
	$input_time = new html_inputfield(array('name' => 'alarmtime[]', 'class' => 'edit-alarm-time form-control', 'size' => 6));
	$select_type = new html_select(array('name' => 'alarmtype[]', 'class' => 'edit-alarm-type form-control', 'id' => $attrib['id']));
	$select_offset = new html_select(array('name' => 'alarmoffset[]', 'class' => 'edit-alarm-offset form-control'));
	$select_related = new html_select(array('name' => 'alarmrelated[]', 'class' => 'edit-alarm-related form-control'));
	$object_type = $attrib['_type'] ?: 'event';

	$select_type->add($this->gettext('none'), '');
	foreach ($alarm_types as $type)
	$select_type->add($this->gettext(strtolower("alarm{$type}option")), $type);

	foreach (array('-M','-H','-D','+M','+H','+D') as $trigger)
	$select_offset->add($this->gettext('trigger' . $trigger), $trigger);

	$select_offset->add($this->gettext('trigger0'), '0');
	if ($absolute_time)
	$select_offset->add($this->gettext('trigger@'), '@');

	$select_related->add($this->gettext('relatedstart'), 'start');
	$select_related->add($this->gettext('relatedend' . $object_type), 'end');

	// pre-set with default values from user settings
	$preset = self::parse_alarm_value($this->rc->config->get('calendar_default_alarm_offset', '-15M'));
	$hidden = array('style' => 'display:none');

	return html::span('edit-alarm-set',
	$select_type->show($this->rc->config->get('calendar_default_alarm_type', '')) . ' ' .
	html::span(array('class' => 'edit-alarm-values input-group', 'style' => 'display:none'),
	$input_value->show($preset[0]) . ' ' .
	$select_offset->show($preset[1]) . ' ' .
	$select_related->show() . ' ' .
	$input_date->show('', $hidden) . ' ' .
	$input_time->show('', $hidden)
	)
	);
	}

	/**
	* Get a list of email addresses of the given user (from login and identities)
	*
	* @param string User Email (default to current user)
	*
	* @return array Email addresses related to the user
	*/
	public function get_user_emails($user = null)
	{
	static $_emails = array();

	if (empty($user)) {
	$user = $this->rc->user->get_username();
	}

	// return cached result
	if (is_array($_emails[$user])) {
	return $_emails[$user];
	}

	$emails = array($user);
	$plugin = $this->rc->plugins->exec_hook('calendar_user_emails', array('emails' => $emails));
	$emails = array_map('strtolower', $plugin['emails']);

	// add all emails from the current user's identities
	if (!$plugin['abort'] && ($user == $this->rc->user->get_username())) {
	foreach ($this->rc->user->list_emails() as $identity) {
	$emails[] = strtolower($identity['email']);
	}
	}

	$_emails[$user] = array_unique($emails);
	return $_emails[$user];
	}

	/**
	* Set the given participant status to the attendee matching the current user's identities
	* Unsets 'rsvp' flag too.
	*
	* @param array &$event Event data
	* @param string $status The PARTSTAT value to set
	* @param bool $recursive Recurive call
	*
	* @return mixed Email address of the updated attendee or False if none matching found
	*/
	public function set_partstat(&$event, $status, $recursive = true)
	{
	$success = false;
	$emails = $this->get_user_emails();
	foreach ((array)$event['attendees'] as $i => $attendee) {
	if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
	$event['attendees'][$i]['status'] = strtoupper($status);
	unset($event['attendees'][$i]['rsvp']);
	$success = $attendee['email'];
	}
	}

	// apply partstat update to each existing exception
	if ($event['recurrence'] && is_array($event['recurrence']['EXCEPTIONS'])) {
	foreach ($event['recurrence']['EXCEPTIONS'] as $i => $exception) {
	$this->set_partstat($event['recurrence']['EXCEPTIONS'][$i], $status, false);
	}

	// set link to top-level exceptions
	$event['exceptions'] = &$event['recurrence']['EXCEPTIONS'];
	}

	return $success;
	}


	/******* Alarms handling *******/

	/**
	* Helper function to convert alarm trigger strings
	* into two-field values (e.g. "-45M" => 45, "-M")
	*/
	public static function parse_alarm_value($val)
	{
	if ($val[0] == '@') {
	return array(new DateTime($val));
	}
	else if (preg_match('/([+-]?)P?(T?\d+[HMSDW])+/', $val, $m) && preg_match_all('/T?(\d+)([HMSDW])/', $val, $m2, PREG_SET_ORDER)) {
	if ($m[1] == '')
	$m[1] = '+';
	foreach ($m2 as $seg) {
	$prefix = $seg[2] == 'D' \|\| $seg[2] == 'W' ? 'P' : 'PT';
	if ($seg[1] > 0) { // ignore zero values
	// convert seconds to minutes
	if ($seg[2] == 'S') {
	$seg[2] = 'M';
	$seg[1] = max(1, round($seg[1]/60));
	}

	return array($seg[1], $m[1].$seg[2], $m[1].$seg[1].$seg[2], $m[1].$prefix.$seg[1].$seg[2]);
	}
	}

	// return zero value nevertheless
	return array($seg[1], $m[1].$seg[2], $m[1].$seg[1].$seg[2], $m[1].$prefix.$seg[1].$seg[2]);
	}

	return false;
	}

	/**
	* Convert the alarms list items to be processed on the client
	*/
	public static function to_client_alarms($valarms)
	{
	return array_map(function($alarm){
	if ($alarm['trigger'] instanceof DateTime) {
	$alarm['trigger'] = '@' . $alarm['trigger']->format('U');
	}
	else if ($trigger = libcalendaring::parse_alarm_value($alarm['trigger'])) {
	$alarm['trigger'] = $trigger[2];
	}
	return $alarm;
	}, (array)$valarms);
	}

	/**
	* Process the alarms values submitted by the client
	*/
	public static function from_client_alarms($valarms)
	{
	return array_map(function($alarm){
	if ($alarm['trigger'][0] == '@') {
	try {
	$alarm['trigger'] = new DateTime($alarm['trigger']);
	$alarm['trigger']->setTimezone(new DateTimeZone('UTC'));
	}
	catch (Exception $e) { /* handle this ? */ }
	}
	else if ($trigger = libcalendaring::parse_alarm_value($alarm['trigger'])) {
	$alarm['trigger'] = $trigger[3];
	}
	return $alarm;
	}, (array)$valarms);
	}

	/**
	* Render localized text for alarm settings
	*/
	public static function alarms_text($alarms)
	{
	if (is_array($alarms) && is_array($alarms[0])) {
	$texts = array();
	foreach ($alarms as $alarm) {
	if ($text = self::alarm_text($alarm))
	$texts[] = $text;
	}

	return join(', ', $texts);
	}
	else {
	return self::alarm_text($alarms);
	}
	}

	/**
	* Render localized text for a single alarm property
	*/
	public static function alarm_text($alarm)
	{
	if (is_string($alarm)) {
	list($trigger, $action) = explode(':', $alarm);
	}
	else {
	$trigger = $alarm['trigger'];
	$action = $alarm['action'];
	$related = $alarm['related'];
	}

	$text = '';
	$rcube = rcube::get_instance();

	switch ($action) {
	case 'EMAIL':
	$text = $rcube->gettext('libcalendaring.alarmemail');
	break;
	case 'DISPLAY':
	$text = $rcube->gettext('libcalendaring.alarmdisplay');
	break;
	case 'AUDIO':
	$text = $rcube->gettext('libcalendaring.alarmaudio');
	break;
	}

	if ($trigger instanceof DateTime) {
	$text .= ' ' . $rcube->gettext(array(
	'name' => 'libcalendaring.alarmat',
	'vars' => array('datetime' => $rcube->format_date($trigger))
	));
	}
	else if (preg_match('/@(\d+)/', $trigger, $m)) {
	$text .= ' ' . $rcube->gettext(array(
	'name' => 'libcalendaring.alarmat',
	'vars' => array('datetime' => $rcube->format_date($m[1]))
	));
	}
	else if ($val = self::parse_alarm_value($trigger)) {
	$r = strtoupper($related ?: 'start') == 'END' ? 'end' : '';
	// TODO: for all-day events say 'on date of event at XX' ?
	if ($val[0] == 0) {
	$text .= ' ' . $rcube->gettext('libcalendaring.triggerattime' . $r);
	}
	else {
	$label = 'libcalendaring.trigger' . $r . $val[1];
	$text .= ' ' . intval($val[0]) . ' ' . $rcube->gettext($label);
	}
	}
	else {
	return false;
	}

	return $text;
	}

	/**
	* Get the next alarm (time & action) for the given event
	*
	* @param array Record data
	* @return array Hash array with alarm time/type or null if no alarms are configured
	*/
	public static function get_next_alarm($rec, $type = 'event')
	{
	- if (!($rec['valarms'] \|\| $rec['alarms']) \|\| $rec['cancelled'] \|\| $rec['status'] == 'CANCELLED')
	+ if (
	+ (empty($rec['valarms']) && empty($rec['alarms']))
	+ \|\| !empty($rec['cancelled'])
	+ \|\| (!empty($rec['status']) && $rec['status'] == 'CANCELLED')
	+ ) {
	return null;
	+ }

	if ($type == 'task') {
	$timezone = self::get_instance()->timezone;
	- if ($rec['startdate'])
	- $rec['start'] = new DateTime($rec['startdate'] . ' ' . ($rec['starttime'] ?: '12:00'), $timezone);
	- if ($rec['date'])
	- $rec[($rec['start'] ? 'end' : 'start')] = new DateTime($rec['date'] . ' ' . ($rec['time'] ?: '12:00'), $timezone);
	+ if (!empty($rec['startdate'])) {
	+ $time = !empty($rec['starttime']) ? $rec['starttime'] : '12:00';
	+ $rec['start'] = new DateTime($rec['startdate'] . ' ' . $time, $timezone);
	+ }
	+ if (!empty($rec['date'])) {
	+ $time = !empty($rec['time']) ? $rec['time'] : '12:00';
	+ $rec[!empty($rec['start']) ? 'end' : 'start'] = new DateTime($rec['date'] . ' ' . $time, $timezone);
	+ }
	}

	- if (!$rec['end'])
	+ if (empty($rec['end'])) {
	$rec['end'] = $rec['start'];
	+ }

	// support legacy format
	- if (!$rec['valarms']) {
	+ if (empty($rec['valarms'])) {
	list($trigger, $action) = explode(':', $rec['alarms'], 2);
	if ($alarm = self::parse_alarm_value($trigger)) {
	$rec['valarms'] = array(array('action' => $action, 'trigger' => $alarm[3] ?: $alarm[0]));
	}
	}

	- $expires = new DateTime('now - 12 hours');
	- $alarm_id = $rec['id']; // alarm ID eq. record ID by default to keep backwards compatibility
	+ // alarm ID eq. record ID by default to keep backwards compatibility
	+ $alarm_id = isset($rec['id']) ? $rec['id'] : null;
	+ $alarm_prop = null;
	+ $expires = new DateTime('now - 12 hours');
	+ $notify_at = null;

	// handle multiple alarms
	- $notify_at = null;
	foreach ($rec['valarms'] as $alarm) {
	$notify_time = null;

	if ($alarm['trigger'] instanceof DateTime) {
	$notify_time = $alarm['trigger'];
	}
	else if (is_string($alarm['trigger'])) {
	- $refdate = $alarm['related'] == 'END' ? $rec['end'] : $rec['start'];
	+ $refdate = !empty($alarm['related']) && $alarm['related'] == 'END' ? $rec['end'] : $rec['start'];

	// abort if no reference date is available to compute notification time
	- if (!is_a($refdate, 'DateTime'))
	+ if (!is_a($refdate, 'DateTime')) {
	continue;
	+ }

	// TODO: for all-day events, take start @ 00:00 as reference date ?

	try {
	$interval = new DateInterval(trim($alarm['trigger'], '+-'));
	$interval->invert = $alarm['trigger'][0] == '-';
	$notify_time = clone $refdate;
	$notify_time->add($interval);
	}
	catch (Exception $e) {
	rcube::raise_error($e, true);
	continue;
	}
	}

	if ($notify_time && (!$notify_at \|\| ($notify_time > $notify_at && $notify_time > $expires))) {
	$notify_at = $notify_time;
	- $action = $alarm['action'];
	+ $action = isset($alarm['action']) ? $alarm['action'] : null;
	$alarm_prop = $alarm;

	// generate a unique alarm ID if multiple alarms are set
	if (count($rec['valarms']) > 1) {
	- $alarm_id = substr(md5($rec['id']), 0, 16) . '-' . $notify_at->format('Ymd\THis');
	+ $rec_id = substr(md5(isset($rec['id']) ? $rec['id'] : 'none'), 0, 16);
	+ $alarm_id = $rec_id . '-' . $notify_at->format('Ymd\THis');
	}
	}
	}

	return !$notify_at ? null : array(
	'time' => $notify_at->format('U'),
	- 'action' => $action ? strtoupper($action) : 'DISPLAY',
	+ 'action' => !empty($action) ? strtoupper($action) : 'DISPLAY',
	'id' => $alarm_id,
	'prop' => $alarm_prop,
	);
	}

	/**
	* Handler for keep-alive requests
	* This will check for pending notifications and pass them to the client
	*/
	public function refresh($attr)
	{
	// collect pending alarms from all providers (e.g. calendar, tasks)
	$plugin = $this->rc->plugins->exec_hook('pending_alarms', array(
	'time' => time(),
	'alarms' => array(),
	));

	if (!$plugin['abort'] && !empty($plugin['alarms'])) {
	// make sure texts and env vars are available on client
	$this->add_texts('localization/', true);
	$this->rc->output->add_label('close');
	$this->rc->output->set_env('snooze_select', $this->snooze_select());
	$this->rc->output->command('plugin.display_alarms', $this->_alarms_output($plugin['alarms']));
	}
	}

	/**
	* Handler for alarm dismiss/snooze requests
	*/
	public function alarms_action()
	{
	// $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
	$data = rcube_utils::get_input_value('data', rcube_utils::INPUT_POST, true);

	$data['ids'] = explode(',', $data['id']);
	$plugin = $this->rc->plugins->exec_hook('dismiss_alarms', $data);

	- if ($plugin['success'])
	+ if (!empty($plugin['success'])) {
	$this->rc->output->show_message('successfullysaved', 'confirmation');
	- else
	+ }
	+ else {
	$this->rc->output->show_message('calendar.errorsaving', 'error');
	+ }
	}

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

	return $out;
	}

	/**
	* Render a dropdown menu to choose snooze time
	*/
	private function snooze_select($attrib = array())
	{
	$steps = array(
	5 => 'repeatinmin',
	10 => 'repeatinmin',
	15 => 'repeatinmin',
	20 => 'repeatinmin',
	30 => 'repeatinmin',
	60 => 'repeatinhr',
	120 => 'repeatinhrs',
	1440 => 'repeattomorrow',
	10080 => 'repeatinweek',
	);

	$items = array();
	foreach ($steps as $n => $label) {
	$items[] = html::tag('li', null, html::a(array('href' => "#" . ($n * 60), 'class' => 'active'),
	$this->gettext(array('name' => $label, 'vars' => array('min' => $n % 60, 'hrs' => intval($n / 60))))));
	}

	return html::tag('ul', $attrib + array('class' => 'toolbarmenu menu'), join("\n", $items), html::$common_attrib);
	}


	/******* Recurrence rules handling ******/

	/**
	* Render localized text describing the recurrence rule of an event
	*/
	public function recurrence_text($rrule)
	{
	$limit = 10;
	$exdates = array();
	$format = $this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format']);
	$format = self::to_php_date_format($format);
	$format_fn = function($dt) use ($format) {
	return rcmail::get_instance()->format_date($dt, $format);
	};

	if (is_array($rrule['EXDATE']) && !empty($rrule['EXDATE'])) {
	$exdates = array_map($format_fn, $rrule['EXDATE']);
	}

	if (empty($rrule['FREQ']) && !empty($rrule['RDATE'])) {
	$rdates = array_map($format_fn, $rrule['RDATE']);

	if (!empty($exdates)) {
	$rdates = array_diff($rdates, $exdates);
	}

	if (count($rdates) > $limit) {
	$rdates = array_slice($rdates, 0, $limit);
	$more = true;
	}

	return $this->gettext('ondate') . ' ' . join(', ', $rdates)
	. ($more ? '...' : '');
	}

	$output = sprintf('%s %d ', $this->gettext('every'), $rrule['INTERVAL'] ?: 1);

	switch ($rrule['FREQ']) {
	case 'DAILY':
	$output .= $this->gettext('days');
	break;
	case 'WEEKLY':
	$output .= $this->gettext('weeks');
	break;
	case 'MONTHLY':
	$output .= $this->gettext('months');
	break;
	case 'YEARLY':
	$output .= $this->gettext('years');
	break;
	}

	if ($rrule['COUNT']) {
	$until = $this->gettext(array('name' => 'forntimes', 'vars' => array('nr' => $rrule['COUNT'])));
	}
	else if ($rrule['UNTIL']) {
	$until = $this->gettext('recurrencend') . ' ' . $this->rc->format_date($rrule['UNTIL'], $format);
	}
	else {
	$until = $this->gettext('forever');
	}

	$output .= ', ' . $until;

	if (!empty($exdates)) {
	if (count($exdates) > $limit) {
	$exdates = array_slice($exdates, 0, $limit);
	$more = true;
	}

	$output .= '; ' . $this->gettext('except') . ' ' . join(', ', $exdates)
	. ($more ? '...' : '');
	}

	return $output;
	}

	/**
	* Generate the form for recurrence settings
	*/
	public function recurrence_form($attrib = array())
	{
	switch ($attrib['part']) {
	// frequency selector
	case 'frequency':
	$select = new html_select(array('name' => 'frequency', 'id' => 'edit-recurrence-frequency', 'class' => 'form-control'));
	$select->add($this->gettext('never'), '');
	$select->add($this->gettext('daily'), 'DAILY');
	$select->add($this->gettext('weekly'), 'WEEKLY');
	$select->add($this->gettext('monthly'), 'MONTHLY');
	$select->add($this->gettext('yearly'), 'YEARLY');
	$select->add($this->gettext('rdate'), 'RDATE');
	$html = html::label(array('for' => 'edit-recurrence-frequency', 'class' => 'col-form-label col-sm-2'), $this->gettext('frequency'))
	. html::div('col-sm-10', $select->show(''));
	break;

	// daily recurrence
	case 'daily':
	$select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval form-control', 'id' => 'edit-recurrence-interval-daily'));
	$html = html::div($attrib, html::label(array('for' => 'edit-recurrence-interval-daily', 'class' => 'col-form-label col-sm-2'), $this->gettext('every'))
	. html::div('col-sm-10 input-group', $select->show(1) . html::span('label-after input-group-append', html::span('input-group-text', $this->gettext('days')))));
	break;

	// weekly recurrence form
	case 'weekly':
	$select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval form-control', 'id' => 'edit-recurrence-interval-weekly'));
	$html = html::div($attrib, html::label(array('for' => 'edit-recurrence-interval-weekly', 'class' => 'col-form-label col-sm-2'), $this->gettext('every'))
	. html::div('col-sm-10 input-group', $select->show(1) . html::span('label-after input-group-append', html::span('input-group-text', $this->gettext('weeks')))));

	// weekday selection
	$daymap = array('sun','mon','tue','wed','thu','fri','sat');
	$checkbox = new html_checkbox(array('name' => 'byday', 'class' => 'edit-recurrence-weekly-byday'));
	$first = $this->rc->config->get('calendar_first_day', 1);

	for ($weekdays = '', $j = $first; $j <= $first+6; $j++) {
	$d = $j % 7;
	$weekdays .= html::label(array('class' => 'weekday'),
	$checkbox->show('', array('value' => strtoupper(substr($daymap[$d], 0, 2)))) .
	$this->gettext($daymap[$d])
	) . ' ';
	}

	$html .= html::div($attrib, html::label(array('class' => 'col-form-label col-sm-2'), $this->gettext('bydays'))
	. html::div('col-sm-10 form-control-plaintext', $weekdays));
	break;

	// monthly recurrence form
	case 'monthly':
	$select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval form-control', 'id' => 'edit-recurrence-interval-monthly'));
	$html = html::div($attrib, html::label(array('for' => 'edit-recurrence-interval-monthly', 'class' => 'col-form-label col-sm-2'), $this->gettext('every'))
	. html::div('col-sm-10 input-group', $select->show(1) . html::span('label-after input-group-append', html::span('input-group-text', $this->gettext('months')))));

	$checkbox = new html_checkbox(array('name' => 'bymonthday', 'class' => 'edit-recurrence-monthly-bymonthday'));
	for ($monthdays = '', $d = 1; $d <= 31; $d++) {
	$monthdays .= html::label(array('class' => 'monthday'), $checkbox->show('', array('value' => $d)) . $d);
	$monthdays .= $d % 7 ? ' ' : html::br();
	}

	// rule selectors
	$radio = new html_radiobutton(array('name' => 'repeatmode', 'class' => 'edit-recurrence-monthly-mode'));
	$table = new html_table(array('cols' => 2, 'border' => 0, 'cellpadding' => 0, 'class' => 'formtable'));
	$table->add('label', html::label(null, $radio->show('BYMONTHDAY', array('value' => 'BYMONTHDAY')) . ' ' . $this->gettext('each')));
	$table->add(null, $monthdays);
	$table->add('label', html::label(null, $radio->show('', array('value' => 'BYDAY')) . ' ' . $this->gettext('every')));
	$table->add('recurrence-onevery', $this->rrule_selectors($attrib['part']));

	$html .= html::div($attrib, html::label(array('class' => 'col-form-label col-sm-2'), $this->gettext('bydays'))
	. html::div('col-sm-10 form-control-plaintext', $table->show()));
	break;

	// annually recurrence form
	case 'yearly':
	$select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval form-control', 'id' => 'edit-recurrence-interval-yearly'));
	$html = html::div($attrib, html::label(array('for' => 'edit-recurrence-interval-yearly', 'class' => 'col-form-label col-sm-2'), $this->gettext('every'))
	. html::div('col-sm-10 input-group', $select->show(1) . html::span('label-after input-group-append', html::span('input-group-text', $this->gettext('years')))));

	// month selector
	$monthmap = array('','jan','feb','mar','apr','may','jun','jul','aug','sep','oct','nov','dec');
	$checkbox = new html_checkbox(array('name' => 'bymonth', 'class' => 'edit-recurrence-yearly-bymonth'));

	for ($months = '', $m = 1; $m <= 12; $m++) {
	$months .= html::label(array('class' => 'month'), $checkbox->show(null, array('value' => $m)) . $this->gettext($monthmap[$m]));
	$months .= $m % 4 ? ' ' : html::br();
	}

	$html .= html::div($attrib, html::label(array('class' => 'col-form-label col-sm-2'), $this->gettext('bymonths'))
	. html::div('col-sm-10 form-control-plaintext',
	html::div(array('id' => 'edit-recurrence-yearly-bymonthblock'), $months)
	. html::div('recurrence-onevery', $this->rrule_selectors($attrib['part'], '---'))
	));
	break;

	// end of recurrence form
	case 'until':
	$radio = new html_radiobutton(array('name' => 'repeat', 'class' => 'edit-recurrence-until'));
	$select = $this->interval_selector(array('name' => 'times', 'id' => 'edit-recurrence-repeat-times', 'class' => 'form-control'));
	$input = new html_inputfield(array('name' => 'untildate', 'id' => 'edit-recurrence-enddate', 'size' => '10', 'class' => 'form-control datepicker'));

	$html = html::div('line first',
	$radio->show('', array('value' => '', 'id' => 'edit-recurrence-repeat-forever'))
	. ' ' . html::label('edit-recurrence-repeat-forever', $this->gettext('forever'))
	);

	$label = $this->gettext('ntimes');
	if (strpos($label, '$') === 0) {
	$label = str_replace('$n', '', $label);
	$group = $select->show(1)
	. html::span('input-group-append', html::span('input-group-text', rcube::Q($label)));
	}
	else {
	$label = str_replace('$n', '', $label);
	$group = html::span('input-group-prepend', html::span('input-group-text', rcube::Q($label)))
	. $select->show(1);
	}

	$html .= html::div('line',
	$radio->show('', array('value' => 'count', 'id' => 'edit-recurrence-repeat-count'))
	. ' ' . html::label('edit-recurrence-repeat-count', $this->gettext('for'))
	. ' ' . html::span('input-group', $group)
	);

	$html .= html::div('line',
	$radio->show('', array('value' => 'until', 'id' => 'edit-recurrence-repeat-until', 'aria-label' => $this->gettext('untilenddate')))
	. ' ' . html::label('edit-recurrence-repeat-until', $this->gettext('untildate'))
	. ' ' . $input->show('', array('aria-label' => $this->gettext('untilenddate')))
	);

	$html = html::div($attrib, html::label(array('class' => 'col-form-label col-sm-2'), ucfirst($this->gettext('recurrencend')))
	. html::div('col-sm-10', $html));
	break;

	case 'rdate':
	$ul = html::tag('ul', array('id' => 'edit-recurrence-rdates', 'class' => 'recurrence-rdates'), '');
	$input = new html_inputfield(array('name' => 'rdate', 'id' => 'edit-recurrence-rdate-input', 'size' => "10", 'class' => 'form-control datepicker'));
	$button = new html_inputfield(array('type' => 'button', 'class' => 'button add', 'value' => $this->gettext('addrdate')));

	$html = html::div($attrib, html::label(array('class' => 'col-form-label col-sm-2', 'for' => 'edit-recurrence-rdate-input'), $this->gettext('bydates'))
	. html::div('col-sm-10', $ul . html::div('inputform', $input->show() . $button->show())));
	break;
	}

	return $html;
	}

	/**
	* Input field for interval selection
	*/
	private function interval_selector($attrib)
	{
	$select = new html_select($attrib);
	$select->add(range(1,30), range(1,30));
	return $select;
	}

	/**
	* Drop-down menus for recurrence rules like "each last sunday of"
	*/
	private function rrule_selectors($part, $noselect = null)
	{
	// rule selectors
	$select_prefix = new html_select(array('name' => 'bydayprefix', 'id' => "edit-recurrence-$part-prefix", 'class' => 'form-control'));
	if ($noselect) $select_prefix->add($noselect, '');
	$select_prefix->add(array(
	$this->gettext('first'),
	$this->gettext('second'),
	$this->gettext('third'),
	$this->gettext('fourth'),
	$this->gettext('last')
	),
	array(1, 2, 3, 4, -1));

	$select_wday = new html_select(array('name' => 'byday', 'id' => "edit-recurrence-$part-byday", 'class' => 'form-control'));
	if ($noselect) $select_wday->add($noselect, '');

	$daymap = array('sunday','monday','tuesday','wednesday','thursday','friday','saturday');
	$first = $this->rc->config->get('calendar_first_day', 1);
	for ($j = $first; $j <= $first+6; $j++) {
	$d = $j % 7;
	$select_wday->add($this->gettext($daymap[$d]), strtoupper(substr($daymap[$d], 0, 2)));
	}

	return $select_prefix->show() . ' ' . $select_wday->show();
	}

	/**
	* Convert the recurrence settings to be processed on the client
	*/
	public function to_client_recurrence($recurrence, $allday = false)
	{
	if ($recurrence['UNTIL']) {
	$recurrence['UNTIL'] = $this->adjust_timezone($recurrence['UNTIL'], $allday)->format('c');
	}

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

	unset($recurrence['EXCEPTIONS']);

	return $recurrence;
	}

	/**
	* Process the alarms values submitted by the client
	*/
	public function from_client_recurrence($recurrence, $start = null)
	{
	if (is_array($recurrence) && !empty($recurrence['UNTIL'])) {
	$recurrence['UNTIL'] = new DateTime($recurrence['UNTIL'], $this->timezone);
	}

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

	return $recurrence;
	}


	/******* iTip message detection *******/

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

	// check all message parts for .ics files
	foreach ((array)$this->ical_message->mime_parts as $part) {
	if (self::part_is_vcalendar($part, $this->ical_message)) {
	if ($part->ctype_parameters['method'])
	$itip_part = $part->mime_id;
	else
	$this->ical_parts[] = $part->mime_id;
	}
	}

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

	/**
	* Getter for the parsed iCal objects attached to the current email message
	*
	* @return object libvcalendar parser instance with the parsed objects
	*/
	public function get_mail_ical_objects()
	{
	// create parser and load ical objects
	if (!$this->mail_ical_parser) {
	$this->mail_ical_parser = $this->get_ical();

	foreach ($this->ical_parts as $mime_id) {
	$part = $this->ical_message->mime_parts[$mime_id];
	$charset = $part->ctype_parameters['charset'] ?: RCUBE_CHARSET;
	$this->mail_ical_parser->import($this->ical_message->get_part_body($mime_id, true), $charset);

	// check if the parsed object is an instance of a recurring event/task
	array_walk($this->mail_ical_parser->objects, 'libcalendaring::identify_recurrence_instance');

	// stop on the part that has an iTip method specified
	if (count($this->mail_ical_parser->objects) && $this->mail_ical_parser->method) {
	$this->mail_ical_parser->message_date = $this->ical_message->headers->date;
	$this->mail_ical_parser->mime_id = $mime_id;

	// store the message's sender address for comparisons
	$from = rcube_mime::decode_address_list($this->ical_message->headers->from, 1, true, null, true);
	$this->mail_ical_parser->sender = !empty($from) ? $from[1] : '';

	if (!empty($this->mail_ical_parser->sender)) {
	foreach ($this->mail_ical_parser->objects as $i => $object) {
	$this->mail_ical_parser->objects[$i]['_sender'] = $this->mail_ical_parser->sender;
	$this->mail_ical_parser->objects[$i]['_sender_utf'] = rcube_utils::idn_to_utf8($this->mail_ical_parser->sender);
	}
	}

	break;
	}
	}
	}

	return $this->mail_ical_parser;
	}

	/**
	* Read the given mime message from IMAP and parse ical data
	*
	* @param string Mailbox name
	* @param string Message UID
	* @param string Message part ID and object index (e.g. '1.2:0')
	* @param string Object type filter (optional)
	*
	* @return array Hash array with the parsed iCal
	*/
	public function mail_get_itip_object($mbox, $uid, $mime_id, $type = null)
	{
	$charset = RCUBE_CHARSET;

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

	if ($uid && $mime_id) {
	list($mime_id, $index) = explode(':', $mime_id);

	$part = $imap->get_message_part($uid, $mime_id);
	$headers = $imap->get_message_headers($uid);
	$parser = $this->get_ical();

	if ($part->ctype_parameters['charset']) {
	$charset = $part->ctype_parameters['charset'];
	}

	if ($part) {
	$objects = $parser->import($part, $charset);
	}
	}

	// successfully parsed events/tasks?
	if (!empty($objects) && ($object = $objects[$index]) && (!$type \|\| $object['_type'] == $type)) {
	if ($parser->method)
	$object['_method'] = $parser->method;

	// store the message's sender address for comparisons
	$from = rcube_mime::decode_address_list($headers->from, 1, true, null, true);
	$object['_sender'] = !empty($from) ? $from[1] : '';
	$object['_sender_utf'] = rcube_utils::idn_to_utf8($object['_sender']);

	// check if this is an instance of a recurring event/task
	self::identify_recurrence_instance($object);

	return $object;
	}

	return null;
	}

	/**
	* Checks if specified message part is a vcalendar data
	*
	* @param rcube_message_part Part object
	* @param rcube_message Message object
	*
	* @return boolean True if part is of type vcard
	*/
	public static function part_is_vcalendar($part, $message = null)
	{
	// First check if the message is "valid" (i.e. not multipart/report)
	if ($message) {
	$level = explode('.', $part->mime_id);

	while (array_pop($level) !== null) {
	$parent = $message->mime_parts[join('.', $level) ?: 0];
	if ($parent->mimetype == 'multipart/report') {
	return false;
	}
	}
	}

	return (
	in_array($part->mimetype, array('text/calendar', 'text/x-vcalendar', 'application/ics')) \|\|
	// Apple sends files as application/x-any (!?)
	($part->mimetype == 'application/x-any' && $part->filename && preg_match('/\.ics$/i', $part->filename))
	);
	}

	/**
	* Single occourrences of recurring events are identified by their RECURRENCE-ID property
	* in iCal which is represented as 'recurrence_date' in our internal data structure.
	*
	* Check if such a property exists and derive the '_instance' identifier and '_savemode'
	* attributes which are used in the storage backend to identify the nested exception item.
	*/
	public static function identify_recurrence_instance(&$object)
	{
	// for savemode=all, remove recurrence instance identifiers
	if (!empty($object['_savemode']) && $object['_savemode'] == 'all' && $object['recurrence']) {
	unset($object['_instance'], $object['recurrence_date']);
	}
	// set instance and 'savemode' according to recurrence-id
	else if (!empty($object['recurrence_date']) && is_a($object['recurrence_date'], 'DateTime')) {
	$object['_instance'] = self::recurrence_instance_identifier($object);
	$object['_savemode'] = $object['thisandfuture'] ? 'future' : 'current';
	}
	else if (!empty($object['recurrence_id']) && !empty($object['_instance'])) {
	if (strlen($object['_instance']) > 4) {
	$object['recurrence_date'] = rcube_utils::anytodatetime($object['_instance'], $object['start']->getTimezone());
	}
	else {
	$object['recurrence_date'] = clone $object['start'];
	}
	}
	}

	/**
	* Return a date() format string to render identifiers for recurrence instances
	*
	* @param array Hash array with event properties
	* @return string Format string
	*/
	public static function recurrence_id_format($event)
	{
	return $event['allday'] ? 'Ymd' : 'Ymd\THis';
	}

	/**
	* Return the identifer for the given instance of a recurring event
	*
	* @param array Hash array with event properties
	* @param bool All-day flag from the main event
	*
	* @return mixed Format string or null if identifier cannot be generated
	*/
	public static function recurrence_instance_identifier($event, $allday = null)
	{
	$instance_date = $event['recurrence_date'] ?: $event['start'];

	if ($instance_date && is_a($instance_date, 'DateTime')) {
	// According to RFC5545 (3.8.4.4) RECURRENCE-ID format should
	// be date/date-time depending on the main event type, not the exception
	if ($allday === null) {
	$allday = $event['allday'];
	}

	return $instance_date->format($allday ? 'Ymd' : 'Ymd\THis');
	}
	}


	/******* Attendee handling functions *******/

	/**
	* Handler for attendee group expansion requests
	*/
	public function expand_attendee_group()
	{
	$id = rcube_utils::get_input_value('id', rcube_utils::INPUT_POST);
	$data = rcube_utils::get_input_value('data', rcube_utils::INPUT_POST, true);
	$result = array('id' => $id, 'members' => array());
	$maxnum = 500;

	// iterate over all autocomplete address books (we don't know the source of the group)
	foreach ((array)$this->rc->config->get('autocomplete_addressbooks', 'sql') as $abook_id) {
	if (($abook = $this->rc->get_address_book($abook_id)) && $abook->groups) {
	foreach ($abook->list_groups($data['name'], 1) as $group) {
	// this is the matching group to expand
	if (in_array($data['email'], (array)$group['email'])) {
	$abook->set_pagesize($maxnum);
	$abook->set_group($group['ID']);

	// get all members
	$res = $abook->list_records($this->rc->config->get('contactlist_fields'));

	// handle errors (e.g. sizelimit, timelimit)
	if ($abook->get_error()) {
	$result['error'] = $this->rc->gettext('expandattendeegrouperror', 'libcalendaring');
	$res = false;
	}
	// check for maximum number of members (we don't wanna bloat the UI too much)
	else if ($res->count > $maxnum) {
	$result['error'] = $this->rc->gettext('expandattendeegroupsizelimit', 'libcalendaring');
	$res = false;
	}

	while ($res && ($member = $res->iterate())) {
	$emails = (array)$abook->get_col_values('email', $member, true);
	if (!empty($emails) && ($email = array_shift($emails))) {
	$result['members'][] = array(
	'email' => $email,
	'name' => rcube_addressbook::compose_list_name($member),
	);
	}
	}

	break 2;
	}
	}
	}
	}

	$this->rc->output->command('plugin.expand_attendee_callback', $result);
	}

	/**
	* Merge attendees of the old and new event version
	* with keeping current user and his delegatees status
	*
	* @param array &$new New object data
	* @param array $old Old object data
	* @param bool $status New status of the current user
	*/
	public function merge_attendees(&$new, $old, $status = null)
	{
	if (empty($status)) {
	$emails = $this->get_user_emails();
	$delegates = array();
	$attendees = array();

	// keep attendee status of the current user
	foreach ((array) $new['attendees'] as $i => $attendee) {
	if (empty($attendee['email'])) {
	continue;
	}

	$attendees[] = $email = strtolower($attendee['email']);

	if (in_array($email, $emails)) {
	foreach ($old['attendees'] as $_attendee) {
	if ($attendee['email'] == $_attendee['email']) {
	$new['attendees'][$i] = $_attendee;
	if ($_attendee['status'] == 'DELEGATED' && ($email = $_attendee['delegated-to'])) {
	$delegates[] = strtolower($email);
	}

	break;
	}
	}
	}
	}

	// make sure delegated attendee is not lost
	foreach ($delegates as $delegatee) {
	if (!in_array($delegatee, $attendees)) {
	foreach ((array) $old['attendees'] as $attendee) {
	if ($attendee['email'] && ($email = strtolower($attendee['email'])) && $email == $delegatee) {
	$new['attendees'][] = $attendee;
	break;
	}
	}
	}
	}
	}

	// We also make sure that status of any attendee
	// is not overriden by NEEDS-ACTION if it was already set
	// which could happen if you work with shared events
	foreach ((array) $new['attendees'] as $i => $attendee) {
	if ($attendee['email'] && $attendee['status'] == 'NEEDS-ACTION') {
	foreach ($old['attendees'] as $_attendee) {
	if ($attendee['email'] == $_attendee['email']) {
	$new['attendees'][$i]['status'] = $_attendee['status'];
	unset($new['attendees'][$i]['rsvp']);
	break;
	}
	}
	}
	}
	}


	/******* Static utility functions *******/

	/**
	* Convert the internal structured data into a vcalendar rrule 2.0 string
	*/
	public static function to_rrule($recurrence, $allday = false)
	{
	- if (is_string($recurrence))
	+ if (is_string($recurrence)) {
	return $recurrence;
	+ }

	$rrule = '';
	foreach ((array)$recurrence as $k => $val) {
	$k = strtoupper($k);
	switch ($k) {
	case 'UNTIL':
	// convert to UTC according to RFC 5545
	if (is_a($val, 'DateTime')) {
	- if (!$allday && !$val->_dateonly) {
	+ if (!$allday && empty($val->_dateonly)) {
	$until = clone $val;
	$until->setTimezone(new DateTimeZone('UTC'));
	$val = $until->format('Ymd\THis\Z');
	}
	else {
	$val = $val->format('Ymd');
	}
	}
	break;
	case 'RDATE':
	case 'EXDATE':
	foreach ((array)$val as $i => $ex) {
	- if (is_a($ex, 'DateTime'))
	+ if (is_a($ex, 'DateTime')) {
	$val[$i] = $ex->format('Ymd\THis');
	+ }
	}
	$val = join(',', (array)$val);
	break;
	case 'EXCEPTIONS':
	continue 2;
	}

	- if (strlen($val))
	+ if (strlen($val)) {
	$rrule .= $k . '=' . $val . ';';
	+ }
	}

	return rtrim($rrule, ';');
	}

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

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

	}
	diff --git a/plugins/libcalendaring/libvcalendar.php b/plugins/libcalendaring/libvcalendar.php
	index 164d1841..3dda65d4 100644
	--- a/plugins/libcalendaring/libvcalendar.php
	+++ b/plugins/libcalendaring/libvcalendar.php
	@@ -1,1468 +1,1532 @@
	<?php

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

	/**
	* Class to parse and build vCalendar (iCalendar) files
	*
	* Uses the Sabre VObject library, version 3.x.
	*
	*/
	class libvcalendar implements Iterator
	{
	private $timezone;
	private $attach_uri = null;
	private $prodid = '-//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',
	'schedule-status' => 'SCHEDULE-STATUS',
	'schedule-agent' => 'SCHEDULE-AGENT',
	'sent-by' => 'SENT-BY',
	);
	private $organizer_keymap = array(
	'name' => 'CN',
	'schedule-status' => 'SCHEDULE-STATUS',
	'schedule-agent' => 'SCHEDULE-AGENT',
	'sent-by' => 'SENT-BY',
	);
	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 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();
	$exceptions = array();

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

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

	// temporarily store this as exception
	- if ($object['recurrence_date']) {
	+ if (!empty($object['recurrence_date'])) {
	$exceptions[] = $object;
	}
	- else if (!$seen[$object['uid']]++) {
	+ else if (empty($seen[$object['uid']])) {
	+ $seen[$object['uid']] = true;
	$this->objects[] = $object;
	}
	}
	else if ($ve->name == 'VFREEBUSY') {
	$this->objects[] = $this->_parse_freebusy($ve);
	}
	}

	// add exceptions to the according master events
	foreach ($exceptions as $exception) {
	$uid = $exception['uid'];

	// make this exception the master
	- if (!$seen[$uid]++) {
	+ if (empty($seen[$uid])) {
	+ $seen[$uid] = true;
	$this->objects[] = $exception;
	}
	else {
	foreach ($this->objects as $i => $object) {
	// add as exception to existing entry with a matching UID
	if ($object['uid'] == $uid) {
	$this->objects[$i]['exceptions'][] = $exception;

	if (!empty($object['recurrence'])) {
	$this->objects[$i]['recurrence']['EXCEPTIONS'] = &$this->objects[$i]['exceptions'];
	}
	break;
	}
	}
	}
	}
	}

	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}) {
	+ if (empty($event[$field]) && !empty($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;

	$value = strval($prop);

	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'] = strval($prop) == 'TRANSPARENT' ? 'free' : 'busy';
	break;

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

	$event['status'] = $value;
	break;

	case 'COMPLETED':
	if (self::convert_datetime($prop)) {
	$event['status'] = 'COMPLETED';
	$event['complete'] = 100;
	}
	break;

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

	case 'RRULE':
	- $params = is_array($event['recurrence']) ? $event['recurrence'] : array();
	+ $params = !empty($event['recurrence']) && is_array($event['recurrence']) ? $event['recurrence'] : array();
	// parse recurrence rule attributes
	foreach ($prop->getParts() as $k => $v) {
	$params[strtoupper($k)] = is_array($v) ? implode(',', $v) : $v;
	}
	- if ($params['UNTIL'])
	+ if (!empty($params['UNTIL'])) {
	$params['UNTIL'] = date_create($params['UNTIL']);
	- if (!$params['INTERVAL'])
	+ }
	+ if (empty($params['INTERVAL'])) {
	$params['INTERVAL'] = 1;
	+ }

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

	case 'EXDATE':
	if (!empty($value)) {
	$exdates = array_map(function($_) { return is_array($_) ? $_[0] : $_; }, self::convert_datetime($prop, true));
	- $event['recurrence']['EXDATE'] = array_merge((array)$event['recurrence']['EXDATE'], $exdates);
	+ if (!empty($event['recurrence']['EXDATE'])) {
	+ $event['recurrence']['EXDATE'] = array_merge($event['recurrence']['EXDATE'], $exdates);
	+ }
	+ else {
	+ $event['recurrence']['EXDATE'] = $exdates;
	+ }
	}
	break;

	case 'RDATE':
	if (!empty($value)) {
	$rdates = array_map(function($_) { return is_array($_) ? $_[0] : $_; }, self::convert_datetime($prop, true));
	- $event['recurrence']['RDATE'] = array_merge((array)$event['recurrence']['RDATE'], $rdates);
	+ if (!empty($event['recurrence']['RDATE'])) {
	+ $event['recurrence']['RDATE'] = array_merge($event['recurrence']['RDATE'], $rdates);
	+ }
	+ else {
	+ $event['recurrence']['RDATE'] = $rdates;
	+ }
	}
	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'] = $value;
	}
	break;

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

	case 'PERCENT-COMPLETE':
	$event['complete'] = intval($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());
	+ if (!empty($event['categories'])) {
	+ $event['categories'] = array_merge((array) $event['categories'], $prop->getParts());
	+ }
	+ else {
	+ $event['categories'] = $prop->getParts();
	+ }
	break;

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

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

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

	if ($prop->name == 'ORGANIZER') {
	$attendee['role'] = 'ORGANIZER';
	$attendee['status'] = 'ACCEPTED';
	$event['organizer'] = $attendee;

	if (array_key_exists('schedule-agent', $attendee)) {
	$schedule_agent = $attendee['schedule-agent'];
	}
	}
	else if ($attendee['email'] != $event['organizer']['email']) {
	$event['attendees'][] = $attendee;
	}
	break;

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

	default:
	if (substr($prop->name, 0, 2) == 'X-')
	$event['x-custom'][] = array($prop->name, strval($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') {
	- $event['allday'] = false;
	-
	- // check for all-day dates
	- if ($event['start']->_dateonly) {
	- $event['allday'] = true;
	- }
	+ $event['allday'] = !empty($event['start']->_dateonly);

	// events may lack the DTEND property, set it to DTSTART (RFC5545 3.6.1)
	if (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) {
	$value = strval($prop);

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

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

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

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

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

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

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

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

	- if ($alarm['trigger'])
	+ if (!empty($alarm['trigger'])) {
	$event['valarms'][] = $alarm;
	+ }
	}
	}

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

	- if ($event['end'] instanceof DateTime) {
	+ if (!empty($event['end']) && $event['end'] instanceof DateTime) {
	$this->_apply_timezone($event['end']);
	}
	else {
	unset($event['end']);
	}

	// some iTip CANCEL messages only contain the start date
	- if (!$event['end'] && $event['start'] && $this->method == 'CANCEL') {
	+ if (empty($event['end']) && !empty($event['start']) && $this->method == 'CANCEL') {
	$event['end'] = clone $event['start'];
	}

	// T2531: Remember SCHEDULE-AGENT in custom property to properly
	// support event updates via CalDAV when SCHEDULE-AGENT=CLIENT is used
	if (isset($schedule_agent)) {
	$event['x-custom'][] = array('SCHEDULE-AGENT', $schedule_agent);
	}

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

	/**
	* Apply user timezone to DateTime object
	*/
	private function _apply_timezone(&$date)
	{
	if (empty($this->timezone)) {
	return;
	}

	// For date-only we'll keep the date and time intact
	if ($date->_dateonly) {
	$dt = new DateTime(null, $this->timezone);
	$dt->setDate($date->format('Y'), $date->format('n'), $date->format('j'));
	$dt->setTime($date->format('G'), $date->format('i'), 0);
	$date = $dt;
	}
	else {
	$date->setTimezone($this->timezone);
	}
	}

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

	$value = strval($prop);

	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');
	+ $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', '', $value);
	break;

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

	// skip dupes
	- if ($seen[$value.':'.$fbtype]++)
	+ if (!empty($seen[$value.':'.$fbtype])) {
	break;
	+ }
	+
	+ $seen[$value.':'.$fbtype] = true;

	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 = DateTimeParser::parse($busyStart);
	$busyEnd = 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'] = $value;
	}
	}

	return $this->freebusy;
	}

	/**
	*
	*/
	public static function convert_string($prop)
	{
	return strval($prop);
	}

	/**
	*
	*/
	public static function unescape($prop)
	{
	return str_replace('\,', ',', strval($prop));
	}

	/**
	* 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\iCalendar\DateTime) {
	if (count($prop->getDateTimes()) > 1) {
	$dt = array();
	$dateonly = !$prop->hasTime();
	foreach ($prop->getDateTimes() as $item) {
	$item->_dateonly = $dateonly;
	$dt[] = $item;
	}
	}
	else {
	$dt = $prop->getDateTime();
	if (!$prop->hasTime()) {
	$dt->_dateonly = true;
	}
	}
	}
	else if ($prop instanceof VObject\Property\iCalendar\Period) {
	$dt = array();
	foreach ($prop->getParts() as $val) {
	try {
	list($start, $end) = explode('/', $val);
	$start = DateTimeParser::parseDateTime($start);

	// This is a duration value.
	if ($end[0] === 'P') {
	$dur = DateTimeParser::parseDuration($end);
	$end = clone $start;
	$end->add($dur);
	}
	else {
	$end = DateTimeParser::parseDateTime($end);
	}
	$dt[] = array($start, $end);
	}
	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 object VObject\Document parent node to create property for
	* @param string Property name
	* @param object DateTime
	* @param boolean Set as UTC date
	* @param boolean Set as VALUE=DATE property
	*/
	public function datetime_prop($cal, $name, $dt, $utc = false, $dateonly = null, $set_type = false)
	{
	if ($utc) {
	$dt->setTimeZone(new \DateTimeZone('UTC'));
	$is_utc = true;
	}
	else {
	$is_utc = ($tz = $dt->getTimezone()) && in_array($tz->getName(), array('UTC','GMT','Z'));
	}
	- $is_dateonly = $dateonly === null ? (bool)$dt->_dateonly : (bool)$dateonly;
	+ $is_dateonly = $dateonly === null ? !empty($dt->_dateonly) : (bool) $dateonly;
	$vdt = $cal->createProperty($name, $dt, null, $is_dateonly ? 'DATE' : 'DATE-TIME');

	if ($is_dateonly) {
	$vdt['VALUE'] = 'DATE';
	}
	else if ($set_type) {
	$vdt['VALUE'] = 'DATE-TIME';
	}

	// register timezone for VTIMEZONE block
	if (!$is_utc && !$dateonly && $tz && ($tzname = $tz->getName())) {
	$ts = $dt->format('U');
	- if (is_array($this->vtimezones[$tzname])) {
	+ if (!empty($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 $name => $value) {
	$params[strtoupper($name)] = strval($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 = new VObject\Component\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], $vcal);
	if (empty($vt)) {
	continue; // no timezone information found
	}

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

	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';
	+ $type = !empty($event['_type']) ? $event['_type'] : 'event';

	$cal = $vcal ?: new VObject\Component\VCalendar();
	$ve = $cal->create($this->type_component_map[$type]);
	$ve->UID = $event['uid'];

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

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

	// we're exporting a recurrence instance only
	- if (!$recurrence_id && $event['recurrence_date'] && $event['recurrence_date'] instanceof DateTime) {
	- $recurrence_id = $this->datetime_prop($cal, 'RECURRENCE-ID', $event['recurrence_date'], false, (bool)$event['allday']);
	- if ($event['thisandfuture'])
	+ if (!$recurrence_id && !empty($event['recurrence_date']) && $event['recurrence_date'] instanceof DateTime) {
	+ $recurrence_id = $this->datetime_prop($cal, 'RECURRENCE-ID', $event['recurrence_date'], false, !empty($event['allday']));
	+ if (!empty($event['thisandfuture'])) {
	$recurrence_id->add('RANGE', 'THISANDFUTURE');
	+ }
	}

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

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

	- if ($event['location'])
	+ if (!empty($event['location'])) {
	$ve->add($this->is_apple() ? new vobject_location_property($cal, 'LOCATION', $event['location']) : $cal->create('LOCATION', $event['location']));
	- if ($event['description'])
	+ }
	+ if (!empty($event['description'])) {
	$ve->add('DESCRIPTION', strtr($event['description'], array("\r\n" => "\n", "\r" => "\n"))); // normalize line endings
	+ }

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

	- if ($event['recurrence'] && !$recurrence_id) {
	+ if (!empty($event['recurrence']) && !$recurrence_id) {
	$exdates = $rdates = null;
	if (isset($event['recurrence']['EXDATE'])) {
	$exdates = $event['recurrence']['EXDATE'];
	unset($event['recurrence']['EXDATE']); // don't serialize EXDATEs into RRULE value
	}
	if (isset($event['recurrence']['RDATE'])) {
	$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'], (bool)$event['allday']));
	+ if (!empty($event['recurrence']['FREQ'])) {
	+ $ve->add('RRULE', libcalendaring::to_rrule($event['recurrence'], !empty($event['allday'])));
	}

	// add EXDATEs each one per line (for Thunderbird Lightning)
	if (is_array($exdates)) {
	foreach ($exdates as $exdate) {
	if ($exdate instanceof DateTime) {
	$ve->add($this->datetime_prop($cal, 'EXDATE', $exdate));
	}
	}
	}
	// add RDATEs
	if (is_array($rdates)) {
	foreach ($rdates as $rdate) {
	$ve->add($this->datetime_prop($cal, 'RDATE', $rdate));
	}
	}
	}

	- if ($event['categories']) {
	+ if (!empty($event['categories'])) {
	$cat = $cal->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 (!empty($event['priority'])) {
	+ $ve->add('PRIORITY', $event['priority']);
	+ }

	- if ($event['cancelled'])
	+ if (!empty($event['cancelled'])) {
	$ve->add('STATUS', 'CANCELLED');
	- else if ($event['free_busy'] == 'tentative')
	+ }
	+ else if (!empty($event['free_busy']) && $event['free_busy'] == 'tentative') {
	$ve->add('STATUS', 'TENTATIVE');
	- else if ($event['complete'] == 100)
	+ }
	+ else if (!empty($event['complete']) && $event['complete'] == 100) {
	$ve->add('STATUS', 'COMPLETED');
	- else if (!empty($event['status']))
	+ }
	+ 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 and BusyCal required the COMPLETED date to be set in order to consider a task complete
	- if ($event['status'] == 'COMPLETED' \|\| $event['complete'] == 100) {
	- $ve->add($this->datetime_prop($cal, 'COMPLETED', $event['changed'] ?: new DateTime('now - 1 hour'), true));
	+ if (
	+ (!empty($event['status']) && $event['status'] == 'COMPLETED')
	+ \|\| (!empty($event['complete']) && $event['complete'] == 100)
	+ ) {
	+ $completed = !empty($event['changed']) ? $event['changed'] : new DateTime('now - 1 hour');
	+ $ve->add($this->datetime_prop($cal, 'COMPLETED', $completed, true));
	}

	- if ($event['valarms']) {
	+ if (!empty($event['valarms'])) {
	foreach ($event['valarms'] as $alarm) {
	$va = $cal->createComponent('VALARM');
	$va->action = $alarm['action'];
	if ($alarm['trigger'] instanceof DateTime) {
	$va->add($this->datetime_prop($cal, 'TRIGGER', $alarm['trigger'], true, null, true));
	}
	else {
	$alarm_props = array();
	- if (strtoupper($alarm['related']) == 'END') {
	+ if (!empty($alarm['related']) && strtoupper($alarm['related']) == 'END') {
	$alarm_props['RELATED'] = 'END';
	}
	$va->add('TRIGGER', $alarm['trigger'], $alarm_props);
	}

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

	// Find SCHEDULE-AGENT
	- foreach ((array)$event['x-custom'] as $prop) {
	- if ($prop[0] === 'SCHEDULE-AGENT') {
	- $schedule_agent = $prop[1];
	+ if (!empty($event['x-custom'])) {
	+ foreach ((array) $event['x-custom'] as $prop) {
	+ if ($prop[0] === 'SCHEDULE-AGENT') {
	+ $schedule_agent = $prop[1];
	+ }
	}
	}

	- 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' : null;
	+ if (!empty($event['attendees'])) {
	+ 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' : null;
	+ }

	- $mailto = $attendee['email'];
	- $attendee = array_filter(self::map_keys($attendee, $this->attendee_keymap));
	+ $mailto = $attendee['email'];
	+ $attendee = array_filter(self::map_keys($attendee, $this->attendee_keymap));

	- if ($schedule_agent !== null && !isset($attendee['SCHEDULE-AGENT'])) {
	- $attendee['SCHEDULE-AGENT'] = $schedule_agent;
	- }
	+ if (isset($schedule_agent) && !isset($attendee['SCHEDULE-AGENT'])) {
	+ $attendee['SCHEDULE-AGENT'] = $schedule_agent;
	+ }

	- $ve->add('ATTENDEE', 'mailto:' . $mailto, $attendee);
	+ $ve->add('ATTENDEE', 'mailto:' . $mailto, $attendee);
	+ }
	}
	}

	- if ($event['organizer']) {
	+ if (!empty($event['organizer'])) {
	$organizer = array_filter(self::map_keys($event['organizer'], $this->organizer_keymap));

	- if ($schedule_agent !== null && !isset($organizer['SCHEDULE-AGENT'])) {
	+ if (isset($schedule_agent) && !isset($organizer['SCHEDULE-AGENT'])) {
	$organizer['SCHEDULE-AGENT'] = $schedule_agent;
	}

	$ve->add('ORGANIZER', 'mailto:' . $event['organizer']['email'], $organizer);
	}

	- foreach ((array)$event['url'] as $url) {
	- if (!empty($url)) {
	- $ve->add('URL', $url);
	+ if (!empty($event['url'])) {
	+ 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'])
	+ if (!empty($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',
	$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);
	+ if (!empty($event['links'])) {
	+ 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]);
	+ if (!empty($event['x-custom'])) {
	+ 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']) {
	+ if (!empty($event['recurrence']) && !empty($event['recurrence']['EXCEPTIONS'])) {
	foreach ($event['recurrence']['EXCEPTIONS'] as $ex) {
	- $exdate = $ex['recurrence_date'] ?: $ex['start'];
	- $recurrence_id = $this->datetime_prop($cal, 'RECURRENCE-ID', $exdate, false, (bool)$event['allday']);
	- if ($ex['thisandfuture'])
	+ $exdate = !empty($ex['recurrence_date']) ? $ex['recurrence_date'] : $ex['start'];
	+ $recurrence_id = $this->datetime_prop($cal, 'RECURRENCE-ID', $exdate, false, !empty($event['allday']));
	+ if (!empty($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
	* @param VObject\Component\VCalendar Optional VCalendar component
	*
	* @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, $cal = null)
	{
	// TODO: Consider using tzurl.org database for better interoperability e.g. with Outlook

	if (!$from) $from = time();
	if (!$to) $to = $from;
	if (!$cal) $cal = new VObject\Component\VCalendar();

	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')) {
	+ if (empty($tz) \|\| !is_a($tz, '\\DateTimeZone')) {
	return false;
	}

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

	// Make sure VTIMEZONE contains at least one STANDARD/DAYLIGHT component
	// when there's only one transition in specified time period (T5626)
	if (count($transitions) == 1) {
	// Get more transitions and use OFFSET from the previous to last
	$more_transitions = $tz->getTransitions(0, $to + $year);
	if (count($more_transitions) > 1) {
	$index = count($more_transitions) - 2;
	$tzfrom = $more_transitions[$index]['offset'] / 3600;
	}
	}

	$vt = $cal->createComponent('VTIMEZONE');
	$vt->TZID = $tz->getName();

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

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

	if ($trans['isdst']) {
	$t_dst = $trans['ts'];
	$dst = $cal->createComponent('DAYLIGHT');
	$cmp = $dst;
	}
	else {
	$t_std = $trans['ts'];
	$std = $cal->createComponent('STANDARD');
	$cmp = $std;
	}

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

	$cmp->DTSTART = $dt->format('Ymd\THis');
	$cmp->TZOFFSETFROM = sprintf('%+03d%02d', floor($tzfrom), ($tzfrom - floor($tzfrom)) * 60);
	$cmp->TZOFFSETTO = sprintf('%+03d%02d', 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) {
	+ if (empty($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\Text that quotes commas in the location property
	* because Apple clients treat that property as list.
	*/
	class vobject_location_property extends VObject\Property\Text
	{
	/**
	* List of properties that are considered 'structured'.
	*
	* @var array
	*/
	protected $structuredValues = array(
	// vCard
	'N',
	'ADR',
	'ORG',
	'GENDER',
	'LOCATION',
	// iCalendar
	'REQUEST-STATUS',
	);
	}
	diff --git a/plugins/libcalendaring/tests/libcalendaring.php b/plugins/libcalendaring/tests/libcalendaring.php
	index 311d25e2..e93e0b32 100644
	--- a/plugins/libcalendaring/tests/libcalendaring.php
	+++ b/plugins/libcalendaring/tests/libcalendaring.php
	@@ -1,184 +1,184 @@
	<?php

	/**
	* libcalendaring plugin's utility functions tests
	*
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2015, 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 libcalendaring_test extends PHPUnit_Framework_TestCase
	+class libcalendaring_test extends PHPUnit\Framework\TestCase
	{
	function setUp()
	{
	require_once __DIR__ . '/../libcalendaring.php';
	}

	/**
	* libcalendaring::parse_alarm_value()
	*/
	function test_parse_alarm_value()
	{
	$alarm = libcalendaring::parse_alarm_value('-15M');
	$this->assertEquals('15', $alarm[0]);
	$this->assertEquals('-M', $alarm[1]);
	$this->assertEquals('-PT15M', $alarm[3]);

	$alarm = libcalendaring::parse_alarm_value('-PT5H');
	$this->assertEquals('5', $alarm[0]);
	$this->assertEquals('-H', $alarm[1]);

	$alarm = libcalendaring::parse_alarm_value('P0DT1H0M0S');
	$this->assertEquals('1', $alarm[0]);
	$this->assertEquals('+H', $alarm[1]);

	// FIXME: this should return something like (1140 + 120 + 30)M
	$alarm = libcalendaring::parse_alarm_value('-P1DT2H30M');
	// $this->assertEquals('1590', $alarm[0]);
	// $this->assertEquals('-M', $alarm[1]);

	$alarm = libcalendaring::parse_alarm_value('@1420722000');
	$this->assertInstanceOf('DateTime', $alarm[0]);
	}

	/**
	* libcalendaring::get_next_alarm()
	*/
	function test_get_next_alarm()
	{
	// alarm 10 minutes before event
	$date = date('Ymd', strtotime('today + 2 days'));
	$event = array(
	'start' => new DateTime($date . 'T160000Z'),
	'end' => new DateTime($date . 'T200000Z'),
	'valarms' => array(
	array(
	'trigger' => '-PT10M',
	'action' => 'DISPLAY',
	),
	),
	);
	$alarm = libcalendaring::get_next_alarm($event);
	$this->assertEquals($event['valarms'][0]['action'], $alarm['action']);
	$this->assertEquals(strtotime($date . 'T155000Z'), $alarm['time']);

	// alarm 1 hour after event start
	$event['valarms'] = array(
	array(
	'trigger' => '+PT1H',
	),
	);
	$alarm = libcalendaring::get_next_alarm($event);
	$this->assertEquals('DISPLAY', $alarm['action']);
	$this->assertEquals(strtotime($date . 'T170000Z'), $alarm['time']);

	// alarm 1 hour before event end
	$event['valarms'] = array(
	array(
	'trigger' => '-PT1H',
	'related' => 'END',
	),
	);
	$alarm = libcalendaring::get_next_alarm($event);
	$this->assertEquals('DISPLAY', $alarm['action']);
	$this->assertEquals(strtotime($date . 'T190000Z'), $alarm['time']);

	// alarm 1 hour after event end
	$event['valarms'] = array(
	array(
	'trigger' => 'PT1H',
	'related' => 'END',
	),
	);
	$alarm = libcalendaring::get_next_alarm($event);
	$this->assertEquals('DISPLAY', $alarm['action']);
	$this->assertEquals(strtotime($date . 'T210000Z'), $alarm['time']);

	// ignore past alarms
	$event['start'] = new DateTime('today 22:00:00');
	$event['end'] = new DateTime('today 23:00:00');
	$event['valarms'] = array(
	array(
	'trigger' => '-P2D',
	'action' => 'EMAIL',
	),
	array(
	'trigger' => '-PT30M',
	'action' => 'DISPLAY',
	),
	);
	$alarm = libcalendaring::get_next_alarm($event);
	$this->assertEquals('DISPLAY', $alarm['action']);
	$this->assertEquals(strtotime('today 21:30:00'), $alarm['time']);

	// absolute alarm date/time
	$event['valarms'] = array(
	array('trigger' => new DateTime('today 20:00:00'))
	);
	$alarm = libcalendaring::get_next_alarm($event);
	$this->assertEquals($event['valarms'][0]['trigger']->format('U'), $alarm['time']);

	// no alarms for cancelled events
	$event['status'] = 'CANCELLED';
	$alarm = libcalendaring::get_next_alarm($event);
	$this->assertEquals(null, $alarm);
	}

	/**
	* libcalendaring::part_is_vcalendar()
	*/
	function test_part_is_vcalendar()
	{
	$part = new StdClass;
	$part->mimetype = 'text/plain';
	$part->filename = 'event.ics';

	$this->assertFalse(libcalendaring::part_is_vcalendar($part));

	$part->mimetype = 'text/calendar';
	$this->assertTrue(libcalendaring::part_is_vcalendar($part));

	$part->mimetype = 'text/x-vcalendar';
	$this->assertTrue(libcalendaring::part_is_vcalendar($part));

	$part->mimetype = 'application/ics';
	$this->assertTrue(libcalendaring::part_is_vcalendar($part));

	$part->mimetype = 'application/x-any';
	$this->assertTrue(libcalendaring::part_is_vcalendar($part));
	}

	/**
	* libcalendaring::to_rrule()
	*/
	function test_to_rrule()
	{
	$rrule = array(
	'FREQ' => 'MONTHLY',
	'BYDAY' => '2WE',
	'INTERVAL' => 2,
	'UNTIL' => new DateTime('2025-05-01 18:00:00 CEST'),
	);

	$s = libcalendaring::to_rrule($rrule);

	$this->assertRegExp('/FREQ='.$rrule['FREQ'].'/', $s, "Recurrence Frequence");
	$this->assertRegExp('/INTERVAL='.$rrule['INTERVAL'].'/', $s, "Recurrence Interval");
	$this->assertRegExp('/BYDAY='.$rrule['BYDAY'].'/', $s, "Recurrence BYDAY");
	$this->assertRegExp('/UNTIL=20250501T160000Z/', $s, "Recurrence End date (in UTC)");
	}
	}
	diff --git a/plugins/libcalendaring/tests/libvcalendar.php b/plugins/libcalendaring/tests/libvcalendar.php
	index 29f73520..5e2503ed 100644
	--- a/plugins/libcalendaring/tests/libvcalendar.php
	+++ b/plugins/libcalendaring/tests/libvcalendar.php
	@@ -1,609 +1,610 @@
	<?php

	/**
	* libcalendaring plugin's iCalendar functions tests
	*
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 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 libvcalendar_test extends PHPUnit_Framework_TestCase
	+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->assertInstanceOf('DateTime', $event['created'], "Created date field");
	$this->assertFalse(array_key_exists('changed', $event), "No changed date field");
	}

	/**
	* Test some extended ical properties such as attendees, recurrence rules, alarms and attachments
	*/
	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(3, 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->assertEquals('carl@mykolab.com', $attendee['delegated-from'], 'Attendee delegated-from');
	$this->assertTrue($attendee['rsvp'], 'Attendee RSVP');

	$delegator = $event['attendees'][2];
	$this->assertEquals('NON-PARTICIPANT', $delegator['role'], 'Delegator ROLE');
	$this->assertEquals('DELEGATED', $delegator['status'], 'Delegator STATUS');
	$this->assertEquals('INDIVIDUAL', $delegator['cutype'], 'Delegator CUTYPE');
	$this->assertEquals('carl@mykolab.com', $delegator['email'], 'Delegator mailto:');
	$this->assertEquals('rolf2@mykolab.com', $delegator['delegated-to'], 'Delegator delegated-to');
	$this->assertFalse($delegator['rsvp'], 'Delegator 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");

	$this->assertTrue(is_array($rrule['EXCEPTIONS']));
	$this->assertEquals(1, count($rrule['EXCEPTIONS']), "Recurrence Exceptions");

	$exception = $rrule['EXCEPTIONS'][0];
	$this->assertEquals($event['uid'], $event['uid'], "Exception UID");
	$this->assertEquals('Recurring Test (Exception)', $exception['title'], "Exception title");
	$this->assertInstanceOf('DateTime', $exception['start'], "Exception start");

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

	// parse a recurrence 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");

	$this->assertEquals(count($events[0]['exceptions']), 1, "Second VEVENT as exception");
	$this->assertEquals($events[0]['exceptions'][0]['uid'], $events[0]['uid'], "Exception UID match");
	$this->assertEquals($events[0]['exceptions'][0]['sequence'], '2', "Exception sequence");
	}

	/**
	*
	*/
	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)");
	$this->assertEquals('END', $event['valarms'][0]['related'], "Full alarm item (related)");

	// 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('', $event['valarms'][0]['related'], "First alarm related property");
	+ $this->assertTrue(empty($event['valarms'][0]['related']), "First alarm related property");
	$this->assertEquals('This is the first event reminder', $event['valarms'][0]['description'], "First alarm text");

	$this->assertEquals(3, 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");
	$this->assertInstanceOf('DateTime', $event['valarms'][2]['trigger'], "Absolute trigger date/time");

	// 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");
	$this->assertContains('TRIGGER;VALUE=DATE-TIME:20130812', $ics, "Date-Time trigger");
	}

	/**
	* @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]);
	$this->assertInstanceOf('DateTime', $event['recurrence']['RDATE'][1]);
	}

	/**
	* @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");
	$periods = $ical->get_busy_periods();
	$this->assertEquals(9, count($periods), "Number of busy periods found");
	$this->assertEquals('BUSY-TENTATIVE', $periods[8][2], "FBTYPE=BUSY-TENTATIVE");
	}

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

	$completed = $tasks[1];
	$this->assertEquals('COMPLETED', $completed['status'], "Task status=completed when COMPLETED property is present");
	$this->assertEquals(100, $completed['complete'], "Task percent complete value");

	$ics = $ical->export(array($completed));
	$this->assertRegExp('/COMPLETED(;VALUE=DATE-TIME)?:[0-9TZ]+/', $ics, "Export COMPLETED property");
	}

	/**
	* 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('America/Montreal'));
	$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('TZOFFSETFROM:-0400', $ics, "TZOFFSETFROM with negative offset (Bug T428)");
	$this->assertContains('TZOFFSETTO:-0500', $ics, "TZOFFSETTO with negative offset (Bug T428)");
	$this->assertContains('END:VTIMEZONE', $ics, "VTIMEZONE encapsulation END");

	$this->assertContains('BEGIN:VEVENT', $ics, "VEVENT encapsulation BEGIN");
	$this->assertSame(2, substr_count($ics, 'DTSTAMP'), "Duplicate DTSTAMP (T1148)");
	$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('/: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;RELATED=END:-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];
	unset($event['recurrence']['EXCEPTIONS']);

	$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;TZID=Europe/Zurich:20130814', $ics, "Recurrence-ID (1) being the exception date");
	$this->assertContains('RECURRENCE-ID;TZID=Europe/Zurich:20131113', $ics, "Recurrence-ID (2) being the exception date");
	$this->assertContains('SUMMARY:'.$exception2['title'], $ics, "Exception title");
	}

	function test_export_valid_rrules()
	{
	$event = array(
	'uid' => '1234567890',
	'start' => new DateTime('now'),
	'end' => new DateTime('now + 30min'),
	'title' => 'test_export_valid_rrules',
	'recurrence' => array(
	'FREQ' => 'DAILY',
	'COUNT' => 5,
	'EXDATE' => array(),
	'RDATE' => array(),
	),
	);
	$ical = new libvcalendar();
	$ics = $ical->export(array($event), null, false, null, false);

	$this->assertNotContains('EXDATE=', $ics);
	$this->assertNotContains('RDATE=', $ics);
	}

	/**
	*
	*/
	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: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();
	$cal = new \Sabre\VObject\Component\VCalendar();
	$localtime = $ical->datetime_prop($cal, 'DTSTART', new DateTime('2013-09-01 12:00:00', new DateTimeZone('Europe/Berlin')));
	$localdate = $ical->datetime_prop($cal, 'DTSTART', new DateTime('2013-09-01', new DateTimeZone('Europe/Berlin')), false, true);
	$utctime = $ical->datetime_prop($cal, 'DTSTART', new DateTime('2013-09-01 12:00:00', new DateTimeZone('UTC')));
	$asutctime = $ical->datetime_prop($cal, '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'));
	+ $dst = array_first($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'));
	+ $std = $vtz->select('STANDARD');
	+ $std = end($std);
	$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());

	// Making sure VTIMEZOONE contains at least one STANDARD/DAYLIGHT component
	// when there's only one transition in specified time period (T5626)
	$vtz = libvcalendar::get_vtimezone('Europe/Istanbul', strtotime('2019-10-04T15:00:00'));

	$this->assertInstanceOf('\Sabre\VObject\Component', $vtz);

	$dst = $vtz->select('DAYLIGHT');
	$std = $vtz->select('STANDARD');

	$this->assertEmpty($dst);
	$this->assertCount(1, $std);

	$std = end($std);
	$this->assertEquals('STANDARD', $std->name);
	$this->assertEquals('20181009T150000', $std->DTSTART);
	$this->assertEquals('+0300', $std->TZOFFSETFROM);
	$this->assertEquals('+0300', $std->TZOFFSETTO);
	$this->assertEquals('+03', $std->TZNAME);
	}

	function get_attachment_data($id, $event)
	{
	return $this->attachment_data;
	}
	}
	diff --git a/plugins/libkolab/libkolab.php b/plugins/libkolab/libkolab.php
	index 8ad0838b..db120aa2 100644
	--- a/plugins/libkolab/libkolab.php
	+++ b/plugins/libkolab/libkolab.php
	@@ -1,378 +1,378 @@
	<?php

	/**
	* Kolab core library
	*
	* Plugin to setup a basic environment for the interaction with a Kolab server.
	* Other Kolab-related plugins will depend on it and can use the library classes
	*
	* @version @package_version@
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2012-2015, 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 libkolab extends rcube_plugin
	{
	static $http_requests = array();
	static $bonnie_api = false;

	/**
	* Required startup method of a Roundcube plugin
	*/
	public function init()
	{
	// load local config
	$this->load_config();

	// extend include path to load bundled lib classes
	$include_path = $this->home . '/lib' . PATH_SEPARATOR . ini_get('include_path');
	set_include_path($include_path);

	$this->add_hook('storage_init', array($this, 'storage_init'));
	$this->add_hook('storage_connect', array($this, 'storage_connect'));
	$this->add_hook('user_delete', array('kolab_storage', 'delete_user_folders'));

	// For Chwala
	$this->add_hook('folder_mod', array('kolab_storage', 'folder_mod'));

	$rcmail = rcube::get_instance();
	try {
	kolab_format::$timezone = new DateTimeZone($rcmail->config->get('timezone', 'GMT'));
	}
	catch (Exception $e) {
	rcube::raise_error($e, true);
	kolab_format::$timezone = new DateTimeZone('GMT');
	}

	$this->add_texts('localization/', false);

	- if ($rcmail->output->type == 'html') {
	+ if (!empty($rcmail->output->type) && $rcmail->output->type == 'html') {
	$rcmail->output->add_handler('libkolab.folder_search_form', array($this, 'folder_search_form'));
	$this->include_stylesheet($this->local_skin_path() . '/libkolab.css');
	}

	// embed scripts and templates for email message audit trail
	if ($rcmail->task == 'mail' && self::get_bonnie_api()) {
	if ($rcmail->output->type == 'html') {
	$this->add_hook('render_page', array($this, 'bonnie_render_page'));
	$this->include_script('libkolab.js');

	// add 'Show history' item to message menu
	$this->api->add_content(html::tag('li', array('role' => 'menuitem'),
	$this->api->output->button(array(
	'command' => 'kolab-mail-history',
	'label' => 'libkolab.showhistory',
	'type' => 'link',
	'classact' => 'icon history active',
	'class' => 'icon history disabled',
	'innerclass' => 'icon history',
	))),
	'messagemenu');
	}

	$this->register_action('plugin.message-changelog', array($this, 'message_changelog'));
	}
	}

	/**
	* Hook into IMAP FETCH HEADER.FIELDS command and request Kolab-specific headers
	*/
	function storage_init($p)
	{
	$p['fetch_headers'] = trim($p['fetch_headers'] .' X-KOLAB-TYPE X-KOLAB-MIME-VERSION MESSAGE-ID');
	return $p;
	}

	/**
	* Hook into IMAP connection to replace client identity
	*/
	function storage_connect($p)
	{
	$client_name = 'Roundcube/Kolab';

	if (empty($p['ident'])) {
	$p['ident'] = array(
	'name' => $client_name,
	'version' => RCUBE_VERSION,
	/*
	'php' => PHP_VERSION,
	'os' => PHP_OS,
	'command' => $_SERVER['REQUEST_URI'],
	*/
	);
	}
	else {
	$p['ident']['name'] = $client_name;
	}

	return $p;
	}

	/**
	* Getter for a singleton instance of the Bonnie API
	*
	* @return mixed kolab_bonnie_api instance if configured, false otherwise
	*/
	public static function get_bonnie_api()
	{
	// get configuration for the Bonnie API
	if (!self::$bonnie_api && ($bonnie_config = rcube::get_instance()->config->get('kolab_bonnie_api', false))) {
	self::$bonnie_api = new kolab_bonnie_api($bonnie_config);
	}

	return self::$bonnie_api;
	}

	/**
	* Hook to append the message history dialog template to the mail view
	*/
	function bonnie_render_page($p)
	{
	if (($p['template'] === 'mail' \|\| $p['template'] === 'message') && !$p['kolab-audittrail']) {
	// append a template for the audit trail dialog
	$this->api->output->add_footer(
	html::div(array('id' => 'mailmessagehistory', 'class' => 'uidialog', 'aria-hidden' => 'true', 'style' => 'display:none'),
	self::object_changelog_table(array('class' => 'records-table changelog-table'))
	)
	);
	$this->api->output->set_env('kolab_audit_trail', true);
	$p['kolab-audittrail'] = true;
	}

	return $p;
	}

	/**
	* Handler for message audit trail changelog requests
	*/
	public function message_changelog()
	{
	if (!self::$bonnie_api) {
	return false;
	}

	$rcmail = rcube::get_instance();
	$msguid = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST, true);
	$mailbox = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);

	$result = $msguid && $mailbox ? self::$bonnie_api->changelog('mail', null, $mailbox, $msguid) : null;
	if (is_array($result)) {
	if (is_array($result['changes'])) {
	$dtformat = $rcmail->config->get('date_format') . ' ' . $rcmail->config->get('time_format');
	array_walk($result['changes'], function(&$change) use ($dtformat, $rcmail) {
	if ($change['date']) {
	$dt = rcube_utils::anytodatetime($change['date']);
	if ($dt instanceof DateTime) {
	$change['date'] = $rcmail->format_date($dt, $dtformat);
	}
	}
	});
	}
	$this->api->output->command('plugin.message_render_changelog', $result['changes']);
	}
	else {
	$this->api->output->command('plugin.message_render_changelog', false);
	}

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

	/**
	* Wrapper function to load and initalize the HTTP_Request2 Object
	*
	* @param string\|Net_Url2 Request URL
	* @param string Request method ('OPTIONS','GET','HEAD','POST','PUT','DELETE','TRACE','CONNECT')
	* @param array Configuration for this Request instance, that will be merged
	* with default configuration
	*
	* @return HTTP_Request2 Request object
	*/
	public static function http_request($url = '', $method = 'GET', $config = array())
	{
	$rcube = rcube::get_instance();
	$http_config = (array) $rcube->config->get('kolab_http_request');

	// deprecated configuration options
	if (empty($http_config)) {
	foreach (array('ssl_verify_peer', 'ssl_verify_host') as $option) {
	$value = $rcube->config->get('kolab_' . $option, true);
	if (is_bool($value)) {
	$http_config[$option] = $value;
	}
	}
	}

	if (!empty($config)) {
	$http_config = array_merge($http_config, $config);
	}

	// force CURL adapter, this allows to handle correctly
	// compressed responses with SplObserver registered (kolab_files) (#4507)
	$http_config['adapter'] = 'HTTP_Request2_Adapter_Curl';

	$key = md5(serialize($http_config));

	if (!($request = self::$http_requests[$key])) {
	// load HTTP_Request2
	require_once 'HTTP/Request2.php';

	try {
	$request = new HTTP_Request2();
	$request->setConfig($http_config);
	}
	catch (Exception $e) {
	rcube::raise_error($e, true, true);
	}

	// proxy User-Agent string
	$request->setHeader('user-agent', $_SERVER['HTTP_USER_AGENT']);

	self::$http_requests[$key] = $request;
	}

	// cleanup
	try {
	$request->setBody('');
	$request->setUrl($url);
	$request->setMethod($method);
	}
	catch (Exception $e) {
	rcube::raise_error($e, true, true);
	}

	return $request;
	}

	/**
	* Table oultine for object changelog display
	*/
	public static function object_changelog_table($attrib = array())
	{
	$rcube = rcube::get_instance();
	$attrib += array('domain' => 'libkolab');

	$table = new html_table(array('cols' => 5, 'border' => 0, 'cellspacing' => 0));
	$table->add_header('diff', '');
	$table->add_header('revision', $rcube->gettext('revision', $attrib['domain']));
	$table->add_header('date', $rcube->gettext('date', $attrib['domain']));
	$table->add_header('user', $rcube->gettext('user', $attrib['domain']));
	$table->add_header('operation', $rcube->gettext('operation', $attrib['domain']));
	$table->add_header('actions', ' ');

	$rcube->output->add_label(
	'libkolab.showrevision',
	'libkolab.actionreceive',
	'libkolab.actionappend',
	'libkolab.actionmove',
	'libkolab.actiondelete',
	'libkolab.actionread',
	'libkolab.actionflagset',
	'libkolab.actionflagclear',
	'libkolab.objectchangelog',
	'libkolab.objectchangelognotavailable',
	'close'
	);

	return $table->show($attrib);
	}

	/**
	* Wrapper function for generating a html diff using the FineDiff class by Raymond Hill
	*/
	public static function html_diff($from, $to, $is_html = null)
	{
	// auto-detect text/html format
	if ($is_html === null) {
	$from_html = (preg_match('/<(html\|body)(\s+[a-z]\|>)/', $from, $m) && strpos($from, '</'.$m[1].'>') > 0);
	$to_html = (preg_match('/<(html\|body)(\s+[a-z]\|>)/', $to, $m) && strpos($to, '</'.$m[1].'>') > 0);
	$is_html = $from_html \|\| $to_html;

	// ensure both parts are of the same format
	if ($is_html && !$from_html) {
	$converter = new rcube_text2html($from, false, array('wrap' => true));
	$from = $converter->get_html();
	}
	if ($is_html && !$to_html) {
	$converter = new rcube_text2html($to, false, array('wrap' => true));
	$to = $converter->get_html();
	}
	}

	// compute diff from HTML
	if ($is_html) {
	include_once __dir__ . '/vendor/Caxy/HtmlDiff/Match.php';
	include_once __dir__ . '/vendor/Caxy/HtmlDiff/Operation.php';
	include_once __dir__ . '/vendor/Caxy/HtmlDiff/HtmlDiff.php';

	// replace data: urls with a transparent image to avoid memory problems
	$from = preg_replace('/src="data:image[^"]+/', 'src="data:image/gif;base64,R0lGODlhAQABAPAAAOjq6gAAACH/C1hNUCBEYXRhWE1QAT8AIfkEBQAAAAAsAAAAAAEAAQAAAgJEAQA7', $from);
	$to = preg_replace('/src="data:image[^"]+/', 'src="data:image/gif;base64,R0lGODlhAQABAPAAAOjq6gAAACH/C1hNUCBEYXRhWE1QAT8AIfkEBQAAAAAsAAAAAAEAAQAAAgJEAQA7', $to);

	$diff = new Caxy\HtmlDiff\HtmlDiff($from, $to);
	$diffhtml = $diff->build();

	// remove empty inserts (from tables)
	return preg_replace('!<ins class="diff\w+">\s*</ins>!Uims', '', $diffhtml);
	}
	else {
	include_once __dir__ . '/vendor/finediff.php';

	$diff = new FineDiff($from, $to, FineDiff::$wordGranularity);
	return $diff->renderDiffToHTML();
	}
	}

	/**
	* Return a date() format string to render identifiers for recurrence instances
	*
	* @param array Hash array with event properties
	* @return string Format string
	*/
	public static function recurrence_id_format($event)
	{
	return $event['allday'] ? 'Ymd' : 'Ymd\THis';
	}

	/**
	* Returns HTML code for folder search widget
	*
	* @param array $attrib Named parameters
	*
	* @return string HTML code for the gui object
	*/
	public function folder_search_form($attrib)
	{
	$rcmail = rcube::get_instance();
	$attrib += array(
	'gui-object' => false,
	'wrapper' => true,
	'form-name' => 'foldersearchform',
	'command' => 'non-extsing-command',
	'reset-command' => 'non-existing-command',
	);

	if ($attrib['label-domain'] && !strpos($attrib['buttontitle'], '.')) {
	$attrib['buttontitle'] = $attrib['label-domain'] . '.' . $attrib['buttontitle'];
	}

	if ($attrib['buttontitle']) {
	$attrib['placeholder'] = $rcmail->gettext($attrib['buttontitle']);
	}

	return $rcmail->output->search_form($attrib);
	}
	}
	diff --git a/plugins/libkolab/tests/kolab_date_recurrence.php b/plugins/libkolab/tests/kolab_date_recurrence.php
	index ad0f3216..ed3e3bd3 100644
	--- a/plugins/libkolab/tests/kolab_date_recurrence.php
	+++ b/plugins/libkolab/tests/kolab_date_recurrence.php
	@@ -1,270 +1,270 @@
	<?php

	/**
	* kolab_date_recurrence tests
	*
	* @author Aleksander Machniak <machniak@kolabsys.com>
	*
	* Copyright (C) 2017, 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_date_recurrence_test extends PHPUnit_Framework_TestCase
	+class kolab_date_recurrence_test extends PHPUnit\Framework\TestCase
	{
	function setUp()
	{
	$rcube = rcmail::get_instance();
	$rcube->plugins->load_plugin('libkolab', true, true);
	}

	/**
	* kolab_date_recurrence::first_occurrence()
	*
	* @dataProvider data_first_occurrence
	*/
	function test_first_occurrence($recurrence_data, $start, $expected)
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$start = new DateTime($start);
	if (!empty($recurrence_data['UNTIL'])) {
	$recurrence_data['UNTIL'] = new DateTime($recurrence_data['UNTIL']);
	}

	$event = array('start' => $start, 'recurrence' => $recurrence_data);
	$object = kolab_format::factory('event', 3.0);
	$object->set($event);

	$recurrence = new kolab_date_recurrence($object);
	$first = $recurrence->first_occurrence();

	$this->assertEquals($expected, $first ? $first->format('Y-m-d H:i:s') : '');
	}

	/**
	* Data for test_first_occurrence()
	*/
	function data_first_occurrence()
	{
	// TODO: BYYEARDAY, BYWEEKNO, BYSETPOS, WKST

	return array(
	// non-recurring
	array(
	array(), // recurrence data
	'2017-08-31 11:00:00', // start date
	'2017-08-31 11:00:00', // expected result
	),
	// daily
	array(
	array('FREQ' => 'DAILY', 'INTERVAL' => '1'), // recurrence data
	'2017-08-31 11:00:00', // start date
	'2017-08-31 11:00:00', // expected result
	),
	// TODO: this one is not supported by the Calendar UI
	array(
	array('FREQ' => 'DAILY', 'INTERVAL' => '1', 'BYMONTH' => 1),
	'2017-08-31 11:00:00',
	'2018-01-01 11:00:00',
	),
	// weekly
	array(
	array('FREQ' => 'WEEKLY', 'INTERVAL' => '1'),
	'2017-08-31 11:00:00', // Thursday
	'2017-08-31 11:00:00',
	),
	array(
	array('FREQ' => 'WEEKLY', 'INTERVAL' => '1', 'BYDAY' => 'WE'),
	'2017-08-31 11:00:00', // Thursday
	'2017-09-06 11:00:00',
	),
	array(
	array('FREQ' => 'WEEKLY', 'INTERVAL' => '1', 'BYDAY' => 'TH'),
	'2017-08-31 11:00:00', // Thursday
	'2017-08-31 11:00:00',
	),
	array(
	array('FREQ' => 'WEEKLY', 'INTERVAL' => '1', 'BYDAY' => 'FR'),
	'2017-08-31 11:00:00', // Thursday
	'2017-09-01 11:00:00',
	),
	array(
	array('FREQ' => 'WEEKLY', 'INTERVAL' => '2'),
	'2017-08-31 11:00:00', // Thursday
	'2017-08-31 11:00:00',
	),
	array(
	array('FREQ' => 'WEEKLY', 'INTERVAL' => '3', 'BYDAY' => 'WE'),
	'2017-08-31 11:00:00', // Thursday
	'2017-09-20 11:00:00',
	),
	array(
	array('FREQ' => 'WEEKLY', 'INTERVAL' => '1', 'BYDAY' => 'WE', 'COUNT' => 1),
	'2017-08-31 11:00:00', // Thursday
	'2017-09-06 11:00:00',
	),
	array(
	array('FREQ' => 'WEEKLY', 'INTERVAL' => '1', 'BYDAY' => 'WE', 'UNTIL' => '2017-09-01'),
	'2017-08-31 11:00:00', // Thursday
	'',
	),
	// monthly
	array(
	array('FREQ' => 'MONTHLY', 'INTERVAL' => '1'),
	'2017-09-08 11:00:00',
	'2017-09-08 11:00:00',
	),
	array(
	array('FREQ' => 'MONTHLY', 'INTERVAL' => '1', 'BYMONTHDAY' => '8,9'),
	'2017-08-31 11:00:00',
	'2017-09-08 11:00:00',
	),
	array(
	array('FREQ' => 'MONTHLY', 'INTERVAL' => '1', 'BYMONTHDAY' => '8,9'),
	'2017-09-08 11:00:00',
	'2017-09-08 11:00:00',
	),
	array(
	array('FREQ' => 'MONTHLY', 'INTERVAL' => '1', 'BYDAY' => '1WE'),
	'2017-08-16 11:00:00',
	'2017-09-06 11:00:00',
	),
	array(
	array('FREQ' => 'MONTHLY', 'INTERVAL' => '1', 'BYDAY' => '-1WE'),
	'2017-08-16 11:00:00',
	'2017-08-30 11:00:00',
	),
	array(
	array('FREQ' => 'MONTHLY', 'INTERVAL' => '2'),
	'2017-09-08 11:00:00',
	'2017-09-08 11:00:00',
	),
	array(
	array('FREQ' => 'MONTHLY', 'INTERVAL' => '2', 'BYMONTHDAY' => '8'),
	'2017-08-31 11:00:00',
	'2017-09-08 11:00:00', // ??????
	),
	// yearly
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '1'),
	'2017-08-16 12:00:00',
	'2017-08-16 12:00:00',
	),
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '1', 'BYMONTH' => '8'),
	'2017-08-16 12:00:00',
	'2017-08-16 12:00:00',
	),
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '1', 'BYDAY' => '-1MO'),
	'2017-08-16 11:00:00',
	'2017-12-25 11:00:00',
	),
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '1', 'BYMONTH' => '8', 'BYDAY' => '-1MO'),
	'2017-08-16 11:00:00',
	'2017-08-28 11:00:00',
	),
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '1', 'BYMONTH' => '1', 'BYDAY' => '1MO'),
	'2017-08-16 11:00:00',
	'2018-01-01 11:00:00',
	),
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '1', 'BYMONTH' => '1,9', 'BYDAY' => '1MO'),
	'2017-08-16 11:00:00',
	'2017-09-04 11:00:00',
	),
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '2'),
	'2017-08-16 11:00:00',
	'2017-08-16 11:00:00',
	),
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '2', 'BYMONTH' => '8'),
	'2017-08-16 11:00:00',
	'2017-08-16 11:00:00',
	),
	array(
	array('FREQ' => 'YEARLY', 'INTERVAL' => '2', 'BYDAY' => '-1MO'),
	'2017-08-16 11:00:00',
	'2017-12-25 11:00:00',
	),
	// on dates (FIXME: do we really expect the first occurrence to be on the start date?)
	array(
	array('RDATE' => array (new DateTime('2017-08-10 11:00:00 Europe/Warsaw'))),
	'2017-08-01 11:00:00',
	'2017-08-01 11:00:00',
	),
	);
	}

	/**
	* kolab_date_recurrence::first_occurrence() for all-day events
	*
	* @dataProvider data_first_occurrence
	*/
	function test_first_occurrence_allday($recurrence_data, $start, $expected)
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$start = new DateTime($start);
	if (!empty($recurrence_data['UNTIL'])) {
	$recurrence_data['UNTIL'] = new DateTime($recurrence_data['UNTIL']);
	}

	$event = array('start' => $start, 'recurrence' => $recurrence_data, 'allday' => true);
	$object = kolab_format::factory('event', 3.0);
	$object->set($event);

	$recurrence = new kolab_date_recurrence($object);
	$first = $recurrence->first_occurrence();

	$this->assertEquals($expected, $first ? $first->format('Y-m-d H:i:s') : '');
	}

	/**
	* kolab_date_recurrence::next_instance()
	*/
	function test_next_instance()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	date_default_timezone_set('America/New_York');

	$start = new DateTime('2017-08-31 11:00:00', new DateTimeZone('Europe/Berlin'));
	$event = array(
	'start' => $start,
	'recurrence' => array('FREQ' => 'WEEKLY', 'INTERVAL' => '1'),
	'allday' => true,
	);

	$object = kolab_format::factory('event', 3.0);
	$object->set($event);

	$recurrence = new kolab_date_recurrence($object);
	$next = $recurrence->next_instance();

	$this->assertEquals($start->format('2017-09-07 H:i:s'), $next['start']->format('Y-m-d H:i:s'), 'Same time');
	$this->assertEquals($start->getTimezone()->getName(), $next['start']->getTimezone()->getName(), 'Same timezone');
	$this->assertSame($next['start']->_dateonly, true, '_dateonly flag');
	}
	}
	diff --git a/plugins/libkolab/tests/kolab_storage_config.php b/plugins/libkolab/tests/kolab_storage_config.php
	index 50a894f2..d0c0ba3f 100644
	--- a/plugins/libkolab/tests/kolab_storage_config.php
	+++ b/plugins/libkolab/tests/kolab_storage_config.php
	@@ -1,238 +1,238 @@
	<?php

	-class kolab_storage_config_test extends PHPUnit_Framework_TestCase
	+class kolab_storage_config_test extends PHPUnit\Framework\TestCase
	{
	private $params_personal = array(
	'folder' => 'Archive',
	'uid' => '9',
	'message-id' => '<1225270@example.org>',
	'date' => 'Mon, 20 Apr 2015 15:30:30 UTC',
	'subject' => 'Archived',
	);
	private $url_personal = 'imap:///user/$user/Archive/9?message-id=%3C1225270%40example.org%3E&date=Mon%2C+20+Apr+2015+15%3A30%3A30+UTC&subject=Archived';

	private $params_shared = array(
	'folder' => 'Shared Folders/shared/Collected',
	'uid' => '4',
	'message-id' => '<5270122@example.org>',
	'date' => 'Mon, 20 Apr 2015 16:33:03 +0200',
	'subject' => 'Shared',
	);
	private $url_shared = 'imap:///shared/Collected/4?message-id=%3C5270122%40example.org%3E&date=Mon%2C+20+Apr+2015+16%3A33%3A03+%2B0200&subject=Shared';

	private $params_other = array(
	'folder' => 'Other Users/lucy.white/Mailings',
	'uid' => '378',
	'message-id' => '<22448899@example.org>',
	'date' => 'Tue, 14 Apr 2015 14:14:30 +0200',
	'subject' => 'Happy Holidays',
	);
	private $url_other = 'imap:///user/lucy.white%40example.org/Mailings/378?message-id=%3C22448899%40example.org%3E&date=Tue%2C+14+Apr+2015+14%3A14%3A30+%2B0200&subject=Happy+Holidays';

	public static function setUpBeforeClass()
	{
	$rcube = rcmail::get_instance();
	$rcube->plugins->load_plugin('libkolab', true, true);

	if (!kolab_format::supports(3)) {
	return;
	}

	if ($rcube->config->get('tests_username')) {
	$authenticated = $rcube->login(
	$rcube->config->get('tests_username'),
	$rcube->config->get('tests_password'),
	$rcube->config->get('default_host'),
	false
	);

	if (!$authenticated) {
	throw new Exception('IMAP login failed for user ' . $rcube->config->get('tests_username'));
	}

	// check for defult groupware folders and clear them
	$imap = $rcube->get_storage();
	$folders = $imap->list_folders('', '*');

	foreach (array('Configuration') as $folder) {
	if (in_array($folder, $folders)) {
	if (!$imap->clear_folder($folder)) {
	throw new Exception("Failed to clear folder '$folder'");
	}
	}
	else {
	throw new Exception("Default folder '$folder' doesn't exits in test user account");
	}
	}
	}
	else {
	throw new Exception('Missing test account username/password in config-test.inc.php');
	}

	kolab_storage::setup();
	}

	function test_001_build_member_url()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$rcube = rcube::get_instance();
	$email = $rcube->get_user_email();
	$personal = str_replace('$user', urlencode($email), $this->url_personal);

	// personal namespace
	$url = kolab_storage_config::build_member_url($this->params_personal);
	$this->assertEquals($personal, $url);

	// shared namespace
	$url = kolab_storage_config::build_member_url($this->params_shared);
	$this->assertEquals($this->url_shared, $url);

	// other users namespace
	$url = kolab_storage_config::build_member_url($this->params_other);
	$this->assertEquals($this->url_other, $url);
	}

	function test_002_parse_member_url()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$rcube = rcube::get_instance();
	$email = $rcube->get_user_email();
	$personal = str_replace('$user', urlencode($email), $this->url_personal);

	// personal namespace
	$params = kolab_storage_config::parse_member_url($personal);
	$this->assertEquals($this->params_personal['uid'], $params['uid']);
	$this->assertEquals($this->params_personal['folder'], $params['folder']);
	$this->assertEquals($this->params_personal['subject'], $params['params']['subject']);
	$this->assertEquals($this->params_personal['message-id'], $params['params']['message-id']);

	// shared namespace
	$params = kolab_storage_config::parse_member_url($this->url_shared);
	$this->assertEquals($this->params_shared['uid'], $params['uid']);
	$this->assertEquals($this->params_shared['folder'], $params['folder']);

	// other users namespace
	$params = kolab_storage_config::parse_member_url($this->url_other);
	$this->assertEquals($this->params_other['uid'], $params['uid']);
	$this->assertEquals($this->params_other['folder'], $params['folder']);
	}

	function test_003_build_parse_member_url()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	// personal namespace
	$params = $this->params_personal;
	$params_ = kolab_storage_config::parse_member_url(kolab_storage_config::build_member_url($params));
	$this->assertEquals($params['uid'], $params_['uid']);
	$this->assertEquals($params['folder'], $params_['folder']);

	// shared namespace
	$params = $this->params_shared;
	$params_ = kolab_storage_config::parse_member_url(kolab_storage_config::build_member_url($params));
	$this->assertEquals($params['uid'], $params_['uid']);
	$this->assertEquals($params['folder'], $params_['folder']);

	// other users namespace
	$params = $this->params_other;
	$params_ = kolab_storage_config::parse_member_url(kolab_storage_config::build_member_url($params));
	$this->assertEquals($params['uid'], $params_['uid']);
	$this->assertEquals($params['folder'], $params_['folder']);
	}

	/**
	* Test relation/tag objects creation
	* These objects will be used by following tests
	*/
	function test_save()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$config = kolab_storage_config::get_instance();
	$tags = array(
	array(
	'category' => 'tag',
	'name' => 'test1',
	),
	array(
	'category' => 'tag',
	'name' => 'test2',
	),
	array(
	'category' => 'tag',
	'name' => 'test3',
	),
	array(
	'category' => 'tag',
	'name' => 'test4',
	),
	);

	foreach ($tags as $tag) {
	$result = $config->save($tag, 'relation');

	$this->assertTrue(!empty($result));
	$this->assertTrue(!empty($tag['uid']));
	}
	}

	/**
	* Tests "race condition" in tags handling (T133)
	*/
	function test_T133()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$config = kolab_storage_config::get_instance();

	// get tags
	$tags = $config->get_tags();
	$this->assertCount(4, $tags);

	// create a tag
	$tag = array(
	'category' => 'tag',
	'name' => 'new',
	);
	$result = $config->save($tag, 'relation');
	$this->assertTrue(!empty($result));

	// get tags again, make sure it contains the new tag
	$tags = $config->get_tags();
	$this->assertCount(5, $tags);

	// update a tag
	$tag['name'] = 'new-tag';
	$result = $config->save($tag, 'relation');
	$this->assertTrue(!empty($result));

	// get tags again, make sure it contains the new tag
	$tags = $config->get_tags();
	$this->assertCount(5, $tags);
	$this->assertSame('new-tag', $tags[4]['name']);

	// remove a tag
	$result = $config->delete($tag['uid']);
	$this->assertTrue(!empty($result));

	// get tags again, make sure it contains the new tag
	$tags = $config->get_tags();
	$this->assertCount(4, $tags);

	foreach ($tags as $_tag) {
	$this->assertTrue($_tag['uid'] != $tag['uid']);
	}
	}
	}
	diff --git a/plugins/libkolab/tests/kolab_storage_folder.php b/plugins/libkolab/tests/kolab_storage_folder.php
	index 273ece26..c242b979 100644
	--- a/plugins/libkolab/tests/kolab_storage_folder.php
	+++ b/plugins/libkolab/tests/kolab_storage_folder.php
	@@ -1,255 +1,255 @@
	<?php

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

	-class kolab_storage_folder_test extends PHPUnit_Framework_TestCase
	+class kolab_storage_folder_test extends PHPUnit\Framework\TestCase
	{
	public static function setUpBeforeClass()
	{
	// load libkolab plugin
	$rcmail = rcmail::get_instance();
	$rcmail->plugins->load_plugin('libkolab', true, true);

	if (!kolab_format::supports(3)) {
	return;
	}

	if ($rcmail->config->get('tests_username')) {
	$authenticated = $rcmail->login(
	$rcmail->config->get('tests_username'),
	$rcmail->config->get('tests_password'),
	$rcmail->config->get('default_host'),
	false
	);

	if (!$authenticated) {
	throw new Exception('IMAP login failed for user ' . $rcmail->config->get('tests_username'));
	}

	// check for defult groupware folders and clear them
	$imap = $rcmail->get_storage();
	$folders = $imap->list_folders('', '*');

	foreach (array('Calendar','Contacts','Files','Tasks','Notes') as $folder) {
	if (in_array($folder, $folders)) {
	if (!$imap->clear_folder($folder)) {
	throw new Exception("Failed to clear folder '$folder'");
	}
	}
	else {
	throw new Exception("Default folder '$folder' doesn't exits in test user account");
	}
	}
	}
	else {
	throw new Exception('Missing test account username/password in config-test.inc.php');
	}

	kolab_storage::setup();
	}

	function test_001_folder_type_check()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$folder = new kolab_storage_folder('Calendar', 'event', 'event.default');
	$this->assertTrue($folder->valid);
	$this->assertEquals($folder->get_error(), 0);

	$folder = new kolab_storage_folder('Calendar', 'event', 'mail');
	$this->assertFalse($folder->valid);
	$this->assertEquals($folder->get_error(), kolab_storage::ERROR_INVALID_FOLDER);

	$folder = new kolab_storage_folder('INBOX');
	$this->assertFalse($folder->valid);
	$this->assertEquals($folder->get_error(), kolab_storage::ERROR_INVALID_FOLDER);
	}

	function test_002_get_owner()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$rcmail = rcmail::get_instance();
	$folder = new kolab_storage_folder('Calendar', 'event', 'event');
	$this->assertEquals($folder->get_owner(), $rcmail->config->get('tests_username'));

	$domain = preg_replace('/^.+@/', '@', $rcmail->config->get('tests_username'));

	$shared_ns = kolab_storage::namespace_root('shared');
	$folder = new kolab_storage_folder($shared_ns . 'A-shared-folder', 'event', 'event');
	$this->assertEquals($folder->get_owner(true), 'anonymous' . $domain);

	$other_ns = kolab_storage::namespace_root('other');
	$folder = new kolab_storage_folder($other_ns . 'major.tom/Calendar', 'event', 'event');
	$this->assertEquals($folder->get_owner(true), 'major.tom' . $domain);
	}

	function test_003_get_resource_uri()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$rcmail = rcmail::get_instance();
	$foldername = 'Calendar';
	$uri = parse_url($rcmail->config->get('default_host'));
	$hostname = $uri['host'];

	$folder = new kolab_storage_folder($foldername, 'event', 'event.default');
	$this->assertEquals($folder->get_resource_uri(), sprintf('imap://%s@%s/%s',
	urlencode($rcmail->config->get('tests_username')),
	$hostname,
	$foldername
	));
	}

	function test_004_get_uid()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$rcmail = rcmail::get_instance();
	$folder = new kolab_storage_folder('Doesnt-Exist', 'event', 'event');

	// generate UID from folder name if IMAP operations fail
	$uid1 = $folder->get_uid();
	$this->assertEquals($folder->get_uid(), $uid1);
	$this->assertEquals($folder->get_error(), kolab_storage::ERROR_IMAP_CONN);
	}

	function test_005_subscribe()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$folder = new kolab_storage_folder('Contacts', 'contact');
	$this->assertTrue($folder->subscribe(true));
	$this->assertTrue($folder->is_subscribed());

	$this->assertTrue($folder->subscribe(false));
	$this->assertFalse($folder->is_subscribed());

	$folder->subscribe(true);
	}

	function test_006_activate()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$folder = new kolab_storage_folder('Calendar', 'event');
	$this->assertTrue($folder->activate(true));
	$this->assertTrue($folder->is_active());

	$this->assertTrue($folder->activate(false));
	$this->assertFalse($folder->is_active());
	}

	function test_010_write_contacts()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$folder = new kolab_storage_folder('Contacts', 'contact');

	$saved = $folder->save(null, 'contact');
	$this->assertFalse($saved);

	$contact = array(
	'name' => 'FN',
	'surname' => 'Last',
	'firstname' => 'First',
	'email' => array(
	array('type' => 'home', 'address' => 'first.last@example.org'),
	),
	'organization' => 'Company A.G.'
	);

	$saved = $folder->save($contact, 'contact');
	$this->assertTrue((bool)$saved);
	}

	/**
	* @depends test_010_write_contacts
	*/
	function test_011_list_contacts()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$folder = new kolab_storage_folder('Contacts', 'contact');
	$this->assertEquals($folder->count(), 1);
	}

	function test_T491_get_uid()
	{
	if (!kolab_format::supports(3)) {
	$this->markTestSkipped('No Kolab support');
	}

	$rcmail = rcmail::get_instance();
	$imap = $rcmail->get_storage();
	$db = $rcmail->get_dbh();

	// clear cache
	//$imap->clear_cache('mailboxes.metadata', true);

	// get folder UID
	$folder = new kolab_storage_folder('Calendar', 'event', 'event');
	$uid = $folder->get_uid();

	// now get folder uniqueid annotations
	$annotations = array(
	'cyrus' => kolab_storage::UID_KEY_CYRUS,
	'shared' => kolab_storage::UID_KEY_SHARED,
	'private' => '/private/vendor/kolab/uniqueid',
	);
	foreach ($annotations as $key => $annotation) {
	$meta = $imap->get_metadata('Calendar', $annotation);
	$annotations[$key] = $meta['Calendar'][$annotation];
	}

	// compare results
	if ($annotations['shared']) {
	$this->assertSame($annotations['shared'], $uid);
	}
	else if ($annotations['cyrus']) {
	$this->assertSame($annotations['cyrus'], $uid);
	}
	else {
	// never use private namespace
	$this->assertTrue($annotations['private'] != $uid);
	}

	// @TODO: check if the cache contains valid entries, not so simple with memcache
	// as the cache key name is quite internal to the rcube_imap class.
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Mar 19, 8:44 AM (20 h, 17 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 456365
Default Alt Text: (202 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions