No OneTemporary
Actions

Authored By

Unknown

Size

94 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/plugins/libkolab/lib/kolab_storage_config.php b/plugins/libkolab/lib/kolab_storage_config.php
	index 302392ff..771b9ff1 100644
	--- a/plugins/libkolab/lib/kolab_storage_config.php
	+++ b/plugins/libkolab/lib/kolab_storage_config.php
	@@ -1,1008 +1,1013 @@
	<?php

	/**
	* Kolab storage class providing access to configuration 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_config
	{
	const FOLDER_TYPE = 'configuration';
	const MAX_RELATIONS = 499; // should be less than kolab_storage_cache::MAX_RECORDS

	/**
	* Singleton instace of kolab_storage_config
	*
	* @var kolab_storage_config
	*/
	static protected $instance;

	private $folders;
	private $default;
	private $enabled;
	private $tags;


	/**
	* This implements the 'singleton' design pattern
	*
	* @return kolab_storage_config The one and only instance
	*/
	static function get_instance()
	{
	if (!self::$instance) {
	self::$instance = new kolab_storage_config();
	}

	return self::$instance;
	}

	/**
	* Private constructor (finds default configuration folder as a config source)
	*/
	private function _init()
	{
	if ($this->enabled !== null) {
	return $this->enabled;
	}

	// get all configuration folders
	$this->folders = kolab_storage::get_folders(self::FOLDER_TYPE, false);

	foreach ($this->folders as $folder) {
	if ($folder->default) {
	$this->default = $folder;
	break;
	}
	}

	// if no folder is set as default, choose the first one
	if (!$this->default) {
	$this->default = reset($this->folders);
	}

	// attempt to create a default folder if it does not exist
	if (!$this->default) {
	$folder_name = 'Configuration';
	$folder_type = self::FOLDER_TYPE . '.default';

	if (kolab_storage::folder_create($folder_name, $folder_type, true)) {
	$this->default = new kolab_storage_folder($folder_name, $folder_type);
	}
	}

	// check if configuration folder exist
	return $this->enabled = $this->default && $this->default->name;
	}

	/**
	* Check wether any configuration storage (folder) exists
	*
	* @return bool
	*/
	public function is_enabled()
	{
	return $this->_init();
	}

	/**
	* Get configuration objects
	*
	* @param array $filter Search filter
	* @param bool $default Enable to get objects only from default folder
	* @param int $limit Max. number of records (per-folder)
	*
	* @return array List of objects
	*/
	public function get_objects($filter = array(), $default = false, $limit = 0)
	{
	$list = array();

	if (!$this->is_enabled()) {
	return $list;
	}

	foreach ($this->folders as $folder) {
	// we only want to read from default folder
	if ($default && !$folder->default) {
	continue;
	}

	// for better performance it's good to assume max. number of records
	if ($limit) {
	$folder->set_order_and_limit(null, $limit);
	}

	foreach ($folder->select($filter) as $object) {
	unset($object['_formatobj']);
	$list[] = $object;
	}
	}

	return $list;
	}

	/**
	* Get configuration object
	*
	* @param string $uid Object UID
	* @param bool $default Enable to get objects only from default folder
	*
	* @return array Object data
	*/
	public function get_object($uid, $default = false)
	{
	if (!$this->is_enabled()) {
	return;
	}

	foreach ($this->folders as $folder) {
	// we only want to read from default folder
	if ($default && !$folder->default) {
	continue;
	}

	if ($object = $folder->get_object($uid)) {
	return $object;
	}
	}
	}

	/**
	* Create/update configuration object
	*
	* @param array $object Object data
	* @param string $type Object type
	*
	* @return bool True on success, False on failure
	*/
	public function save(&$object, $type)
	{
	if (!$this->is_enabled()) {
	return false;
	}

	$folder = $this->find_folder($object);

	if ($type) {
	$object['type'] = $type;
	}

	$status = $folder->save($object, self::FOLDER_TYPE . '.' . $object['type'], $object['uid']);

	// on success, update cached tags list
	if ($status && is_array($this->tags)) {
	$found = false;
	unset($object['_formatobj']); // we don't need it anymore

	foreach ($this->tags as $idx => $tag) {
	if ($tag['uid'] == $object['uid']) {
	$found = true;
	$this->tags[$idx] = $object;
	}
	}

	if (!$found) {
	$this->tags[] = $object;
	}
	}

	return !empty($status);
	}

	/**
	* Remove configuration object
	*
	* @param string\|array $object Object array or its UID
	*
	* @return bool True on success, False on failure
	*/
	public function delete($object)
	{
	if (!$this->is_enabled()) {
	return false;
	}

	// fetch the object to find folder
	if (!is_array($object)) {
	$object = $this->get_object($object);
	}

	if (!$object) {
	return false;
	}

	$folder = $this->find_folder($object);
	$status = $folder->delete($object);

	// on success, update cached tags list
	if ($status && is_array($this->tags)) {
	foreach ($this->tags as $idx => $tag) {
	if ($tag['uid'] == $uid) {
	unset($this->tags[$idx]);
	break;
	}
	}
	}

	return $status;
	}

	/**
	* Find folder
	*/
	public function find_folder($object = array())
	{
	if (!$this->is_enabled()) {
	return;
	}

	// find folder object
	if ($object['_mailbox']) {
	foreach ($this->folders as $folder) {
	if ($folder->name == $object['_mailbox']) {
	break;
	}
	}
	}
	else {
	$folder = $this->default;
	}

	return $folder;
	}

	/**
	* Builds relation member URI
	*
	* @param string\|array Object UUID or Message folder, UID, Search headers (Message-Id, Date)
	*
	* @return string $url Member URI
	*/
	public static function build_member_url($params)
	{
	// param is object UUID
	if (is_string($params) && !empty($params)) {
	return 'urn:uuid:' . $params;
	}

	if (empty($params) \|\| !strlen($params['folder'])) {
	return null;
	}

	$rcube = rcube::get_instance();
	$storage = $rcube->get_storage();
	list($username, $domain) = explode('@', $rcube->get_user_name());

	if (strlen($domain)) {
	$domain = '@' . $domain;
	}

	// modify folder spec. according to namespace
	$folder = $params['folder'];
	$ns = $storage->folder_namespace($folder);

	if ($ns == 'shared') {
	// Note: this assumes there's only one shared namespace root
	if ($ns = $storage->get_namespace('shared')) {
	if ($prefix = $ns[0][0]) {
	$folder = substr($folder, strlen($prefix));
	}
	}
	}
	else {
	if ($ns == 'other') {
	// Note: this assumes there's only one other users namespace root
	if ($ns = $storage->get_namespace('other')) {
	if ($prefix = $ns[0][0]) {
	list($otheruser, $path) = explode('/', substr($folder, strlen($prefix)), 2);
	$folder = 'user/' . $otheruser . $domain . '/' . $path;
	}
	}
	}
	else {
	$folder = 'user/' . $username . $domain . '/' . $folder;
	}
	}

	$folder = implode('/', array_map('rawurlencode', explode('/', $folder)));

	// build URI
	$url = 'imap:///' . $folder;

	// UID is optional here because sometimes we want
	// to build just a member uri prefix
	if ($params['uid']) {
	$url .= '/' . $params['uid'];
	}

	unset($params['folder']);
	unset($params['uid']);

	if (!empty($params)) {
	$url .= '?' . http_build_query($params, '', '&');
	}

	return $url;
	}

	/**
	* Parses relation member string
	*
	* @param string $url Member URI
	*
	* @return array Message folder, UID, Search headers (Message-Id, Date)
	*/
	public static function parse_member_url($url)
	{
	// Look for IMAP URI:
	// imap:///(user/username@domain\|shared)/<folder>/<UID>?<search_params>
	if (strpos($url, 'imap:///') === 0) {
	$rcube = rcube::get_instance();
	$storage = $rcube->get_storage();

	// parse_url does not work with imap:/// prefix
	$url = parse_url(substr($url, 8));
	$path = explode('/', $url['path']);
	parse_str($url['query'], $params);

	$uid = array_pop($path);
	$ns = array_shift($path);
	$path = array_map('rawurldecode', $path);

	// resolve folder name
	if ($ns == 'user') {
	$username = array_shift($path);
	$folder = implode('/', $path);

	if ($username != $rcube->get_user_name()) {
	list($user, $domain) = explode('@', $username);

	// Note: this assumes there's only one other users namespace root
	if ($ns = $storage->get_namespace('other')) {
	if ($prefix = $ns[0][0]) {
	$folder = $prefix . $user . '/' . $folder;
	}
	}
	}
	else if (!strlen($folder)) {
	$folder = 'INBOX';
	}
	}
	else {
	$folder = $ns . '/' . implode('/', $path);
	// Note: this assumes there's only one shared namespace root
	if ($ns = $storage->get_namespace('shared')) {
	if ($prefix = $ns[0][0]) {
	$folder = $prefix . $folder;
	}
	}
	}

	return array(
	'folder' => $folder,
	'uid' => $uid,
	'params' => $params,
	);
	}

	return false;
	}

	/**
	* Build array of member URIs from set of messages
	*
	* @param string $folder Folder name
	* @param array $messages Array of rcube_message objects
	*
	* @return array List of members (IMAP URIs)
	*/
	public static function build_members($folder, $messages)
	{
	$members = array();

	foreach ((array) $messages as $msg) {
	$params = array(
	'folder' => $folder,
	'uid' => $msg->uid,
	);

	// add search parameters:
	// we don't want to build "invalid" searches e.g. that
	// will return false positives (more or wrong messages)
	if (($messageid = $msg->get('message-id', false)) && ($date = $msg->get('date', false))) {
	$params['message-id'] = $messageid;
	$params['date'] = $date;

	if ($subject = $msg->get('subject', false)) {
	$params['subject'] = substr($subject, 0, 256);
	}
	}

	$members[] = self::build_member_url($params);
	}

	return $members;
	}

	/**
	* Resolve/validate/update members (which are IMAP URIs) of relation object.
	*
	* @param array $tag Tag object
	* @param bool $force Force members list update
	*
	* @return array Folder/UIDs list
	*/
	public static function resolve_members(&$tag, $force = true)
	{
	$result = array();

	foreach ((array) $tag['members'] as $member) {
	// IMAP URI members
	if ($url = self::parse_member_url($member)) {
	$folder = $url['folder'];

	if (!$force) {
	$result[$folder][] = $url['uid'];
	}
	else {
	$result[$folder]['uid'][] = $url['uid'];
	$result[$folder]['params'][] = $url['params'];
	$result[$folder]['member'][] = $member;
	}
	}
	}

	if (empty($result) \|\| !$force) {
	return $result;
	}

	$rcube = rcube::get_instance();
	$storage = $rcube->get_storage();
	$search = array();
	$missing = array();

	// first we search messages by Folder+UID
	foreach ($result as $folder => $data) {
	// @FIXME: maybe better use index() which is cached?
	// @TODO: consider skip_deleted option
	$index = $storage->search_once($folder, 'UID ' . rcube_imap_generic::compressMessageSet($data['uid']));
	$uids = $index->get();

	// messages that were not found need to be searched by search parameters
	$not_found = array_diff($data['uid'], $uids);
	if (!empty($not_found)) {
	foreach ($not_found as $uid) {
	$idx = array_search($uid, $data['uid']);

	if ($p = $data['params'][$idx]) {
	$search[] = $p;
	}

	$missing[] = $result[$folder]['member'][$idx];

	unset($result[$folder]['uid'][$idx]);
	unset($result[$folder]['params'][$idx]);
	unset($result[$folder]['member'][$idx]);
	}
	}

	$result[$folder] = $uids;
	}

	// search in all subscribed mail folders using search parameters
	if (!empty($search)) {
	// remove not found members from the members list
	$tag['members'] = array_diff($tag['members'], $missing);

	// get subscribed folders
	$folders = $storage->list_folders_subscribed('', '*', 'mail', null, true);

	// @TODO: do this search in chunks (for e.g. 10 messages)?
	$search_str = '';

	foreach ($search as $p) {
	$search_params = array();
	foreach ($p as $key => $val) {
	$key = strtoupper($key);
	// don't search by subject, we don't want false-positives
	if ($key != 'SUBJECT') {
	$search_params[] = 'HEADER ' . $key . ' ' . rcube_imap_generic::escape($val);
	}
	}

	$search_str .= ' (' . implode(' ', $search_params) . ')';
	}

	$search_str = trim(str_repeat(' OR', count($search)-1) . $search_str);

	// search
	$search = $storage->search_once($folders, $search_str);

	// handle search result
	$folders = (array) $search->get_parameters('MAILBOX');

	foreach ($folders as $folder) {
	$set = $search->get_set($folder);
	$uids = $set->get();

	if (!empty($uids)) {
	$msgs = $storage->fetch_headers($folder, $uids, false);
	$members = self::build_members($folder, $msgs);

	// merge new members into the tag members list
	$tag['members'] = array_merge($tag['members'], $members);

	// add UIDs into the result
	$result[$folder] = array_unique(array_merge((array)$result[$folder], $uids));
	}
	}

	// update tag object with new members list
	$tag['members'] = array_unique($tag['members']);
	kolab_storage_config::get_instance()->save($tag, 'relation', false);
	}

	return $result;
	}

	/**
	* Assign tags to kolab objects
	*
	- * @param array $records List of kolab objects
	+ * @param array $records List of kolab objects
	+ * @param bool $no_return Don't return anything
	*
	* @return array List of tags
	*/
	- public function apply_tags(&$records)
	+ public function apply_tags(&$records, $no_return = false)
	{
	+ if (empty($records) && $no_return) {
	+ return;
	+ }
	+
	// first convert categories into tags
	foreach ($records as $i => $rec) {
	if (!empty($rec['categories'])) {
	$folder = new kolab_storage_folder($rec['_mailbox']);
	if ($object = $folder->get_object($rec['uid'])) {
	$tags = $rec['categories'];

	unset($object['categories']);
	unset($records[$i]['categories']);

	$this->save_tags($rec['uid'], $tags);
	$folder->save($object, $rec['_type'], $rec['uid']);
	}
	}
	}

	$tags = array();

	// assign tags to objects
	foreach ($this->get_tags() as $tag) {
	foreach ($records as $idx => $rec) {
	$uid = self::build_member_url($rec['uid']);
	if (in_array($uid, (array) $tag['members'])) {
	$records[$idx]['tags'][] = $tag['name'];
	}
	}

	$tags[] = $tag['name'];
	}

	- $tags = array_unique($tags);
	+ $tags = $no_return ? null : array_unique($tags);

	return $tags;
	}

	/**
	* Assign links (relations) to kolab objects
	*
	* @param array $records List of kolab objects
	*/
	public function apply_links(&$records)
	{
	$links = array();
	$uids = array();
	$ids = array();
	$limit = 25;

	// get list of object UIDs and UIRs map
	foreach ($records as $i => $rec) {
	$uids[] = $rec['uid'];
	// there can be many objects with the same uid (recurring events)
	$ids[self::build_member_url($rec['uid'])][] = $i;
	$records[$i]['links'] = array();
	}

	if (!empty($uids)) {
	$uids = array_unique($uids);
	}

	// The whole story here is to not do SELECT for every object.
	// We'll build one SELECT for many (limit above) objects at once

	while (!empty($uids)) {
	$chunk = array_splice($uids, 0, $limit);
	$chunk = array_map(function($v) { return array('member', '=', $v); }, $chunk);

	$filter = array(
	array('type', '=', 'relation'),
	array('category', '=', 'generic'),
	array($chunk, 'OR'),
	);

	$relations = $this->get_objects($filter, true, self::MAX_RELATIONS);

	foreach ($relations as $relation) {
	$links[$relation['uid']] = $relation;
	}
	}

	if (empty($links)) {
	return;
	}

	// assign links of related messages
	foreach ($links as $relation) {
	// make relation members up-to-date
	kolab_storage_config::resolve_members($relation);

	$members = array();
	foreach ((array) $relation['members'] as $member) {
	if (strpos($member, 'imap://') === 0) {
	$members[$member] = $member;
	}
	}
	$members = array_values($members);

	// assign links to objects
	foreach ((array) $relation['members'] as $member) {
	if (($id = $ids[$member]) !== null) {
	foreach ($id as $i) {
	$records[$i]['links'] = array_unique(array_merge($records[$i]['links'], $members));
	}
	}
	}
	}
	}

	/**
	* Update object tags
	*
	* @param string $uid Kolab object UID
	* @param array $tags List of tag names
	*/
	public function save_tags($uid, $tags)
	{
	$url = self::build_member_url($uid);
	$relations = $this->get_tags();

	foreach ($relations as $idx => $relation) {
	$selected = !empty($tags) && in_array($relation['name'], $tags);
	$found = !empty($relation['members']) && in_array($url, $relation['members']);
	$update = false;

	// remove member from the relation
	if ($found && !$selected) {
	$relation['members'] = array_diff($relation['members'], (array) $url);
	$update = true;
	}
	// add member to the relation
	else if (!$found && $selected) {
	$relation['members'][] = $url;
	$update = true;
	}

	if ($update) {
	if ($this->save($relation, 'relation')) {
	$this->tags[$idx] = $relation; // update in-memory cache
	}
	}

	if ($selected) {
	$tags = array_diff($tags, (array)$relation['name']);
	}
	}

	// create new relations
	if (!empty($tags)) {
	foreach ($tags as $tag) {
	$relation = array(
	'name' => $tag,
	'members' => (array) $url,
	'category' => 'tag',
	);

	if ($this->save($relation, 'relation')) {
	$this->tags[] = $relation; // update in-memory cache
	}
	}
	}
	}

	/**
	* Get tags (all or referring to specified object)
	*
	* @param string $member Optional object UID or mail message-id
	*
	* @return array List of Relation objects
	*/
	public function get_tags($member = '*')
	{
	if (!isset($this->tags)) {
	$default = true;
	$filter = array(
	array('type', '=', 'relation'),
	array('category', '=', 'tag')
	);

	// use faster method
	if ($member && $member != '*') {
	$filter[] = array('member', '=', $member);
	$tags = $this->get_objects($filter, $default, self::MAX_RELATIONS);
	}
	else {
	$this->tags = $tags = $this->get_objects($filter, $default, self::MAX_RELATIONS);
	}
	}
	else {
	$tags = $this->tags;
	}

	if ($member === '*') {
	return $tags;
	}

	$result = array();

	if ($member[0] == '<') {
	$search_msg = urlencode($member);
	}
	else {
	$search_uid = self::build_member_url($member);
	}

	foreach ($tags as $tag) {
	if ($search_uid && in_array($search_uid, (array) $tag['members'])) {
	$result[] = $tag;
	}
	else if ($search_msg) {
	foreach ($tag['members'] as $m) {
	if (strpos($m, $search_msg) !== false) {
	$result[] = $tag;
	break;
	}
	}
	}
	}

	return $result;
	}

	/**
	* Find objects linked with the given groupware object through a relation
	*
	* @param string Object UUID
	*
	* @return array List of related URIs
	*/
	public function get_object_links($uid)
	{
	$links = array();
	$object_uri = self::build_member_url($uid);

	foreach ($this->get_relations_for_member($uid) as $relation) {
	if (in_array($object_uri, (array) $relation['members'])) {
	// make relation members up-to-date
	kolab_storage_config::resolve_members($relation);

	foreach ($relation['members'] as $member) {
	if ($member != $object_uri) {
	$links[] = $member;
	}
	}
	}
	}

	return array_unique($links);
	}

	/**
	* Save relations of an object.
	* Note, that we already support only one-to-one relations.
	* So, all relations to the object that are not provided in $links
	* argument will be removed.
	*
	* @param string $uid Object UUID
	* @param array $links List of related-object URIs
	*
	* @return bool True on success, False on failure
	*/
	public function save_object_links($uid, $links)
	{
	$object_uri = self::build_member_url($uid);
	$relations = $this->get_relations_for_member($uid);
	$done = false;

	foreach ($relations as $relation) {
	// make relation members up-to-date
	kolab_storage_config::resolve_members($relation);

	// remove and add links
	$members = array($object_uri);
	$members = array_unique(array_merge($members, $links));

	// remove relation if no other members remain
	if (count($members) <= 1) {
	$done = $this->delete($relation);
	}
	// update relation object if members changed
	else if (count(array_diff($members, $relation['members'])) \|\| count(array_diff($relation['members'], $members))) {
	$relation['members'] = $members;
	$done = $this->save($relation, 'relation');
	$links = array();
	}
	// no changes, we're happy
	else {
	$done = true;
	$links = array();
	}
	}

	// create a new relation
	if (!$done && !empty($links)) {
	$relation = array(
	'members' => array_merge($links, array($object_uri)),
	'category' => 'generic',
	);

	$done = $this->save($relation, 'relation');
	}

	return $done;
	}

	/**
	* Find relation objects referring to specified note
	*/
	public function get_relations_for_member($uid, $reltype = 'generic')
	{
	$default = true;
	$filter = array(
	array('type', '=', 'relation'),
	array('category', '=', $reltype),
	array('member', '=', $uid),
	);

	return $this->get_objects($filter, $default, self::MAX_RELATIONS);
	}

	/**
	* Find kolab objects assigned to specified e-mail message
	*
	* @param rcube_message $message E-mail message
	* @param string $folder Folder name
	* @param string $type Result objects type
	*
	* @return array List of kolab objects
	*/
	public function get_message_relations($message, $folder, $type)
	{
	static $_cache = array();

	$result = array();
	$uids = array();
	$default = true;
	$uri = self::get_message_uri($message, $folder);
	$filter = array(
	array('type', '=', 'relation'),
	array('category', '=', 'generic'),
	);

	// query by message-id
	$member_id = $message->get('message-id', false);
	if (empty($member_id)) {
	// derive message identifier from URI
	$member_id = md5($uri);
	}
	$filter[] = array('member', '=', $member_id);

	if (!isset($_cache[$uri])) {
	// get UIDs of related groupware objects
	foreach ($this->get_objects($filter, $default) as $relation) {
	// we don't need to update members if the URI is found
	if (!in_array($uri, $relation['members'])) {
	// update members...
	$messages = kolab_storage_config::resolve_members($relation);
	// ...and check again
	if (empty($messages[$folder]) \|\| !in_array($message->uid, $messages[$folder])) {
	continue;
	}
	}

	// find groupware object UID(s)
	foreach ($relation['members'] as $member) {
	if (strpos($member, 'urn:uuid:') === 0) {
	$uids[] = substr($member, 9);
	}
	}
	}

	// remember this lookup
	$_cache[$uri] = $uids;
	}
	else {
	$uids = $_cache[$uri];
	}

	// get kolab objects of specified type
	if (!empty($uids)) {
	$query = array(array('uid', '=', array_unique($uids)));
	$result = kolab_storage::select($query, $type, count($uids));
	}

	return $result;
	}

	/**
	* Build a URI representing the given message reference
	*/
	public static function get_message_uri($headers, $folder)
	{
	$params = array(
	'folder' => $headers->folder ?: $folder,
	'uid' => $headers->uid,
	);

	if (($messageid = $headers->get('message-id', false)) && ($date = $headers->get('date', false))) {
	$params['message-id'] = $messageid;
	$params['date'] = $date;

	if ($subject = $headers->get('subject')) {
	$params['subject'] = $subject;
	}
	}

	return self::build_member_url($params);
	}

	/**
	* Resolve the email message reference from the given URI
	*/
	public static function get_message_reference($uri, $rel = null)
	{
	if ($linkref = self::parse_member_url($uri)) {
	$linkref['subject'] = $linkref['params']['subject'];
	$linkref['uri'] = $uri;

	$rcmail = rcube::get_instance();
	if (method_exists($rcmail, 'url')) {
	$linkref['mailurl'] = $rcmail->url(array(
	'task' => 'mail',
	'action' => 'show',
	'mbox' => $linkref['folder'],
	'uid' => $linkref['uid'],
	'rel' => $rel,
	));
	}

	unset($linkref['params']);
	}

	return $linkref;
	}
	}
	diff --git a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
	index 0c5a65c6..fe1af558 100644
	--- a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
	+++ b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
	@@ -1,1754 +1,1754 @@
	<?php

	/**
	* Kolab Groupware driver for the Tasklist plugin
	*
	* @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 tasklist_kolab_driver extends tasklist_driver
	{
	// features supported by the backend
	public $alarms = false;
	public $attachments = true;
	public $attendees = true;
	public $undelete = false; // task undelete action
	public $alarm_types = array('DISPLAY','AUDIO');
	public $search_more_results;

	private $rc;
	private $plugin;
	private $lists;
	private $folders = array();
	private $tasks = array();
	private $tags = array();
	private $bonnie_api = false;


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

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

	// tasklist use fully encoded identifiers
	kolab_storage::$encode_ids = true;

	// get configuration for the Bonnie API
	$this->bonnie_api = libkolab::get_bonnie_api();

	$this->plugin->register_action('folder-acl', array($this, 'folder_acl'));
	}

	/**
	* Read available calendars for the current user and store them internally
	*/
	private function _read_lists($force = false)
	{
	// already read sources
	if (isset($this->lists) && !$force) {
	return $this->lists;
	}

	// get all folders that have type "task"
	$folders = kolab_storage::sort_folders(kolab_storage::get_folders('task'));
	$this->lists = $this->folders = array();

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

	// find default folder
	$default_index = 0;
	foreach ($folders as $i => $folder) {
	if ($folder->default && strpos($folder->name, $delim) === false)
	$default_index = $i;
	}

	// put default folder (aka INBOX) on top of the list
	if ($default_index > 0) {
	$default_folder = $folders[$default_index];
	unset($folders[$default_index]);
	array_unshift($folders, $default_folder);
	}

	$prefs = $this->rc->config->get('kolab_tasklists', array());

	foreach ($folders as $folder) {
	$tasklist = $this->folder_props($folder, $prefs);

	$this->lists[$tasklist['id']] = $tasklist;
	$this->folders[$tasklist['id']] = $folder;
	$this->folders[$folder->name] = $folder;
	}

	return $this->lists;
	}

	/**
	* Derive list properties from the given kolab_storage_folder object
	*/
	protected function folder_props($folder, $prefs)
	{
	if ($folder->get_namespace() == 'personal') {
	$norename = false;
	$editable = true;
	$rights = 'lrswikxtea';
	$alarms = true;
	}
	else {
	$alarms = false;
	$rights = 'lr';
	$editable = false;
	if (($myrights = $folder->get_myrights()) && !PEAR::isError($myrights)) {
	$rights = $myrights;
	if (strpos($rights, 't') !== false \|\| strpos($rights, 'd') !== false)
	$editable = strpos($rights, 'i');
	}
	$info = $folder->get_folder_info();
	$norename = $readonly \|\| $info['norename'] \|\| $info['protected'];
	}

	$list_id = $folder->id; #kolab_storage::folder_id($folder->name);
	$old_id = kolab_storage::folder_id($folder->name, false);

	if (!isset($prefs[$list_id]['showalarms']) && isset($prefs[$old_id]['showalarms'])) {
	$prefs[$list_id]['showalarms'] = $prefs[$old_id]['showalarms'];
	}

	return array(
	'id' => $list_id,
	'name' => $folder->get_name(),
	'listname' => $folder->get_foldername(),
	'editname' => $folder->get_foldername(),
	'color' => $folder->get_color('0000CC'),
	'showalarms' => isset($prefs[$list_id]['showalarms']) ? $prefs[$list_id]['showalarms'] : $alarms,
	'editable' => $editable,
	'rights' => $rights,
	'norename' => $norename,
	'active' => $folder->is_active(),
	'parentfolder' => $folder->get_parent(),
	'default' => $folder->default,
	'virtual' => $folder->virtual,
	'children' => true, // TODO: determine if that folder indeed has child folders
	'subscribed' => (bool)$folder->is_subscribed(),
	'removable' => !$folder->default,
	'subtype' => $folder->subtype,
	'group' => $folder->default ? 'default' : $folder->get_namespace(),
	'class' => trim($folder->get_namespace() . ($folder->default ? ' default' : '')),
	'caldavuid' => $folder->get_uid(),
	'history' => !empty($this->bonnie_api),
	);
	}

	/**
	* Get a list of available task lists from this source
	*/
	public function get_lists(&$tree = null)
	{
	$this->_read_lists();

	// attempt to create a default list for this user
	if (empty($this->lists) && !isset($this->search_more_results)) {
	$prop = array('name' => 'Tasks', 'color' => '0000CC', 'default' => true);
	if ($this->create_list($prop))
	$this->_read_lists(true);
	}

	$folders = array();
	foreach ($this->lists as $id => $list) {
	if (!empty($this->folders[$id])) {
	$folders[] = $this->folders[$id];
	}
	}

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

	$delim = $this->rc->get_storage()->get_hierarchy_delimiter();
	$prefs = $this->rc->config->get('kolab_tasklists', array());

	$lists = array();
	foreach ($folders as $folder) {
	$list_id = $folder->id; // kolab_storage::folder_id($folder->name);
	$imap_path = explode($delim, $folder->name);

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

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

	$fullname = $folder->get_name();
	$listname = $folder->get_foldername();

	// special handling for virtual folders
	if ($folder instanceof kolab_storage_folder_user) {
	$lists[$list_id] = array(
	'id' => $list_id,
	'name' => $fullname,
	'listname' => $listname,
	'title' => $folder->get_title(),
	'virtual' => true,
	'editable' => false,
	'rights' => 'l',
	'group' => 'other virtual',
	'class' => 'user',
	'parent' => $parent_id,
	);
	}
	else if ($folder->virtual) {
	$lists[$list_id] = array(
	'id' => $list_id,
	'name' => $fullname,
	'listname' => $listname,
	'virtual' => true,
	'editable' => false,
	'rights' => 'l',
	'group' => $folder->get_namespace(),
	'class' => 'folder',
	'parent' => $parent_id,
	);
	}
	else {
	if (!$this->lists[$list_id]) {
	$this->lists[$list_id] = $this->folder_props($folder, $prefs);
	$this->folders[$list_id] = $folder;
	}
	$this->lists[$list_id]['parent'] = $parent_id;
	$lists[$list_id] = $this->lists[$list_id];
	}
	}

	return $lists;
	}

	/**
	* Get the kolab_calendar instance for the given calendar ID
	*
	* @param string List identifier (encoded imap folder name)
	* @return object kolab_storage_folder Object nor null if list doesn't exist
	*/
	protected function get_folder($id)
	{
	$this->_read_lists();

	// create list and folder instance if necesary
	if (!$this->lists[$id]) {
	$folder = kolab_storage::get_folder(kolab_storage::id_decode($id));
	if ($folder->type) {
	$this->folders[$id] = $folder;
	$this->lists[$id] = $this->folder_props($folder, $this->rc->config->get('kolab_tasklists', array()));
	}
	}

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


	/**
	* Create a new list assigned to the current user
	*
	* @param array Hash array with list properties
	* name: List name
	* color: The color of the list
	* showalarms: True if alarms are enabled
	* @return mixed ID of the new list on success, False on error
	*/
	public function create_list(&$prop)
	{
	$prop['type'] = 'task' . ($prop['default'] ? '.default' : '');
	$prop['active'] = true; // activate folder by default
	$prop['subscribed'] = true;
	$folder = kolab_storage::folder_update($prop);

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

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

	$prefs['kolab_tasklists'] = $this->rc->config->get('kolab_tasklists', array());

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

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

	// force page reload to properly render folder hierarchy
	if (!empty($prop['parent'])) {
	$prop['_reload'] = true;
	}
	else {
	$folder = kolab_storage::get_folder($folder);
	$prop += $this->folder_props($folder, array());
	}

	return $id;
	}

	/**
	* Update properties of an existing tasklist
	*
	* @param array Hash array with list properties
	* id: List Identifier
	* name: List name
	* color: The color of the list
	* showalarms: True if alarms are enabled (if supported)
	* @return boolean True on success, Fales on failure
	*/
	public function edit_list(&$prop)
	{
	if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
	$prop['oldname'] = $folder->name;
	$prop['type'] = 'task';
	$newfolder = kolab_storage::folder_update($prop);

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

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

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

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

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

	// force page reload if folder name/hierarchy changed
	if ($newfolder != $prop['oldname'])
	$prop['_reload'] = true;

	return $id;
	}

	return false;
	}

	/**
	* Set active/subscribed state of a list
	*
	* @param array Hash array with list properties
	* id: List Identifier
	* active: True if list is active, false if not
	* permanent: True if list is to be subscribed permanently
	* @return boolean True on success, Fales on failure
	*/
	public function subscribe_list($prop)
	{
	if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
	$ret = false;
	if (isset($prop['permanent']))
	$ret \|= $folder->subscribe(intval($prop['permanent']));
	if (isset($prop['active']))
	$ret \|= $folder->activate(intval($prop['active']));

	// apply to child folders, too
	if ($prop['recursive']) {
	foreach ((array)kolab_storage::list_folders($folder->name, '*', 'task') as $subfolder) {
	if (isset($prop['permanent']))
	($prop['permanent'] ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
	if (isset($prop['active']))
	($prop['active'] ? kolab_storage::folder_activate($subfolder) : kolab_storage::folder_deactivate($subfolder));
	}
	}

	return $ret;
	}

	return false;
	}

	/**
	* Delete the given list with all its contents
	*
	* @param array Hash array with list properties
	* id: list Identifier
	* @return boolean True on success, Fales on failure
	*/
	public function delete_list($prop)
	{
	if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
	if (kolab_storage::folder_delete($folder->name)) {
	return true;
	}

	$this->last_error = kolab_storage::$last_error;
	}

	return false;
	}

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

	$this->search_more_results = false;
	$this->lists = $this->folders = array();

	// find unsubscribed IMAP folders that have "event" type
	if ($source == 'folders') {
	foreach ((array)kolab_storage::search_folders('task', $query, array('other')) as $folder) {
	$this->folders[$folder->id] = $folder;
	$this->lists[$folder->id] = $this->folder_props($folder, array());
	}
	}
	// search other user's namespace via LDAP
	else if ($source == 'users') {
	$limit = $this->rc->config->get('autocomplete_max', 15) * 2; // we have slightly more space, so display twice the number
	foreach (kolab_storage::search_users($query, 0, array(), $limit * 10) as $user) {
	$folders = array();
	// search for tasks folders shared by this user
	foreach (kolab_storage::list_user_folders($user, 'task', false) as $foldername) {
	$folders[] = new kolab_storage_folder($foldername, 'task');
	}

	if (count($folders)) {
	$userfolder = new kolab_storage_folder_user($user['kolabtargetfolder'], '', $user);
	$this->folders[$userfolder->id] = $userfolder;
	$this->lists[$userfolder->id] = $this->folder_props($userfolder, array());

	foreach ($folders as $folder) {
	$this->folders[$folder->id] = $folder;
	$this->lists[$folder->id] = $this->folder_props($folder, array());
	$count++;
	}
	}

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

	return $this->get_lists();
	}

	/**
	* Get a list of tags to assign tasks to
	*
	* @return array List of tags
	*/
	public function get_tags()
	{
	$config = kolab_storage_config::get_instance();
	$tags = $config->get_tags();
	$backend_tags = array_map(function($v) { return $v['name']; }, $tags);

	return array_values(array_unique(array_merge($this->tags, $backend_tags)));
	}

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

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

	$counts = array('all' => 0, 'flagged' => 0, 'today' => 0, 'tomorrow' => 0, 'overdue' => 0, 'nodate' => 0, 'mytasks' => 0);

	foreach ($lists as $list_id) {
	if (!$folder = $this->get_folder($list_id)) {
	continue;
	}

	foreach ($folder->select(array(array('tags','!~','x-complete'))) as $record) {
	$rec = $this->_to_rcube_task($record, $list_id, false);

	if ($this->is_complete($rec)) // don't count complete tasks
	continue;

	$counts['all']++;
	if ($rec['flagged'])
	$counts['flagged']++;
	if (empty($rec['date']))
	$counts['nodate']++;
	else if ($rec['date'] == $today)
	$counts['today']++;
	else if ($rec['date'] == $tomorrow)
	$counts['tomorrow']++;
	else if ($rec['date'] < $today)
	$counts['overdue']++;
	if ($this->plugin->is_attendee($rec) !== false)
	$counts['mytasks']++;
	}
	}

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

	return $counts;
	}

	/**
	* Get all task records matching the given filter
	*
	* @param array Hash array with filter criterias:
	* - mask: Bitmask representing the filter selection (check against tasklist::FILTER_MASK_* constants)
	* - from: Date range start as string (Y-m-d)
	* - to: Date range end as string (Y-m-d)
	* - search: Search query string
	* @param array List of lists to get tasks from
	* @return array List of tasks records matchin the criteria
	*/
	public function list_tasks($filter, $lists = null)
	{
	if (empty($lists)) {
	$lists = $this->_read_lists();
	$lists = array_keys($lists);
	}
	else if (is_string($lists)) {
	$lists = explode(',', $lists);
	}

	$config = kolab_storage_config::get_instance();
	$results = array();

	// query Kolab storage
	$query = array();
	if ($filter['mask'] & tasklist::FILTER_MASK_COMPLETE)
	$query[] = array('tags','~','x-complete');
	else if (empty($filter['since']))
	$query[] = array('tags','!~','x-complete');

	// full text search (only works with cache enabled)
	if ($filter['search']) {
	$search = mb_strtolower($filter['search']);
	foreach (rcube_utils::normalize_string($search, true) as $word) {
	$query[] = array('words', '~', $word);
	}
	}

	if ($filter['since']) {
	$query[] = array('changed', '>=', $filter['since']);
	}

	foreach ($lists as $list_id) {
	if (!$folder = $this->get_folder($list_id)) {
	continue;
	}

	foreach ($folder->select($query) as $record) {
	// TODO: post-filter tasks returned from storage
	$record['list_id'] = $list_id;
	$results[] = $record;
	}
	}

	- $config->apply_tags($results);
	+ $config->apply_tags($results, true);
	$config->apply_links($results);

	foreach (array_keys($results) as $idx) {
	$results[$idx] = $this->_to_rcube_task($results[$idx], $results[$idx]['list_id']);
	}

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

	return $results;
	}

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

	$id = $prop['uid'];
	$list_id = $prop['list'];
	$folders = $list_id ? array($list_id => $this->get_folder($list_id)) : $this->folders;

	// find task in the available folders
	foreach ($folders as $list_id => $folder) {
	if (is_numeric($list_id) \|\| !$folder)
	continue;
	if (!$this->tasks[$id] && ($object = $folder->get_object($id))) {
	$this->load_tags($object);
	$this->tasks[$id] = $this->_to_rcube_task($object, $list_id);
	break;
	}
	}

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

	/**
	* Get all decendents of the given task record
	*
	* @param mixed Hash array with task properties or task UID
	* @param boolean True if all childrens children should be fetched
	* @return array List of all child task IDs
	*/
	public function get_childs($prop, $recursive = false)
	{
	if (is_string($prop)) {
	$task = $this->get_task($prop);
	$prop = array('uid' => $task['uid'], 'list' => $task['list']);
	}
	else {
	$this->_parse_id($prop);
	}

	$childs = array();
	$list_id = $prop['list'];
	$task_ids = array($prop['uid']);
	$folder = $this->get_folder($list_id);

	// query for childs (recursively)
	while ($folder && !empty($task_ids)) {
	$query_ids = array();
	foreach ($task_ids as $task_id) {
	$query = array(array('tags','=','x-parent:' . $task_id));
	foreach ($folder->select($query) as $record) {
	// don't rely on kolab_storage_folder filtering
	if ($record['parent_id'] == $task_id) {
	$childs[] = $list_id . ':' . $record['uid'];
	$query_ids[] = $record['uid'];
	}
	}
	}

	if (!$recursive)
	break;

	$task_ids = $query_ids;
	}

	return $childs;
	}

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

	list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);

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

	return false;
	}

	/**
	* Return full data of a specific revision of an event
	*
	* @param mixed $task UID string or hash array with task properties
	* @param mixed $rev Revision number
	*
	* @return array Task object as hash array
	* @see tasklist_driver::get_task_revision()
	*/
	public function get_task_revison($prop, $rev)
	{
	if (empty($this->bonnie_api)) {
	return false;
	}

	$this->_parse_id($prop);
	$uid = $prop['uid'];
	$list_id = $prop['list'];
	list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);

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

	if ($format->is_valid()) {
	$rec = self::_to_rcube_task($rec, $list_id, false);
	$rec['rev'] = $result['rev'];
	return $rec;
	}
	}

	return false;
	}

	/**
	* Command the backend to restore a certain revision of a task.
	* This shall replace the current object with an older version.
	*
	* @param mixed $task UID string or hash array with task properties
	* @param mixed $rev Revision number
	*
	* @return boolean True on success, False on failure
	* @see tasklist_driver::restore_task_revision()
	*/
	public function restore_task_revision($prop, $rev)
	{
	if (empty($this->bonnie_api)) {
	return false;
	}

	$this->_parse_id($prop);
	$uid = $prop['uid'];
	$list_id = $prop['list'];
	list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);

	$folder = $this->get_folder($list_id);
	$success = false;

	if ($folder && ($raw_msg = $this->bonnie_api->rawdata('task', $uid, $rev, $mailbox))) {
	$imap = $this->rc->get_storage();

	// insert $raw_msg as new message
	if ($imap->save_message($folder->name, $raw_msg, null, false)) {
	$success = true;

	// delete old revision from imap and cache
	$imap->delete_message($msguid, $folder->name);
	$folder->cache->set($msguid, false);
	}
	}

	return $success;
	}

	/**
	* Get a list of property changes beteen two revisions of a task object
	*
	* @param array $task Hash array with task properties
	* @param mixed $rev Revisions: "from:to"
	*
	* @return array List of property changes, each as a hash array
	* @see tasklist_driver::get_task_diff()
	*/
	public function get_task_diff($prop, $rev1, $rev2)
	{
	$this->_parse_id($prop);
	$uid = $prop['uid'];
	$list_id = $prop['list'];
	list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);

	// call Bonnie API
	$result = $this->bonnie_api->diff('task', $uid, $rev1, $rev2, $mailbox, $msguid, $instance_id);
	if (is_array($result) && $result['uid'] == $uid) {
	$result['rev1'] = $rev1;
	$result['rev2'] = $rev2;

	$keymap = array(
	'start' => 'start',
	'due' => 'date',
	'dstamp' => 'changed',
	'summary' => 'title',
	'alarm' => 'alarms',
	'attendee' => 'attendees',
	'attach' => 'attachments',
	'rrule' => 'recurrence',
	'related-to' => 'parent_id',
	'percent-complete' => 'complete',
	'lastmodified-date' => 'changed',
	);
	$prop_keymaps = array(
	'attachments' => array('fmttype' => 'mimetype', 'label' => 'name'),
	'attendees' => array('partstat' => 'status'),
	);
	$special_changes = array();

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

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

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

	return $result;
	}

	return false;
	}

	/**
	* Helper method to resolved the given task identifier into uid and folder
	*
	* @return array (uid,folder,msguid) tuple
	*/
	private function _resolve_task_identity($prop)
	{
	$mailbox = $msguid = null;

	$this->_parse_id($prop);
	$uid = $prop['uid'];
	$list_id = $prop['list'];

	if ($folder = $this->get_folder($list_id)) {
	$mailbox = $folder->get_mailbox_id();

	// get task object from storage in order to get the real object uid an msguid
	if ($rec = $folder->get_object($uid)) {
	$msguid = $rec['_msguid'];
	$uid = $rec['uid'];
	}
	}

	return array($uid, $mailbox, $msguid);
	}

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

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

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

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

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

	$time = $slot + $interval;

	$candidates = array();
	$query = array(
	array('tags', '=', 'x-has-alarms'),
	array('tags', '!=', 'x-complete')
	);

	$this->_read_lists();

	foreach ($this->lists as $lid => $list) {
	// skip lists with alarms disabled
	if (!$list['showalarms'] \|\| ($lists && !in_array($lid, $lists)))
	continue;

	$folder = $this->get_folder($lid);
	foreach ($folder->select($query) as $record) {
	if (!($record['valarms'] \|\| $record['alarms']) \|\| $record['status'] == 'COMPLETED' \|\| $record['complete'] == 100) // don't trust query :-)
	continue;

	$task = $this->_to_rcube_task($record, $lid, false);

	// add to list if alarm is set
	$alarm = libcalendaring::get_next_alarm($task, 'task');
	if ($alarm && $alarm['time'] && $alarm['time'] <= $time && in_array($alarm['action'], $this->alarm_types)) {
	$id = $alarm['id']; // use alarm-id as primary identifier
	$candidates[$id] = array(
	'id' => $id,
	'title' => $task['title'],
	'date' => $task['date'],
	'time' => $task['time'],
	'notifyat' => $alarm['time'],
	'action' => $alarm['action'],
	);
	}
	}
	}

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

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

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

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

	return $alarms;
	}

	/**
	* (User) feedback after showing an alarm notification
	* This should mark the alarm as 'shown' or snooze it for the given amount of time
	*
	* @param string Task identifier
	* @param integer Suspend the alarm for this number of seconds
	*/
	public function dismiss_alarm($id, $snooze = 0)
	{
	// delete old alarm entry
	$this->rc->db->query(
	"DELETE FROM " . $this->rc->db->table_name('kolab_alarms', true) . "
	WHERE `alarm_id` = ? AND `user_id` = ?",
	$id,
	$this->rc->user->ID
	);

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

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

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

	/**
	* Remove alarm dismissal or snooze state
	*
	* @param string Task identifier
	*/
	public function clear_alarms($id)
	{
	// delete alarm entry
	$this->rc->db->query(
	"DELETE FROM " . $this->rc->db->table_name('kolab_alarms', true) . "
	WHERE `alarm_id` = ? AND `user_id` = ?",
	$id,
	$this->rc->user->ID
	);

	return true;
	}

	/**
	* Get task tags
	*/
	private function load_tags(&$object)
	{
	// this task hasn't been migrated yet
	if (!empty($object['categories'])) {
	// OPTIONAL: call kolab_storage_config::apply_tags() to migrate the object
	$object['tags'] = (array)$object['categories'];
	if (!empty($object['tags'])) {
	$this->tags = array_merge($this->tags, $object['tags']);
	}
	}
	else {
	$config = kolab_storage_config::get_instance();
	$tags = $config->get_tags($object['uid']);
	$object['tags'] = array_map(function($v) { return $v['name']; }, $tags);
	}
	}

	/**
	* Update task tags
	*/
	private function save_tags($uid, $tags)
	{
	$config = kolab_storage_config::get_instance();
	$config->save_tags($uid, $tags);
	}

	/**
	* Find messages linked with a task record
	*/
	private function get_links($uid)
	{
	$config = kolab_storage_config::get_instance();
	return $config->get_object_links($uid);
	}

	/**
	*
	*/
	private function save_links($uid, $links)
	{
	$config = kolab_storage_config::get_instance();
	return $config->save_object_links($uid, (array) $links);
	}

	/**
	* Extract uid + list identifiers from the given input
	*
	* @param mixed array or string with task identifier(s)
	*/
	private function _parse_id(&$prop)
	{
	$id_ = null;
	if (is_array($prop)) {
	// 'uid' + 'list' available, nothing to be done
	if (!empty($prop['uid']) && !empty($prop['list'])) {
	return;
	}

	// 'id' is given
	if (!empty($prop['id'])) {
	if (!empty($prop['list'])) {
	$list_id = $prop['_fromlist'] ?: $prop['list'];
	if (strpos($prop['id'], $list_id.':') === 0) {
	$prop['uid'] = substr($prop['id'], strlen($list_id)+1);
	}
	else {
	$prop['uid'] = $prop['id'];
	}
	}
	else {
	$id_ = $prop['id'];
	}
	}
	}
	else {
	$id_ = strval($prop);
	$prop = array();
	}

	// split 'id' into list + uid
	if (!empty($id_)) {
	list($list, $uid) = explode(':', $id_, 2);
	if (!empty($uid)) {
	$prop['uid'] = $uid;
	$prop['list'] = $list;
	}
	else {
	$prop['uid'] = $id_;
	}
	}
	}

	/**
	* Convert from Kolab_Format to internal representation
	*/
	private function _to_rcube_task($record, $list_id, $all = true)
	{
	$id_prefix = $list_id . ':';
	$task = array(
	'id' => $id_prefix . $record['uid'],
	'uid' => $record['uid'],
	'title' => $record['title'],
	// 'location' => $record['location'],
	'description' => $record['description'],
	'flagged' => $record['priority'] == 1,
	'complete' => floatval($record['complete'] / 100),
	'status' => $record['status'],
	'parent_id' => $record['parent_id'] ? $id_prefix . $record['parent_id'] : null,
	'recurrence' => $record['recurrence'],
	'attendees' => $record['attendees'],
	'organizer' => $record['organizer'],
	'sequence' => $record['sequence'],
	'tags' => $record['tags'],
	'list' => $list_id,
	'links' => $record['links'],
	);

	// we can sometimes skip this expensive operation
	if ($all && !array_key_exists('links', $task)) {
	$task['links'] = $this->get_links($task['uid']);
	}

	// convert from DateTime to internal date format
	if (is_a($record['due'], 'DateTime')) {
	$due = $this->plugin->lib->adjust_timezone($record['due']);
	$task['date'] = $due->format('Y-m-d');
	if (!$record['due']->_dateonly)
	$task['time'] = $due->format('H:i');
	}
	// convert from DateTime to internal date format
	if (is_a($record['start'], 'DateTime')) {
	$start = $this->plugin->lib->adjust_timezone($record['start']);
	$task['startdate'] = $start->format('Y-m-d');
	if (!$record['start']->_dateonly)
	$task['starttime'] = $start->format('H:i');
	}
	if (is_a($record['changed'], 'DateTime')) {
	$task['changed'] = $record['changed'];
	}
	if (is_a($record['created'], 'DateTime')) {
	$task['created'] = $record['created'];
	}

	if ($record['valarms']) {
	$task['valarms'] = $record['valarms'];
	}
	else if ($record['alarms']) {
	$task['alarms'] = $record['alarms'];
	}

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

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

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

	return $task;
	}

	/**
	* Convert the given task record into a data structure that can be passed to kolab_storage backend for saving
	* (opposite of self::_to_rcube_event())
	*/
	private function _from_rcube_task($task, $old = array())
	{
	$object = $task;
	$id_prefix = $task['list'] . ':';

	if (!empty($task['date'])) {
	$object['due'] = rcube_utils::anytodatetime($task['date'].' '.$task['time'], $this->plugin->timezone);
	if (empty($task['time']))
	$object['due']->_dateonly = true;
	unset($object['date']);
	}

	if (!empty($task['startdate'])) {
	$object['start'] = rcube_utils::anytodatetime($task['startdate'].' '.$task['starttime'], $this->plugin->timezone);
	if (empty($task['starttime']))
	$object['start']->_dateonly = true;
	unset($object['startdate']);
	}

	// as per RFC (and the Kolab schema validation), start and due dates need to be of the same type (#3614)
	// this should be catched in the client already but just make sure we don't write invalid objects
	if (!empty($object['start']) && !empty($object['due']) && $object['due']->_dateonly != $object['start']->_dateonly) {
	$object['start']->_dateonly = true;
	$object['due']->_dateonly = true;
	}

	$object['complete'] = $task['complete'] * 100;
	if ($task['complete'] == 1.0 && empty($task['complete']))
	$object['status'] = 'COMPLETED';

	if ($task['flagged'])
	$object['priority'] = 1;
	else
	$object['priority'] = $old['priority'] > 1 ? $old['priority'] : 0;

	// remove list: prefix from parent_id
	if (!empty($task['parent_id']) && strpos($task['parent_id'], $id_prefix) === 0) {
	$object['parent_id'] = substr($task['parent_id'], strlen($id_prefix));
	}

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

	// copy recurrence rules if the client didn't submit it (#2713)
	if (!array_key_exists('recurrence', $object) && $old['recurrence']) {
	$object['recurrence'] = $old['recurrence'];
	}

	// delete existing attachment(s)
	if (!empty($task['deleted_attachments'])) {
	foreach ($task['deleted_attachments'] as $attachment) {
	if (is_array($object['_attachments'])) {
	foreach ($object['_attachments'] as $idx => $att) {
	if ($att['id'] == $attachment)
	$object['_attachments'][$idx] = false;
	}
	}
	}
	unset($task['deleted_attachments']);
	}

	// in kolab_storage attachments are indexed by content-id
	if (is_array($task['attachments'])) {
	foreach ($task['attachments'] as $idx => $attachment) {
	$key = null;
	// Roundcube ID has nothing to do with the storage ID, remove it
	if ($attachment['content'] \|\| $attachment['path']) {
	unset($attachment['id']);
	}
	else {
	foreach ((array)$old['_attachments'] as $cid => $oldatt) {
	if ($oldatt && $attachment['id'] == $oldatt['id'])
	$key = $cid;
	}
	}

	// replace existing entry
	if ($key) {
	$object['_attachments'][$key] = $attachment;
	}
	// append as new attachment
	else {
	$object['_attachments'][] = $attachment;
	}
	}

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

	// allow sequence increments if I'm the organizer
	if ($this->plugin->is_organizer($object) && empty($object['_method'])) {
	unset($object['sequence']);
	}
	else if (isset($old['sequence']) && empty($object['_method'])) {
	$object['sequence'] = $old['sequence'];
	}

	unset($object['tempid'], $object['raw'], $object['list'], $object['flagged'], $object['tags'], $object['created']);
	return $object;
	}

	/**
	* Add a single task to the database
	*
	* @param array Hash array with task properties (see header of tasklist_driver.php)
	* @return mixed New task ID on success, False on error
	*/
	public function create_task($task)
	{
	return $this->edit_task($task);
	}

	/**
	* Update an task entry with the given data
	*
	* @param array Hash array with task properties (see header of tasklist_driver.php)
	* @return boolean True on success, False on error
	*/
	public function edit_task($task)
	{
	$this->_parse_id($task);
	$list_id = $task['list'];
	if (!$list_id \|\| !($folder = $this->get_folder($list_id))) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid list identifer to save task: " . print_r($list_id, true)),
	true, false);
	return false;
	}

	// email links and tags are stored separately
	$links = $task['links'];
	$tags = $task['tags'];
	unset($task['tags'], $task['links']);

	// moved from another folder
	if ($task['_fromlist'] && ($fromfolder = $this->get_folder($task['_fromlist']))) {
	if (!$fromfolder->move($task['uid'], $folder))
	return false;

	unset($task['_fromlist']);
	}

	// load previous version of this task to merge
	if ($task['id']) {
	$old = $folder->get_object($task['uid']);
	if (!$old \|\| PEAR::isError($old))
	return false;

	// merge existing properties if the update isn't complete
	if (!isset($task['title']) \|\| !isset($task['complete']))
	$task += $this->_to_rcube_task($old, $list_id);
	}

	// generate new task object from RC input
	$object = $this->_from_rcube_task($task, $old);
	$saved = $folder->save($object, 'task', $task['uid']);

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

	$task = $this->_to_rcube_task($object, $list_id);
	$task['tags'] = (array) $tags;
	$this->tasks[$task['uid']] = $task;
	}

	return $saved;
	}

	/**
	* Move a single task to another list
	*
	* @param array Hash array with task properties:
	* @return boolean True on success, False on error
	* @see tasklist_driver::move_task()
	*/
	public function move_task($task)
	{
	$this->_parse_id($task);
	$list_id = $task['list'];
	if (!$list_id \|\| !($folder = $this->get_folder($list_id)))
	return false;

	// execute move command
	if ($task['_fromlist'] && ($fromfolder = $this->get_folder($task['_fromlist']))) {
	return $fromfolder->move($task['uid'], $folder);
	}

	return false;
	}

	/**
	* Remove a single task from the database
	*
	* @param array Hash array with task properties:
	* id: Task identifier
	* @param boolean Remove record irreversible (mark as deleted otherwise, if supported by the backend)
	* @return boolean True on success, False on error
	*/
	public function delete_task($task, $force = true)
	{
	$this->_parse_id($task);
	$list_id = $task['list'];
	if (!$list_id \|\| !($folder = $this->get_folder($list_id)))
	return false;

	$status = $folder->delete($task['uid']);

	if ($status) {
	// remove tag assignments
	// @TODO: don't do this when undelete feature will be implemented
	$this->save_tags($task['uid'], null);
	}

	return $status;
	}

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


	/**
	* Get attachment properties
	*
	* @param string $id Attachment identifier
	* @param array $task Hash array with event properties:
	* id: Task identifier
	* list: List identifier
	* rev: Revision (optional)
	*
	* @return array Hash array with attachment properties:
	* id: Attachment identifier
	* name: Attachment name
	* mimetype: MIME content type of the attachment
	* size: Attachment size
	*/
	public function get_attachment($id, $task)
	{
	// get old revision of the object
	if ($task['rev']) {
	$task = $this->get_task_revison($task, $task['rev']);
	}
	else {
	$task = $this->get_task($task);
	}

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

	return null;
	}

	/**
	* Get attachment body
	*
	* @param string $id Attachment identifier
	* @param array $task Hash array with event properties:
	* id: Task identifier
	* list: List identifier
	* rev: Revision (optional)
	*
	* @return string Attachment body
	*/
	public function get_attachment_body($id, $task)
	{
	$this->_parse_id($task);

	// get old revision of event
	if ($task['rev']) {
	if (empty($this->bonnie_api)) {
	return false;
	}

	$cid = substr($id, 4);

	// call Bonnie API and get the raw mime message
	list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($task);
	if ($msg_raw = $this->bonnie_api->rawdata('task', $uid, $task['rev'], $mailbox, $msguid)) {
	// parse the message and find the part with the matching content-id
	$message = rcube_mime::parse_message($msg_raw);
	foreach ((array)$message->parts as $part) {
	if ($part->headers['content-id'] && trim($part->headers['content-id'], '<>') == $cid) {
	return $part->body;
	}
	}
	}

	return false;
	}


	if ($storage = $this->get_folder($task['list'])) {
	return $storage->get_attachment($task['uid'], $id);
	}

	return false;
	}

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

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

	return false;
	}

	/**
	* Find tasks assigned to a specified message
	*
	* @see tasklist_driver::get_message_related_tasks()
	*/
	public function get_message_related_tasks($headers, $folder)
	{
	$config = kolab_storage_config::get_instance();
	$result = $config->get_message_relations($headers, $folder, 'task');

	foreach ($result as $idx => $rec) {
	$result[$idx] = $this->_to_rcube_task($rec, kolab_storage::folder_id($rec['_mailbox']));
	}

	return $result;
	}

	/**
	*
	*/
	public function tasklist_edit_form($action, $list, $fieldprop)
	{
	$this->_read_lists();

	if ($list['id'] && ($list = $this->lists[$list['id']])) {
	$folder_name = $this->get_folder($list['id'])->name; // UTF7
	}
	else {
	$folder_name = '';
	}

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

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

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

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

	// folder name (default field)
	$input_name = new html_inputfield(array('name' => 'name', 'id' => 'taskedit-tasklistame', 'size' => 20));
	$fieldprop['name']['value'] = $input_name->show($list['editname'], array('disabled' => ($options['norename'] \|\| $options['protected'])));

	// prevent user from moving folder
	if (!empty($options) && ($options['norename'] \|\| $options['protected'])) {
	$hidden_fields[] = array('name' => 'parent', 'value' => $path_imap);
	}
	else {
	$select = kolab_storage::folder_selector('task', array('name' => 'parent', 'id' => 'taskedit-parentfolder'), $folder_name);
	$fieldprop['parent'] = array(
	'id' => 'taskedit-parentfolder',
	'label' => $this->plugin->gettext('parentfolder'),
	'value' => $select->show($path_imap),
	);
	}

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

	foreach (array('name','parent','showalarms') as $f) {
	$form['properties']['fields'][$f] = $fieldprop[$f];
	}

	// add folder ACL tab
	if ($action != 'form-new') {
	$form['sharing'] = array(
	'name' => rcube::Q($this->plugin->gettext('tabsharing')),
	'content' => html::tag('iframe', array(
	'src' => $this->rc->url(array('_action' => 'folder-acl', '_folder' => $folder_name, 'framed' => 1)),
	'width' => '100%',
	'height' => 280,
	'border' => 0,
	'style' => 'border:0'),
	'')
	);
	}

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

	// create form output
	foreach ($form as $tab) {
	if (is_array($tab['fields']) && empty($tab['content'])) {
	$table = new html_table(array('cols' => 2));
	foreach ($tab['fields'] as $col => $colprop) {
	$label = !empty($colprop['label']) ? $colprop['label'] : $this->plugin->gettext($col);

	$table->add('title', html::label($colprop['id'], rcube::Q($label)));
	$table->add(null, $colprop['value']);
	}
	$content = $table->show();
	}
	else {
	$content = $tab['content'];
	}

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

	return $form_html;
	}

	/**
	* Handler to render ACL form for a notes folder
	*/
	public function folder_acl()
	{
	$this->plugin->require_plugin('acl');
	$this->rc->output->add_handler('folderacl', array($this, 'folder_acl_form'));
	$this->rc->output->send('tasklist.kolabacl');
	}

	/**
	* Handler for ACL form template object
	*/
	public function folder_acl_form()
	{
	$folder = rcube_utils::get_input_value('_folder', rcube_utils::INPUT_GPC);

	if (strlen($folder)) {
	$storage = $this->rc->get_storage();
	$options = $storage->folder_info($folder);

	// get sharing UI from acl plugin
	$acl = $this->rc->plugins->exec_hook('folder_form',
	array('form' => array(), 'options' => $options, 'name' => $folder));
	}

	return $acl['form']['sharing']['content'] ?: html::div('hint', $this->plugin->gettext('aclnorights'));
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Apr 5, 11:15 PM (1 w, 6 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 18831533
Default Alt Text: (94 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions