No OneTemporary
Actions

Size

102 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/ext/Syncroton/Command/Sync.php b/lib/ext/Syncroton/Command/Sync.php
	index c5da42b..3308bed 100644
	--- a/lib/ext/Syncroton/Command/Sync.php
	+++ b/lib/ext/Syncroton/Command/Sync.php
	@@ -1,938 +1,938 @@
	<?php
	/**
	* Syncroton
	*
	* @package Syncroton
	* @subpackage Command
	* @license http://www.tine20.org/licenses/lgpl.html LGPL Version 3
	* @copyright Copyright (c) 2009-2012 Metaways Infosystems GmbH (http://www.metaways.de)
	* @author Lars Kneschke <l.kneschke@metaways.de>
	*/

	/**
	* class to handle ActiveSync Sync command
	*
	* @package Syncroton
	* @subpackage Command
	*/
	class Syncroton_Command_Sync extends Syncroton_Command_Wbxml
	{
	const STATUS_SUCCESS = 1;
	const STATUS_PROTOCOL_VERSION_MISMATCH = 2;
	const STATUS_INVALID_SYNC_KEY = 3;
	const STATUS_PROTOCOL_ERROR = 4;
	const STATUS_SERVER_ERROR = 5;
	const STATUS_ERROR_IN_CLIENT_SERVER_CONVERSION = 6;
	const STATUS_CONFLICT_MATCHING_THE_CLIENT_AND_SERVER_OBJECT = 7;
	const STATUS_OBJECT_NOT_FOUND = 8;
	const STATUS_USER_ACCOUNT_MAYBE_OUT_OF_DISK_SPACE = 9;
	const STATUS_ERROR_SETTING_NOTIFICATION_GUID = 10;
	const STATUS_DEVICE_NOT_PROVISIONED_FOR_NOTIFICATIONS = 11;
	const STATUS_FOLDER_HIERARCHY_HAS_CHANGED = 12;
	const STATUS_RESEND_FULL_XML = 13;
	const STATUS_WAIT_INTERVAL_OUT_OF_RANGE = 14;

	const CONFLICT_OVERWRITE_SERVER = 0;
	const CONFLICT_OVERWRITE_PIM = 1;

	const MIMESUPPORT_DONT_SEND_MIME = 0;
	const MIMESUPPORT_SMIME_ONLY = 1;
	const MIMESUPPORT_SEND_MIME = 2;

	const BODY_TYPE_PLAIN_TEXT = 1;
	const BODY_TYPE_HTML = 2;
	const BODY_TYPE_RTF = 3;
	const BODY_TYPE_MIME = 4;

	/**
	* truncate types
	*/
	const TRUNCATE_ALL = 0;
	const TRUNCATE_4096 = 1;
	const TRUNCATE_5120 = 2;
	const TRUNCATE_7168 = 3;
	const TRUNCATE_10240 = 4;
	const TRUNCATE_20480 = 5;
	const TRUNCATE_51200 = 6;
	const TRUNCATE_102400 = 7;
	const TRUNCATE_NOTHING = 8;

	/**
	* filter types
	*/
	const FILTER_NOTHING = 0;
	const FILTER_1_DAY_BACK = 1;
	const FILTER_3_DAYS_BACK = 2;
	const FILTER_1_WEEK_BACK = 3;
	const FILTER_2_WEEKS_BACK = 4;
	const FILTER_1_MONTH_BACK = 5;
	const FILTER_3_MONTHS_BACK = 6;
	const FILTER_6_MONTHS_BACK = 7;
	const FILTER_INCOMPLETE = 8;


	protected $_defaultNameSpace = 'uri:AirSync';
	protected $_documentElement = 'Sync';

	/**
	* list of collections
	*
	* @var array
	*/
	protected $_collections = array();

	protected $_modifications = array();

	/**
	* the global WindowSize
	*
	* @var integer
	*/
	protected $_globalWindowSize;

	/**
	* there are more entries than WindowSize available
	* the MoreAvailable tag hot added to the xml output
	*
	* @var boolean
	*/
	protected $_moreAvailable = false;

	/**
	* @var Syncroton_Model_SyncState
	*/
	protected $_syncState;

	protected $_maxWindowSize = 100;

	protected $_heartbeatInterval = null;

	/**
	* process the XML file and add, change, delete or fetches data
	*/
	public function handle()
	{
	// input xml
	$xml = simplexml_import_dom($this->_requestBody);

	if (isset($xml->HeartbeatInterval)) {
	$this->_heartbeatInterval = (int)$xml->HeartbeatInterval;
	} elseif (isset($xml->Wait)) {
	$this->_heartbeatInterval = (int)$xml->Wait * 60;
	}

	$this->_globalWindowSize = isset($xml->WindowSize) ? (int)$xml->WindowSize : 100;


	if ($this->_globalWindowSize > $this->_maxWindowSize) {
	$this->_globalWindowSize = $this->_maxWindowSize;
	}

	$collections = array();
	$isPartialRequest = isset($xml->Partial);

	// try to restore collections from previous request
	if ($isPartialRequest) {
	$decodedCollections = Zend_Json::decode($this->_device->lastsynccollection);

	if (is_array($decodedCollections)) {
	foreach ($decodedCollections as $collection) {
	$collections[$collection['collectionId']] = new Syncroton_Model_SyncCollection($collection);
	}
	}
	}

	// Collections element is optional when Partial element is sent
	if (isset($xml->Collections)) {
	foreach ($xml->Collections->Collection as $xmlCollection) {
	$collectionId = (string)$xmlCollection->CollectionId;

	// do we have to update a collection sent in previous sync request?
	if ($isPartialRequest && isset($collections[$collectionId])) {
	$collections[$collectionId]->setFromSimpleXMLElement($xmlCollection);
	} else {
	$collections[$collectionId] = new Syncroton_Model_SyncCollection($xmlCollection);
	}
	}

	// store current value of $collections for next Sync command request
	$collectionsToSave = array();

	foreach ($collections as $collection) {
	$collectionsToSave[$collection->collectionId] = $collection->toArray();
	}

	$this->_device->lastsynccollection = Zend_Json::encode($collectionsToSave);

	if ($this->_device->isDirty()) {
	Syncroton_Registry::getDeviceBackend()->update($this->_device);
	}
	}

	foreach ($collections as $collectionData) {
	// has the folder been synchronised to the device already
	try {
	$collectionData->folder = $this->_folderBackend->getFolder($this->_device, $collectionData->collectionId);

	} catch (Syncroton_Exception_NotFound $senf) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " folder {$collectionData->collectionId} not found");

	// trigger INVALID_SYNCKEY instead of OBJECT_NOTFOUND when synckey is higher than 0
	// to avoid a syncloop for the iPhone
	if ($collectionData->syncKey > 0) {
	$collectionData->folder = new Syncroton_Model_Folder(array(
	'deviceId' => $this->_device,
	'serverId' => $collectionData->collectionId
	));
	}

	$this->_collections[$collectionData->collectionId] = $collectionData;

	continue;
	}

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " SyncKey is {$collectionData->syncKey} Class: {$collectionData->folder->class} CollectionId: {$collectionData->collectionId}");

	// initial synckey
	if($collectionData->syncKey === 0) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " initial client synckey 0 provided");

	// reset sync state for this folder
	$this->_syncStateBackend->resetState($this->_device, $collectionData->folder);
	$this->_contentStateBackend->resetState($this->_device, $collectionData->folder);

	$collectionData->syncState = new Syncroton_Model_SyncState(array(
	'device_id' => $this->_device,
	'counter' => 0,
	'type' => $collectionData->folder,
	'lastsync' => $this->_syncTimeStamp
	));

	$this->_collections[$collectionData->collectionId] = $collectionData;

	continue;
	}

	// check for invalid sycnkey
	if(($collectionData->syncState = $this->_syncStateBackend->validate($this->_device, $collectionData->folder, $collectionData->syncKey)) === false) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " invalid synckey {$collectionData->syncKey} provided");

	// reset sync state for this folder
	$this->_syncStateBackend->resetState($this->_device, $collectionData->folder);
	$this->_contentStateBackend->resetState($this->_device, $collectionData->folder);

	$this->_collections[$collectionData->collectionId] = $collectionData;

	continue;
	}

	$dataController = Syncroton_Data_Factory::factory($collectionData->folder->class, $this->_device, $this->_syncTimeStamp);

	switch($collectionData->folder->class) {
	case Syncroton_Data_Factory::CLASS_CALENDAR:
	$dataClass = 'Syncroton_Model_Event';

	break;

	case Syncroton_Data_Factory::CLASS_CONTACTS:
	$dataClass = 'Syncroton_Model_Contact';

	break;

	case Syncroton_Data_Factory::CLASS_EMAIL:
	$dataClass = 'Syncroton_Model_Email';

	break;

	case Syncroton_Data_Factory::CLASS_TASKS:
	$dataClass = 'Syncroton_Model_Task';

	break;

	default:
	throw new Syncroton_Exception_UnexpectedValue('invalid class provided');

	break;
	}

	$clientModifications = array(
	'added' => array(),
	'changed' => array(),
	'deleted' => array(),
	'forceAdd' => array(),
	'forceChange' => array(),
	'toBeFetched' => array(),
	);

	// handle incoming data
	if($collectionData->hasClientAdds()) {
	$adds = $collectionData->getClientAdds();

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found " . count($adds) . " entries to be added to server");

	foreach ($adds as $add) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " add entry with clientId " . (string) $add->ClientId);

	try {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " adding entry as new");

	$serverId = $dataController->createEntry($collectionData->collectionId, new $dataClass($add->ApplicationData));

	$clientModifications['added'][$serverId] = array(
	'clientId' => (string)$add->ClientId,
	'serverId' => $serverId,
	'status' => self::STATUS_SUCCESS,
	'contentState' => $this->_contentStateBackend->create(new Syncroton_Model_Content(array(
	'device_id' => $this->_device,
	'folder_id' => $collectionData->folder,
	'contentid' => $serverId,
	'creation_time' => $this->_syncTimeStamp,
	'creation_synckey' => $collectionData->syncKey + 1
	)))
	);

	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " failed to add entry " . $e->getMessage());
	$clientModifications['added'][] = array(
	'clientId' => (string)$add->ClientId,
	'status' => self::STATUS_SERVER_ERROR
	);
	}
	}
	}

	// handle changes, but only if not first sync
	if($collectionData->syncKey > 1 && $collectionData->hasClientChanges()) {
	$changes = $collectionData->getClientChanges();

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found " . count($changes) . " entries to be updated on server");

	foreach ($changes as $change) {
	$serverId = (string)$change->ServerId;

	try {
	$dataController->updateEntry($collectionData->collectionId, $serverId, new $dataClass($change->ApplicationData));
	$clientModifications['changed'][$serverId] = self::STATUS_SUCCESS;

	} catch (Syncroton_Exception_AccessDenied $e) {
	$clientModifications['changed'][$serverId] = self::STATUS_CONFLICT_MATCHING_THE_CLIENT_AND_SERVER_OBJECT;
	$clientModifications['forceChange'][$serverId] = $serverId;

	} catch (Syncroton_Exception_NotFound $e) {
	// entry does not exist anymore, will get deleted automaticaly
	$clientModifications['changed'][$serverId] = self::STATUS_OBJECT_NOT_FOUND;

	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " failed to update entry " . $e);
	// something went wrong while trying to update the entry
	$clientModifications['changed'][$serverId] = self::STATUS_SERVER_ERROR;
	}
	}
	}

	// handle deletes, but only if not first sync
	if($collectionData->hasClientDeletes()) {
	$deletes = $collectionData->getClientDeletes();
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found " . count($deletes) . " entries to be deleted on server");

	foreach ($deletes as $delete) {
	$serverId = (string)$delete->ServerId;

	try {
	// check if we have sent this entry to the phone
	$state = $this->_contentStateBackend->getContentState($this->_device, $collectionData->folder, $serverId);

	try {
	$dataController->deleteEntry($collectionData->collectionId, $serverId, $collectionData);

	} catch(Syncroton_Exception_NotFound $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->crit(__METHOD__ . '::' . __LINE__ . ' tried to delete entry ' . $serverId . ' but entry was not found');

	} catch (Syncroton_Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . ' tried to delete entry ' . $serverId . ' but a error occured: ' . $e->getMessage());
	$clientModifications['forceAdd'][$serverId] = $serverId;
	}
	$this->_contentStateBackend->delete($state);

	} catch (Syncroton_Exception_NotFound $senf) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . ' ' . $serverId . ' should have been removed from client already');
	// should we send a special status???
	//$collectionData->deleted[$serverId] = self::STATUS_SUCCESS;
	}

	$clientModifications['deleted'][$serverId] = self::STATUS_SUCCESS;
	}
	}

	// handle fetches, but only if not first sync
	if($collectionData->syncKey > 1 && $collectionData->hasClientFetches()) {
	// the default value for GetChanges is 1. If the phone don't want the changes it must set GetChanges to 0
	// some prevoius versions of iOS did not set GetChanges to 0 for fetches. Let's enforce getChanges to false here.
	$collectionData->getChanges = false;

	$fetches = $collectionData->getClientFetches();
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found " . count($fetches) . " entries to be fetched from server");

	$toBeFecthed = array();

	foreach ($fetches as $fetch) {
	$serverId = (string)$fetch->ServerId;

	$toBeFetched[$serverId] = $serverId;
	}

	$collectionData->toBeFetched = $toBeFetched;
	}

	$this->_collections[$collectionData->collectionId] = $collectionData;
	$this->_modifications[$collectionData->collectionId] = $clientModifications;
	}
	}

	/**
	* (non-PHPdoc)
	* @see Syncroton_Command_Wbxml::getResponse()
	*/
	public function getResponse()
	{
	$sync = $this->_outputDom->documentElement;

	if (count($this->_collections) == 0) {
	$sync->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_RESEND_FULL_XML));

	return $this->_outputDom;
	}

	$collections = $sync->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Collections'));

	$totalChanges = 0;

	// continue only if there are changes or no time is left
	if ($this->_heartbeatInterval > 0) {
	$intervalStart = time();

	do {
	// take a break to save battery lifetime
	sleep(Syncroton_Registry::getPingTimeout());

	$now = new DateTime(null, new DateTimeZone('utc'));

	foreach($this->_collections as $collectionData) {
	// countinue immediately if folder does not exist
	if (! ($collectionData->folder instanceof Syncroton_Model_IFolder)) {
	break 2;

	// countinue immediately if syncstate is invalid
	} elseif (! ($collectionData->syncState instanceof Syncroton_Model_ISyncState)) {
	break 2;

	} else {
	if ($collectionData->getChanges !== true) {
	continue;
	}

	try {
	// just check if the folder still exists
	$this->_folderBackend->get($collectionData->folder);
	} catch (Syncroton_Exception_NotFound $senf) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " collection does not exist anymore: " . $collectionData->collectionId);

	$collectionData->getChanges = false;

	// make sure this is the last while loop
	// no break 2 here, as we like to check the other folders too
	$intervalStart -= $this->_heartbeatInterval;
	}

	// check that the syncstate still exists and is still valid
	try {
	$syncState = $this->_syncStateBackend->getSyncState($this->_device, $collectionData->folder);

	// another process synchronized data of this folder already. let's skip it
	if ($syncState->id !== $collectionData->syncState->id) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " syncstate changed during heartbeat interval for collection: " . $collectionData->folder->serverId);

	$collectionData->getChanges = false;

	// make sure this is the last while loop
	// no break 2 here, as we like to check the other folders too
	$intervalStart -= $this->_heartbeatInterval;
	}
	} catch (Syncroton_Exception_NotFound $senf) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " no syncstate found anymore for collection: " . $collectionData->folder->serverId);

	$collectionData->syncState = null;

	// make sure this is the last while loop
	// no break 2 here, as we like to check the other folders too
	$intervalStart -= $this->_heartbeatInterval;
	}


	// safe battery time by skipping folders which got synchronied less than Syncroton_Command_Ping::$quietTime seconds ago
	if (($now->getTimestamp() - $collectionData->syncState->lastsync->getTimestamp()) < Syncroton_Registry::getQuietTime()) {
	continue;
	}

	$dataController = Syncroton_Data_Factory::factory($collectionData->folder->class , $this->_device, $this->_syncTimeStamp);

	$hasChanges = $dataController->hasChanges($this->_contentStateBackend, $collectionData->folder, $collectionData->syncState);

	// countinue immediately if there are any changes available
	if ($hasChanges) {
	break 2;
	}
	}
	}

	$this->_syncTimeStamp = clone $now;

	// See: http://www.tine20.org/forum/viewtopic.php?f=12&t=12146
	//
	// break if there are less than PingTimeout + 10 seconds left for the next loop
	// otherwise the response will be returned after the client has finished his Ping
	// request already maybe
	} while (time() - $intervalStart < $this->_heartbeatInterval - (Syncroton_Registry::getPingTimeout() + 10));
	}

	foreach($this->_collections as $collectionData) {
	$collectionChanges = 0;

	/**
	* keep track of entries added on server side
	*/
	$newContentStates = array();

	/**
	* keep track of entries deleted on server side
	*/
	$deletedContentStates = array();

	// invalid collectionid provided
	if (! ($collectionData->folder instanceof Syncroton_Model_IFolder)) {
	$collection = $collections->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Collection'));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'SyncKey', 0));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'CollectionId', $collectionData->collectionId));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_FOLDER_HIERARCHY_HAS_CHANGED));

	// invalid synckey provided
	} elseif (! ($collectionData->syncState instanceof Syncroton_Model_ISyncState)) {
	// set synckey to 0
	$collection = $collections->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Collection'));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'SyncKey', 0));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'CollectionId', $collectionData->collectionId));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_INVALID_SYNC_KEY));

	// initial sync
	} elseif ($collectionData->syncState->counter === 0) {
	$collectionData->syncState->counter++;

	// initial sync
	// send back a new SyncKey only
	$collection = $collections->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Collection'));
	if (!empty($collectionData->folder->class)) {
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Class', $collectionData->folder->class));
	}
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'SyncKey', $collectionData->syncState->counter));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'CollectionId', $collectionData->collectionId));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_SUCCESS));

	} else {

	$dataController = Syncroton_Data_Factory::factory($collectionData->folder->class , $this->_device, $this->_syncTimeStamp);

	$clientModifications = $this->_modifications[$collectionData->collectionId];
	$serverModifications = array(
	'added' => array(),
	'changed' => array(),
	'deleted' => array(),
	);

	if($collectionData->getChanges === true) {
	// continue sync session?
	if(is_array($collectionData->syncState->pendingdata)) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " restored from sync state ");

	$serverModifications = $collectionData->syncState->pendingdata;

	} else {
	try {
	// fetch entries added since last sync
	$allClientEntries = $this->_contentStateBackend->getFolderState($this->_device, $collectionData->folder);
	$allServerEntries = $dataController->getServerEntries($collectionData->collectionId, $collectionData->options['filterType']);

	// add entries
	$serverDiff = array_diff($allServerEntries, $allClientEntries);
	// add entries which produced problems during delete from client
	$serverModifications['added'] = $clientModifications['forceAdd'];
	// add entries not yet sent to client
	$serverModifications['added'] = array_unique(array_merge($serverModifications['added'], $serverDiff));

	// @todo still needed?
	foreach($serverModifications['added'] as $id => $serverId) {
	// skip entries added by client during this sync session
	if(isset($clientModifications['added'][$serverId]) && !isset($clientModifications['forceAdd'][$serverId])) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " skipped added entry: " . $serverId);
	unset($serverModifications['added'][$id]);
	}
	}

	// entries to be deleted
	$serverModifications['deleted'] = array_diff($allClientEntries, $allServerEntries);

	// fetch entries changed since last sync
	- $serverModifications['changed'] = $dataController->getChangedEntries($collectionData->collectionId, $collectionData->syncState->lastsync, $this->_syncTimeStamp);
	+ $serverModifications['changed'] = $dataController->getChangedEntries($collectionData->collectionId, $collectionData->syncState->lastsync, $this->_syncTimeStamp, $collectionData->options['filterType']);
	$serverModifications['changed'] = array_merge($serverModifications['changed'], $clientModifications['forceChange']);

	foreach($serverModifications['changed'] as $id => $serverId) {
	// skip entry, if it got changed by client during current sync
	if(isset($clientModifications['changed'][$serverId]) && !isset($clientModifications['forceChange'][$serverId])) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " skipped changed entry: " . $serverId);
	unset($serverModifications['changed'][$id]);
	}
	// skip entry, make sure we don't sent entries already added by client in this request
	else if (isset($clientModifications['added'][$serverId]) && !isset($clientModifications['forceAdd'][$serverId])) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " skipped change for added entry: " . $serverId);
	unset($serverModifications['changed'][$id]);
	}
	}

	// entries comeing in scope are already in $serverModifications['added'] and do not need to
	// be send with $serverCanges
	$serverModifications['changed'] = array_diff($serverModifications['changed'], $serverModifications['added']);
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->crit(__METHOD__ . '::' . __LINE__ . " Folder state checking failed: " . $e->getMessage());
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " Folder state checking failed: " . $e->getTraceAsString());

	// Prevent from removing client entries when getServerEntries() fails
	// @todo: should we set Status and break the loop here?
	$serverModifications = array(
	'added' => array(),
	'changed' => array(),
	'deleted' => array(),
	);
	}
	}

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found (added/changed/deleted) " . count($serverModifications['added']) . '/' . count($serverModifications['changed']) . '/' . count($serverModifications['deleted']) . ' entries for sync from server to client');
	}

	// collection header
	$collection = $collections->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Collection'));
	if (!empty($collectionData->folder->class)) {
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Class', $collectionData->folder->class));
	}

	$syncKeyElement = $collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'SyncKey'));

	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'CollectionId', $collectionData->collectionId));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_SUCCESS));

	$responses = $this->_outputDom->createElementNS('uri:AirSync', 'Responses');

	// send reponse for newly added entries
	if(!empty($clientModifications['added'])) {
	foreach($clientModifications['added'] as $entryData) {
	$add = $responses->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Add'));
	$add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ClientId', $entryData['clientId']));
	// we have no serverId is the add failed
	if(isset($entryData['serverId'])) {
	$add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $entryData['serverId']));
	}
	$add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', $entryData['status']));
	}
	}

	// send reponse for changed entries
	if(!empty($clientModifications['changed'])) {
	foreach($clientModifications['changed'] as $serverId => $status) {
	if ($status !== Syncroton_Command_Sync::STATUS_SUCCESS) {
	$change = $responses->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Change'));
	$change->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));
	$change->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', $status));
	}
	}
	}

	// send response for to be fetched entries
	if(!empty($collectionData->toBeFetched)) {
	foreach($collectionData->toBeFetched as $serverId) {
	$fetch = $responses->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Fetch'));
	$fetch->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));

	try {
	$applicationData = $this->_outputDom->createElementNS('uri:AirSync', 'ApplicationData');

	$dataController
	->getEntry($collectionData, $serverId)
	->appendXML($applicationData, $this->_device);

	$fetch->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_SUCCESS));

	$fetch->appendChild($applicationData);
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getMessage());
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getTraceAsString());
	$fetch->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_OBJECT_NOT_FOUND));
	}
	}
	}

	if ($responses->hasChildNodes() === true) {
	$collection->appendChild($responses);
	}

	$commands = $this->_outputDom->createElementNS('uri:AirSync', 'Commands');

	foreach($serverModifications['added'] as $id => $serverId) {
	if($collectionChanges == $collectionData->windowSize \|\| $totalChanges + $collectionChanges >= $this->_globalWindowSize) {
	break;
	}

	#/**
	# * somewhere is a problem in the logic for handling moreAvailable
	# *
	# * it can happen, that we have a contentstate (which means we sent the entry to the client
	# * and that this entry is yet in $collectionData->syncState->pendingdata['serverAdds']
	# * I have no idea how this can happen, but the next lines of code work around this problem
	# */
	#try {
	# $this->_contentStateBackend->getContentState($this->_device, $collectionData->folder, $serverId);
	#
	# if ($this->_logger instanceof Zend_Log)
	# $this->_logger->info(__METHOD__ . '::' . __LINE__ . " skipped an entry($serverId) which is already on the client");
	#
	# unset($serverModifications['added'][$id]);
	# continue;
	#
	#} catch (Syncroton_Exception_NotFound $senf) {
	# // do nothing => content state should not exist yet
	#}

	try {
	$add = $this->_outputDom->createElementNS('uri:AirSync', 'Add');
	$add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));

	$applicationData = $add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ApplicationData'));

	$dataController
	->getEntry($collectionData, $serverId)
	->appendXML($applicationData, $this->_device);

	$commands->appendChild($add);

	$collectionChanges++;
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getMessage());
	}

	// mark as send to the client, even the conversion to xml might have failed
	$newContentStates[] = new Syncroton_Model_Content(array(
	'device_id' => $this->_device,
	'folder_id' => $collectionData->folder,
	'contentid' => $serverId,
	'creation_time' => $this->_syncTimeStamp,
	'creation_synckey' => $collectionData->syncState->counter + 1
	));
	unset($serverModifications['added'][$id]);
	}

	/**
	* process entries changed on server side
	*/
	foreach($serverModifications['changed'] as $id => $serverId) {
	if($collectionChanges == $collectionData->windowSize \|\| $totalChanges + $collectionChanges >= $this->_globalWindowSize) {
	break;
	}

	try {
	$change = $this->_outputDom->createElementNS('uri:AirSync', 'Change');
	$change->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));

	$applicationData = $change->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ApplicationData'));

	$dataController
	->getEntry($collectionData, $serverId)
	->appendXML($applicationData, $this->_device);


	$commands->appendChild($change);

	$collectionChanges++;
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getMessage());
	}

	unset($serverModifications['changed'][$id]);
	}

	foreach($serverModifications['deleted'] as $id => $serverId) {
	if($collectionChanges == $collectionData->windowSize \|\| $totalChanges + $collectionChanges >= $this->_globalWindowSize) {
	break;
	}

	try {
	// check if we have sent this entry to the phone
	$state = $this->_contentStateBackend->getContentState($this->_device, $collectionData->folder, $serverId);

	$delete = $this->_outputDom->createElementNS('uri:AirSync', 'Delete');
	$delete->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));

	$deletedContentStates[] = $state;

	$commands->appendChild($delete);

	$collectionChanges++;
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getMessage());
	}

	unset($serverModifications['deleted'][$id]);
	}

	$countOfPendingChanges = (count($serverModifications['added']) + count($serverModifications['changed']) + count($serverModifications['deleted']));
	if ($countOfPendingChanges > 0) {
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'MoreAvailable'));
	} else {
	$serverModifications = null;
	}

	if ($commands->hasChildNodes() === true) {
	$collection->appendChild($commands);
	}

	$totalChanges += $collectionChanges;

	// increase SyncKey if needed
	if ((
	// sent the clients updates?
	!empty($clientModifications['added']) \|\|
	!empty($clientModifications['changed']) \|\|
	!empty($clientModifications['deleted'])
	) \|\| (
	// sends the server updates to the client?
	$commands->hasChildNodes() === true
	) \|\| (
	// changed the pending data?
	$collectionData->syncState->pendingdata != $serverModifications
	)
	) {
	// then increase SyncKey
	$collectionData->syncState->counter++;
	}
	$syncKeyElement->appendChild($this->_outputDom->createTextNode($collectionData->syncState->counter));

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " new synckey is ". $collectionData->syncState->counter);
	}

	if (isset($collectionData->syncState) && $collectionData->syncState instanceof Syncroton_Model_ISyncState &&
	$collectionData->syncState->counter != $collectionData->syncKey) {

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " update syncState for collection: " . $collectionData->collectionId);

	// store pending data in sync state when needed
	if(isset($countOfPendingChanges) && $countOfPendingChanges > 0) {
	$collectionData->syncState->pendingdata = array(
	'added' => (array)$serverModifications['added'],
	'changed' => (array)$serverModifications['changed'],
	'deleted' => (array)$serverModifications['deleted']
	);
	} else {
	$collectionData->syncState->pendingdata = null;
	}


	if (!empty($clientModifications['added'])) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " remove previous synckey as client added new entries");
	$keepPreviousSyncKey = false;
	} else {
	$keepPreviousSyncKey = true;
	}

	$collectionData->syncState->lastsync = clone $this->_syncTimeStamp;
	// increment sync timestamp by 1 second
	$collectionData->syncState->lastsync->modify('+1 sec');

	try {
	$transactionId = Syncroton_Registry::getTransactionManager()->startTransaction(Syncroton_Registry::getDatabase());

	// store new synckey
	$this->_syncStateBackend->create($collectionData->syncState, $keepPreviousSyncKey);

	// store contentstates for new entries added to client
	foreach($newContentStates as $state) {
	$this->_contentStateBackend->create($state);
	}

	// remove contentstates for entries to be deleted on client
	foreach($deletedContentStates as $state) {
	$this->_contentStateBackend->delete($state);
	}

	Syncroton_Registry::getTransactionManager()->commitTransaction($transactionId);
	} catch (Zend_Db_Statement_Exception $zdse) {
	// something went wrong
	// maybe another parallel request added a new synckey
	// we must remove data added from client
	if (!empty($clientModifications['added'])) {
	foreach ($clientModifications['added'] as $added) {
	$this->_contentStateBackend->delete($added['contentState']);
	$dataController->deleteEntry($collectionData->collectionId, $added['serverId'], array());
	}
	}

	Syncroton_Registry::getTransactionManager()->rollBack();

	throw $zdse;
	}


	// store current filter type
	try {
	$folderState = $this->_folderBackend->getFolder($this->_device, $collectionData->collectionId);
	$folderState->lastfiltertype = $collectionData->options['filterType'];
	$this->_folderBackend->update($folderState);
	} catch (Syncroton_Exception_NotFound $senf) {
	// failed to get folderstate => should not happen but is also no problem in this state
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->crit(__METHOD__ . '::' . __LINE__ . ' failed to get content state for: ' . $collectionData->collectionId);
	}
	}
	}

	return $this->_outputDom;
	}
	}
	diff --git a/lib/ext/Syncroton/Data/AData.php b/lib/ext/Syncroton/Data/AData.php
	index 97a821d..e99e0b9 100644
	--- a/lib/ext/Syncroton/Data/AData.php
	+++ b/lib/ext/Syncroton/Data/AData.php
	@@ -1,244 +1,244 @@
	<?php
	/**
	* Syncroton
	*
	* @package Model
	* @license http://www.tine20.org/licenses/lgpl.html LGPL Version 3
	* @copyright Copyright (c) 2009-2012 Metaways Infosystems GmbH (http://www.metaways.de)
	* @author Lars Kneschke <l.kneschke@metaways.de>
	*/

	/**
	* class to handle ActiveSync Sync command
	*
	* @package Model
	*/

	abstract class Syncroton_Data_AData implements Syncroton_Data_IData
	{
	const LONGID_DELIMITER = "\xe2\x87\x94"; # UTF8 ⇔

	/**
	* used by unit tests only to simulated added folders
	*/
	public static $changedEntries = array();

	public function __construct(Syncroton_Model_IDevice $_device, DateTime $_timeStamp)
	{
	$this->_device = $_device;
	$this->_timestamp = $_timeStamp;
	$this->_db = Syncroton_Registry::getDatabase();
	$this->_tablePrefix = 'Syncroton_';
	$this->_ownerId = '1234';
	}

	public function getFolder($id)
	{
	$select = $this->_db->select()
	->from($this->_tablePrefix . 'data_folder')
	->where('owner_id = ?', $this->_ownerId)
	->where('id = ?', $id);

	$stmt = $this->_db->query($select);
	$folder = $stmt->fetch();
	$stmt = null; # see https://bugs.php.net/bug.php?id=44081

	if ($folder === false) {
	throw new Syncroton_Exception_NotFound("folder $id not found");
	}

	return new Syncroton_Model_Folder(array(
	'serverId' => $folder['id'],
	'displayName' => $folder['name'],
	'type' => $folder['type'],
	'parentId' => !empty($folder['parent_id']) ? $folder['parent_id'] : null
	));
	}

	public function createFolder(Syncroton_Model_IFolder $folder)
	{
	if (!in_array($folder->type, $this->_supportedFolderTypes)) {
	throw new Syncroton_Exception_UnexpectedValue();
	}

	$id = !empty($folder->serverId) ? $folder->serverId : sha1(mt_rand(). microtime());

	$this->_db->insert($this->_tablePrefix . 'data_folder', array(
	'id' => $id,
	'type' => $folder->type,
	'name' => $folder->displayName,
	'owner_id' => $this->_ownerId,
	'parent_id' => $folder->parentId
	));

	return $this->getFolder($id);
	}

	public function createEntry($_folderId, Syncroton_Model_IEntry $_entry)
	{
	$id = sha1(mt_rand(). microtime());

	$this->_db->insert($this->_tablePrefix . 'data', array(
	'id' => $id,
	'class' => get_class($_entry),
	'folder_id' => $_folderId,
	'data' => serialize($_entry)
	));

	return $id;
	}

	public function deleteEntry($_folderId, $_serverId, $_collectionData)
	{
	$folderId = $_folderId instanceof Syncroton_Model_IFolder ? $_folderId->serverId : $_folderId;

	$result = $this->_db->delete($this->_tablePrefix . 'data', array('id = ?' => $_serverId));

	return (bool) $result;
	}

	public function deleteFolder($_folderId)
	{
	$folderId = $_folderId instanceof Syncroton_Model_IFolder ? $_folderId->serverId : $_folderId;

	$result = $this->_db->delete($this->_tablePrefix . 'data', array('folder_id = ?' => $folderId));
	$result = $this->_db->delete($this->_tablePrefix . 'data_folder', array('id = ?' => $folderId));

	return (bool) $result;
	}

	public function getAllFolders()
	{
	$select = $this->_db->select()
	->from($this->_tablePrefix . 'data_folder')
	->where('type IN (?)', $this->_supportedFolderTypes)
	->where('owner_id = ?', $this->_ownerId);

	$stmt = $this->_db->query($select);
	$folders = $stmt->fetchAll();
	$stmt = null; # see https://bugs.php.net/bug.php?id=44081

	$result = array();

	foreach ((array) $folders as $folder) {
	$result[$folder['id']] = new Syncroton_Model_Folder(array(
	'serverId' => $folder['id'],
	'displayName' => $folder['name'],
	'type' => $folder['type'],
	'parentId' => $folder['parent_id']
	));
	}

	return $result;
	}

	- public function getChangedEntries($_folderId, DateTime $_startTimeStamp, DateTime $_endTimeStamp = NULL)
	+ public function getChangedEntries($_folderId, DateTime $_startTimeStamp, DateTime $_endTimeStamp = NULL, $filterType = NULL)
	{
	if (!isset(Syncroton_Data_AData::$changedEntries[get_class($this)])) {
	return array();
	} else {
	return Syncroton_Data_AData::$changedEntries[get_class($this)];
	}
	}

	/**
	* @param Syncroton_Model_IFolder\|string $_folderId
	* @param string $_filter
	* @return array
	*/
	public function getServerEntries($_folderId, $_filter)
	{
	$folderId = $_folderId instanceof Syncroton_Model_IFolder ? $_folderId->id : $_folderId;

	$select = $this->_db->select()
	->from($this->_tablePrefix . 'data', array('id'))
	->where('folder_id = ?', $_folderId);

	$ids = array();

	$stmt = $this->_db->query($select);
	while ($id = $stmt->fetchColumn()) {
	$ids[] = $id;
	}

	return $ids;
	}

	public function getCountOfChanges(Syncroton_Backend_IContent $contentBackend, Syncroton_Model_IFolder $folder, Syncroton_Model_ISyncState $syncState)
	{
	$allClientEntries = $contentBackend->getFolderState($this->_device, $folder);
	$allServerEntries = $this->getServerEntries($folder->serverId, $folder->lastfiltertype);

	$addedEntries = array_diff($allServerEntries, $allClientEntries);
	$deletedEntries = array_diff($allClientEntries, $allServerEntries);
	- $changedEntries = $this->getChangedEntries($folder->serverId, $syncState->lastsync);
	+ $changedEntries = $this->getChangedEntries($folder->serverId, $syncState->lastsync, null, $folder->lastfiltertype);

	return count($addedEntries) + count($deletedEntries) + count($changedEntries);
	}

	public function getFileReference($fileReference)
	{
	throw new Syncroton_Exception_NotFound('filereference not found');
	}

	/**
	* (non-PHPdoc)
	* @see Syncroton_Data_IData::getEntry()
	*/
	public function getEntry(Syncroton_Model_SyncCollection $collection, $serverId)
	{
	$select = $this->_db->select()
	->from($this->_tablePrefix . 'data', array('data'))
	->where('id = ?', $serverId);

	$stmt = $this->_db->query($select);
	$entry = $stmt->fetchColumn();

	if ($entry === false) {
	throw new Syncroton_Exception_NotFound("entry $serverId not found in folder {$collection->collectionId}");
	}

	return unserialize($entry);
	}

	/**
	* (non-PHPdoc)
	* @see Syncroton_Data_IData::hasChanges()
	*/
	public function hasChanges(Syncroton_Backend_IContent $contentBackend, Syncroton_Model_IFolder $folder, Syncroton_Model_ISyncState $syncState)
	{
	return !!$this->getCountOfChanges($contentBackend, $folder, $syncState);
	}

	public function moveItem($_srcFolderId, $_serverId, $_dstFolderId)
	{
	$this->_db->update($this->_tablePrefix . 'data', array(
	'folder_id' => $_dstFolderId,
	), array(
	'id = ?' => $_serverId
	));

	return $_serverId;
	}

	public function updateEntry($_folderId, $_serverId, Syncroton_Model_IEntry $_entry)
	{
	$this->_db->update($this->_tablePrefix . 'data', array(
	'folder_id' => $_folderId,
	'data' => serialize($_entry)
	), array(
	'id = ?' => $_serverId
	));
	}

	public function updateFolder(Syncroton_Model_IFolder $folder)
	{
	$this->_db->update($this->_tablePrefix . 'data_folder', array(
	'name' => $folder->displayName,
	'parent_id' => $folder->parentId
	), array(
	'id = ?' => $folder->serverId
	));
	}
	}

	diff --git a/lib/ext/Syncroton/Data/IData.php b/lib/ext/Syncroton/Data/IData.php
	index db286d3..a21dfd5 100644
	--- a/lib/ext/Syncroton/Data/IData.php
	+++ b/lib/ext/Syncroton/Data/IData.php
	@@ -1,106 +1,106 @@
	<?php

	/**
	* Syncroton
	*
	* @package Model
	* @license http://www.tine20.org/licenses/lgpl.html LGPL Version 3
	* @copyright Copyright (c) 2009-2012 Metaways Infosystems GmbH (http://www.metaways.de)
	* @author Lars Kneschke <l.kneschke@metaways.de>
	*/

	/**
	* class to handle ActiveSync Sync command
	*
	* @package Model
	*/

	interface Syncroton_Data_IData
	{
	/**
	* create new entry
	*
	* @param string $folderId
	* @param Syncroton_Model_IEntry $entry
	* @return string id of created entry
	*/
	public function createEntry($folderId, Syncroton_Model_IEntry $entry);

	/**
	* create a new folder in backend
	*
	* @param Syncroton_Model_IFolder $folder
	* @return Syncroton_Model_IFolder
	*/
	public function createFolder(Syncroton_Model_IFolder $folder);

	/**
	* delete entry in backend
	*
	* @param string $_folderId
	* @param string $_serverId
	* @param unknown_type $_collectionData
	*/
	public function deleteEntry($_folderId, $_serverId, $_collectionData);

	public function deleteFolder($_folderId);

	/**
	* return list off all folders
	* @return array of Syncroton_Model_IFolder
	*/
	public function getAllFolders();

	- public function getChangedEntries($folderId, DateTime $startTimeStamp, DateTime $endTimeStamp = NULL);
	+ public function getChangedEntries($folderId, DateTime $startTimeStamp, DateTime $endTimeStamp = NULL, $filterType = NULL);

	public function getCountOfChanges(Syncroton_Backend_IContent $contentBackend, Syncroton_Model_IFolder $folder, Syncroton_Model_ISyncState $syncState);

	/**
	*
	* @param Syncroton_Model_SyncCollection $collection
	* @param string $serverId
	* @return Syncroton_Model_IEntry
	*/
	public function getEntry(Syncroton_Model_SyncCollection $collection, $serverId);

	/**
	*
	* @param unknown_type $fileReference
	* @return Syncroton_Model_FileReference
	*/
	public function getFileReference($fileReference);

	/**
	* return array of all id's stored in folder
	*
	* @param Syncroton_Model_IFolder\|string $folderId
	* @param string $filter
	* @return array
	*/
	public function getServerEntries($folderId, $filter);

	/**
	* return true if any data got modified in the backend
	*
	* @param Syncroton_Backend_IContent $contentBackend
	* @param Syncroton_Model_IFolder $folder
	* @param Syncroton_Model_ISyncState $syncState
	* @return bool
	*/
	public function hasChanges(Syncroton_Backend_IContent $contentBackend, Syncroton_Model_IFolder $folder, Syncroton_Model_ISyncState $syncState);

	public function moveItem($srcFolderId, $serverId, $dstFolderId);

	/**
	* update existing entry
	*
	* @param string $folderId
	* @param string $serverId
	* @param Syncroton_Model_IEntry $entry
	* @return string id of updated entry
	*/
	public function updateEntry($folderId, $serverId, Syncroton_Model_IEntry $entry);

	public function updateFolder(Syncroton_Model_IFolder $folder);
	}

	diff --git a/lib/kolab_sync_data.php b/lib/kolab_sync_data.php
	index 82d6547..795d534 100644
	--- a/lib/kolab_sync_data.php
	+++ b/lib/kolab_sync_data.php
	@@ -1,1292 +1,1297 @@
	<?php

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

	/**
	* Base class for Syncroton data backends
	*/
	abstract class kolab_sync_data implements Syncroton_Data_IData
	{
	/**
	* ActiveSync protocol version
	*
	* @var int
	*/
	protected $asversion = 0;

	/**
	* information about the current device
	*
	* @var Syncroton_Model_IDevice
	*/
	protected $device;

	/**
	* timestamp to use for all sync requests
	*
	* @var DateTime
	*/
	protected $syncTimeStamp;

	/**
	* name of model to use
	*
	* @var string
	*/
	protected $modelName;

	/**
	* type of the default folder
	*
	* @var int
	*/
	protected $defaultFolderType;

	/**
	* default container for new entries
	*
	* @var string
	*/
	protected $defaultFolder;

	/**
	* type of user created folders
	*
	* @var int
	*/
	protected $folderType;

	/**
	* Internal cache for kolab_storage folder objects
	*
	* @var array
	*/
	protected $folders = array();

	/**
	* Timezone
	*
	* @var string
	*/
	protected $timezone;

	const RESULT_OBJECT = 0;
	const RESULT_UID = 1;
	const RESULT_COUNT = 2;


	/**
	* Recurrence types
	*/
	const RECUR_TYPE_DAILY = 0; // Recurs daily.
	const RECUR_TYPE_WEEKLY = 1; // Recurs weekly
	const RECUR_TYPE_MONTHLY = 2; // Recurs monthly
	const RECUR_TYPE_MONTHLY_DAYN = 3; // Recurs monthly on the nth day
	const RECUR_TYPE_YEARLY = 5; // Recurs yearly
	const RECUR_TYPE_YEARLY_DAYN = 6; // Recurs yearly on the nth day

	/**
	* Day of week constants
	*/
	const RECUR_DOW_SUNDAY = 1;
	const RECUR_DOW_MONDAY = 2;
	const RECUR_DOW_TUESDAY = 4;
	const RECUR_DOW_WEDNESDAY = 8;
	const RECUR_DOW_THURSDAY = 16;
	const RECUR_DOW_FRIDAY = 32;
	const RECUR_DOW_SATURDAY = 64;
	const RECUR_DOW_LAST = 127; // The last day of the month. Used as a special value in monthly or yearly recurrences.

	/**
	* Mapping of recurrence types
	*
	* @var array
	*/
	protected $recurTypeMap = array(
	self::RECUR_TYPE_DAILY => 'DAILY',
	self::RECUR_TYPE_WEEKLY => 'WEEKLY',
	self::RECUR_TYPE_MONTHLY => 'MONTHLY',
	self::RECUR_TYPE_MONTHLY_DAYN => 'MONTHLY',
	self::RECUR_TYPE_YEARLY => 'YEARLY',
	self::RECUR_TYPE_YEARLY_DAYN => 'YEARLY',
	);

	/**
	* Mapping of weekdays
	* NOTE: ActiveSync uses a bitmask
	*
	* @var array
	*/
	protected $recurDayMap = array(
	'SU' => self::RECUR_DOW_SUNDAY,
	'MO' => self::RECUR_DOW_MONDAY,
	'TU' => self::RECUR_DOW_TUESDAY,
	'WE' => self::RECUR_DOW_WEDNESDAY,
	'TH' => self::RECUR_DOW_THURSDAY,
	'FR' => self::RECUR_DOW_FRIDAY,
	'SA' => self::RECUR_DOW_SATURDAY,
	);


	/**
	* the constructor
	*
	* @param Syncroton_Model_IDevice $device
	* @param DateTime $syncTimeStamp
	*/
	public function __construct(Syncroton_Model_IDevice $device, DateTime $syncTimeStamp)
	{
	$this->backend = kolab_sync_backend::get_instance();
	$this->device = $device;
	$this->asversion = floatval($device->acsversion);
	$this->syncTimeStamp = $syncTimeStamp;

	$this->defaultRootFolder = $this->defaultFolder . '::Syncroton';

	// set internal timezone of kolab_format to user timezone
	try {
	$this->timezone = rcube::get_instance()->config->get('timezone', 'GMT');
	kolab_format::$timezone = new DateTimeZone($this->timezone);
	}
	catch (Exception $e) {
	//rcube::raise_error($e, true);
	$this->timezone = 'GMT';
	kolab_format::$timezone = new DateTimeZone('GMT');
	}
	}

	/**
	* return list of supported folders for this backend
	*
	* @return array
	*/
	public function getAllFolders()
	{
	$list = array();

	// device supports multiple folders ?
	if (in_array(strtolower($this->device->devicetype), array('iphone', 'ipad', 'thundertine', 'windowsphone'))) {
	// get the folders the user has access to
	$list = $this->backend->folders_list($this->device->deviceid, $this->modelName);
	}
	else if ($default = $this->getDefaultFolder()) {
	$list = array($default['serverId'] => $default);
	}

	// getAllFolders() is called only in FolderSync
	// throw Syncroton_Exception_Status_FolderSync exception
	if (!is_array($list)) {
	throw new Syncroton_Exception_Status_FolderSync(Syncroton_Exception_Status_FolderSync::FOLDER_SERVER_ERROR);
	}

	foreach ($list as $idx => $folder) {
	$list[$idx] = new Syncroton_Model_Folder($folder);
	}

	return $list;
	}

	/**
	* Returns default folder for current class type.
	*/
	protected function getDefaultFolder()
	{
	// Check if there's any folder configured for sync
	$folders = $this->backend->folders_list($this->device->deviceid, $this->modelName);

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

	foreach ($folders as $folder) {
	if ($folder['type'] == $this->defaultFolderType) {
	$default = $folder;
	break;
	}
	}

	// Return first on the list if there's no default
	if (empty($default)) {
	$key = array_shift(array_keys($folders));
	$default = $folders[$key];
	// make sure the type is default here
	$default['type'] = $this->defaultFolderType;
	}

	// Remember real folder ID and set ID/name to root folder
	$default['realid'] = $default['serverId'];
	$default['serverId'] = $this->defaultRootFolder;
	$default['displayName'] = $this->defaultFolder;

	return $default;
	}

	/**
	* Creates a folder
	*/
	public function createFolder(Syncroton_Model_IFolder $folder)
	{
	$parentid = $folder->parentId;
	$type = $folder->type;
	$display_name = $folder->displayName;

	if ($parentid) {
	$parent = $this->backend->folder_id2name($parentid, $this->device->deviceid);
	}

	$name = rcube_charset::convert($display_name, kolab_sync::CHARSET, 'UTF7-IMAP');

	if ($parent !== null) {
	$rcube = rcube::get_instance();
	$storage = $rcube->get_storage();
	$delim = $storage->get_hierarchy_delimiter();
	$name = $parent . $delim . $name;
	}

	// Create IMAP folder
	$result = $this->backend->folder_create($name, $type, $this->device->deviceid);

	if ($result) {
	$folder->serverId = $this->backend->folder_id($name);
	return $folder;
	}

	// @TODO: throw exception
	}

	/**
	* Updates a folder
	*/
	public function updateFolder(Syncroton_Model_IFolder $folder)
	{
	$parentid = $folder->parentId;
	$type = $folder->type;
	$display_name = $folder->displayName;
	$old_name = $this->backend->folder_id2name($folder->serverId, $this->device->deviceid);

	if ($parentid) {
	$parent = $this->backend->folder_id2name($parentid, $this->device->deviceid);
	}

	$name = rcube_charset::convert($display_name, kolab_sync::CHARSET, 'UTF7-IMAP');

	if ($parent !== null) {
	$rcube = rcube::get_instance();
	$storage = $rcube->get_storage();
	$delim = $storage->get_hierarchy_delimiter();
	$name = $parent . $delim . $name;
	}

	// Rename/move IMAP folder
	if ($name == $old_name) {
	$result = true;
	// @TODO: folder type change?
	}
	else {
	$result = $this->backend->folder_rename($old_name, $name, $type, $this->device->deviceid);
	}

	if ($result) {
	$folder->serverId = $this->backend->folder_id($name);
	return $folder;
	}

	// @TODO: throw exception
	}

	/**
	* Deletes a folder
	*/
	public function deleteFolder($folder)
	{
	if ($folder instanceof Syncroton_Model_IFolder) {
	$folder = $folder->serverId;
	}

	$name = $this->backend->folder_id2name($folder, $this->device->deviceid);

	// @TODO: throw exception
	return $this->backend->folder_delete($name, $this->device->deviceid);
	}

	/**
	* Moves object into another location (folder)
	*
	* @param string $srcFolderId Source folder identifier
	* @param string $serverId Object identifier
	* @param string $dstFolderId Destination folder identifier
	*
	* @throws Syncroton_Exception_Status
	* @return string New object identifier
	*/
	public function moveItem($srcFolderId, $serverId, $dstFolderId)
	{
	$item = $this->getObject($srcFolderId, $serverId, $folder);

	if (!$item \|\| !$folder) {
	throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_SOURCE);
	}

	$dstname = $this->backend->folder_id2name($dstFolderId, $this->device->deviceid);

	if ($dstname === null) {
	throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_DESTINATION);
	}

	if (!$folder->move($serverId, $dstname)) {
	throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_SOURCE);
	}

	return $item['uid'];
	}

	/**
	* Add entry
	*
	* @param string $folderId Folder identifier
	* @param Syncroton_Model_IEntry $entry Entry object
	*
	* @return string ID of the created entry
	*/
	public function createEntry($folderId, Syncroton_Model_IEntry $entry)
	{
	$entry = $this->toKolab($entry, $folderId);
	$entry = $this->createObject($folderId, $entry);

	if (empty($entry)) {
	throw new Syncroton_Exception_Status_Sync(Syncroton_Exception_Status_Sync::SYNC_SERVER_ERROR);
	}

	return $entry['uid'];
	}

	/**
	* update existing entry
	*
	* @param string $folderId
	* @param string $serverId
	* @param SimpleXMLElement $entry
	*
	* @return string ID of the updated entry
	*/
	public function updateEntry($folderId, $serverId, Syncroton_Model_IEntry $entry)
	{
	$oldEntry = $this->getObject($folderId, $serverId);

	if (empty($oldEntry)) {
	throw new Syncroton_Exception_NotFound('id not found');
	}

	$entry = $this->toKolab($entry, $folderId, $oldEntry);
	$entry = $this->updateObject($folderId, $serverId, $entry);

	if (empty($entry)) {
	throw new Syncroton_Exception_Status_Sync(Syncroton_Exception_Status_Sync::SYNC_SERVER_ERROR);
	}

	return $entry['uid'];
	}

	/**
	* delete entry
	*
	* @param string $folderId
	* @param string $serverId
	* @param array $collectionData
	*/
	public function deleteEntry($folderId, $serverId, $collectionData)
	{
	$deleted = $this->deleteObject($folderId, $serverId);

	if (!$deleted) {
	throw new Syncroton_Exception_Status_Sync(Syncroton_Exception_Status_Sync::SYNC_SERVER_ERROR);
	}
	}


	public function getFileReference($fileReference)
	{
	// to be implemented by Email data class
	// @TODO: throw "unimplemented" exception here?
	}


	/**
	* Search for existing entries
	*
	* @param string $folderid
	* @param array $filter
	* @param int $result_type Type of the result (see RESULT_* constants)
	*
	* @return array\|int Search result as count or array of uids/objects
	*/
	protected function searchEntries($folderid, $filter = array(), $result_type = self::RESULT_UID)
	{
	if ($folderid == $this->defaultRootFolder) {
	$folders = $this->backend->folders_list($this->device->deviceid, $this->modelName);

	if (!is_array($folders)) {
	throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR);
	}

	$folders = array_keys($folders);
	}
	else {
	$folders = array($folderid);
	}

	// there's a PHP Warning from kolab_storage if $filter isn't an array
	if (empty($filter)) {
	$filter = array();
	}

	$result = $result_type == self::RESULT_COUNT ? 0 : array();

	foreach ($folders as $folderid) {
	$foldername = $this->backend->folder_id2name($folderid, $this->device->deviceid);

	if ($foldername === null) {
	continue;
	}

	$folder = $this->getFolderObject($foldername);

	if (!$folder) {
	continue;
	}

	switch ($result_type) {
	case self::RESULT_COUNT:
	$result += (int) $folder->count($filter);
	break;

	case self::RESULT_UID:
	if ($uids = $folder->get_uids($filter)) {
	$result = array_merge($result, $uids);
	}
	break;

	case self::RESULT_OBJECT:
	default:
	if ($objects = $folder->select($filter)) {
	$result = array_merge($result, $objects);
	}
	}
	}

	return $result;
	}

	/**
	* Returns filter query array according to specified ActiveSync FilterType
	*
	* @param int $filter_type Filter type
	*
	* @param array Filter query
	*/
	protected function filter($filter_type = 0)
	{
	// overwrite by child class according to specified type
	return array();
	}

	/**
	* get all entries changed between to dates
	*
	* @param string $folderId
	* @param DateTime $start
	* @param DateTime $end
	+ * @param int $filterType
	+ *
	* @return array
	*/
	- public function getChangedEntries($folderId, DateTime $start, DateTime $end = null)
	+ public function getChangedEntries($folderId, DateTime $start, DateTime $end = null, $filter_type = null)
	{
	- $filter = array(array('changed', '>', $start));
	+ $filter = $this->filter($filter_type);
	+ $filter[] = array('changed', '>', $start);

	- if ($endTimeStamp) {
	+ if ($end) {
	$filter[] = array('changed', '<=', $end);
	}

	$result = $this->searchEntries($folderId, $filter, self::RESULT_UID);

	return $result;
	}

	/**
	* get count of entries changed between two dates
	*
	* @param string $folderId
	* @param DateTime $start
	* @param DateTime $end
	+ * @param int $filterType
	*
	* @return int
	*/
	- public function getChangedEntriesCount($folderId, DateTime $start, DateTime $end = null)
	+ public function getChangedEntriesCount($folderId, DateTime $start, DateTime $end = null, $filter_type = null)
	{
	- $filter = array(array('changed', '>', $start));
	+ $filter = $this->filter($filter_type);
	+ $filter[] = array('changed', '>', $start);

	- if ($endTimeStamp) {
	+ if ($end) {
	$filter[] = array('changed', '<=', $end);
	}

	$result = $this->searchEntries($folderId, $filter, self::RESULT_COUNT);

	return $result;
	}

	/**
	* get id's of all entries available on the server
	*
	* @param string $folderId
	* @param int $filterType
	*
	* @return array
	*/
	public function getServerEntries($folder_id, $filter_type)
	{
	$filter = $this->filter($filter_type);
	$result = $this->searchEntries($folder_id, $filter, self::RESULT_UID);

	return $result;
	}

	/**
	* get count of all entries available on the server
	*
	* @param string $folderId
	* @param int $filterType
	*
	* @return int
	*/
	public function getServerEntriesCount($folder_id, $filter_type)
	{
	$filter = $this->filter($filter_type);
	$result = $this->searchEntries($folder_id, $filter, self::RESULT_COUNT);

	return $result;
	}

	/**
	* Returns number of changed objects in the backend folder
	*
	* @param Syncroton_Backend_IContent $contentBackend
	* @param Syncroton_Model_IFolder $folder
	* @param Syncroton_Model_ISyncState $syncState
	*
	* @return int
	*/
	public function getCountOfChanges(Syncroton_Backend_IContent $contentBackend, Syncroton_Model_IFolder $folder, Syncroton_Model_ISyncState $syncState)
	{
	$allClientEntries = $contentBackend->getFolderState($this->device, $folder);
	$allServerEntries = $this->getServerEntries($folder->serverId, $folder->lastfiltertype);
	- $changedEntries = $this->getChangedEntriesCount($folder->serverId, $syncState->lastsync);
	+ $changedEntries = $this->getChangedEntriesCount($folder->serverId, $syncState->lastsync, null, $folder->lastfiltertype);
	$addedEntries = array_diff($allServerEntries, $allClientEntries);
	$deletedEntries = array_diff($allClientEntries, $allServerEntries);

	return count($addedEntries) + count($deletedEntries) + $changedEntries;
	}

	/**
	* Returns true if any data got modified in the backend folder
	*
	* @param Syncroton_Backend_IContent $contentBackend
	* @param Syncroton_Model_IFolder $folder
	* @param Syncroton_Model_ISyncState $syncState
	*
	* @return bool
	*/
	public function hasChanges(Syncroton_Backend_IContent $contentBackend, Syncroton_Model_IFolder $folder, Syncroton_Model_ISyncState $syncState)
	{
	- if ($this->getChangedEntriesCount($folder->serverId, $syncState->lastsync)) {
	+ if ($this->getChangedEntriesCount($folder->serverId, $syncState->lastsync, null, $folder->lastfiltertype)) {
	return true;
	}

	$allClientEntries = $contentBackend->getFolderState($this->device, $folder);

	// @TODO: Consider looping over all folders here, not in getServerEntries() and
	// getChangedEntriesCount(). This way we could break the loop and not check all folders
	// or at least skip redundant cache sync of the same folder
	$allServerEntries = $this->getServerEntries($folder->serverId, $folder->lastfiltertype);

	$addedEntries = array_diff($allServerEntries, $allClientEntries);
	$deletedEntries = array_diff($allClientEntries, $allServerEntries);

	return count($addedEntries) > 0 \|\| count($deletedEntries) > 0;
	}

	/**
	* Fetches the entry from the backend
	*/
	protected function getObject($folderid, $entryid, &$folder = null)
	{
	if ($folderid instanceof Syncroton_Model_IFolder) {
	$folderid = $folderid->serverId;
	}

	if ($folderid == $this->defaultRootFolder) {
	$folders = $this->backend->folders_list($this->device->deviceid, $this->modelName);

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

	$folders = array_keys($folders);
	}
	else {
	$folders = array($folderid);
	}

	foreach ($folders as $folderid) {
	$foldername = $this->backend->folder_id2name($folderid, $this->device->deviceid);

	if ($foldername === null) {
	continue;
	}

	$folder = $this->getFolderObject($foldername);

	if ($folder && ($object = $folder->get_object($entryid))) {
	$object['_folderid'] = $folderid;

	return $object;
	}
	}
	}

	/**
	* Saves the entry on the backend
	*/
	protected function createObject($folderid, $data)
	{
	if ($folderid == $this->defaultRootFolder) {
	$default = $this->getDefaultFolder();

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

	$folderid = isset($default['realid']) ? $default['realid'] : $default['serverId'];
	}

	$foldername = $this->backend->folder_id2name($folderid, $this->device->deviceid);
	$folder = $this->getFolderObject($foldername);

	if ($folder && $folder->save($data)) {
	return $data;
	}
	}

	/**
	* Updates the entry on the backend
	*/
	protected function updateObject($folderid, $entryid, $data)
	{
	$object = $this->getObject($folderid, $entryid);

	if ($object) {
	$folder = $this->getFolderObject($object['_mailbox']);

	if ($folder && $folder->save($data)) {
	return $data;
	}
	}
	}

	/**
	* Removes the entry from the backend
	*/
	protected function deleteObject($folderid, $entryid)
	{
	$object = $this->getObject($folderid, $entryid);

	if ($object) {
	$folder = $this->getFolderObject($object['_mailbox']);
	return $folder && $folder->delete($entryid);
	}
	}

	/**
	* Returns Folder object (uses internal cache)
	*
	* @param string $name Folder name (UTF7-IMAP)
	*
	* @return kolab_storage_folder Folder object
	*/
	protected function getFolderObject($name)
	{
	if ($name === null) {
	return null;
	}

	if (!isset($this->folders[$name])) {
	$this->folders[$name] = kolab_storage::get_folder($name);
	}

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

	/**
	* Returns ActiveSync settings of specified folder
	*
	* @param string $name Folder name (UTF7-IMAP)
	*
	* @return array Folder settings
	*/
	protected function getFolderConfig($name)
	{
	$metadata = $this->backend->folder_meta();

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

	$deviceid = $this->device->deviceid;
	$config = $metadata[$name]['FOLDER'][$deviceid];

	return array(
	'ALARMS' => $config['S'] == 2,
	);
	}

	/**
	* Convert contact from xml to kolab format
	*
	* @param Syncroton_Model_IEntry $data Contact data
	* @param string $folderId Folder identifier
	* @param array $entry Old Contact data for merge
	*
	* @return array
	*/
	abstract function toKolab(Syncroton_Model_IEntry $data, $folderId, $entry = null);

	/**
	* Extracts data from kolab data array
	*/
	protected function getKolabDataItem($data, $name)
	{
	$name_items = explode('.', $name);
	$count = count($name_items);

	// multi-level array (e.g. address, phone)
	if ($count == 3) {
	$name = $name_items[0];
	$type = $name_items[1];
	$key_name = $name_items[2];

	if (!empty($data[$name]) && is_array($data[$name])) {
	foreach ($data[$name] as $element) {
	if ($element['type'] == $type) {
	return $element[$key_name];
	}
	}
	}

	return null;
	}
	/*
	// hash array e.g. organizer
	else if ($count == 2) {
	$name = $name_items[0];
	$type = $name_items[1];
	$key_name = $name_items[2];

	if (!empty($data[$name]) && is_array($data[$name])) {
	foreach ($data[$name] as $element) {
	if ($element['type'] == $type) {
	return $element[$key_name];
	}
	}
	}

	return null;
	}
	*/
	$name_items = explode(':', $name);
	$name = $name_items[0];

	if (empty($data[$name])) {
	return null;
	}

	// simple array (e.g. email)
	if (count($name_items) == 2) {
	return $data[$name][$name_items[1]];
	}

	return $data[$name];
	}

	/**
	* Saves data in kolab data array
	*/
	protected function setKolabDataItem(&$data, $name, $value)
	{
	if (empty($value)) {
	return $this->unsetKolabDataItem($data, $name);
	}

	$name_items = explode('.', $name);

	// multi-level array (e.g. address, phone)
	if (count($name_items) == 3) {
	$name = $name_items[0];
	$type = $name_items[1];
	$key_name = $name_items[2];

	if (!isset($data[$name])) {
	$data[$name] = array();
	}

	foreach ($data[$name] as $idx => $element) {
	if ($element['type'] == $type) {
	$found = $idx;
	break;
	}
	}

	if (!isset($found)) {
	$data[$name] = array_values($data[$name]);
	$found = count($data[$name]);
	$data[$name][$found] = array('type' => $type);
	}

	$data[$name][$found][$key_name] = $value;

	return;
	}

	$name_items = explode(':', $name);
	$name = $name_items[0];

	// simple array (e.g. email)
	if (count($name_items) == 2) {
	$data[$name][$name_items[1]] = $value;
	return;
	}

	$data[$name] = $value;
	}

	/**
	* Unsets data item in kolab data array
	*/
	protected function unsetKolabDataItem(&$data, $name)
	{
	$name_items = explode('.', $name);

	// multi-level array (e.g. address, phone)
	if (count($name_items) == 3) {
	$name = $name_items[0];
	$type = $name_items[1];
	$key_name = $name_items[2];

	if (!isset($data[$name])) {
	return;
	}

	foreach ($data[$name] as $idx => $element) {
	if ($element['type'] == $type) {
	$found = $idx;
	break;
	}
	}

	if (!isset($found)) {
	return;
	}

	unset($data[$name][$found][$key_name]);

	// if there's only one element and it's 'type', remove it
	if (count($data[$name][$found]) == 1 && isset($data[$name][$found]['type'])) {
	unset($data[$name][$found]['type']);
	}
	if (empty($data[$name][$found])) {
	unset($data[$name][$found]);
	}
	if (empty($data[$name])) {
	unset($data[$name]);
	}

	return;
	}

	$name_items = explode(':', $name);
	$name = $name_items[0];

	// simple array (e.g. email)
	if (count($name_items) == 2) {
	unset($data[$name][$name_items[1]]);
	if (empty($data[$name])) {
	unset($data[$name]);
	}
	return;
	}

	unset($data[$name]);
	}

	/**
	* Setter for Body attribute according to client version
	*
	* @param string $value Body
	* @param array $param Body parameters
	*
	* @reurn Syncroton_Model_EmailBody Body element
	*/
	protected function setBody($value, $params = array())
	{
	if (empty($value) && empty($params)) {
	return;
	}

	// Old protocol version doesn't support AirSyncBase:Body, it's eg. WindowsCE
	if ($this->asversion < 12) {
	return;
	}

	if (!empty($value)) {
	$params['data'] = $value;
	}

	if (!isset($params['type'])) {
	$params['type'] = Syncroton_Model_EmailBody::TYPE_PLAINTEXT;
	}

	return new Syncroton_Model_EmailBody($params);
	}

	/**
	* Getter for Body attribute value according to client version
	*
	* @param mixed $body Body element
	* @param int $type Result data type (to which the body will be converted, if specified).
	* One of Syncroton_Model_EmailBody constants.
	*
	* @return string Body value
	*/
	protected function getBody($body, $type = null)
	{
	if ($body && $body->data) {
	$data = $body->data;
	}

	// Convert to specified type
	if ($data && $type && $body->type != $type) {
	$converter = new kolab_sync_body_converter($data, $body->type);
	$data = $converter->convert($type);
	}

	return $data;
	}

	/**
	* Converts PHP DateTime, date (YYYY-MM-DD) or unixtimestamp into PHP DateTime in UTC
	*
	* @param DateTime\|int\|string $date Unix timestamp, date (YYYY-MM-DD) or PHP DateTime object
	*
	* @return DateTime Datetime object
	*/
	protected static function date_from_kolab($date)
	{
	if (!empty($date)) {
	if (is_numeric($date)) {
	$date = new DateTime('@' . $date);
	}
	else if (is_string($date)) {
	$date = new DateTime($date, new DateTimeZone('UTC'));
	}
	else if ($date instanceof DateTime) {
	$date = clone $date;
	$tz = $date->getTimezone();
	$tz_name = $tz->getName();

	// convert to UTC if needed
	if ($tz_name != 'UTC') {
	$date->setTimezone(new DateTimeZone('UTC'));
	}
	}
	else {
	return null; // invalid input
	}

	return $date;
	}
	}

	/**
	* Convert Kolab event/task recurrence into ActiveSync
	*/
	protected function recurrence_from_kolab($data, $type = 'Event')
	{
	if (empty($data['recurrence'])) {
	return null;
	}

	$recurrence = array();
	$r = $data['recurrence'];

	// required fields
	switch($r['FREQ']) {
	case 'DAILY':
	$recurrence['type'] = self::RECUR_TYPE_DAILY;
	break;

	case 'WEEKLY':
	$recurrence['type'] = self::RECUR_TYPE_WEEKLY;
	$recurrence['dayOfWeek'] = $this->day2bitmask($r['BYDAY']);
	break;

	case 'MONTHLY':
	if (!empty($r['BYMONTHDAY'])) {
	// @TODO: ActiveSync doesn't support multi-valued month days,
	// should we replicate the recurrence element for each day of month?
	$month_day = array_shift(explode(',', $r['BYMONTHDAY']));
	$recurrence['type'] = self::RECUR_TYPE_MONTHLY;
	$recurrence['dayOfMonth'] = $month_day;
	}
	else {
	$week = (int) substr($r['BYDAY'], 0, -2);
	$week = ($week == -1) ? 5 : $week;
	$day = substr($r['BYDAY'], -2);
	$recurrence['type'] = self::RECUR_TYPE_MONTHLY_DAYN;
	$recurrence['weekOfMonth'] = $week;
	$recurrence['dayOfWeek'] = $this->day2bitmask($day);
	}
	break;

	case 'YEARLY':
	// @TODO: ActiveSync doesn't support multi-valued months,
	// should we replicate the recurrence element for each month?
	$month = array_shift(explode(',', $r['BYMONTH']));

	if (!empty($r['BYDAY'])) {
	$week = (int) substr($r['BYDAY'], 0, -2);
	$week = ($week == -1) ? 5 : $week;
	$day = substr($r['BYDAY'], -2);
	$recurrence['type'] = self::RECUR_TYPE_YEARLY_DAYN;
	$recurrence['weekOfMonth'] = $week;
	$recurrence['dayOfWeek'] = $this->day2bitmask($day);
	$recurrence['monthOfYear'] = $month;
	}
	else if (!empty($r['BYMONTHDAY'])) {
	// @TODO: ActiveSync doesn't support multi-valued month days,
	// should we replicate the recurrence element for each day of month?
	$month_day = array_shift(explode(',', $r['BYMONTHDAY']));
	$recurrence['type'] = self::RECUR_TYPE_YEARLY;
	$recurrence['dayOfMonth'] = $month_day;
	$recurrence['monthOfYear'] = $month;
	}
	else {
	$recurrence['type'] = self::RECUR_TYPE_YEARLY;
	$recurrence['monthOfYear'] = $month;
	}
	break;
	}

	// required field
	$recurrence['interval'] = $r['INTERVAL'] ? $r['INTERVAL'] : 1;

	if (!empty($r['UNTIL'])) {
	$recurrence['until'] = $this->date_from_kolab($r['UNTIL']);
	}
	else if (!empty($r['COUNT'])) {
	$recurrence['occurrences'] = $r['COUNT'];
	}

	$class = 'Syncroton_Model_' . $type . 'Recurrence';

	return new $class($recurrence);
	}

	/**
	* Convert ActiveSync event/task recurrence into Kolab
	*/
	protected function recurrence_to_kolab($recurrence, $timezone = null)
	{
	if (!($recurrence instanceof Syncroton_Model_EventRecurrence) \|\| !isset($recurrence->type)) {
	return null;
	}

	$type = $recurrence->type;

	switch ($type) {
	case self::RECUR_TYPE_DAILY:
	break;

	case self::RECUR_TYPE_WEEKLY:
	$rrule['BYDAY'] = $this->bitmask2day($recurrence->dayOfWeek);
	break;

	case self::RECUR_TYPE_MONTHLY:
	$rrule['BYMONTHDAY'] = $recurrence->dayOfMonth;
	break;

	case self::RECUR_TYPE_MONTHLY_DAYN:
	$week = $recurrence->weekOfMonth;
	$day = $recurrence->dayOfWeek;
	$byDay = $week == 5 ? -1 : $week;
	$byDay .= $this->bitmask2day($day);

	$rrule['BYDAY'] = $byDay;
	break;

	case self::RECUR_TYPE_YEARLY:
	$rrule['BYMONTH'] = $recurrence->monthOfYear;
	$rrule['BYMONTHDAY'] = $recurrence->dayOfMonth;
	break;

	case self::RECUR_TYPE_YEARLY_DAYN:
	$rrule['BYMONTH'] = $recurrence->monthOfYear;

	$week = $recurrence->weekOfMonth;
	$day = $recurrence->dayOfWeek;
	$byDay = $week == 5 ? -1 : $week;
	$byDay .= $this->bitmask2day($day);

	$rrule['BYDAY'] = $byDay;
	break;
	}

	$rrule['FREQ'] = $this->recurTypeMap[$type];
	$rrule['INTERVAL'] = isset($recurrence->interval) ? $recurrence->interval : 1;

	if (isset($recurrence->until)) {
	if ($timezone) {
	$recurrence->until->setTimezone($timezone);
	}
	$rrule['UNTIL'] = $recurrence->until;
	}
	else if (!empty($recurrence->occurrences)) {
	$rrule['COUNT'] = $recurrence->occurrences;
	}

	return $rrule;
	}

	/**
	* Convert Kolab event recurrence exceptions into ActiveSync
	*/
	protected function exceptions_from_kolab($data, $start_date)
	{
	if (empty($data['recurrence'])) {
	return null;
	}

	$rex = (array) $data['recurrence']['EXDATE'];
	$exceptions = array();

	foreach ($rex as $ex_date) {
	if (!($ex_date instanceof DateTime)) {
	continue;
	}

	$start = clone $ex_date;
	$end = clone $ex_date;

	$start->setTime(0, 0, 0);
	$end->setTime(0, 0, 0);
	$end->modify('+1 day');

	$ex = array(
	'exceptionStartTime' => $start_date,
	'startTime' => self::date_from_kolab($start),
	'endTime' => self::date_from_kolab($end),
	'deleted' => 1,
	);

	if ($data['allday']) {
	$ex['allDayEvent'] = 1;
	}

	$exceptions[] = new Syncroton_Model_EventException($ex);
	}

	return $exceptions;
	}

	/**
	* Convert ActiveSync event recurrence exceptions into Kolab
	*/
	protected function exceptions_to_kolab($exceptions, $timezone = null)
	{
	$exdates = array();
	// handle exceptions from recurrence
	if (!empty($exceptions)) {
	foreach ($exceptions as $exception) {
	if ($exception->deleted && $exception->startTime) {
	$date = clone $exception->startTime;
	$date->setTimezone($timezone);
	$date->setTime(0, 0, 0);
	$exdates[] = $date;
	}
	else {
	// @TODO: handle modification exceptions (that doesn't delete) ?
	}
	}
	}

	return !empty($exdates) ? $exdates : null;
	}

	/**
	* Converts string of days (TU,TH) to bitmask used by ActiveSync
	*
	* @param string $days
	*
	* @return int
	*/
	protected function day2bitmask($days)
	{
	$days = explode(',', $days);
	$result = 0;

	foreach ($days as $day) {
	$result = $result + $this->recurDayMap[$day];
	}

	return $result;
	}

	/**
	* Convert bitmask used by ActiveSync to string of days (TU,TH)
	*
	* @param int $days
	*
	* @return string
	*/
	protected function bitmask2day($days)
	{
	$days_arr = array();

	for ($bitmask = 1; $bitmask <= self::RECUR_DOW_SATURDAY; $bitmask = $bitmask << 1) {
	$dayMatch = $days & $bitmask;
	if ($dayMatch === $bitmask) {
	$days_arr[] = array_search($bitmask, $this->recurDayMap);
	}
	}
	$result = implode(',', $days_arr);

	return $result;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Mar 19, 8:42 AM (18 h, 27 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 458496
Default Alt Text: (102 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions