No OneTemporary
Actions

Size

76 KB

Subscribers

None

View Options

	diff --git a/action/ajax.php b/action/ajax.php
	--- a/action/ajax.php
	+++ b/action/ajax.php
	@@ -1,178 +1,202 @@
	<?php

	/**
	* DokuWiki DAVCal PlugIn - Ajax component
	*/

	if(!defined('DOKU_INC')) die();

	class action_plugin_davcal_ajax extends DokuWiki_Action_Plugin {

	/**
	* @var helper_plugin_davcal
	*/
	private $hlp = null;

	function __construct() {
	$this->hlp =& plugin_load('helper','davcal');
	}

	function register(Doku_Event_Handler $controller) {
	$controller->register_hook('AJAX_CALL_UNKNOWN', 'BEFORE', $this, 'handle_ajax_call_unknown');
	}

	function handle_ajax_call_unknown(&$event, $param) {
	if($event->data != 'plugin_davcal') return;

	$event->preventDefault();
	$event->stopPropagation();
	global $INPUT;

	$action = trim($INPUT->post->str('action'));
	$id = trim($INPUT->post->str('id'));
	$page = trim($INPUT->post->str('page'));
	$params = $INPUT->post->arr('params');
	if(isset($_SERVER['REMOTE_USER']) && !is_null($_SERVER['REMOTE_USER']))
	$user = $_SERVER['REMOTE_USER'];
	else
	$user = null;
	$write = false;
	$multi = false;

	if(!checkSecurityToken())
	{
	echo "CSRF Attack.";
	return;
	}

	$data = array();

	$data['result'] = false;
	$data['html'] = $this->getLang('unknown_error');

	// Check if we have access to the calendar ($id is given by parameters,
	// that's not necessarily the page we come from)
	$acl = auth_quickaclcheck($id);
	if($acl > AUTH_READ)
	{
	$write = true;
	}
	elseif($acl < AUTH_READ)
	{
	$data['result'] = false;
	$data['html'] = $this->getLang('no_permission');
	// Set to an invalid action in order to just return the result
	$action = 'invalid';
	}

	// Retrieve the calendar pages based on the meta data
	$calendarPages = $this->hlp->getCalendarPagesByMeta($page);
	if($calendarPages === false)
	{
	$calendarPages = array($page => null);
	}
	if(count($calendarPages) > 1)
	$multi = true;

	// Parse the requested action
	switch($action)
	{
	// Add a new Event
	case 'newEvent':
	if($write)
	{
	- $data['result'] = true;
	- $data['html'] = $this->getLang('event_added');
	- $this->hlp->addCalendarEntryToCalendarForPage($id, $user, $params);
	+ $res = $this->hlp->addCalendarEntryToCalendarForPage($id, $user, $params);
	+ if($res === true)
	+ {
	+ $data['result'] = true;
	+ $data['html'] = $this->getLang('event_added');
	+ }
	+ else
	+ {
	+ $data['result'] = false;
	+ $data['html'] = $this->getLang('unknown_error');
	+ }
	}
	else
	{
	$data['result'] = false;
	$data['html'] = $this->getLang('no_permission');
	}
	break;
	// Retrieve existing Events
	case 'getEvents':
	$startDate = $INPUT->post->str('start');
	$endDate = $INPUT->post->str('end');
	$timezone = $INPUT->post->str('timezone');
	$data = array();
	foreach($calendarPages as $calPage => $color)
	{
	$data = array_merge($data, $this->hlp->getEventsWithinDateRange($calPage,
	$user, $startDate, $endDate, $timezone, $color));
	}
	break;
	// Edit an event
	case 'editEvent':
	if($write)
	{
	- $data['result'] = true;
	- $data['html'] = $this->getLang('event_edited');
	- $this->hlp->editCalendarEntryForPage($id, $user, $params);
	+ $res = $this->hlp->editCalendarEntryForPage($id, $user, $params);
	+ if($res === true)
	+ {
	+ $data['result'] = true;
	+ $data['html'] = $this->getLang('event_edited');
	+ }
	+ else
	+ {
	+ $data['result'] = false;
	+ $data['html'] = $this->getLang('unknown_error');
	+ }
	}
	else
	{
	$data['result'] = false;
	$data['html'] = $this->getLang('no_permission');
	}
	break;
	// Delete an Event
	case 'deleteEvent':
	if($write)
	{
	- $data['result'] = true;
	- $data['html'] = $this->getLang('event_deleted');
	- $this->hlp->deleteCalendarEntryForPage($id, $params);
	+ $res = $this->hlp->deleteCalendarEntryForPage($id, $params);
	+ if($res === true)
	+ {
	+ $data['result'] = true;
	+ $data['html'] = $this->getLang('event_deleted');
	+ }
	+ else
	+ {
	+ $data['result'] = false;
	+ $data['html'] = $this->getLang('unknown_error');
	+ }
	}
	else
	{
	$data['result'] = false;
	$data['html'] = $this->getLang('no_permission');
	}
	break;
	// Get personal settings
	case 'getSettings':
	$data['result'] = true;
	$data['settings'] = $this->hlp->getPersonalSettings($user);
	$data['settings']['multi'] = $multi;
	$data['settings']['calids'] = $this->hlp->getCalendarMapForIDs($calendarPages);
	$data['settings']['readonly'] = !$write;
	$data['settings']['syncurl'] = $this->hlp->getSyncUrlForPage($page, $user);
	$data['settings']['privateurl'] = $this->hlp->getPrivateURLForPage($page);
	$data['settings']['principalurl'] = $this->hlp->getPrincipalUrlForUser($user);
	$data['settings']['meta'] = $this->hlp->getCalendarMetaForPage($page);
	break;
	// Save personal settings
	case 'saveSettings':
	$settings = array();
	$settings['weeknumbers'] = $params['weeknumbers'];
	$settings['timezone'] = $params['timezone'];
	$settings['workweek'] = $params['workweek'];
	$settings['monday'] = $params['monday'];
	$settings['timeformat'] = $params['timeformat'];
	if($this->hlp->savePersonalSettings($settings, $user))
	{
	$data['result'] = true;
	$data['html'] = $this->getLang('settings_saved');
	}
	else
	{
	$data['result'] = false;
	$data['html'] = $this->getLang('error_saving');
	}
	break;
	}

	// If we are still here, JSON output is requested

	//json library of DokuWiki
	require_once DOKU_INC . 'inc/JSON.php';
	$json = new JSON();

	//set content type
	header('Content-Type: application/json');
	echo $json->encode($data);
	}

	}
	diff --git a/conf/default.php b/conf/default.php
	--- a/conf/default.php
	+++ b/conf/default.php
	@@ -1,15 +1,16 @@
	<?php
	/**
	* Default settings for the davcal plugin
	*
	* @author Andreas Boehler <dev@aboehler.at>
	*/

	$conf['hide_settings'] = 0;
	$conf['disable_ics'] = 1;
	$conf['disable_sync'] = 1;
	$conf['monday'] = 0;
	$conf['timezone'] = 'local';
	$conf['workweek'] = 0;
	$conf['weeknumbers'] = 0;
	$conf['timeformat'] = 'lang';
	+$conf['default_client_id'] = '';
	diff --git a/conf/metadata.php b/conf/metadata.php
	--- a/conf/metadata.php
	+++ b/conf/metadata.php
	@@ -1,16 +1,17 @@
	<?php
	/**
	* Options for the davcal plugin
	*
	* @author Andreas Boehler <dev@aboehler.at>
	*/


	$meta['hide_settings'] = array('onoff');
	$meta['disable_sync'] = array('onoff');
	$meta['disable_ics'] = array('onoff');
	$meta['monday'] = array('onoff');
	$meta['timezone'] = array('string');
	$meta['timeformat'] = array('multichoice', '_choices' => array('lang', '24h', '12h'));
	$meta['workweek'] = array('onoff');
	$meta['weeknumbers'] = array('onoff');
	+$meta['default_client_id'] = array('string');
	diff --git a/helper.php b/helper.php
	--- a/helper.php
	+++ b/helper.php
	@@ -1,1650 +1,1749 @@
	<?php
	/**
	* Helper Class for the DAVCal plugin
	* This helper does the actual work.
	*
	*/

	// must be run within Dokuwiki
	if(!defined('DOKU_INC')) die();

	class helper_plugin_davcal extends DokuWiki_Plugin {

	protected $sqlite = null;
	protected $cachedValues = array();

	/**
	* Constructor to load the configuration and the SQLite plugin
	*/
	public function helper_plugin_davcal() {
	$this->sqlite =& plugin_load('helper', 'sqlite');
	global $conf;
	if($conf['allowdebug'])
	dbglog('---- DAVCAL helper.php init');
	if(!$this->sqlite)
	{
	if($conf['allowdebug'])
	dbglog('This plugin requires the sqlite plugin. Please install it.');
	msg('This plugin requires the sqlite plugin. Please install it.');
	return;
	}

	if(!$this->sqlite->init('davcal', DOKU_PLUGIN.'davcal/db/'))
	{
	if($conf['allowdebug'])
	dbglog('Error initialising the SQLite DB for DAVCal');
	return;
	}
	}

	/**
	* Retrieve meta data for a given page
	*
	* @param string $id optional The page ID
	* @return array The metadata
	*/
	private function getMeta($id = null) {
	global $ID;
	global $INFO;

	if ($id === null) $id = $ID;

	if($ID === $id && $INFO['meta']) {
	$meta = $INFO['meta'];
	} else {
	$meta = p_get_metadata($id);
	}

	return $meta;
	}

	/**
	* Retrieve the meta data for a given page
	*
	* @param string $id optional The page ID
	* @return array with meta data
	*/
	public function getCalendarMetaForPage($id = null)
	{
	if(is_null($id))
	{
	global $ID;
	$id = $ID;
	}

	$meta = $this->getMeta($id);
	if(isset($meta['plugin_davcal']))
	return $meta['plugin_davcal'];
	else
	return array();
	}

	/**
	* Filter calendar pages and return only those where the current
	* user has at least read permission.
	*
	* @param array $calendarPages Array with calendar pages to check
	* @return array with filtered calendar pages
	*/
	public function filterCalendarPagesByUserPermission($calendarPages)
	{
	$retList = array();
	foreach($calendarPages as $page => $data)
	{
	- if(auth_quickaclcheck($page) >= AUTH_READ)
	+ // WebDAV Connections are always readable
	+ if(strpos($page, 'webdav://') === 0)
	+ {
	+ $retList[$page] = $data;
	+ }
	+ elseif(auth_quickaclcheck($page) >= AUTH_READ)
	{
	$retList[$page] = $data;
	}
	}
	return $retList;
	}

	/**
	* Get all calendar pages used by a given page
	* based on the stored metadata
	*
	* @param string $id optional The page id
	* @return mixed The pages as array or false
	*/
	public function getCalendarPagesByMeta($id = null)
	{
	if(is_null($id))
	{
	global $ID;
	$id = $ID;
	}

	$meta = $this->getCalendarMetaForPage($id);
	+
	if(isset($meta['id']))
	{
	// Filter the list of pages by permission
	$pages = $this->filterCalendarPagesByUserPermission($meta['id']);
	if(empty($pages))
	return false;
	return $pages;
	}
	return false;
	}

	/**
	* Get a list of calendar names/pages/ids/colors
	* for an array of page ids
	*
	* @param array $calendarPages The calendar pages to retrieve
	* @return array The list
	*/
	public function getCalendarMapForIDs($calendarPages)
	{
	$data = array();
	foreach($calendarPages as $page => $color)
	{
	- $calid = $this->getCalendarIdForPage($page);
	- if($calid !== false)
	- {
	- $settings = $this->getCalendarSettings($calid);
	- $name = $settings['displayname'];
	- $write = (auth_quickaclcheck($page) > AUTH_READ);
	+ if(strpos($page, 'webdav://') === 0)
	+ {
	+ $wdc =& plugin_load('helper', 'webdavclient');
	+ if(is_null($wdc))
	+ continue;
	+ $connectionId = str_replace('webdav://', '', $page);
	+ $settings = $wdc->getConnection($connectionId);
	+ if($settings === false)
	+ continue;
	+ $name = $settings['displayname'];
	+ $write = $settings['write'];
	+ $calid = $connectionId;
	+ }
	+ else
	+ {
	+ $calid = $this->getCalendarIdForPage($page);
	+ if($calid !== false)
	+ {
	+ $settings = $this->getCalendarSettings($calid);
	+ $name = $settings['displayname'];
	+ //$color = $settings['calendarcolor'];
	+ $write = (auth_quickaclcheck($page) > AUTH_READ);
	+ }
	+ else
	+ {
	+ continue;
	+ }
	+ }
	$data[] = array('name' => $name, 'page' => $page, 'calid' => $calid,
	'color' => $color, 'write' => $write);
	- }
	}
	return $data;
	}

	/**
	* Get the saved calendar color for a given page.
	*
	* @param string $id optional The page ID
	* @return mixed The color on success, otherwise false
	*/
	public function getCalendarColorForPage($id = null)
	{
	if(is_null($id))
	{
	global $ID;
	$id = $ID;
	}

	$calid = $this->getCalendarIdForPage($id);
	if($calid === false)
	return false;

	return $this->getCalendarColorForCalendar($calid);
	}

	/**
	* Get the saved calendar color for a given calendar ID.
	*
	* @param string $id optional The calendar ID
	* @return mixed The color on success, otherwise false
	*/
	public function getCalendarColorForCalendar($calid)
	{
	if(isset($this->cachedValues['calendarcolor'][$calid]))
	return $this->cachedValues['calendarcolor'][$calid];

	$row = $this->getCalendarSettings($calid);

	if(!isset($row['calendarcolor']))
	return false;

	$color = $row['calendarcolor'];
	$this->cachedValues['calendarcolor'][$calid] = $color;
	return $color;
	}

	/**
	* Get the user's principal URL for iOS sync
	* @param string $user the user name
	* @return the URL to the principal sync
	*/
	public function getPrincipalUrlForUser($user)
	{
	if(is_null($user))
	return false;
	$url = DOKU_URL.'lib/plugins/davcal/calendarserver.php/principals/'.$user;
	return $url;
	}

	/**
	* Set the calendar color for a given page.
	*
	* @param string $color The color definition
	* @param string $id optional The page ID
	* @return boolean True on success, otherwise false
	*/
	public function setCalendarColorForPage($color, $id = null)
	{
	if(is_null($id))
	{
	global $ID;
	$id = $ID;
	}
	$calid = $this->getCalendarIdForPage($id);
	if($calid === false)
	return false;

	$query = "UPDATE calendars SET calendarcolor = ? ".
	" WHERE id = ?";
	$res = $this->sqlite->query($query, $color, $calid);
	if($res !== false)
	{
	$this->cachedValues['calendarcolor'][$calid] = $color;
	return true;
	}
	return false;
	}

	/**
	* Set the calendar name and description for a given page with a given
	* page id.
	* If the calendar doesn't exist, the calendar is created!
	*
	* @param string $name The name of the new calendar
	* @param string $description The description of the new calendar
	* @param string $id (optional) The ID of the page
	* @param string $userid The userid of the creating user
	*
	* @return boolean True on success, otherwise false.
	*/
	public function setCalendarNameForPage($name, $description, $id = null, $userid = null)
	{
	if(is_null($id))
	{
	global $ID;
	$id = $ID;
	}
	if(is_null($userid))
	{
	if(isset($_SERVER['REMOTE_USER']) && !is_null($_SERVER['REMOTE_USER']))
	{
	$userid = $_SERVER['REMOTE_USER'];
	}
	else
	{
	$userid = uniqid('davcal-');
	}
	}
	$calid = $this->getCalendarIdForPage($id);
	if($calid === false)
	return $this->createCalendarForPage($name, $description, $id, $userid);

	$query = "UPDATE calendars SET displayname = ?, description = ? WHERE id = ?";
	$res = $this->sqlite->query($query, $name, $description, $calid);
	if($res !== false)
	return true;
	return false;
	}

	/**
	* Update a calendar's displayname
	*
	* @param int $calid The calendar's ID
	* @param string $name The new calendar name
	*
	* @return boolean True on success, otherwise false
	*/
	public function updateCalendarName($calid, $name)
	{
	$query = "UPDATE calendars SET displayname = ? WHERE id = ?";
	$res = $this->sqlite->query($query, $calid, $name);
	if($res !== false)
	{
	$this->updateSyncTokenLog($calid, '', 'modified');
	return true;
	}
	return false;
	}

	/**
	* Update the calendar description
	*
	* @param int $calid The calendar's ID
	* @param string $description The new calendar's description
	*
	* @return boolean True on success, otherwise false
	*/
	public function updateCalendarDescription($calid, $description)
	{
	$query = "UPDATE calendars SET description = ? WHERE id = ?";
	$res = $this->sqlite->query($query, $calid, $description);
	if($res !== false)
	{
	$this->updateSyncTokenLog($calid, '', 'modified');
	return true;
	}
	return false;
	}

	/**
	* Update a calendar's timezone information
	*
	* @param int $calid The calendar's ID
	* @param string $timezone The new timezone to set
	*
	* @return boolean True on success, otherwise false
	*/
	public function updateCalendarTimezone($calid, $timezone)
	{
	$query = "UPDATE calendars SET timezone = ? WHERE id = ?";
	$res = $this->sqlite->query($query, $calid, $timezone);
	if($res !== false)
	{
	$this->updateSyncTokenLog($calid, '', 'modified');
	return true;
	}
	return false;
	}

	/**
	* Save the personal settings to the SQLite database 'calendarsettings'.
	*
	* @param array $settings The settings array to store
	* @param string $userid (optional) The userid to store
	*
	* @param boolean True on success, otherwise false
	*/
	public function savePersonalSettings($settings, $userid = null)
	{
	if(is_null($userid))
	{
	if(isset($_SERVER['REMOTE_USER']) && !is_null($_SERVER['REMOTE_USER']))
	{
	$userid = $_SERVER['REMOTE_USER'];
	}
	else
	{
	return false;
	}
	}
	$this->sqlite->query("BEGIN TRANSACTION");

	$query = "DELETE FROM calendarsettings WHERE userid = ?";
	$this->sqlite->query($query, $userid);

	foreach($settings as $key => $value)
	{
	$query = "INSERT INTO calendarsettings (userid, key, value) VALUES (?, ?, ?)";
	$res = $this->sqlite->query($query, $userid, $key, $value);
	if($res === false)
	return false;
	}
	$this->sqlite->query("COMMIT TRANSACTION");
	$this->cachedValues['settings'][$userid] = $settings;
	return true;
	}

	/**
	* Retrieve the settings array for a given user id.
	* Some sane defaults are returned, currently:
	*
	* timezone => local
	* weeknumbers => 0
	* workweek => 0
	*
	* @param string $userid (optional) The user id to retrieve
	*
	* @return array The settings array
	*/
	public function getPersonalSettings($userid = null)
	{
	// Some sane default settings
	$settings = array(
	'timezone' => $this->getConf('timezone'),
	'weeknumbers' => $this->getConf('weeknumbers'),
	'workweek' => $this->getConf('workweek'),
	'monday' => $this->getConf('monday'),
	'timeformat' => $this->getConf('timeformat')
	);
	if(is_null($userid))
	{
	if(isset($_SERVER['REMOTE_USER']) && !is_null($_SERVER['REMOTE_USER']))
	{
	$userid = $_SERVER['REMOTE_USER'];
	}
	else
	{
	return $settings;
	}
	}

	if(isset($this->cachedValues['settings'][$userid]))
	return $this->cachedValues['settings'][$userid];
	$query = "SELECT key, value FROM calendarsettings WHERE userid = ?";
	$res = $this->sqlite->query($query, $userid);
	$arr = $this->sqlite->res2arr($res);
	foreach($arr as $row)
	{
	$settings[$row['key']] = $row['value'];
	}
	$this->cachedValues['settings'][$userid] = $settings;
	return $settings;
	}

	/**
	* Retrieve the calendar ID based on a page ID from the SQLite table
	* 'pagetocalendarmapping'.
	*
	* @param string $id (optional) The page ID to retrieve the corresponding calendar
	*
	* @return mixed the ID on success, otherwise false
	*/
	public function getCalendarIdForPage($id = null)
	{
	if(is_null($id))
	{
	global $ID;
	$id = $ID;
	}

	if(isset($this->cachedValues['calid'][$id]))
	return $this->cachedValues['calid'][$id];

	$query = "SELECT calid FROM pagetocalendarmapping WHERE page = ?";
	$res = $this->sqlite->query($query, $id);
	$row = $this->sqlite->res2row($res);
	if(isset($row['calid']))
	{
	$calid = $row['calid'];
	$this->cachedValues['calid'] = $calid;
	return $calid;
	}
	return false;
	}

	/**
	* Retrieve the complete calendar id to page mapping.
	* This is necessary to be able to retrieve a list of
	* calendars for a given user and check the access rights.
	*
	* @return array The mapping array
	*/
	public function getCalendarIdToPageMapping()
	{
	$query = "SELECT calid, page FROM pagetocalendarmapping";
	$res = $this->sqlite->query($query);
	$arr = $this->sqlite->res2arr($res);
	return $arr;
	}

	/**
	* Retrieve all calendar IDs a given user has access to.
	* The user is specified by the principalUri, so the
	* user name is actually split from the URI component.
	*
	* Access rights are checked against DokuWiki's ACL
	* and applied accordingly.
	*
	* @param string $principalUri The principal URI to work on
	*
	* @return array An associative array of calendar IDs
	*/
	public function getCalendarIdsForUser($principalUri)
	{
	global $auth;
	$user = explode('/', $principalUri);
	$user = end($user);
	$mapping = $this->getCalendarIdToPageMapping();
	$calids = array();
	$ud = $auth->getUserData($user);
	$groups = $ud['grps'];
	foreach($mapping as $row)
	{
	$id = $row['calid'];
	$page = $row['page'];
	$acl = auth_aclcheck($page, $user, $groups);
	if($acl >= AUTH_READ)
	{
	$write = $acl > AUTH_READ;
	$calids[$id] = array('readonly' => !$write);
	}
	}
	return $calids;
	}

	/**
	* Create a new calendar for a given page ID and set name and description
	* accordingly. Also update the pagetocalendarmapping table on success.
	*
	* @param string $name The calendar's name
	* @param string $description The calendar's description
	* @param string $id (optional) The page ID to work on
	* @param string $userid (optional) The user ID that created the calendar
	*
	* @return boolean True on success, otherwise false
	*/
	public function createCalendarForPage($name, $description, $id = null, $userid = null)
	{
	if(is_null($id))
	{
	global $ID;
	$id = $ID;
	}
	if(is_null($userid))
	{
	if(isset($_SERVER['REMOTE_USER']) && !is_null($_SERVER['REMOTE_USER']))
	{
	$userid = $_SERVER['REMOTE_USER'];
	}
	else
	{
	$userid = uniqid('davcal-');
	}
	}
	$values = array('principals/'.$userid,
	$name,
	str_replace(array('/', ' ', ':'), '_', $id),
	$description,
	'VEVENT,VTODO',
	0,
	1);
	$query = "INSERT INTO calendars (principaluri, displayname, uri, description, components, transparent, synctoken) ".
	"VALUES (?, ?, ?, ?, ?, ?, ?)";
	$res = $this->sqlite->query($query, $values[0], $values[1], $values[2], $values[3], $values[4], $values[5], $values[6]);
	if($res === false)
	return false;

	// Get the new calendar ID
	$query = "SELECT id FROM calendars WHERE principaluri = ? AND displayname = ? AND ".
	"uri = ? AND description = ?";
	$res = $this->sqlite->query($query, $values[0], $values[1], $values[2], $values[3]);
	$row = $this->sqlite->res2row($res);

	// Update the pagetocalendarmapping table with the new calendar ID
	if(isset($row['id']))
	{
	$query = "INSERT INTO pagetocalendarmapping (page, calid) VALUES (?, ?)";
	$res = $this->sqlite->query($query, $id, $row['id']);
	return ($res !== false);
	}

	return false;
	}

	/**
	* Add a new calendar entry to the given calendar. Calendar data is
	* specified as ICS file, thus it needs to be parsed first.
	*
	* This is mainly needed for the sync support.
	*
	* @param int $calid The calendar's ID
	* @param string $uri The new object URI
	* @param string $ics The ICS file
	*
	* @return mixed The etag.
	*/
	public function addCalendarEntryToCalendarByICS($calid, $uri, $ics)
	{
	$extraData = $this->getDenormalizedData($ics);

	$query = "INSERT INTO calendarobjects (calendarid, uri, calendardata, lastmodified, etag, size, componenttype, firstoccurence, lastoccurence, uid) VALUES (?,?,?,?,?,?,?,?,?,?)";
	$res = $this->sqlite->query($query,
	$calid,
	$uri,
	$ics,
	time(),
	$extraData['etag'],
	$extraData['size'],
	$extraData['componentType'],
	$extraData['firstOccurence'],
	$extraData['lastOccurence'],
	$extraData['uid']);
	// If successfully, update the sync token database
	if($res !== false)
	{
	$this->updateSyncTokenLog($calid, $uri, 'added');
	}
	return $extraData['etag'];
	}

	/**
	* Edit a calendar entry by providing a new ICS file. This is mainly
	* needed for the sync support.
	*
	* @param int $calid The calendar's IS
	* @param string $uri The object's URI to modify
	* @param string $ics The new object's ICS file
	*/
	public function editCalendarEntryToCalendarByICS($calid, $uri, $ics)
	{
	$extraData = $this->getDenormalizedData($ics);

	$query = "UPDATE calendarobjects SET calendardata = ?, lastmodified = ?, etag = ?, size = ?, componenttype = ?, firstoccurence = ?, lastoccurence = ?, uid = ? WHERE calendarid = ? AND uri = ?";
	$res = $this->sqlite->query($query,
	$ics,
	time(),
	$extraData['etag'],
	$extraData['size'],
	$extraData['componentType'],
	$extraData['firstOccurence'],
	$extraData['lastOccurence'],
	$extraData['uid'],
	$calid,
	$uri
	);
	if($res !== false)
	{
	$this->updateSyncTokenLog($calid, $uri, 'modified');
	}
	return $extraData['etag'];
	}

	/**
	* Add a new iCal entry for a given page, i.e. a given calendar.
	*
	* The parameter array needs to contain
	* detectedtz => The timezone as detected by the browser
	* currenttz => The timezone in use by the calendar
	* eventfrom => The event's start date
	* eventfromtime => The event's start time
	* eventto => The event's end date
	* eventtotime => The event's end time
	* eventname => The event's name
	* eventdescription => The event's description
	*
	* @param string $id The page ID to work on
	* @param string $user The user who created the calendar
	* @param string $params A parameter array with values to create
	*
	* @return boolean True on success, otherwise false
	*/
	public function addCalendarEntryToCalendarForPage($id, $user, $params)
	{
	if($params['currenttz'] !== '' && $params['currenttz'] !== 'local')
	$timezone = new \DateTimeZone($params['currenttz']);
	elseif($params['currenttz'] === 'local')
	$timezone = new \DateTimeZone($params['detectedtz']);
	else
	$timezone = new \DateTimeZone('UTC');

	// Retrieve dates from settings
	$startDate = explode('-', $params['eventfrom']);
	$startTime = explode(':', $params['eventfromtime']);
	$endDate = explode('-', $params['eventto']);
	$endTime = explode(':', $params['eventtotime']);

	// Load SabreDAV
	require_once(DOKU_PLUGIN.'davcal/vendor/autoload.php');
	$vcalendar = new \Sabre\VObject\Component\VCalendar();

	// Add VCalendar, UID and Event Name
	$event = $vcalendar->add('VEVENT');
	$uuid = \Sabre\VObject\UUIDUtil::getUUID();
	$event->add('UID', $uuid);
	$event->summary = $params['eventname'];

	// Add a description if requested
	$description = $params['eventdescription'];
	if($description !== '')
	$event->add('DESCRIPTION', $description);

	// Add attachments
	$attachments = $params['attachments'];
	if(!is_null($attachments))
	foreach($attachments as $attachment)
	$event->add('ATTACH', $attachment);

	// Create a timestamp for last modified, created and dtstamp values in UTC
	$dtStamp = new \DateTime(null, new \DateTimeZone('UTC'));
	$event->add('DTSTAMP', $dtStamp);
	$event->add('CREATED', $dtStamp);
	$event->add('LAST-MODIFIED', $dtStamp);

	// Adjust the start date, based on the given timezone information
	$dtStart = new \DateTime();
	$dtStart->setTimezone($timezone);
	$dtStart->setDate(intval($startDate[0]), intval($startDate[1]), intval($startDate[2]));

	// Only add the time values if it's not an allday event
	if($params['allday'] != '1')
	$dtStart->setTime(intval($startTime[0]), intval($startTime[1]), 0);

	// Adjust the end date, based on the given timezone information
	$dtEnd = new \DateTime();
	$dtEnd->setTimezone($timezone);
	$dtEnd->setDate(intval($endDate[0]), intval($endDate[1]), intval($endDate[2]));

	// Only add the time values if it's not an allday event
	if($params['allday'] != '1')
	$dtEnd->setTime(intval($endTime[0]), intval($endTime[1]), 0);

	// According to the VCal spec, we need to add a whole day here
	if($params['allday'] == '1')
	$dtEnd->add(new \DateInterval('P1D'));

	// Really add Start and End events
	$dtStartEv = $event->add('DTSTART', $dtStart);
	$dtEndEv = $event->add('DTEND', $dtEnd);

	// Adjust the DATE format for allday events
	if($params['allday'] == '1')
	{
	$dtStartEv['VALUE'] = 'DATE';
	$dtEndEv['VALUE'] = 'DATE';
	}

	- // Actually add the values to the database
	- $calid = $this->getCalendarIdForPage($id);
	- $uri = uniqid('dokuwiki-').'.ics';
	- $now = new DateTime();
	$eventStr = $vcalendar->serialize();

	- $query = "INSERT INTO calendarobjects (calendarid, uri, calendardata, lastmodified, componenttype, firstoccurence, lastoccurence, size, etag, uid) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
	- $res = $this->sqlite->query($query, $calid, $uri, $eventStr, $now->getTimestamp(), 'VEVENT',
	- $event->DTSTART->getDateTime()->getTimeStamp(), $event->DTEND->getDateTime()->getTimeStamp(),
	- strlen($eventStr), md5($eventStr), $uuid);
	-
	- // If successfully, update the sync token database
	- if($res !== false)
	+ if(strpos($id, 'webdav://') === 0)
	+ {
	+ $wdc =& plugin_load('helper', 'webdavclient');
	+ if(is_null($wdc))
	+ return false;
	+ $connectionId = str_replace('webdav://', '', $id);
	+ return $wdc->addCalendarEntry($connectionId, $eventStr);
	+ }
	+ else
	{
	- $this->updateSyncTokenLog($calid, $uri, 'added');
	- return true;
	+ // Actually add the values to the database
	+ $calid = $this->getCalendarIdForPage($id);
	+ $uri = uniqid('dokuwiki-').'.ics';
	+ $now = new \DateTime();
	+
	+ $query = "INSERT INTO calendarobjects (calendarid, uri, calendardata, lastmodified, componenttype, firstoccurence, lastoccurence, size, etag, uid) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
	+ $res = $this->sqlite->query($query, $calid, $uri, $eventStr, $now->getTimestamp(), 'VEVENT',
	+ $event->DTSTART->getDateTime()->getTimeStamp(), $event->DTEND->getDateTime()->getTimeStamp(),
	+ strlen($eventStr), md5($eventStr), $uuid);
	+
	+ // If successfully, update the sync token database
	+ if($res !== false)
	+ {
	+ $this->updateSyncTokenLog($calid, $uri, 'added');
	+ return true;
	+ }
	}
	return false;
	}

	/**
	* Retrieve the calendar settings of a given calendar id
	*
	* @param string $calid The calendar ID
	*
	* @return array The calendar settings array
	*/
	public function getCalendarSettings($calid)
	{
	$query = "SELECT id, principaluri, calendarcolor, displayname, uri, description, components, transparent, synctoken FROM calendars WHERE id= ? ";
	$res = $this->sqlite->query($query, $calid);
	$row = $this->sqlite->res2row($res);
	return $row;
	}

	/**
	* Retrieve all events that are within a given date range,
	* based on the timezone setting.
	*
	* There is also support for retrieving recurring events,
	* using Sabre's VObject Iterator. Recurring events are represented
	* as individual calendar entries with the same UID.
	*
	* @param string $id The page ID to work with
	* @param string $user The user ID to work with
	* @param string $startDate The start date as a string
	* @param string $endDate The end date as a string
	* @param string $color (optional) The calendar's color
	*
	* @return array An array containing the calendar entries.
	*/
	public function getEventsWithinDateRange($id, $user, $startDate, $endDate, $timezone, $color = null)
	{
	if($timezone !== '' && $timezone !== 'local')
	$timezone = new \DateTimeZone($timezone);
	else
	$timezone = new \DateTimeZone('UTC');
	$data = array();

	- // Load SabreDAV
	- require_once(DOKU_PLUGIN.'davcal/vendor/autoload.php');
	- $calid = $this->getCalendarIdForPage($id);
	- if(is_null($color))
	- $color = $this->getCalendarColorForCalendar($calid);
	$query = "SELECT calendardata, componenttype, uid FROM calendarobjects WHERE calendarid = ?";
	$startTs = null;
	$endTs = null;
	if($startDate !== null)
	{
	$startTs = new \DateTime($startDate);
	$query .= " AND lastoccurence > ".$this->sqlite->quote_string($startTs->getTimestamp());
	}
	if($endDate !== null)
	{
	$endTs = new \DateTime($endDate);
	$query .= " AND firstoccurence < ".$this->sqlite->quote_string($endTs->getTimestamp());
	}
	-
	- // Retrieve matching calendar objects
	- $res = $this->sqlite->query($query, $calid);
	- $arr = $this->sqlite->res2arr($res);
	+
	+ // Load SabreDAV
	+ require_once(DOKU_PLUGIN.'davcal/vendor/autoload.php');
	+
	+ if(strpos($id, 'webdav://') === 0)
	+ {
	+ $wdc =& plugin_load('helper', 'webdavclient');
	+ if(is_null($wdc))
	+ return $data;
	+ $connectionId = str_replace('webdav://', '', $id);
	+ $arr = $wdc->getCalendarEntries($connectionId, $startDate, $endDate);
	+ }
	+ else
	+ {
	+ $calid = $this->getCalendarIdForPage($id);
	+ if(is_null($color))
	+ $color = $this->getCalendarColorForCalendar($calid);
	+
	+ // Retrieve matching calendar objects
	+ $res = $this->sqlite->query($query, $calid);
	+ $arr = $this->sqlite->res2arr($res);
	+ }

	// Parse individual calendar entries
	foreach($arr as $row)
	{
	if(isset($row['calendardata']))
	{
	$entry = array();
	$vcal = \Sabre\VObject\Reader::read($row['calendardata']);
	$recurrence = $vcal->VEVENT->RRULE;
	// If it is a recurring event, pass it through Sabre's EventIterator
	if($recurrence != null)
	{
	$rEvents = new \Sabre\VObject\Recur\EventIterator(array($vcal->VEVENT));
	$rEvents->rewind();
	while($rEvents->valid())
	{
	$event = $rEvents->getEventObject();
	// If we are after the given time range, exit
	if(($endTs !== null) && ($rEvents->getDtStart()->getTimestamp() > $endTs->getTimestamp()))
	break;

	// If we are before the given time range, continue
	if(($startTs != null) && ($rEvents->getDtEnd()->getTimestamp() < $startTs->getTimestamp()))
	{
	$rEvents->next();
	continue;
	}

	// If we are within the given time range, parse the event
	$data[] = $this->convertIcalDataToEntry($event, $id, $timezone, $row['uid'], $color, true);
	$rEvents->next();
	}
	}
	else
	$data[] = $this->convertIcalDataToEntry($vcal->VEVENT, $id, $timezone, $row['uid'], $color);
	}
	}
	return $data;
	}

	/**
	* Helper function that parses the iCal data of a VEVENT to a calendar entry.
	*
	* @param \Sabre\VObject\VEvent $event The event to parse
	* @param \DateTimeZone $timezone The timezone object
	* @param string $uid The entry's UID
	* @param boolean $recurring (optional) Set to true to define a recurring event
	*
	* @return array The parse calendar entry
	*/
	private function convertIcalDataToEntry($event, $page, $timezone, $uid, $color, $recurring = false)
	{
	$entry = array();
	$start = $event->DTSTART;
	// Parse only if the start date/time is present
	if($start !== null)
	{
	$dtStart = $start->getDateTime();
	$dtStart->setTimezone($timezone);

	// moment.js doesn't like times be given even if
	// allDay is set to true
	// This should fix T23
	if($start['VALUE'] == 'DATE')
	{
	$entry['allDay'] = true;
	$entry['start'] = $dtStart->format("Y-m-d");
	}
	else
	{
	$entry['allDay'] = false;
	$entry['start'] = $dtStart->format(\DateTime::ATOM);
	}
	}
	$end = $event->DTEND;
	// Parse only if the end date/time is present
	if($end !== null)
	{
	$dtEnd = $end->getDateTime();
	$dtEnd->setTimezone($timezone);
	if($end['VALUE'] == 'DATE')
	$entry['end'] = $dtEnd->format("Y-m-d");
	else
	$entry['end'] = $dtEnd->format(\DateTime::ATOM);
	}
	$description = $event->DESCRIPTION;
	if($description !== null)
	$entry['description'] = (string)$description;
	else
	$entry['description'] = '';
	$attachments = $event->ATTACH;
	if($attachments !== null)
	{
	$entry['attachments'] = array();
	foreach($attachments as $attachment)
	$entry['attachments'][] = (string)$attachment;
	}
	$entry['title'] = (string)$event->summary;
	$entry['id'] = $uid;
	$entry['page'] = $page;
	$entry['color'] = $color;
	$entry['recurring'] = $recurring;

	return $entry;
	}

	/**
	* Retrieve an event by its UID
	*
	* @param string $uid The event's UID
	*
	* @return mixed The table row with the given event
	*/
	public function getEventWithUid($uid)
	{
	$query = "SELECT calendardata, calendarid, componenttype, uri FROM calendarobjects WHERE uid = ?";
	$res = $this->sqlite->query($query, $uid);
	$row = $this->sqlite->res2row($res);
	return $row;
	}

	/**
	* Retrieve information of a calendar's object, not including the actual
	* calendar data! This is mainly neede for the sync support.
	*
	* @param int $calid The calendar ID
	*
	* @return mixed The result
	*/
	public function getCalendarObjects($calid)
	{
	$query = "SELECT id, uri, lastmodified, etag, calendarid, size, componenttype FROM calendarobjects WHERE calendarid = ?";
	$res = $this->sqlite->query($query, $calid);
	$arr = $this->sqlite->res2arr($res);
	return $arr;
	}

	/**
	* Retrieve a single calendar object by calendar ID and URI
	*
	* @param int $calid The calendar's ID
	* @param string $uri The object's URI
	*
	* @return mixed The result
	*/
	public function getCalendarObjectByUri($calid, $uri)
	{
	$query = "SELECT id, uri, lastmodified, etag, calendarid, size, calendardata, componenttype FROM calendarobjects WHERE calendarid = ? AND uri = ?";
	$res = $this->sqlite->query($query, $calid, $uri);
	$row = $this->sqlite->res2row($res);
	return $row;
	}

	/**
	* Retrieve several calendar objects by specifying an array of URIs.
	* This is mainly neede for sync.
	*
	* @param int $calid The calendar's ID
	* @param array $uris An array of URIs
	*
	* @return mixed The result
	*/
	public function getMultipleCalendarObjectsByUri($calid, $uris)
	{
	$query = "SELECT id, uri, lastmodified, etag, calendarid, size, calendardata, componenttype FROM calendarobjects WHERE calendarid = ? AND uri IN (";
	// Inserting a whole bunch of question marks
	$query .= implode(',', array_fill(0, count($uris), '?'));
	$query .= ')';
	$vals = array_merge(array($calid), $uris);

	$res = $this->sqlite->query($query, $vals);
	$arr = $this->sqlite->res2arr($res);
	return $arr;
	}

	/**
	* Retrieve all calendar events for a given calendar ID
	*
	* @param string $calid The calendar's ID
	*
	* @return array An array containing all calendar data
	*/
	public function getAllCalendarEvents($calid)
	{
	$query = "SELECT calendardata, uid, componenttype, uri FROM calendarobjects WHERE calendarid = ?";
	$res = $this->sqlite->query($query, $calid);
	$arr = $this->sqlite->res2arr($res);
	return $arr;
	}

	/**
	* Edit a calendar entry for a page, given by its parameters.
	* The params array has the same format as @see addCalendarEntryForPage
	*
	* @param string $id The page's ID to work on
	* @param string $user The user's ID to work on
	* @param array $params The parameter array for the edited calendar event
	*
	* @return boolean True on success, otherwise false
	*/
	public function editCalendarEntryForPage($id, $user, $params)
	{
	if($params['currenttz'] !== '' && $params['currenttz'] !== 'local')
	$timezone = new \DateTimeZone($params['currenttz']);
	elseif($params['currenttz'] === 'local')
	$timezone = new \DateTimeZone($params['detectedtz']);
	else
	$timezone = new \DateTimeZone('UTC');

	// Parse dates
	$startDate = explode('-', $params['eventfrom']);
	$startTime = explode(':', $params['eventfromtime']);
	$endDate = explode('-', $params['eventto']);
	$endTime = explode(':', $params['eventtotime']);

	// Retrieve the existing event based on the UID
	$uid = $params['uid'];
	- $event = $this->getEventWithUid($uid);
	+
	+ if(strpos($id, 'webdav://') === 0)
	+ {
	+ $wdc =& plugin_load('helper', 'webdavclient');
	+ if(is_null($wdc))
	+ return false;
	+ $event = $wdc->getCalendarEntryByUid($uid);
	+ }
	+ else
	+ {
	+ $event = $this->getEventWithUid($uid);
	+ }

	// Load SabreDAV
	require_once(DOKU_PLUGIN.'davcal/vendor/autoload.php');
	if(!isset($event['calendardata']))
	return false;
	$uri = $event['uri'];
	$calid = $event['calendarid'];

	// Parse the existing event
	$vcal = \Sabre\VObject\Reader::read($event['calendardata']);
	$vevent = $vcal->VEVENT;

	// Set the new event values
	$vevent->summary = $params['eventname'];
	$dtStamp = new \DateTime(null, new \DateTimeZone('UTC'));
	$description = $params['eventdescription'];

	// Remove existing timestamps to overwrite them
	$vevent->remove('DESCRIPTION');
	$vevent->remove('DTSTAMP');
	$vevent->remove('LAST-MODIFIED');
	$vevent->remove('ATTACH');

	// Add new time stamps and description
	$vevent->add('DTSTAMP', $dtStamp);
	$vevent->add('LAST-MODIFIED', $dtStamp);
	if($description !== '')
	$vevent->add('DESCRIPTION', $description);

	// Add attachments
	$attachments = $params['attachments'];
	if(!is_null($attachments))
	foreach($attachments as $attachment)
	$vevent->add('ATTACH', $attachment);

	// Setup DTSTART
	$dtStart = new \DateTime();
	$dtStart->setTimezone($timezone);
	$dtStart->setDate(intval($startDate[0]), intval($startDate[1]), intval($startDate[2]));
	if($params['allday'] != '1')
	$dtStart->setTime(intval($startTime[0]), intval($startTime[1]), 0);

	// Setup DTEND
	$dtEnd = new \DateTime();
	$dtEnd->setTimezone($timezone);
	$dtEnd->setDate(intval($endDate[0]), intval($endDate[1]), intval($endDate[2]));
	if($params['allday'] != '1')
	$dtEnd->setTime(intval($endTime[0]), intval($endTime[1]), 0);

	// According to the VCal spec, we need to add a whole day here
	if($params['allday'] == '1')
	$dtEnd->add(new \DateInterval('P1D'));
	$vevent->remove('DTSTART');
	$vevent->remove('DTEND');
	$dtStartEv = $vevent->add('DTSTART', $dtStart);
	$dtEndEv = $vevent->add('DTEND', $dtEnd);

	// Remove the time for allday events
	if($params['allday'] == '1')
	{
	$dtStartEv['VALUE'] = 'DATE';
	$dtEndEv['VALUE'] = 'DATE';
	}
	- $now = new DateTime();
	$eventStr = $vcal->serialize();
	- // Actually write to the database
	- $query = "UPDATE calendarobjects SET calendardata = ?, lastmodified = ?, ".
	- "firstoccurence = ?, lastoccurence = ?, size = ?, etag = ? WHERE uid = ?";
	- $res = $this->sqlite->query($query, $eventStr, $now->getTimestamp(), $dtStart->getTimestamp(),
	- $dtEnd->getTimestamp(), strlen($eventStr), md5($eventStr), $uid);
	+ if(strpos($id, 'webdav://') === 0)
	+ {
	+ $connectionId = str_replace('webdav://', '', $id);
	+ return $wdc->editCalendarEntry($connectionId, $uid, $eventStr);
	+ }
	+ else
	+ {
	+ $now = new DateTime();
	+ // Actually write to the database
	+ $query = "UPDATE calendarobjects SET calendardata = ?, lastmodified = ?, ".
	+ "firstoccurence = ?, lastoccurence = ?, size = ?, etag = ? WHERE uid = ?";
	+ $res = $this->sqlite->query($query, $eventStr, $now->getTimestamp(), $dtStart->getTimestamp(),
	+ $dtEnd->getTimestamp(), strlen($eventStr), md5($eventStr), $uid);
	+ if($res !== false)
	+ {
	+ $this->updateSyncTokenLog($calid, $uri, 'modified');
	+ return true;
	+ }
	+ }
	+ return false;
	+ }
	+
	+ /**
	+ * Delete an event from a calendar by calendar ID and URI
	+ *
	+ * @param int $calid The calendar's ID
	+ * @param string $uri The object's URI
	+ *
	+ * @return true
	+ */
	+ public function deleteCalendarEntryForCalendarByUri($calid, $uri)
	+ {
	+ $query = "DELETE FROM calendarobjects WHERE calendarid = ? AND uri = ?";
	+ $res = $this->sqlite->query($query, $calid, $uri);
	if($res !== false)
	{
	- $this->updateSyncTokenLog($calid, $uri, 'modified');
	- return true;
	+ $this->updateSyncTokenLog($calid, $uri, 'deleted');
	}
	- return false;
	+ return true;
	}

	/**
	* Delete an event from a calendar by calendar ID and URI
	*
	* @param int $calid The calendar's ID
	* @param string $uri The object's URI
	*
	* @return true
	*/
	public function deleteCalendarEntryForCalendarByUri($calid, $uri)
	{
	$query = "DELETE FROM calendarobjects WHERE calendarid = ? AND uri = ?";
	$res = $this->sqlite->query($query, $calid, $uri);
	if($res !== false)
	{
	$this->updateSyncTokenLog($calid, $uri, 'deleted');
	}
	return true;
	}

	/**
	* Delete a calendar entry for a given page. Actually, the event is removed
	* based on the entry's UID, so that page ID is no used.
	*
	* @param string $id The page's ID (unused)
	* @param array $params The parameter array to work with
	*
	* @return boolean True
	*/
	public function deleteCalendarEntryForPage($id, $params)
	{
	$uid = $params['uid'];
	+ if(strpos($id, 'webdav://') === 0)
	+ {
	+ $wdc =& plugin_load('helper', 'webdavclient');
	+ if(is_null($wdc))
	+ return false;
	+ $connectionId = str_replace('webdav://', '', $id);
	+ $result = $wdc->deleteCalendarEntry($connectionId, $uid);
	+ return $result;
	+ }
	$event = $this->getEventWithUid($uid);
	$calid = $event['calendarid'];
	$uri = $event['uri'];
	$query = "DELETE FROM calendarobjects WHERE uid = ?";
	$res = $this->sqlite->query($query, $uid);
	if($res !== false)
	{
	$this->updateSyncTokenLog($calid, $uri, 'deleted');
	}
	return true;
	}

	/**
	* Retrieve the current sync token for a calendar
	*
	* @param string $calid The calendar id
	*
	* @return mixed The synctoken or false
	*/
	public function getSyncTokenForCalendar($calid)
	{
	$row = $this->getCalendarSettings($calid);
	if(isset($row['synctoken']))
	return $row['synctoken'];
	return false;
	}

	/**
	* Helper function to convert the operation name to
	* an operation code as stored in the database
	*
	* @param string $operationName The operation name
	*
	* @return mixed The operation code or false
	*/
	public function operationNameToOperation($operationName)
	{
	switch($operationName)
	{
	case 'added':
	return 1;
	break;
	case 'modified':
	return 2;
	break;
	case 'deleted':
	return 3;
	break;
	}
	return false;
	}

	/**
	* Update the sync token log based on the calendar id and the
	* operation that was performed.
	*
	* @param string $calid The calendar ID that was modified
	* @param string $uri The calendar URI that was modified
	* @param string $operation The operation that was performed
	*
	* @return boolean True on success, otherwise false
	*/
	private function updateSyncTokenLog($calid, $uri, $operation)
	{
	$currentToken = $this->getSyncTokenForCalendar($calid);
	$operationCode = $this->operationNameToOperation($operation);
	if(($operationCode === false) \|\| ($currentToken === false))
	return false;
	$values = array($uri,
	$currentToken,
	$calid,
	$operationCode
	);
	$query = "INSERT INTO calendarchanges (uri, synctoken, calendarid, operation) VALUES(?, ?, ?, ?)";
	$res = $this->sqlite->query($query, $uri, $currentToken, $calid, $operationCode);
	if($res === false)
	return false;
	$currentToken++;
	$query = "UPDATE calendars SET synctoken = ? WHERE id = ?";
	$res = $this->sqlite->query($query, $currentToken, $calid);
	return ($res !== false);
	}

	/**
	* Return the sync URL for a given Page, i.e. a calendar
	*
	* @param string $id The page's ID
	* @param string $user (optional) The user's ID
	*
	* @return mixed The sync url or false
	*/
	public function getSyncUrlForPage($id, $user = null)
	{
	if(is_null($userid))
	{
	if(isset($_SERVER['REMOTE_USER']) && !is_null($_SERVER['REMOTE_USER']))
	{
	$userid = $_SERVER['REMOTE_USER'];
	}
	else
	{
	return false;
	}
	}

	$calid = $this->getCalendarIdForPage($id);
	if($calid === false)
	return false;

	$calsettings = $this->getCalendarSettings($calid);
	if(!isset($calsettings['uri']))
	return false;

	$syncurl = DOKU_URL.'lib/plugins/davcal/calendarserver.php/calendars/'.$user.'/'.$calsettings['uri'];
	return $syncurl;
	}

	/**
	* Return the private calendar's URL for a given page
	*
	* @param string $id the page ID
	*
	* @return mixed The private URL or false
	*/
	public function getPrivateURLForPage($id)
	{
	$calid = $this->getCalendarIdForPage($id);
	if($calid === false)
	return false;

	return $this->getPrivateURLForCalendar($calid);
	}

	/**
	* Return the private calendar's URL for a given calendar ID
	*
	* @param string $calid The calendar's ID
	*
	* @return mixed The private URL or false
	*/
	public function getPrivateURLForCalendar($calid)
	{
	if(isset($this->cachedValues['privateurl'][$calid]))
	return $this->cachedValues['privateurl'][$calid];
	$query = "SELECT url FROM calendartoprivateurlmapping WHERE calid = ?";
	$res = $this->sqlite->query($query, $calid);
	$row = $this->sqlite->res2row($res);
	if(!isset($row['url']))
	{
	$url = uniqid("dokuwiki-").".ics";
	$query = "INSERT INTO calendartoprivateurlmapping (url, calid) VALUES(?, ?)";
	$res = $this->sqlite->query($query, $url, $calid);
	if($res === false)
	return false;
	}
	else
	{
	$url = $row['url'];
	}

	$url = DOKU_URL.'lib/plugins/davcal/ics.php/'.$url;
	$this->cachedValues['privateurl'][$calid] = $url;
	return $url;
	}

	/**
	* Retrieve the calendar ID for a given private calendar URL
	*
	* @param string $url The private URL
	*
	* @return mixed The calendar ID or false
	*/
	public function getCalendarForPrivateURL($url)
	{
	$query = "SELECT calid FROM calendartoprivateurlmapping WHERE url = ?";
	$res = $this->sqlite->query($query, $url);
	$row = $this->sqlite->res2row($res);
	if(!isset($row['calid']))
	return false;
	return $row['calid'];
	}

	/**
	* Return a given calendar as ICS feed, i.e. all events in one ICS file.
	*
	* @param string $calid The calendar ID to retrieve
	*
	* @return mixed The calendar events as string or false
	*/
	public function getCalendarAsICSFeed($calid)
	{
	$calSettings = $this->getCalendarSettings($calid);
	if($calSettings === false)
	return false;
	$events = $this->getAllCalendarEvents($calid);
	if($events === false)
	return false;

	// Load SabreDAV
	require_once(DOKU_PLUGIN.'davcal/vendor/autoload.php');
	$out = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//DAVCal//DAVCal for DokuWiki//EN\r\nCALSCALE:GREGORIAN\r\nX-WR-CALNAME:";
	$out .= $calSettings['displayname']."\r\n";
	foreach($events as $event)
	{
	$vcal = \Sabre\VObject\Reader::read($event['calendardata']);
	$evt = $vcal->VEVENT;
	$out .= $evt->serialize();
	}
	$out .= "END:VCALENDAR\r\n";
	return $out;
	}

	/**
	* Retrieve a configuration option for the plugin
	*
	* @param string $key The key to query
	* @return mixed The option set, null if not found
	*/
	public function getConfig($key)
	{
	return $this->getConf($key);
	}

	/**
	* Parses some information from calendar objects, used for optimized
	* calendar-queries. Taken nearly unmodified from Sabre's PDO backend
	*
	* Returns an array with the following keys:
	* * etag - An md5 checksum of the object without the quotes.
	* * size - Size of the object in bytes
	* * componentType - VEVENT, VTODO or VJOURNAL
	* * firstOccurence
	* * lastOccurence
	* * uid - value of the UID property
	*
	* @param string $calendarData
	* @return array
	*/
	protected function getDenormalizedData($calendarData)
	{
	require_once(DOKU_PLUGIN.'davcal/vendor/autoload.php');

	$vObject = \Sabre\VObject\Reader::read($calendarData);
	$componentType = null;
	$component = null;
	$firstOccurence = null;
	$lastOccurence = null;
	$uid = null;
	foreach ($vObject->getComponents() as $component)
	{
	if ($component->name !== 'VTIMEZONE')
	{
	$componentType = $component->name;
	$uid = (string)$component->UID;
	break;
	}
	}
	if (!$componentType)
	{
	return false;
	}
	if ($componentType === 'VEVENT')
	{
	$firstOccurence = $component->DTSTART->getDateTime()->getTimeStamp();
	// Finding the last occurence is a bit harder
	if (!isset($component->RRULE))
	{
	if (isset($component->DTEND))
	{
	$lastOccurence = $component->DTEND->getDateTime()->getTimeStamp();
	}
	elseif (isset($component->DURATION))
	{
	$endDate = clone $component->DTSTART->getDateTime();
	$endDate->add(\Sabre\VObject\DateTimeParser::parse($component->DURATION->getValue()));
	$lastOccurence = $endDate->getTimeStamp();
	}
	elseif (!$component->DTSTART->hasTime())
	{
	$endDate = clone $component->DTSTART->getDateTime();
	$endDate->modify('+1 day');
	$lastOccurence = $endDate->getTimeStamp();
	}
	else
	{
	$lastOccurence = $firstOccurence;
	}
	}
	else
	{
	$it = new \Sabre\VObject\Recur\EventIterator($vObject, (string)$component->UID);
	$maxDate = new \DateTime('2038-01-01');
	if ($it->isInfinite())
	{
	$lastOccurence = $maxDate->getTimeStamp();
	}
	else
	{
	$end = $it->getDtEnd();
	while ($it->valid() && $end < $maxDate)
	{
	$end = $it->getDtEnd();
	$it->next();
	}
	$lastOccurence = $end->getTimeStamp();
	}
	}
	}

	return array(
	'etag' => md5($calendarData),
	'size' => strlen($calendarData),
	'componentType' => $componentType,
	'firstOccurence' => $firstOccurence,
	'lastOccurence' => $lastOccurence,
	'uid' => $uid,
	);

	}

	/**
	* Query a calendar by ID and taking several filters into account.
	* This is heavily based on Sabre's PDO backend.
	*
	* @param int $calendarId The calendar's ID
	* @param array $filters The filter array to apply
	*
	* @return mixed The result
	*/
	public function calendarQuery($calendarId, $filters)
	{
	$componentType = null;
	$requirePostFilter = true;
	$timeRange = null;

	// if no filters were specified, we don't need to filter after a query
	if (!$filters['prop-filters'] && !$filters['comp-filters'])
	{
	$requirePostFilter = false;
	}

	// Figuring out if there's a component filter
	if (count($filters['comp-filters']) > 0 && !$filters['comp-filters'][0]['is-not-defined'])
	{
	$componentType = $filters['comp-filters'][0]['name'];

	// Checking if we need post-filters
	if (!$filters['prop-filters'] && !$filters['comp-filters'][0]['comp-filters'] && !$filters['comp-filters'][0]['time-range'] && !$filters['comp-filters'][0]['prop-filters'])
	{
	$requirePostFilter = false;
	}
	// There was a time-range filter
	if ($componentType == 'VEVENT' && isset($filters['comp-filters'][0]['time-range']))
	{
	$timeRange = $filters['comp-filters'][0]['time-range'];

	// If start time OR the end time is not specified, we can do a
	// 100% accurate mysql query.
	if (!$filters['prop-filters'] && !$filters['comp-filters'][0]['comp-filters'] && !$filters['comp-filters'][0]['prop-filters'] && (!$timeRange['start'] \|\| !$timeRange['end']))
	{
	$requirePostFilter = false;
	}
	}

	}

	if ($requirePostFilter)
	{
	$query = "SELECT uri, calendardata FROM calendarobjects WHERE calendarid = ?";
	}
	else
	{
	$query = "SELECT uri FROM calendarobjects WHERE calendarid = ?";
	}

	$values = array(
	$calendarId
	);

	if ($componentType)
	{
	$query .= " AND componenttype = ?";
	$values[] = $componentType;
	}

	if ($timeRange && $timeRange['start'])
	{
	$query .= " AND lastoccurence > ?";
	$values[] = $timeRange['start']->getTimeStamp();
	}
	if ($timeRange && $timeRange['end'])
	{
	$query .= " AND firstoccurence < ?";
	$values[] = $timeRange['end']->getTimeStamp();
	}

	$res = $this->sqlite->query($query, $values);
	$arr = $this->sqlite->res2arr($res);

	$result = array();
	foreach($arr as $row)
	{
	if ($requirePostFilter)
	{
	if (!$this->validateFilterForObject($row, $filters))
	{
	continue;
	}
	}
	$result[] = $row['uri'];

	}

	return $result;
	}

	/**
	* This method validates if a filter (as passed to calendarQuery) matches
	* the given object. Taken from Sabre's PDO backend
	*
	* @param array $object
	* @param array $filters
	* @return bool
	*/
	protected function validateFilterForObject($object, $filters)
	{
	require_once(DOKU_PLUGIN.'davcal/vendor/autoload.php');
	// Unfortunately, setting the 'calendardata' here is optional. If
	// it was excluded, we actually need another call to get this as
	// well.
	if (!isset($object['calendardata']))
	{
	$object = $this->getCalendarObjectByUri($object['calendarid'], $object['uri']);
	}

	$vObject = \Sabre\VObject\Reader::read($object['calendardata']);
	$validator = new \Sabre\CalDAV\CalendarQueryValidator();

	return $validator->validate($vObject, $filters);

	}

	/**
	* Retrieve changes for a given calendar based on the given syncToken.
	*
	* @param int $calid The calendar's ID
	* @param int $syncToken The supplied sync token
	* @param int $syncLevel The sync level
	* @param int $limit The limit of changes
	*
	* @return array The result
	*/
	public function getChangesForCalendar($calid, $syncToken, $syncLevel, $limit = null)
	{
	// Current synctoken
	$currentToken = $this->getSyncTokenForCalendar($calid);

	if ($currentToken === false) return null;

	$result = array(
	'syncToken' => $currentToken,
	'added' => array(),
	'modified' => array(),
	'deleted' => array(),
	);

	if ($syncToken)
	{

	$query = "SELECT uri, operation FROM calendarchanges WHERE synctoken >= ? AND synctoken < ? AND calendarid = ? ORDER BY synctoken";
	if ($limit > 0) $query .= " LIMIT " . (int)$limit;

	// Fetching all changes
	$res = $this->sqlite->query($query, $syncToken, $currentToken, $calid);
	if($res === false)
	return null;

	$arr = $this->sqlite->res2arr($res);
	$changes = array();

	// This loop ensures that any duplicates are overwritten, only the
	// last change on a node is relevant.
	foreach($arr as $row)
	{
	$changes[$row['uri']] = $row['operation'];
	}

	foreach ($changes as $uri => $operation)
	{
	switch ($operation)
	{
	case 1 :
	$result['added'][] = $uri;
	break;
	case 2 :
	$result['modified'][] = $uri;
	break;
	case 3 :
	$result['deleted'][] = $uri;
	break;
	}

	}
	}
	else
	{
	// No synctoken supplied, this is the initial sync.
	$query = "SELECT uri FROM calendarobjects WHERE calendarid = ?";
	$res = $this->sqlite->query($query);
	$arr = $this->sqlite->res2arr($res);

	$result['added'] = $arr;
	}
	return $result;
	}

	}
	diff --git a/lang/de-informal/settings.php b/lang/de-informal/settings.php
	--- a/lang/de-informal/settings.php
	+++ b/lang/de-informal/settings.php
	@@ -1,14 +1,15 @@
	<?php
	/**
	* German language file for DAVCal
	*
	* @author Andreas Böhler <dev@aboehler.at>
	*/
	$lang['hide_settings'] = 'Verstecke den Knopf Einstellungen unterhalb des Kalenders';
	$lang['disable_sync'] = 'Deaktiviere CalDAV Synchronisation (aber erlaube Private URL)';
	$lang['disable_ics'] = 'Deaktiviere Private URL Synchronisation (aber erlaube CalDAV Synchronisierung)';
	$lang['monday'] = 'Wochenbeginn ist am Montag statt am Sonntag';
	$lang['timezone'] = 'Setze die Zeitzone des Kalenders (zB "Europe/Vienna" oder "local" für Browser-basierende Zeit)';
	$lang['workweek'] = 'Zeige nur die Arbeitswoche';
	$lang['weeknumbers'] = 'Zeige Wochennummern';
	$lang['timeformat'] = 'Zeitformat, \'lang\' bedeutet sprachbasiert';
	+$lang['default_client_id'] = 'Standard-ID im Client-Modus ({{caldavclient>) verwenden, zB webdav://8';
	diff --git a/lang/de/settings.php b/lang/de/settings.php
	--- a/lang/de/settings.php
	+++ b/lang/de/settings.php
	@@ -1,15 +1,16 @@
	<?php
	/**
	* German language file for DAVCal
	*
	* @author Andreas Böhler <dev@aboehler.at>
	*/

	$lang['hide_settings'] = 'Verstecke den Knopf Einstellungen unterhalb des Kalenders';
	$lang['disable_sync'] = 'Deaktiviere CalDAV Synchronisation (aber erlaube Private URL)';
	$lang['disable_ics'] = 'Deaktiviere Private URL Synchronisation (aber erlaube CalDAV Synchronisierung)';
	$lang['monday'] = 'Wochenbeginn ist am Montag statt am Sonntag';
	$lang['timezone'] = 'Setze die Zeitzone des Kalenders (zB "Europe/Vienna" oder "local" für Browser-basierende Zeit)';
	$lang['workweek'] = 'Zeige nur die Arbeitswoche';
	$lang['weeknumbers'] = 'Zeige Wochennummern';
	$lang['timeformat'] = 'Zeitformat, \'lang\' bedeutet sprachbasiert';
	+$lang['default_client_id'] = 'Standard-ID im Client-Modus ({{caldavclient>) verwenden, zB webdav://8';
	diff --git a/lang/en/settings.php b/lang/en/settings.php
	--- a/lang/en/settings.php
	+++ b/lang/en/settings.php
	@@ -1,14 +1,15 @@
	<?php
	/**
	* English language file for DAVCal
	*
	* @author Andreas Böhler <dev@aboehler.at>
	*/
	$lang['hide_settings'] = 'Hide the settings button beneath the calendar';
	$lang['disable_sync'] = 'Disable CalDAV synchronisation (but still allow private ICS URL)';
	$lang['disable_ics'] = 'Disable private ICS URL synchronisation (but still allow CalDAV sync)';
	$lang['monday'] = 'Start week on Monday instead of Sunday';
	$lang['timezone'] = 'Set the timezone of the calendar (e.g. "Europe/Vienna" or "local" for browser-based)';
	$lang['workweek'] = 'Show only workweek';
	$lang['weeknumbers'] = 'Show week numbers';
	$lang['timeformat'] = 'Time format to use, lang means based on language';
	+$lang['default_client_id'] = 'Default ID when specified as davcalclient, e.g. webdav://8';
	diff --git a/syntax/calendar.php b/syntax/calendar.php
	--- a/syntax/calendar.php
	+++ b/syntax/calendar.php
	@@ -1,163 +1,178 @@
	<?php
	/**
	* DokuWiki Plugin DAVCal (Calendar Syntax Component)
	*
	* @license GPL 2 http://www.gnu.org/licenses/gpl-2.0.html
	* @author Andreas Böhler <dev@aboehler.at>
	*/

	// must be run within Dokuwiki
	if(!defined('DOKU_INC')) die();

	if(!defined('DOKU_PLUGIN')) define('DOKU_PLUGIN',DOKU_INC.'lib/plugins/');
	require_once(DOKU_PLUGIN.'syntax.php');

	class syntax_plugin_davcal_calendar extends DokuWiki_Syntax_Plugin {

	protected $hlp = null;

	// Load the helper plugin
	public function syntax_plugin_davcal_calendar() {
	$this->hlp =& plugin_load('helper', 'davcal');
	}


	/**
	* What kind of syntax are we?
	*/
	function getType(){
	return 'substition';
	}

	/**
	* What about paragraphs?
	*/
	function getPType(){
	return 'normal';
	}

	/**
	* Where to sort in?
	*/
	function getSort(){
	return 165;
	}

	/**
	* Connect pattern to lexer
	*/
	function connectTo($mode) {
	$this->Lexer->addSpecialPattern('\{\{davcal>[^}]*\}\}',$mode,'plugin_davcal_calendar');
	+ $this->Lexer->addSpecialPattern('\{\{davcalclient>[^}]*\}\}',$mode,'plugin_davcal_calendar');
	}

	/**
	* Handle the match
	*/
	function handle($match, $state, $pos, Doku_Handler $handler){
	global $ID;
	- $options = trim(substr($match,9,-2));
	- $options = explode(',', $options);
	$data = array('name' => $ID,
	'description' => $this->getLang('created_by_davcal'),
	'id' => array(),
	'settings' => 'show',
	'view' => 'month',
	'forcetimezone' => 'no',
	'forcetimeformat' => 'no'
	- );
	- $lastid = $ID;
	+ );
	+ if(strpos($match, '{{davcalclient') === 0)
	+ {
	+ $options = trim(substr($match,15,-2));
	+ $defaultId = $this->getConf('default_client_id');
	+ if(isset($defaultId) && ($defaultId != ''))
	+ {
	+ $data['id'][$defaultId] = '#3a87ad';
	+ $lastid = $defaultId;
	+ }
	+ }
	+ else
	+ {
	+ $options = trim(substr($match,9,-2));
	+ $lastid = $ID;
	+ }
	+ $options = explode(',', $options);
	+
	foreach($options as $option)
	{
	list($key, $val) = explode('=', $option);
	$key = strtolower(trim($key));
	$val = trim($val);
	switch($key)
	{
	case 'id':
	$lastid = $val;
	if(!in_array($val, $data['id']))
	$data['id'][$val] = '#3a87ad';
	break;
	case 'color':
	$data['id'][$lastid] = $val;
	break;
	case 'view':
	if(in_array($val, array('month', 'basicDay', 'basicWeek', 'agendaWeek', 'agendaDay')))
	$data['view'] = $val;
	else
	$data['view'] = 'month';
	break;
	case 'forcetimezone':
	$tzlist = \DateTimeZone::listIdentifiers(DateTimeZone::ALL);
	if(in_array($val, $tzlist) \|\| $val === 'no')
	$data['forcetimezone'] = $val;
	else
	msg($this->getLang('error_timezone_not_in_list'), -1);
	break;
	case 'forcetimeformat':
	$tfopt = array('lang', '24h', '12h');
	if(in_array($val, $tfopt) \|\| $val === 'no')
	$data['forcetimeformat'] = $val;
	else
	msg($this->getLang('error_option_error'), -1);
	break;
	default:
	$data[$key] = $val;
	}
	}
	// Handle the default case when the user didn't enter a different ID
	if(empty($data['id']))
	{
	$data['id'] = array($ID => '#3a87ad');
	}
	// Only update the calendar name/description if the ID matches the page ID.
	// Otherwise, the calendar is included in another page and we don't want
	// to interfere with its data.
	if(in_array($ID, array_keys($data['id'])))
	{
	if(isset($_SERVER['REMOTE_USER']) && !is_null($_SERVER['REMOTE_USER']))
	$username = $_SERVER['REMOTE_USER'];
	else
	$username = uniqid('davcal-');
	$this->hlp->setCalendarNameForPage($data['name'], $data['description'], $ID, $username);
	$this->hlp->setCalendarColorForPage($data['id'][$ID], $ID);
	}

	p_set_metadata($ID, array('plugin_davcal' => $data));

	return $data;
	}

	/**
	* Create output
	*/
	function render($format, Doku_Renderer $R, $data) {
	if($format != 'xhtml') return false;
	global $ID;
	$tzlist = \DateTimeZone::listIdentifiers(DateTimeZone::ALL);

	// Render the Calendar. Timezone list is within a hidden div,
	// the calendar ID is in a data-calendarid tag.
	if($data['forcetimezone'] !== 'no')
	$R->doc .= '<div id="fullCalendarTimezoneWarning">'.sprintf($this->getLang('this_calendar_uses_timezone'), $data['forcetimezone']).'</div>';
	$R->doc .= '<div id="fullCalendar" data-calendarpage="'.$ID.'"></div>';
	$R->doc .= '<div id="fullCalendarTimezoneList" class="fullCalendarTimezoneList" style="display:none">';
	$R->doc .= '<select id="fullCalendarTimezoneDropdown">';
	$R->doc .= '<option value="local">'.$this->getLang('local_time').'</option>';
	foreach($tzlist as $tz)
	{
	$R->doc .= '<option value="'.$tz.'">'.$tz.'</option>';
	}
	$R->doc .= '</select></div>';
	if(($this->getConf('hide_settings') !== 1) && ($data['settings'] !== 'hide'))
	{
	$R->doc .= '<div class="fullCalendarSettings"><a href="#" class="fullCalendarSettings"><img src="'.DOKU_URL.'lib/plugins/davcal/images/settings.png'.'">'.$this->getLang('settings').'</a></div>';
	}

	}



	}

	// vim:ts=4:sw=4:et:enc=utf-8:

File Metadata

Mime Type: text/x-diff
Expires: Thu, Dec 5, 3:24 PM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 524824
Default Alt Text: (76 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions