No OneTemporary
Actions

Size

100 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/plugins/libkolab/config.inc.php.dist b/plugins/libkolab/config.inc.php.dist
	index 5973d333..6e4b613e 100644
	--- a/plugins/libkolab/config.inc.php.dist
	+++ b/plugins/libkolab/config.inc.php.dist
	@@ -1,66 +1,74 @@
	<?php

	/* Configuration for libkolab */

	// Enable caching of Kolab objects in local database
	$config['kolab_cache'] = true;

	// Cache refresh interval (default is 12 hours)
	// after this period, cache is forced to synchronize with IMAP
	$config['kolab_cache_refresh'] = '12h';

	// Specify format version to write Kolab objects (must be a string value!)
	$config['kolab_format_version'] = '3.0';

	// Optional override of the URL to read and trigger Free/Busy information of Kolab users
	// Defaults to https://<imap-server->/freebusy
	$config['kolab_freebusy_server'] = null;

	// Enables listing of only subscribed folders. This e.g. will limit
	// folders in calendar view or available addressbooks
	$config['kolab_use_subscriptions'] = false;

	// List any of 'personal','shared','other' namespaces to be excluded from groupware folder listing
	// example: array('other');
	$config['kolab_skip_namespace'] = null;

	// Enables the use of displayname folder annotations as introduced in KEP:?
	// for displaying resource folder names (experimental!)
	$config['kolab_custom_display_names'] = false;

	// Configuration of HTTP requests.
	// See http://pear.php.net/manual/en/package.http.http-request2.config.php
	// for list of supported configuration options (array keys)
	$config['kolab_http_request'] = array();

	// When kolab_cache is enabled Roundcube's messages cache will be redundant
	// when working on kolab folders. Here we can:
	// 2 - bypass messages/indexes cache completely
	// 1 - bypass only messages, but use index cache
	$config['kolab_messages_cache_bypass'] = 0;

	+// These event properties contribute to a significant revision to the calendar component
	+// and if changed will increment the sequence number relevant for scheduling according to RFC 5545
	+$config['kolab_event_scheduling_properties'] = array('start', 'end', 'allday', 'location', 'status', 'cancelled');
	+
	+// These task properties contribute to a significant revision to the calendar component
	+// and if changed will increment the sequence number relevant for scheduling according to RFC 5545
	+$config['kolab_task_scheduling_properties'] = array('start', 'due', 'summary', 'status');
	+
	// LDAP directory to find avilable users for folder sharing.
	// Either contains an array with LDAP addressbook configuration or refers to entry in $config['ldap_public'].
	// If not specified, the configuraton from 'kolab_auth_addressbook' will be used.
	// Should be provided for multi-domain setups with placeholders like %dc, %d, %u, %fu or %dn.
	$config['kolab_users_directory'] = null;

	// Filter to be used for resolving user folders in LDAP.
	// Defaults to the 'kolab_auth_filter' configuration option.
	$config['kolab_users_filter'] = '(&(objectclass=kolabInetOrgPerson)(\|(uid=%u)(mail=%fu)))';

	// Which property of the LDAP user record to use for user folder mapping in IMAP.
	// Defaults to the 'kolab_auth_login' configuration option.
	$config['kolab_users_id_attrib'] = null;

	// Use these attributes when searching users in LDAP
	$config['kolab_users_search_attrib'] = array('cn','mail','alias');

	// JSON-RPC endpoint configuration of the Bonnie web service providing historic data for groupware objects
	$config['kolab_bonnie_api'] = array(
	'uri' => 'https://<kolab-hostname>:8080/api/rpc',
	'user' => 'webclient',
	'pass' => 'Welcome2KolabSystems',
	'secret' => '8431f191707fffffff00000000cccc',
	'debug' => true, // logs requests/responses to <log-dir>/bonnie
	);
	diff --git a/plugins/libkolab/lib/kolab_format_event.php b/plugins/libkolab/lib/kolab_format_event.php
	index 03b5dde1..075c5178 100644
	--- a/plugins/libkolab/lib/kolab_format_event.php
	+++ b/plugins/libkolab/lib/kolab_format_event.php
	@@ -1,273 +1,276 @@
	<?php

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

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

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

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

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

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

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

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

	return false;
	}

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

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

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

	// save recurrence exceptions
	if (is_array($object['recurrence']) && is_array($object['recurrence']['EXCEPTIONS'])) {
	$recurrence_id_format = $object['allday'] ? 'Ymd' : 'Ymd\THis';
	$vexceptions = new vectorevent;
	foreach((array)$object['recurrence']['EXCEPTIONS'] as $i => $exception) {
	$exevent = new kolab_format_event;
	$exevent->set(($compacted = $this->compact_exception($exception, $object))); // only save differing values

	// get value for recurrence-id
	if (!empty($exception['recurrence_date']) && is_a($exception['recurrence_date'], 'DateTime')) {
	$recurrence_id = $exception['recurrence_date'];
	$compacted['_instance'] = $recurrence_id->format($recurrence_id_format);
	}
	else if (!empty($exception['_instance']) && strlen($exception['_instance']) > 4) {
	$recurrence_id = rcube_utils::anytodatetime($exception['_instance'], $object['start']->getTimezone());
	$compacted['recurrence_date'] = $recurrence_id;
	}
	$exevent->obj->setRecurrenceID(self::get_datetime($recurrence_id ?: $exception['start'], null, $object['allday']), (bool)$exception['thisandfuture']);

	$vexceptions->push($exevent->obj);

	// write cleaned-up exception data back to memory/cache
	$object['recurrence']['EXCEPTIONS'][$i] = $this->expand_exception($compacted, $object);
	}
	$this->obj->setExceptions($vexceptions);
	}

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

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

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

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

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

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

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

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

	// this is an exception object
	if ($this->obj->recurrenceID()->isValid()) {
	$object['thisandfuture'] = $this->obj->thisAndFuture();
	$object['recurrence_date'] = self::php_datetime($this->obj->recurrenceID());
	}
	// read exception event objects
	else if (($exceptions = $this->obj->exceptions()) && is_object($exceptions) && $exceptions->size()) {
	$recurrence_exceptions = array();
	$recurrence_id_format = $object['allday'] ? 'Ymd' : 'Ymd\THis';
	for ($i=0; $i < $exceptions->size(); $i++) {
	if (($exobj = $exceptions->get($i))) {
	$exception = new kolab_format_event($exobj);
	if ($exception->is_valid()) {
	$exdata = $exception->to_array();

	// fix date-only recurrence ID saved by old versions
	if ($exdata['recurrence_date'] && $exdata['recurrence_date']->_dateonly && !$object['allday']) {
	$exdata['recurrence_date']->setTimezone($object['start']->getTimezone());
	$exdata['recurrence_date']->setTime($object['start']->format('G'), intval($object['start']->format('i')), intval($object['start']->format('s')));
	}

	$recurrence_id = $exdata['recurrence_date'] ?: $exdata['start'];
	$exdata['_instance'] = $recurrence_id->format($recurrence_id_format);
	$recurrence_exceptions[] = $this->expand_exception($exdata, $object);
	}
	}
	}
	$object['recurrence']['EXCEPTIONS'] = $recurrence_exceptions;
	}

	return $this->data = $object;
	}

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

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

	return $tags;
	}

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

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

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

	+ // preserve this property for date serialization
	+ $exception['allday'] = $master['allday'];
	+
	return $exception;
	}

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

	return $exception;
	}

	}
	diff --git a/plugins/libkolab/lib/kolab_format_task.php b/plugins/libkolab/lib/kolab_format_task.php
	index 52744d45..ee0ca6a9 100644
	--- a/plugins/libkolab/lib/kolab_format_task.php
	+++ b/plugins/libkolab/lib/kolab_format_task.php
	@@ -1,129 +1,129 @@
	<?php

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

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

	- public $scheduling_properties = array('start', 'due', 'summary', 'status');
	+ public static $scheduling_properties = array('start', 'due', 'summary', 'status');

	protected $objclass = 'Todo';
	protected $read_func = 'readTodo';
	protected $write_func = 'writeTodo';


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

	$this->obj->setPercentComplete(intval($object['complete']));

	$status = kolabformat::StatusUndefined;
	if ($object['complete'] == 100 && !array_key_exists('status', $object))
	$status = kolabformat::StatusCompleted;
	else if ($object['status'] && array_key_exists($object['status'], $this->status_map))
	$status = $this->status_map[$object['status']];
	$this->obj->setStatus($status);

	$this->obj->setStart(self::get_datetime($object['start'], null, $object['start']->_dateonly));
	$this->obj->setDue(self::get_datetime($object['due'], null, $object['due']->_dateonly));

	$related = new vectors;
	if (!empty($object['parent_id']))
	$related->push($object['parent_id']);
	$this->obj->setRelatedTo($related);

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

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

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

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

	$object['complete'] = intval($this->obj->percentComplete());

	// if due date is set
	if ($due = $this->obj->due())
	$object['due'] = self::php_datetime($due);

	// related-to points to parent task; we only support one relation
	$related = self::vector2array($this->obj->relatedTo());
	if (count($related))
	$object['parent_id'] = $related[0];

	// TODO: map more properties

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

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

	if ($this->data['status'] == 'COMPLETED' \|\| ($this->data['complete'] == 100 && empty($this->data['status'])))
	$tags[] = 'x-complete';

	if ($this->data['priority'] == 1)
	$tags[] = 'x-flagged';

	if ($this->data['parent_id'])
	$tags[] = 'x-parent:' . $this->data['parent_id'];

	return $tags;
	}
	}
	diff --git a/plugins/libkolab/lib/kolab_format_xcal.php b/plugins/libkolab/lib/kolab_format_xcal.php
	index 33ada933..d0f89b63 100644
	--- a/plugins/libkolab/lib/kolab_format_xcal.php
	+++ b/plugins/libkolab/lib/kolab_format_xcal.php
	@@ -1,641 +1,640 @@
	<?php

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

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

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

	- public $scheduling_properties = array('start', 'end', 'location');
	+ public static $scheduling_properties = array('start', 'end', 'location');

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

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

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

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

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

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

	protected $status_map = array(
	'NEEDS-ACTION' => kolabformat::StatusNeedsAction,
	'IN-PROCESS' => kolabformat::StatusInProcess,
	'COMPLETED' => kolabformat::StatusCompleted,
	'CANCELLED' => kolabformat::StatusCancelled,
	'TENTATIVE' => kolabformat::StatusTentative,
	'CONFIRMED' => kolabformat::StatusConfirmed,
	'DRAFT' => kolabformat::StatusDraft,
	'FINAL' => kolabformat::StatusFinal,
	);

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


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

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

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

	if (method_exists($this->obj, 'comment')) {
	$object['comment'] = $this->obj->comment();
	}

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

	$role_map = array_flip($this->role_map);
	$cutype_map = array_flip($this->cutype_map);
	$part_status_map = array_flip($this->part_status_map);
	$attvec = $this->obj->attendees();
	for ($i=0; $i < $attvec->size(); $i++) {
	$attendee = $attvec->get($i);
	$cr = $attendee->contact();
	if ($cr->email() != $object['organizer']['email']) {
	$delegators = $delegatees = array();
	$vdelegators = $attendee->delegatedFrom();
	for ($j=0; $j < $vdelegators->size(); $j++) {
	$delegators[] = $vdelegators->get($j)->email();
	}
	$vdelegatees = $attendee->delegatedTo();
	for ($j=0; $j < $vdelegatees->size(); $j++) {
	$delegatees[] = $vdelegatees->get($j)->email();
	}

	$object['attendees'][] = array(
	'role' => $role_map[$attendee->role()],
	'cutype' => $cutype_map[$attendee->cutype()],
	'status' => $part_status_map[$attendee->partStat()],
	'rsvp' => $attendee->rsvp(),
	'email' => $cr->email(),
	'name' => $cr->name(),
	'delegated-from' => $delegators,
	'delegated-to' => $delegatees,
	);
	}
	}

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

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

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

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

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

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

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

	if ($rdates = $this->obj->recurrenceDates()) {
	for ($i=0; $i < $rdates->size(); $i++) {
	if ($rdate = self::php_datetime($rdates->get($i)))
	$object['recurrence']['RDATE'][] = $rdate;
	}
	}

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

	if ($type == 'DISPLAY' \|\| $type == 'EMAIL' \|\| $type == 'AUDIO') { // only some alarms are supported
	$valarm = array(
	'action' => $type,
	'summary' => $alarm->summary(),
	'description' => $alarm->description(),
	);

	if ($type == 'EMAIL') {
	$valarm['attendees'] = array();
	$attvec = $alarm->attendees();
	for ($j=0; $j < $attvec->size(); $j++) {
	$cr = $attvec->get($j);
	$valarm['attendees'][] = $cr->email();
	}
	}
	else if ($type == 'AUDIO') {
	$attach = $alarm->audioFile();
	$valarm['uri'] = $attach->uri();
	}

	if ($start = self::php_datetime($alarm->start())) {
	$object['alarms'] = '@' . $start->format('U');
	$valarm['trigger'] = $start;
	}
	else if ($offset = $alarm->relativeStart()) {
	$prefix = $alarm->relativeTo() == kolabformat::End ? '+' : '-';
	$value = $time = '';
	if ($w = $offset->weeks()) $value .= $w . 'W';
	else if ($d = $offset->days()) $value .= $d . 'D';
	else if ($h = $offset->hours()) $time .= $h . 'H';
	else if ($m = $offset->minutes()) $time .= $m . 'M';
	else if ($s = $offset->seconds()) $time .= $s . 'S';

	// assume 'at event time'
	if (empty($value) && empty($time)) {
	$prefix = '';
	$time = '0S';
	}

	$object['alarms'] = $prefix . $value . $time;
	$valarm['trigger'] = $prefix . 'P' . $value . ($time ? 'T' . $time : '');
	}

	// read alarm duration and repeat properties
	if (($duration = $alarm->duration()) && $duration->isValid()) {
	$value = $time = '';
	if ($w = $duration->weeks()) $value .= $w . 'W';
	else if ($d = $duration->days()) $value .= $d . 'D';
	else if ($h = $duration->hours()) $time .= $h . 'H';
	else if ($m = $duration->minutes()) $time .= $m . 'M';
	else if ($s = $duration->seconds()) $time .= $s . 'S';
	$valarm['duration'] = 'P' . $value . ($time ? 'T' . $time : '');
	$valarm['repeat'] = $alarm->numrepeat();
	}

	$object['alarms'] .= ':' . $type; // legacy property
	$object['valarms'][] = array_filter($valarm);
	}
	}

	$this->get_attachments($object);

	return $object;
	}


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

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

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

	// set sequence value
	if (!isset($object['sequence'])) {
	if ($is_new) {
	$object['sequence'] = 0;
	}
	else {
	$object['sequence'] = $old_sequence;
	$old = $this->data['uid'] ? $this->data : $this->to_array();

	// increment sequence when updating properties relevant for scheduling.
	// RFC 5545: "It is incremented [...] each time the Organizer makes a significant revision to the calendar component."
	- // TODO: make the list of properties considered 'significant' for scheduling configurable
	- foreach ($this->scheduling_properties as $prop) {
	+ foreach (self::$scheduling_properties as $prop) {
	$a = $old[$prop];
	$b = $object[$prop];
	if ($object['allday'] && ($prop == 'start' \|\| $prop == 'end') && $a instanceof DateTime && $b instanceof DateTime) {
	$a = $a->format('Y-m-d');
	$b = $b->format('Y-m-d');
	}
	if ($a != $b) {
	$object['sequence']++;
	break;
	}
	}
	}
	}
	$this->obj->setSequence(intval($object['sequence']));

	if ($object['sequence'] > $old_sequence) {
	$reschedule = true;
	}

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

	if (method_exists($this->obj, 'setComment')) {
	$this->obj->setComment($object['comment']);
	}

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

	// set attendee RSVP if missing
	if (!isset($attendee['rsvp'])) {
	$object['attendees'][$i]['rsvp'] = $attendee['rsvp'] = true;
	}

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

	if (!empty($attendee['delegated-from'])) {
	$vdelegators = new vectorcontactref;
	foreach ((array)$attendee['delegated-from'] as $delegator) {
	$vdelegators->push(new ContactReference(ContactReference::EmailReference, $delegator));
	}
	$att->setDelegatedFrom($vdelegators);
	}
	if (!empty($attendee['delegated-to'])) {
	$vdelegatees = new vectorcontactref;
	foreach ((array)$attendee['delegated-to'] as $delegatee) {
	$vdelegatees->push(new ContactReference(ContactReference::EmailReference, $delegatee));
	}
	$att->setDelegatedTo($vdelegatees);
	}

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

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

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

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

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

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

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

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

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

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

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

	// save recurrence dates (aka RDATE)
	if (!empty($object['recurrence']['RDATE'])) {
	$rdates = new vectordatetime;
	foreach ((array)$object['recurrence']['RDATE'] as $rdate)
	$rdates->push(self::get_datetime($rdate, null, true));
	$this->obj->setRecurrenceDates($rdates);
	}

	// save alarm
	$valarms = new vectoralarm;
	if ($object['valarms']) {
	foreach ($object['valarms'] as $valarm) {
	if (!array_key_exists($valarm['action'], $this->alarm_type_map)) {
	continue; // skip unknown alarm types
	}

	if ($valarm['action'] == 'EMAIL') {
	$recipients = new vectorcontactref;
	foreach (($valarm['attendees'] ?: array($object['_owner'])) as $email) {
	$recipients->push(new ContactReference(ContactReference::EmailReference, $email));
	}
	$alarm = new Alarm(
	strval($valarm['summary'] ?: $object['title']),
	strval($valarm['description'] ?: $object['description']),
	$recipients
	);
	}
	else if ($valarm['action'] == 'AUDIO') {
	$attach = new Attachment;
	$attach->setUri($valarm['uri'] ?: 'null', 'unknown');
	$alarm = new Alarm($attach);
	}
	else {
	// action == DISPLAY
	$alarm = new Alarm(strval($valarm['summary'] ?: $object['title']));
	}

	if (is_object($valarm['trigger']) && $valarm['trigger'] instanceof DateTime) {
	$alarm->setStart(self::get_datetime($valarm['trigger'], new DateTimeZone('UTC')));
	}
	else {
	try {
	$prefix = $valarm['trigger'][0];
	$period = new DateInterval(preg_replace('/[^0-9PTWDHMS]/', '', $valarm['trigger']));
	$duration = new Duration($period->d, $period->h, $period->i, $period->s, $prefix == '-');
	}
	catch (Exception $e) {
	// skip alarm with invalid trigger values
	rcube::raise_error($e, true);
	continue;
	}

	$alarm->setRelativeStart($duration, $prefix == '-' ? kolabformat::Start : kolabformat::End);
	}

	if ($valarm['duration']) {
	try {
	$d = new DateInterval($valarm['duration']);
	$duration = new Duration($d->d, $d->h, $d->i, $d->s);
	$alarm->setDuration($duration, intval($valarm['repeat']));
	}
	catch (Exception $e) {
	// ignore
	}
	}

	$valarms->push($alarm);
	}
	}
	// legacy support
	else if ($object['alarms']) {
	list($offset, $type) = explode(":", $object['alarms']);

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

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

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

	$this->set_attachments($object);
	}

	/**
	* Callback for kolab_storage_cache to get words to index for fulltext search
	*
	* @return array List of words to save in cache
	*/
	public function get_words($obj = null)
	{
	$data = '';
	$object = $obj ?: $this->data;

	foreach (self::$fulltext_cols as $colname) {
	list($col, $field) = explode(':', $colname);

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

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

	$words = rcube_utils::normalize_string($data, true);

	// collect words from recurrence exceptions
	if (is_array($object['recurrence']) && $object['recurrence']['EXCEPTIONS']) {
	foreach((array)$object['recurrence']['EXCEPTIONS'] as $exception) {
	$words = array_merge($words, $this->get_words($exception));
	}
	}

	return array_unique($words);
	}

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

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

	// create tags reflecting participant status
	if (is_array($this->data['attendees'])) {
	foreach ($this->data['attendees'] as $attendee) {
	if (!empty($attendee['email']) && !empty($attendee['status']))
	$tags[] = 'x-partstat:' . $attendee['email'] . ':' . strtolower($attendee['status']);
	}
	}

	return $tags;
	}
	}
	\ No newline at end of file
	diff --git a/plugins/libkolab/lib/kolab_storage.php b/plugins/libkolab/lib/kolab_storage.php
	index 47c1e4be..bc38adc2 100644
	--- a/plugins/libkolab/lib/kolab_storage.php
	+++ b/plugins/libkolab/lib/kolab_storage.php
	@@ -1,1571 +1,1580 @@
	<?php

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

	class kolab_storage
	{
	const CTYPE_KEY = '/shared/vendor/kolab/folder-type';
	const CTYPE_KEY_PRIVATE = '/private/vendor/kolab/folder-type';
	const COLOR_KEY_SHARED = '/shared/vendor/kolab/color';
	const COLOR_KEY_PRIVATE = '/private/vendor/kolab/color';
	const NAME_KEY_SHARED = '/shared/vendor/kolab/displayname';
	const NAME_KEY_PRIVATE = '/private/vendor/kolab/displayname';
	const UID_KEY_SHARED = '/shared/vendor/kolab/uniqueid';
	const UID_KEY_PRIVATE = '/private/vendor/kolab/uniqueid';
	const UID_KEY_CYRUS = '/shared/vendor/cmu/cyrus-imapd/uniqueid';

	const ERROR_IMAP_CONN = 1;
	const ERROR_CACHE_DB = 2;
	const ERROR_NO_PERMISSION = 3;
	const ERROR_INVALID_FOLDER = 4;

	public static $version = '3.0';
	public static $last_error;
	public static $encode_ids = false;

	private static $ready = false;
	private static $with_tempsubs = true;
	private static $subscriptions;
	private static $typedata = array();
	private static $states;
	private static $config;
	private static $imap;
	private static $ldap;

	// Default folder names
	private static $default_folders = array(
	'event' => 'Calendar',
	'contact' => 'Contacts',
	'task' => 'Tasks',
	'note' => 'Notes',
	'file' => 'Files',
	'configuration' => 'Configuration',
	'journal' => 'Journal',
	'mail.inbox' => 'INBOX',
	'mail.drafts' => 'Drafts',
	'mail.sentitems' => 'Sent',
	'mail.wastebasket' => 'Trash',
	'mail.outbox' => 'Outbox',
	'mail.junkemail' => 'Junk',
	);


	/**
	* Setup the environment needed by the libs
	*/
	public static function setup()
	{
	if (self::$ready)
	return true;

	$rcmail = rcube::get_instance();
	self::$config = $rcmail->config;
	self::$version = strval($rcmail->config->get('kolab_format_version', self::$version));
	self::$imap = $rcmail->get_storage();
	self::$ready = class_exists('kolabformat') &&
	(self::$imap->get_capability('METADATA') \|\| self::$imap->get_capability('ANNOTATEMORE') \|\| self::$imap->get_capability('ANNOTATEMORE2'));

	if (self::$ready) {
	// set imap options
	self::$imap->set_options(array(
	'skip_deleted' => true,
	'threading' => false,
	));
	}
	else if (!class_exists('kolabformat')) {
	rcube::raise_error(array(
	'code' => 900, 'type' => 'php',
	'message' => "required kolabformat module not found"
	), true);
	}
	else {
	rcube::raise_error(array(
	'code' => 900, 'type' => 'php',
	'message' => "IMAP server doesn't support METADATA or ANNOTATEMORE"
	), true);
	}

	+ // adjust some configurable settings
	+ if ($event_scheduling_prop = $rcmail->config->get('kolab_event_scheduling_properties', null)) {
	+ kolab_format_event::$scheduling_properties = (array)$event_scheduling_prop;
	+ }
	+ // adjust some configurable settings
	+ if ($task_scheduling_prop = $rcmail->config->get('kolab_task_scheduling_properties', null)) {
	+ kolab_format_task::$scheduling_properties = (array)$task_scheduling_prop;
	+ }
	+
	return self::$ready;
	}

	/**
	* Initializes LDAP object to resolve Kolab users
	*/
	public static function ldap()
	{
	if (self::$ldap) {
	return self::$ldap;
	}

	self::setup();

	$config = self::$config->get('kolab_users_directory', self::$config->get('kolab_auth_addressbook'));

	if (!is_array($config)) {
	$ldap_config = (array)self::$config->get('ldap_public');
	$config = $ldap_config[$config];
	}

	if (empty($config)) {
	return null;
	}

	// overwrite filter option
	if ($filter = self::$config->get('kolab_users_filter')) {
	self::$config->set('kolab_auth_filter', $filter);
	}

	// re-use the LDAP wrapper class from kolab_auth plugin
	require_once rtrim(RCUBE_PLUGINS_DIR, '/') . '/kolab_auth/kolab_auth_ldap.php';

	self::$ldap = new kolab_auth_ldap($config);

	return self::$ldap;
	}

	/**
	* Get a list of storage folders for the given data type
	*
	* @param string Data type to list folders for (contact,distribution-list,event,task,note)
	* @param boolean Enable to return subscribed folders only (null to use configured subscription mode)
	*
	* @return array List of Kolab_Folder objects (folder names in UTF7-IMAP)
	*/
	public static function get_folders($type, $subscribed = null)
	{
	$folders = $folderdata = array();

	if (self::setup()) {
	foreach ((array)self::list_folders('', '*', $type, $subscribed, $folderdata) as $foldername) {
	$folders[$foldername] = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
	}
	}

	return $folders;
	}

	/**
	* Getter for the storage folder for the given type
	*
	* @param string Data type to list folders for (contact,distribution-list,event,task,note)
	* @return object kolab_storage_folder The folder object
	*/
	public static function get_default_folder($type)
	{
	if (self::setup()) {
	foreach ((array)self::list_folders('', '*', $type . '.default', false, $folderdata) as $foldername) {
	return new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
	}
	}

	return null;
	}

	/**
	* Getter for a specific storage folder
	*
	* @param string IMAP folder to access (UTF7-IMAP)
	* @param string Expected folder type
	*
	* @return object kolab_storage_folder The folder object
	*/
	public static function get_folder($folder, $type = null)
	{
	return self::setup() ? new kolab_storage_folder($folder, $type) : null;
	}

	/**
	* Getter for a single Kolab object, identified by its UID.
	* This will search all folders storing objects of the given type.
	*
	* @param string Object UID
	* @param string Object type (contact,event,task,journal,file,note,configuration)
	* @return array The Kolab object represented as hash array or false if not found
	*/
	public static function get_object($uid, $type)
	{
	self::setup();
	$folder = null;
	foreach ((array)self::list_folders('', '*', $type, null, $folderdata) as $foldername) {
	if (!$folder)
	$folder = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
	else
	$folder->set_folder($foldername, $type, $folderdata[$foldername]);

	if ($object = $folder->get_object($uid, '*'))
	return $object;
	}

	return false;
	}

	/**
	* Execute cross-folder searches with the given query.
	*
	* @param array Pseudo-SQL query as list of filter parameter triplets
	* @param string Object type (contact,event,task,journal,file,note,configuration)
	* @return array List of Kolab data objects (each represented as hash array)
	* @see kolab_storage_format::select()
	*/
	public static function select($query, $type)
	{
	self::setup();
	$folder = null;
	$result = array();

	foreach ((array)self::list_folders('', '*', $type, null, $folderdata) as $foldername) {
	if (!$folder)
	$folder = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
	else
	$folder->set_folder($foldername, $type, $folderdata[$foldername]);

	foreach ($folder->select($query, '*') as $object) {
	$result[] = $object;
	}
	}

	return $result;
	}

	/**
	* Returns Free-busy server URL
	*/
	public static function get_freebusy_server()
	{
	$url = 'https://' . $_SESSION['imap_host'] . '/freebusy';
	$url = self::$config->get('kolab_freebusy_server', $url);
	$url = rcube_utils::resolve_url($url);

	return unslashify($url);
	}

	/**
	* Compose an URL to query the free/busy status for the given user
	*/
	public static function get_freebusy_url($email)
	{
	return self::get_freebusy_server() . '/' . $email . '.ifb';
	}

	/**
	* Creates folder ID from folder name
	*
	* @param string $folder Folder name (UTF7-IMAP)
	* @param boolean $enc Use lossless encoding
	* @return string Folder ID string
	*/
	public static function folder_id($folder, $enc = null)
	{
	return $enc == true \|\| ($enc === null && self::$encode_ids) ?
	self::id_encode($folder) :
	asciiwords(strtr($folder, '/.-', '___'));
	}

	/**
	* Encode the given ID to a safe ascii representation
	*
	* @param string $id Arbitrary identifier string
	*
	* @return string Ascii representation
	*/
	public static function id_encode($id)
	{
	return rtrim(strtr(base64_encode($id), '+/', '-_'), '=');
	}

	/**
	* Convert the given identifier back to it's raw value
	*
	* @param string $id Ascii identifier
	* @return string Raw identifier string
	*/
	public static function id_decode($id)
	{
	return base64_decode(str_pad(strtr($id, '-_', '+/'), strlen($id) % 4, '=', STR_PAD_RIGHT));
	}

	/**
	* Return the (first) path of the requested IMAP namespace
	*
	* @param string Namespace name (personal, shared, other)
	* @return string IMAP root path for that namespace
	*/
	public static function namespace_root($name)
	{
	foreach ((array)self::$imap->get_namespace($name) as $paths) {
	if (strlen($paths[0]) > 1) {
	return $paths[0];
	}
	}

	return '';
	}


	/**
	* Deletes IMAP folder
	*
	* @param string $name Folder name (UTF7-IMAP)
	*
	* @return bool True on success, false on failure
	*/
	public static function folder_delete($name)
	{
	// clear cached entries first
	if ($folder = self::get_folder($name))
	$folder->cache->purge();

	$rcmail = rcube::get_instance();
	$plugin = $rcmail->plugins->exec_hook('folder_delete', array('name' => $name));

	$success = self::$imap->delete_folder($name);
	self::$last_error = self::$imap->get_error_str();

	return $success;
	}

	/**
	* Creates IMAP folder
	*
	* @param string $name Folder name (UTF7-IMAP)
	* @param string $type Folder type
	* @param bool $subscribed Sets folder subscription
	* @param bool $active Sets folder state (client-side subscription)
	*
	* @return bool True on success, false on failure
	*/
	public static function folder_create($name, $type = null, $subscribed = false, $active = false)
	{
	self::setup();

	$rcmail = rcube::get_instance();
	$plugin = $rcmail->plugins->exec_hook('folder_create', array('record' => array(
	'name' => $name,
	'subscribe' => $subscribed,
	)));

	if ($saved = self::$imap->create_folder($name, $subscribed)) {
	// set metadata for folder type
	if ($type) {
	$saved = self::set_folder_type($name, $type);

	// revert if metadata could not be set
	if (!$saved) {
	self::$imap->delete_folder($name);
	}
	// activate folder
	else if ($active) {
	self::set_state($name, true);
	}
	}
	}

	if ($saved) {
	return true;
	}

	self::$last_error = self::$imap->get_error_str();
	return false;
	}


	/**
	* Renames IMAP folder
	*
	* @param string $oldname Old folder name (UTF7-IMAP)
	* @param string $newname New folder name (UTF7-IMAP)
	*
	* @return bool True on success, false on failure
	*/
	public static function folder_rename($oldname, $newname)
	{
	self::setup();

	$rcmail = rcube::get_instance();
	$plugin = $rcmail->plugins->exec_hook('folder_rename', array(
	'oldname' => $oldname, 'newname' => $newname));

	$oldfolder = self::get_folder($oldname);
	$active = self::folder_is_active($oldname);
	$success = self::$imap->rename_folder($oldname, $newname);
	self::$last_error = self::$imap->get_error_str();

	// pass active state to new folder name
	if ($success && $active) {
	self::set_state($oldname, false);
	self::set_state($newname, true);
	}

	// assign existing cache entries to new resource uri
	if ($success && $oldfolder) {
	$oldfolder->cache->rename($newname);
	}

	return $success;
	}


	/**
	* Rename or Create a new IMAP folder.
	*
	* Does additional checks for permissions and folder name restrictions
	*
	* @param array Hash array with folder properties and metadata
	* - name: Folder name
	* - oldname: Old folder name when changed
	* - parent: Parent folder to create the new one in
	* - type: Folder type to create
	* - subscribed: Subscribed flag (IMAP subscription)
	* - active: Activation flag (client-side subscription)
	* @return mixed New folder name or False on failure
	*/
	public static function folder_update(&$prop)
	{
	self::setup();

	$folder = rcube_charset::convert($prop['name'], RCUBE_CHARSET, 'UTF7-IMAP');
	$oldfolder = $prop['oldname']; // UTF7
	$parent = $prop['parent']; // UTF7
	$delimiter = self::$imap->get_hierarchy_delimiter();

	if (strlen($oldfolder)) {
	$options = self::$imap->folder_info($oldfolder);
	}

	if (!empty($options) && ($options['norename'] \|\| $options['protected'])) {
	}
	// sanity checks (from steps/settings/save_folder.inc)
	else if (!strlen($folder)) {
	self::$last_error = 'cannotbeempty';
	return false;
	}
	else if (strlen($folder) > 128) {
	self::$last_error = 'nametoolong';
	return false;
	}
	else {
	// these characters are problematic e.g. when used in LIST/LSUB
	foreach (array($delimiter, '%', '*') as $char) {
	if (strpos($folder, $char) !== false) {
	self::$last_error = 'forbiddencharacter';
	return false;
	}
	}
	}

	if (!empty($options) && ($options['protected'] \|\| $options['norename'])) {
	$folder = $oldfolder;
	}
	else if (strlen($parent)) {
	$folder = $parent . $delimiter . $folder;
	}
	else {
	// add namespace prefix (when needed)
	$folder = self::$imap->mod_folder($folder, 'in');
	}

	// Check access rights to the parent folder
	if (strlen($parent) && (!strlen($oldfolder) \|\| $oldfolder != $folder)) {
	$parent_opts = self::$imap->folder_info($parent);
	if ($parent_opts['namespace'] != 'personal'
	&& (empty($parent_opts['rights']) \|\| !preg_match('/[ck]/', implode($parent_opts['rights'])))
	) {
	self::$last_error = 'No permission to create folder';
	return false;
	}
	}

	// update the folder name
	if (strlen($oldfolder)) {
	if ($oldfolder != $folder) {
	$result = self::folder_rename($oldfolder, $folder);
	}
	else
	$result = true;
	}
	// create new folder
	else {
	$result = self::folder_create($folder, $prop['type'], $prop['subscribed'], $prop['active']);
	}

	if ($result) {
	self::set_folder_props($folder, $prop);
	}

	return $result ? $folder : false;
	}


	/**
	* Getter for human-readable name of Kolab object (folder)
	* See http://wiki.kolab.org/UI-Concepts/Folder-Listing for reference
	*
	* @param string $folder IMAP folder name (UTF7-IMAP)
	* @param string $folder_ns Will be set to namespace name of the folder
	*
	* @return string Name of the folder-object
	*/
	public static function object_name($folder, &$folder_ns=null)
	{
	self::setup();

	// find custom display name in folder METADATA
	if ($name = self::custom_displayname($folder)) {
	return $name;
	}

	$found = false;
	$namespace = self::$imap->get_namespace();

	if (!empty($namespace['shared'])) {
	foreach ($namespace['shared'] as $ns) {
	if (strlen($ns[0]) && strpos($folder, $ns[0]) === 0) {
	$prefix = '';
	$folder = substr($folder, strlen($ns[0]));
	$delim = $ns[1];
	$found = true;
	$folder_ns = 'shared';
	break;
	}
	}
	}
	if (!$found && !empty($namespace['other'])) {
	foreach ($namespace['other'] as $ns) {
	if (strlen($ns[0]) && strpos($folder, $ns[0]) === 0) {
	// remove namespace prefix
	$folder = substr($folder, strlen($ns[0]));
	$delim = $ns[1];
	// get username
	$pos = strpos($folder, $delim);
	if ($pos) {
	$prefix = '('.substr($folder, 0, $pos).')';
	$folder = substr($folder, $pos+1);
	}
	else {
	$prefix = '('.$folder.')';
	$folder = '';
	}

	$found = true;
	$folder_ns = 'other';
	break;
	}
	}
	}
	if (!$found && !empty($namespace['personal'])) {
	foreach ($namespace['personal'] as $ns) {
	if (strlen($ns[0]) && strpos($folder, $ns[0]) === 0) {
	// remove namespace prefix
	$folder = substr($folder, strlen($ns[0]));
	$prefix = '';
	$delim = $ns[1];
	$found = true;
	break;
	}
	}
	}

	if (empty($delim))
	$delim = self::$imap->get_hierarchy_delimiter();

	$folder = rcube_charset::convert($folder, 'UTF7-IMAP');
	$folder = html::quote($folder);
	$folder = str_replace(html::quote($delim), ' » ', $folder);

	if ($prefix)
	$folder = html::quote($prefix) . ($folder !== '' ? ' ' . $folder : '');

	if (!$folder_ns)
	$folder_ns = 'personal';

	return $folder;
	}

	/**
	* Get custom display name (saved in metadata) for the given folder
	*/
	public static function custom_displayname($folder)
	{
	// find custom display name in folder METADATA
	if (self::$config->get('kolab_custom_display_names', true)) {
	$metadata = self::$imap->get_metadata($folder, array(self::NAME_KEY_PRIVATE, self::NAME_KEY_SHARED));
	if (($name = $metadata[$folder][self::NAME_KEY_PRIVATE]) \|\| ($name = $metadata[$folder][self::NAME_KEY_SHARED])) {
	return $name;
	}
	}

	return false;
	}

	/**
	* Helper method to generate a truncated folder name to display.
	* Note: $origname is a string returned by self::object_name()
	*/
	public static function folder_displayname($origname, &$names)
	{
	$name = $origname;

	// find folder prefix to truncate
	for ($i = count($names)-1; $i >= 0; $i--) {
	if (strpos($name, $names[$i] . ' » ') === 0) {
	$length = strlen($names[$i] . ' » ');
	$prefix = substr($name, 0, $length);
	$count = count(explode(' » ', $prefix));
	$diff = 1;

	// check if prefix folder is in other users namespace
	for ($n = count($names)-1; $n >= 0; $n--) {
	if (strpos($prefix, '(' . $names[$n] . ') ') === 0) {
	$diff = 0;
	break;
	}
	}

	$name = str_repeat('   ', $count - $diff) . '» ' . substr($name, $length);
	break;
	}
	// other users namespace and parent folder exists
	else if (strpos($name, '(' . $names[$i] . ') ') === 0) {
	$length = strlen('(' . $names[$i] . ') ');
	$prefix = substr($name, 0, $length);
	$count = count(explode(' » ', $prefix));
	$name = str_repeat('   ', $count) . '» ' . substr($name, $length);
	break;
	}
	}

	$names[] = $origname;

	return $name;
	}


	/**
	* Creates a SELECT field with folders list
	*
	* @param string $type Folder type
	* @param array $attrs SELECT field attributes (e.g. name)
	* @param string $current The name of current folder (to skip it)
	*
	* @return html_select SELECT object
	*/
	public static function folder_selector($type, $attrs, $current = '')
	{
	// get all folders of specified type (sorted)
	$folders = self::get_folders($type, true);

	$delim = self::$imap->get_hierarchy_delimiter();
	$names = array();
	$len = strlen($current);

	if ($len && ($rpos = strrpos($current, $delim))) {
	$parent = substr($current, 0, $rpos);
	$p_len = strlen($parent);
	}

	// Filter folders list
	foreach ($folders as $c_folder) {
	$name = $c_folder->name;

	// skip current folder and it's subfolders
	if ($len) {
	if ($name == $current) {
	// Make sure parent folder is listed (might be skipped e.g. if it's namespace root)
	if ($p_len && !isset($names[$parent])) {
	$names[$parent] = self::object_name($parent);
	}
	continue;
	}
	if (strpos($name, $current.$delim) === 0) {
	continue;
	}
	}

	// always show the parent of current folder
	if ($p_len && $name == $parent) {
	}
	// skip folders where user have no rights to create subfolders
	else if ($c_folder->get_owner() != $_SESSION['username']) {
	$rights = $c_folder->get_myrights();
	if (!preg_match('/[ck]/', $rights)) {
	continue;
	}
	}

	$names[$name] = self::object_name($name);
	}

	// Build SELECT field of parent folder
	$attrs['is_escaped'] = true;
	$select = new html_select($attrs);
	$select->add('---', '');

	$listnames = array();
	foreach (array_keys($names) as $imap_name) {
	$name = $origname = $names[$imap_name];

	// find folder prefix to truncate
	for ($i = count($listnames)-1; $i >= 0; $i--) {
	if (strpos($name, $listnames[$i].' » ') === 0) {
	$length = strlen($listnames[$i].' » ');
	$prefix = substr($name, 0, $length);
	$count = count(explode(' » ', $prefix));
	$name = str_repeat('  ', $count-1) . '» ' . substr($name, $length);
	break;
	}
	}

	$listnames[] = $origname;
	$select->add($name, $imap_name);
	}

	return $select;
	}


	/**
	* Returns a list of folder names
	*
	* @param string Optional root folder
	* @param string Optional name pattern
	* @param string Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
	* @param boolean Enable to return subscribed folders only (null to use configured subscription mode)
	* @param array Will be filled with folder-types data
	*
	* @return array List of folders
	*/
	public static function list_folders($root = '', $mbox = '*', $filter = null, $subscribed = null, &$folderdata = array())
	{
	if (!self::setup()) {
	return null;
	}

	// use IMAP subscriptions
	if ($subscribed === null && self::$config->get('kolab_use_subscriptions')) {
	$subscribed = true;
	}

	if (!$filter) {
	// Get ALL folders list, standard way
	if ($subscribed) {
	$folders = self::$imap->list_folders_subscribed($root, $mbox);
	// add temporarily subscribed folders
	if (self::$with_tempsubs && is_array($_SESSION['kolab_subscribed_folders'])) {
	$folders = array_unique(array_merge($folders, $_SESSION['kolab_subscribed_folders']));
	}
	}
	else {
	$folders = self::_imap_list_folders($root, $mbox);
	}

	return $folders;
	}
	$prefix = $root . $mbox;
	$regexp = '/^' . preg_quote($filter, '/') . '(\..+)?$/';

	// get folders types for all folders
	if (!$subscribed \|\| $prefix == '*' \|\| !self::$config->get('kolab_skip_namespace')) {
	$folderdata = self::folders_typedata($prefix);
	}
	else {
	// fetch folder types for the effective list of (subscribed) folders when post-filtering
	$folderdata = array();
	}

	if (!is_array($folderdata)) {
	return array();
	}

	// In some conditions we can skip LIST command (?)
	if (!$subscribed && $filter != 'mail' && $prefix == '*') {
	foreach ($folderdata as $folder => $type) {
	if (!preg_match($regexp, $type)) {
	unset($folderdata[$folder]);
	}
	}

	return self::$imap->sort_folder_list(array_keys($folderdata), true);
	}

	// Get folders list
	if ($subscribed) {
	$folders = self::$imap->list_folders_subscribed($root, $mbox);

	// add temporarily subscribed folders
	if (self::$with_tempsubs && is_array($_SESSION['kolab_subscribed_folders'])) {
	$folders = array_unique(array_merge($folders, $_SESSION['kolab_subscribed_folders']));
	}
	}
	else {
	$folders = self::_imap_list_folders($root, $mbox);
	}

	// In case of an error, return empty list (?)
	if (!is_array($folders)) {
	return array();
	}

	// Filter folders list
	foreach ($folders as $idx => $folder) {
	// lookup folder type
	if (!array_key_exists($folder, $folderdata)) {
	$folderdata[$folder] = self::folder_type($folder);
	}

	$type = $folderdata[$folder];

	if ($filter == 'mail' && empty($type)) {
	continue;
	}
	if (empty($type) \|\| !preg_match($regexp, $type)) {
	unset($folders[$idx]);
	}
	}

	return $folders;
	}

	/**
	* Wrapper for rcube_imap::list_folders() with optional post-filtering
	*/
	protected static function _imap_list_folders($root, $mbox)
	{
	$postfilter = null;

	// compose a post-filter expression for the excluded namespaces
	if ($root . $mbox == '*' && ($skip_ns = self::$config->get('kolab_skip_namespace'))) {
	$excludes = array();
	foreach ((array)$skip_ns as $ns) {
	if ($ns_root = self::namespace_root($ns)) {
	$excludes[] = $ns_root;
	}
	}

	if (count($excludes)) {
	$postfilter = '!^(' . join(')\|(', array_map('preg_quote', $excludes)) . ')!';
	}
	}

	// use normal LIST command to return all folders, it's fast enough
	$folders = self::$imap->list_folders($root, $mbox, null, null, !empty($postfilter));

	if (!empty($postfilter)) {
	$folders = array_filter($folders, function($folder) use ($postfilter) { return !preg_match($postfilter, $folder); });
	$folders = self::$imap->sort_folder_list($folders);
	}

	return $folders;
	}


	/**
	* Search for shared or otherwise not listed groupware folders the user has access
	*
	* @param string Folder type of folders to search for
	* @param string Search string
	* @param array Namespace(s) to exclude results from
	*
	* @return array List of matching kolab_storage_folder objects
	*/
	public static function search_folders($type, $query, $exclude_ns = array())
	{
	if (!self::setup()) {
	return array();
	}

	$folders = array();
	$query = str_replace('*', '', $query);

	// find unsubscribed IMAP folders of the given type
	foreach ((array)self::list_folders('', '*', $type, false, $folderdata) as $foldername) {
	// FIXME: only consider the last part of the folder path for searching?
	$realname = strtolower(rcube_charset::convert($foldername, 'UTF7-IMAP'));
	if (($query == '' \|\| strpos($realname, $query) !== false) &&
	!self::folder_is_subscribed($foldername, true) &&
	!in_array(self::$imap->folder_namespace($foldername), (array)$exclude_ns)
	) {
	$folders[] = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
	}
	}

	return $folders;
	}


	/**
	* Sort the given list of kolab folders by namespace/name
	*
	* @param array List of kolab_storage_folder objects
	* @return array Sorted list of folders
	*/
	public static function sort_folders($folders)
	{
	$pad = ' ';
	$out = array();
	$nsnames = array('personal' => array(), 'shared' => array(), 'other' => array());

	foreach ($folders as $folder) {
	$folders[$folder->name] = $folder;
	$ns = $folder->get_namespace();
	$nsnames[$ns][$folder->name] = strtolower(html_entity_decode(self::object_name($folder->name, $ns), ENT_COMPAT, RCUBE_CHARSET)) . $pad; // decode »
	}

	// $folders is a result of get_folders() we can assume folders were already sorted
	foreach (array_keys($nsnames) as $ns) {
	asort($nsnames[$ns], SORT_LOCALE_STRING);
	foreach (array_keys($nsnames[$ns]) as $utf7name) {
	$out[] = $folders[$utf7name];
	}
	}

	return $out;
	}


	/**
	* Check the folder tree and add the missing parents as virtual folders
	*
	* @param array $folders Folders list
	* @param object $tree Reference to the root node of the folder tree
	*
	* @return array Flat folders list
	*/
	public static function folder_hierarchy($folders, &$tree = null)
	{
	$_folders = array();
	$delim = self::$imap->get_hierarchy_delimiter();
	$other_ns = rtrim(self::namespace_root('other'), $delim);
	$tree = new kolab_storage_folder_virtual('', '<root>', ''); // create tree root
	$refs = array('' => $tree);

	foreach ($folders as $idx => $folder) {
	$path = explode($delim, $folder->name);
	array_pop($path);
	$folder->parent = join($delim, $path);
	$folder->children = array(); // reset list

	// skip top folders or ones with a custom displayname
	if (count($path) < 1 \|\| kolab_storage::custom_displayname($folder->name)) {
	$tree->children[] = $folder;
	}
	else {
	$parents = array();
	$depth = $folder->get_namespace() == 'personal' ? 1 : 2;

	while (count($path) >= $depth && ($parent = join($delim, $path))) {
	array_pop($path);
	$parent_parent = join($delim, $path);
	if (!$refs[$parent]) {
	if ($folder->type && self::folder_type($parent) == $folder->type) {
	$refs[$parent] = new kolab_storage_folder($parent, $folder->type, $folder->type);
	$refs[$parent]->parent = $parent_parent;
	}
	else if ($parent_parent == $other_ns) {
	$refs[$parent] = new kolab_storage_folder_user($parent, $parent_parent);
	}
	else {
	$name = kolab_storage::object_name($parent, $folder->get_namespace());
	$refs[$parent] = new kolab_storage_folder_virtual($parent, $name, $folder->get_namespace(), $parent_parent);
	}
	$parents[] = $refs[$parent];
	}
	}

	if (!empty($parents)) {
	$parents = array_reverse($parents);
	foreach ($parents as $parent) {
	$parent_node = $refs[$parent->parent] ?: $tree;
	$parent_node->children[] = $parent;
	$_folders[] = $parent;
	}
	}

	$parent_node = $refs[$folder->parent] ?: $tree;
	$parent_node->children[] = $folder;
	}

	$refs[$folder->name] = $folder;
	$_folders[] = $folder;
	unset($folders[$idx]);
	}

	return $_folders;
	}


	/**
	* Returns folder types indexed by folder name
	*
	* @param string $prefix Folder prefix (Default '*' for all folders)
	*
	* @return array\|bool List of folders, False on failure
	*/
	public static function folders_typedata($prefix = '*')
	{
	if (!self::setup()) {
	return false;
	}

	// return cached result
	if (is_array(self::$typedata[$prefix])) {
	return self::$typedata[$prefix];
	}

	$type_keys = array(self::CTYPE_KEY, self::CTYPE_KEY_PRIVATE);

	// fetch metadata from some folders only
	if (($prefix == '*' \|\| $prefix == '') && ($skip_ns = self::$config->get('kolab_skip_namespace'))) {
	$delimiter = self::$imap->get_hierarchy_delimiter();
	$folderdata = $blacklist = array();
	foreach ((array)$skip_ns as $ns) {
	if ($ns_root = rtrim(self::namespace_root($ns), $delimiter)) {
	$blacklist[] = $ns_root;
	}
	}
	foreach (array('personal','other','shared') as $ns) {
	if (!in_array($ns, (array)$skip_ns)) {
	$ns_root = rtrim(self::namespace_root($ns), $delimiter);

	// list top-level folders and their childs one by one
	// GETMETADATA "%" doesn't list shared or other namespace folders but "*" would
	if ($ns_root == '') {
	foreach ((array)self::$imap->get_metadata('%', $type_keys) as $folder => $metadata) {
	if (!in_array($folder, $blacklist)) {
	$folderdata[$folder] = $metadata;
	$opts = self::$imap->folder_attributes($folder);
	if (!in_array('\\HasNoChildren', $opts) && ($data = self::$imap->get_metadata($folder.$delimiter.'*', $type_keys))) {
	$folderdata += $data;
	}
	}
	}
	}
	else if ($data = self::$imap->get_metadata($ns_root.$delimiter.'*', $type_keys)) {
	$folderdata += $data;
	}
	}
	}
	}
	else {
	$folderdata = self::$imap->get_metadata($prefix, $type_keys);
	}

	if (!is_array($folderdata)) {
	return false;
	}

	// keep list in memory
	self::$typedata[$prefix] = array_map(array('kolab_storage', 'folder_select_metadata'), $folderdata);

	return self::$typedata[$prefix];
	}


	/**
	* Callback for array_map to select the correct annotation value
	*/
	public static function folder_select_metadata($types)
	{
	if (!empty($types[self::CTYPE_KEY_PRIVATE])) {
	return $types[self::CTYPE_KEY_PRIVATE];
	}
	else if (!empty($types[self::CTYPE_KEY])) {
	list($ctype, ) = explode('.', $types[self::CTYPE_KEY]);
	return $ctype;
	}
	return null;
	}


	/**
	* Returns type of IMAP folder
	*
	* @param string $folder Folder name (UTF7-IMAP)
	*
	* @return string Folder type
	*/
	public static function folder_type($folder)
	{
	self::setup();

	// return in-memory cached result
	foreach (self::$typedata as $typedata) {
	if (array_key_exists($folder, $typedata)) {
	return $typedata[$folder];
	}
	}

	$metadata = self::$imap->get_metadata($folder, array(self::CTYPE_KEY, self::CTYPE_KEY_PRIVATE));

	if (!is_array($metadata)) {
	return null;
	}

	if (!empty($metadata[$folder])) {
	return self::folder_select_metadata($metadata[$folder]);
	}

	return 'mail';
	}


	/**
	* Sets folder content-type.
	*
	* @param string $folder Folder name
	* @param string $type Content type
	*
	* @return boolean True on success
	*/
	public static function set_folder_type($folder, $type='mail')
	{
	self::setup();

	list($ctype, $subtype) = explode('.', $type);

	$success = self::$imap->set_metadata($folder, array(self::CTYPE_KEY => $ctype, self::CTYPE_KEY_PRIVATE => $subtype ? $type : null));

	if (!$success) // fallback: only set private annotation
	$success \|= self::$imap->set_metadata($folder, array(self::CTYPE_KEY_PRIVATE => $type));

	return $success;
	}


	/**
	* Check subscription status of this folder
	*
	* @param string $folder Folder name
	* @param boolean $temp Include temporary/session subscriptions
	*
	* @return boolean True if subscribed, false if not
	*/
	public static function folder_is_subscribed($folder, $temp = false)
	{
	if (self::$subscriptions === null) {
	self::setup();
	self::$with_tempsubs = false;
	self::$subscriptions = self::$imap->list_folders_subscribed();
	self::$with_tempsubs = true;
	}

	return in_array($folder, self::$subscriptions) \|\|
	($temp && in_array($folder, (array)$_SESSION['kolab_subscribed_folders']));
	}


	/**
	* Change subscription status of this folder
	*
	* @param string $folder Folder name
	* @param boolean $temp Only subscribe temporarily for the current session
	*
	* @return True on success, false on error
	*/
	public static function folder_subscribe($folder, $temp = false)
	{
	self::setup();

	// temporary/session subscription
	if ($temp) {
	if (self::folder_is_subscribed($folder)) {
	return true;
	}
	else if (!is_array($_SESSION['kolab_subscribed_folders']) \|\| !in_array($folder, $_SESSION['kolab_subscribed_folders'])) {
	$_SESSION['kolab_subscribed_folders'][] = $folder;
	return true;
	}
	}
	else if (self::$imap->subscribe($folder)) {
	self::$subscriptions = null;
	return true;
	}

	return false;
	}


	/**
	* Change subscription status of this folder
	*
	* @param string $folder Folder name
	* @param boolean $temp Only remove temporary subscription
	*
	* @return True on success, false on error
	*/
	public static function folder_unsubscribe($folder, $temp = false)
	{
	self::setup();

	// temporary/session subscription
	if ($temp) {
	if (is_array($_SESSION['kolab_subscribed_folders']) && ($i = array_search($folder, $_SESSION['kolab_subscribed_folders'])) !== false) {
	unset($_SESSION['kolab_subscribed_folders'][$i]);
	}
	return true;
	}
	else if (self::$imap->unsubscribe($folder)) {
	self::$subscriptions = null;
	return true;
	}

	return false;
	}


	/**
	* Check activation status of this folder
	*
	* @param string $folder Folder name
	*
	* @return boolean True if active, false if not
	*/
	public static function folder_is_active($folder)
	{
	$active_folders = self::get_states();

	return in_array($folder, $active_folders);
	}


	/**
	* Change activation status of this folder
	*
	* @param string $folder Folder name
	*
	* @return True on success, false on error
	*/
	public static function folder_activate($folder)
	{
	// activation implies temporary subscription
	self::folder_subscribe($folder, true);
	return self::set_state($folder, true);
	}


	/**
	* Change activation status of this folder
	*
	* @param string $folder Folder name
	*
	* @return True on success, false on error
	*/
	public static function folder_deactivate($folder)
	{
	// remove from temp subscriptions, really?
	self::folder_unsubscribe($folder, true);

	return self::set_state($folder, false);
	}


	/**
	* Return list of active folders
	*/
	private static function get_states()
	{
	if (self::$states !== null) {
	return self::$states;
	}

	$rcube = rcube::get_instance();
	$folders = $rcube->config->get('kolab_active_folders');

	if ($folders !== null) {
	self::$states = !empty($folders) ? explode('**', $folders) : array();
	}
	// for backward-compatibility copy server-side subscriptions to activation states
	else {
	self::setup();
	if (self::$subscriptions === null) {
	self::$with_tempsubs = false;
	self::$subscriptions = self::$imap->list_folders_subscribed();
	self::$with_tempsubs = true;
	}
	self::$states = self::$subscriptions;
	$folders = implode(self::$states, '**');
	$rcube->user->save_prefs(array('kolab_active_folders' => $folders));
	}

	return self::$states;
	}


	/**
	* Update list of active folders
	*/
	private static function set_state($folder, $state)
	{
	self::get_states();

	// update in-memory list
	$idx = array_search($folder, self::$states);
	if ($state && $idx === false) {
	self::$states[] = $folder;
	}
	else if (!$state && $idx !== false) {
	unset(self::$states[$idx]);
	}

	// update user preferences
	$folders = implode(self::$states, '**');
	$rcube = rcube::get_instance();
	return $rcube->user->save_prefs(array('kolab_active_folders' => $folders));
	}

	/**
	* Creates default folder of specified type
	* To be run when none of subscribed folders (of specified type) is found
	*
	* @param string $type Folder type
	* @param string $props Folder properties (color, etc)
	*
	* @return string Folder name
	*/
	public static function create_default_folder($type, $props = array())
	{
	if (!self::setup()) {
	return;
	}

	$folders = self::$imap->get_metadata('*', array(kolab_storage::CTYPE_KEY_PRIVATE));

	// from kolab_folders config
	$folder_type = strpos($type, '.') ? str_replace('.', '_', $type) : $type . '_default';
	$default_name = self::$config->get('kolab_folders_' . $folder_type);
	$folder_type = str_replace('_', '.', $folder_type);

	// check if we have any folder in personal namespace
	// folder(s) may exist but not subscribed
	foreach ((array)$folders as $f => $data) {
	if (strpos($data[self::CTYPE_KEY_PRIVATE], $type) === 0) {
	$folder = $f;
	break;
	}
	}

	if (!$folder) {
	if (!$default_name) {
	$default_name = self::$default_folders[$type];
	}

	if (!$default_name) {
	return;
	}

	$folder = rcube_charset::convert($default_name, RCUBE_CHARSET, 'UTF7-IMAP');
	$prefix = self::$imap->get_namespace('prefix');

	// add personal namespace prefix if needed
	if ($prefix && strpos($folder, $prefix) !== 0 && $folder != 'INBOX') {
	$folder = $prefix . $folder;
	}

	if (!self::$imap->folder_exists($folder)) {
	if (!self::$imap->create_folder($folder)) {
	return;
	}
	}

	self::set_folder_type($folder, $folder_type);
	}

	self::folder_subscribe($folder);

	if ($props['active']) {
	self::set_state($folder, true);
	}

	if (!empty($props)) {
	self::set_folder_props($folder, $props);
	}

	return $folder;
	}

	/**
	* Sets folder metadata properties
	*
	* @param string $folder Folder name
	* @param array $prop Folder properties
	*/
	public static function set_folder_props($folder, &$prop)
	{
	if (!self::setup()) {
	return;
	}

	// TODO: also save 'showalarams' and other properties here
	$ns = self::$imap->folder_namespace($folder);
	$supported = array(
	'color' => array(self::COLOR_KEY_SHARED, self::COLOR_KEY_PRIVATE),
	'displayname' => array(self::NAME_KEY_SHARED, self::NAME_KEY_PRIVATE),
	);

	foreach ($supported as $key => $metakeys) {
	if (array_key_exists($key, $prop)) {
	$meta_saved = false;
	if ($ns == 'personal') // save in shared namespace for personal folders
	$meta_saved = self::$imap->set_metadata($folder, array($metakeys[0] => $prop[$key]));
	if (!$meta_saved) // try in private namespace
	$meta_saved = self::$imap->set_metadata($folder, array($metakeys[1] => $prop[$key]));
	if ($meta_saved)
	unset($prop[$key]); // unsetting will prevent fallback to local user prefs
	}
	}
	}


	/**
	*
	* @param mixed $query Search value (or array of field => value pairs)
	* @param int $mode Matching mode: 0 - partial (abc), 1 - strict (=), 2 - prefix (abc*)
	* @param array $required List of fields that shall ot be empty
	* @param int $limit Maximum number of records
	* @param int $count Returns the number of records found
	*
	* @return array List or false on error
	*/
	public static function search_users($query, $mode = 1, $required = array(), $limit = 0, &$count = 0)
	{
	$query = str_replace('*', '', $query);

	// requires a working LDAP setup
	if (!self::ldap() \|\| strlen($query) == 0) {
	return array();
	}

	// search users using the configured attributes
	$results = self::$ldap->dosearch(self::$config->get('kolab_users_search_attrib', array('cn','mail','alias')), $query, $mode, $required, $limit, $count);

	// exclude myself
	if ($_SESSION['kolab_dn']) {
	unset($results[$_SESSION['kolab_dn']]);
	}

	// resolve to IMAP folder name
	$root = self::namespace_root('other');
	$user_attrib = self::$config->get('kolab_users_id_attrib', self::$config->get('kolab_auth_login', 'mail'));

	array_walk($results, function(&$user, $dn) use ($root, $user_attrib) {
	list($localpart, ) = explode('@', $user[$user_attrib]);
	$user['kolabtargetfolder'] = $root . $localpart;
	});

	return $results;
	}


	/**
	* Returns a list of IMAP folders shared by the given user
	*
	* @param array User entry from LDAP
	* @param string Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
	* @param boolean Return subscribed folders only (null to use configured subscription mode)
	* @param array Will be filled with folder-types data
	*
	* @return array List of folders
	*/
	public static function list_user_folders($user, $type, $subscribed = null, &$folderdata = array())
	{
	self::setup();

	$folders = array();

	// use localpart of user attribute as root for folder listing
	$user_attrib = self::$config->get('kolab_users_id_attrib', self::$config->get('kolab_auth_login', 'mail'));
	if (!empty($user[$user_attrib])) {
	list($mbox) = explode('@', $user[$user_attrib]);

	$delimiter = self::$imap->get_hierarchy_delimiter();
	$other_ns = self::namespace_root('other');
	$folders = self::list_folders($other_ns . $mbox . $delimiter, '*', $type, $subscribed, $folderdata);
	}

	return $folders;
	}


	/**
	* Get a list of (virtual) top-level folders from the other users namespace
	*
	* @param string Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
	* @param boolean Enable to return subscribed folders only (null to use configured subscription mode)
	*
	* @return array List of kolab_storage_folder_user objects
	*/
	public static function get_user_folders($type, $subscribed)
	{
	$folders = $folderdata = array();

	if (self::setup()) {
	$delimiter = self::$imap->get_hierarchy_delimiter();
	$other_ns = rtrim(self::namespace_root('other'), $delimiter);
	$path_len = count(explode($delimiter, $other_ns));

	foreach ((array)self::list_folders($other_ns . $delimiter, '*', '', $subscribed) as $foldername) {
	if ($foldername == 'INBOX') // skip INBOX which is added by default
	continue;

	$path = explode($delimiter, $foldername);

	// compare folder type if a subfolder is listed
	if ($type && count($path) > $path_len + 1 && $type != self::folder_type($foldername)) {
	continue;
	}

	// truncate folder path to top-level folders of the 'other' namespace
	$foldername = join($delimiter, array_slice($path, 0, $path_len + 1));

	if (!$folders[$foldername]) {
	$folders[$foldername] = new kolab_storage_folder_user($foldername, $other_ns);
	}
	}

	// for every (subscribed) user folder, list all (unsubscribed) subfolders
	foreach ($folders as $userfolder) {
	foreach ((array)self::list_folders($userfolder->name . $delimiter, '*', $type, false, $folderdata) as $foldername) {
	if (!$folders[$foldername]) {
	$folders[$foldername] = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
	$userfolder->children[] = $folders[$foldername];
	}
	}
	}
	}

	return $folders;
	}


	/**
	* Handler for user_delete plugin hooks
	*
	* Remove all cache data from the local database related to the given user.
	*/
	public static function delete_user_folders($args)
	{
	$db = rcmail::get_instance()->get_dbh();
	$prefix = 'imap://' . urlencode($args['username']) . '@' . $args['host'] . '/%';
	$db->query("DELETE FROM " . $db->table_name('kolab_folders', true) . " WHERE `resource` LIKE ?", $prefix);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Feb 2, 12:23 PM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 426891
Default Alt Text: (100 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions