2014-01-10 20:12:53 +01:00
|
|
|
/*
|
|
|
|
|
|
|
|
Copyright (c) 2014, Inverse inc.
|
|
|
|
All rights reserved.
|
|
|
|
|
2014-01-13 17:46:32 +01:00
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
|
|
|
|
* Redistributions of source code must retain the above copyright
|
|
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
|
|
notice, this list of conditions and the following disclaimer in the
|
|
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
* Neither the name of the Inverse inc. nor the
|
|
|
|
names of its contributors may be used to endorse or promote products
|
|
|
|
derived from this software without specific prior written permission.
|
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
|
|
|
|
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
2014-01-10 20:12:53 +01:00
|
|
|
|
|
|
|
*/
|
|
|
|
#import "SOGoActiveSyncDispatcher+Sync.h"
|
|
|
|
|
|
|
|
#import <Foundation/NSArray.h>
|
2014-12-04 17:27:10 +01:00
|
|
|
#import <Foundation/NSAutoreleasePool.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <Foundation/NSCalendarDate.h>
|
2014-05-15 21:03:24 +02:00
|
|
|
#import <Foundation/NSNull.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <Foundation/NSProcessInfo.h>
|
2014-11-14 15:13:14 +01:00
|
|
|
#import <Foundation/NSSortDescriptor.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <Foundation/NSTimeZone.h>
|
|
|
|
#import <Foundation/NSURL.h>
|
2014-05-15 21:03:24 +02:00
|
|
|
#import <Foundation/NSValue.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
|
|
|
|
#import <NGObjWeb/NSException+HTTP.h>
|
|
|
|
#import <NGObjWeb/SoApplication.h>
|
|
|
|
#import <NGObjWeb/SoObject.h>
|
|
|
|
#import <NGObjWeb/WOContext.h>
|
|
|
|
#import <NGObjWeb/WOContext+SoObjects.h>
|
|
|
|
#import <NGObjWeb/WOCookie.h>
|
|
|
|
#import <NGObjWeb/WODirectAction.h>
|
|
|
|
#import <NGObjWeb/WORequest.h>
|
|
|
|
#import <NGObjWeb/WOResponse.h>
|
|
|
|
|
2014-02-03 16:24:33 +01:00
|
|
|
#import <NGCards/iCalCalendar.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <NGCards/iCalEntityObject.h>
|
|
|
|
#import <NGCards/iCalEvent.h>
|
2014-02-17 14:46:05 +01:00
|
|
|
#import <NGCards/iCalPerson.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <NGCards/iCalToDo.h>
|
|
|
|
#import <NGCards/NGVCard.h>
|
|
|
|
|
|
|
|
#import <NGExtensions/NSCalendarDate+misc.h>
|
2015-01-22 19:31:31 +01:00
|
|
|
#import <NGExtensions/NSObject+Logs.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <NGExtensions/NSString+misc.h>
|
|
|
|
|
|
|
|
#import <NGImap4/NSString+Imap4.h>
|
|
|
|
|
|
|
|
#import <DOM/DOMElement.h>
|
|
|
|
#import <DOM/DOMProtocols.h>
|
|
|
|
|
|
|
|
#import <EOControl/EOQualifier.h>
|
|
|
|
|
|
|
|
#import <SOGo/NSArray+DAV.h>
|
2014-03-19 16:31:54 +01:00
|
|
|
#import <SOGo/SOGoCache.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <SOGo/NSDictionary+DAV.h>
|
|
|
|
#import <SOGo/SOGoDAVAuthenticator.h>
|
|
|
|
#import <SOGo/SOGoDomainDefaults.h>
|
|
|
|
#import <SOGo/SOGoMailer.h>
|
2014-02-11 02:16:43 +01:00
|
|
|
#import <SOGo/SOGoSystemDefaults.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <SOGo/SOGoUser.h>
|
|
|
|
#import <SOGo/SOGoUserSettings.h>
|
2014-05-15 21:03:24 +02:00
|
|
|
#import <SOGo/SOGoCacheGCSObject.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
|
|
|
|
#import <Appointments/SOGoAppointmentObject.h>
|
|
|
|
#import <Appointments/SOGoAppointmentFolder.h>
|
|
|
|
#import <Appointments/SOGoAppointmentFolders.h>
|
|
|
|
#import <Appointments/SOGoTaskObject.h>
|
|
|
|
|
|
|
|
#import <Contacts/SOGoContactGCSEntry.h>
|
|
|
|
#import <Contacts/SOGoContactGCSFolder.h>
|
|
|
|
#import <Contacts/SOGoContactFolders.h>
|
|
|
|
#import <Contacts/SOGoContactSourceFolder.h>
|
|
|
|
|
|
|
|
#import <Mailer/SOGoMailAccount.h>
|
|
|
|
#import <Mailer/SOGoMailAccounts.h>
|
2014-02-17 14:46:05 +01:00
|
|
|
#import <Mailer/SOGoMailFolder.h>
|
2014-01-10 20:12:53 +01:00
|
|
|
#import <Mailer/SOGoMailObject.h>
|
|
|
|
|
|
|
|
#import <Foundation/NSObject.h>
|
|
|
|
#import <Foundation/NSString.h>
|
|
|
|
|
|
|
|
#include "iCalEvent+ActiveSync.h"
|
|
|
|
#include "iCalToDo+ActiveSync.h"
|
|
|
|
#include "NGDOMElement+ActiveSync.h"
|
|
|
|
#include "NGVCard+ActiveSync.h"
|
2014-01-20 16:13:16 +01:00
|
|
|
#include "NSCalendarDate+ActiveSync.h"
|
2014-01-16 21:13:09 +01:00
|
|
|
#include "NSDate+ActiveSync.h"
|
2014-01-10 20:12:53 +01:00
|
|
|
#include "NSData+ActiveSync.h"
|
|
|
|
#include "NSString+ActiveSync.h"
|
|
|
|
#include "SOGoActiveSyncConstants.h"
|
|
|
|
#include "SOGoMailObject+ActiveSync.h"
|
2014-05-15 21:03:24 +02:00
|
|
|
#include "SOGoSyncCacheObject.h"
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-02-04 17:19:33 +01:00
|
|
|
#include <unistd.h>
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
@implementation SOGoActiveSyncDispatcher (Sync)
|
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
- (void) _setFolderMetadata: (NSDictionary *) theFolderMetadata
|
|
|
|
forKey: (NSString *) theFolderKey
|
|
|
|
{
|
|
|
|
SOGoCacheGCSObject *o;
|
2014-12-04 17:27:10 +01:00
|
|
|
NSDictionary *values;
|
2014-05-15 21:03:24 +02:00
|
|
|
NSString *key;
|
|
|
|
|
|
|
|
key = [NSString stringWithFormat: @"%@+%@", [context objectForKey: @"DeviceId"], theFolderKey];
|
2014-12-04 17:27:10 +01:00
|
|
|
values = [theFolderMetadata copy];
|
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
o = [SOGoCacheGCSObject objectWithName: key inContainer: nil];
|
|
|
|
[o setObjectType: ActiveSyncFolderCacheObject];
|
|
|
|
[o setTableUrl: [self folderTableURL]];
|
2014-12-04 17:27:10 +01:00
|
|
|
//[o reloadIfNeeded];
|
2014-11-14 15:13:14 +01:00
|
|
|
|
2014-06-10 17:04:27 +02:00
|
|
|
[[o properties] removeObjectForKey: @"SyncKey"];
|
2014-05-27 20:44:57 +02:00
|
|
|
[[o properties] removeObjectForKey: @"SyncCache"];
|
|
|
|
[[o properties] removeObjectForKey: @"DateCache"];
|
2014-06-25 21:05:25 +02:00
|
|
|
[[o properties] removeObjectForKey: @"MoreAvailable"];
|
2015-03-30 15:49:44 +02:00
|
|
|
[[o properties] removeObjectForKey: @"BodyPreferenceType"];
|
2014-12-08 16:25:37 +01:00
|
|
|
[[o properties] removeObjectForKey: @"SuccessfulMoveItemsOps"];
|
2014-05-27 20:44:57 +02:00
|
|
|
|
2014-12-04 17:27:10 +01:00
|
|
|
[[o properties] addEntriesFromDictionary: values];
|
2014-05-15 21:03:24 +02:00
|
|
|
[o save];
|
2014-12-04 17:27:10 +01:00
|
|
|
[values release];
|
2014-05-15 21:03:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
- (NSMutableDictionary *) _folderMetadataForKey: (NSString *) theFolderKey
|
|
|
|
{
|
|
|
|
SOGoCacheGCSObject *o;
|
|
|
|
NSString *key;
|
|
|
|
|
|
|
|
key = [NSString stringWithFormat: @"%@+%@", [context objectForKey: @"DeviceId"], theFolderKey];
|
|
|
|
|
|
|
|
o = [SOGoCacheGCSObject objectWithName: key inContainer: nil];
|
|
|
|
[o setObjectType: ActiveSyncFolderCacheObject];
|
|
|
|
[o setTableUrl: [self folderTableURL]];
|
|
|
|
[o reloadIfNeeded];
|
|
|
|
|
|
|
|
return [o properties];
|
|
|
|
}
|
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
- (NSString *) _getNameInCache: (id) theCollection withType: (SOGoMicrosoftActiveSyncFolderType) theFolderType
|
|
|
|
{
|
|
|
|
NSString *nameInCache;
|
|
|
|
|
|
|
|
if (theFolderType == ActiveSyncMailFolder)
|
|
|
|
nameInCache= [[[theCollection mailAccountFolder] imapFolderGUIDs] objectForKey: [theCollection nameInContainer]];
|
|
|
|
else
|
|
|
|
{
|
|
|
|
NSString *component_name;
|
|
|
|
if (theFolderType == ActiveSyncContactFolder)
|
|
|
|
component_name = @"vcard";
|
|
|
|
else if (theFolderType == ActiveSyncEventFolder)
|
|
|
|
component_name = @"vevent";
|
|
|
|
else
|
|
|
|
component_name = @"vtodo";
|
|
|
|
|
|
|
|
nameInCache= [NSString stringWithFormat: @"%@/%@", component_name, [theCollection nameInContainer]];
|
|
|
|
}
|
|
|
|
|
|
|
|
return nameInCache;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
//
|
|
|
|
// <?xml version="1.0"?>
|
|
|
|
// <!DOCTYPE ActiveSync PUBLIC "-//MICROSOFT//DTD ActiveSync//EN" "http://www.microsoft.com/">
|
|
|
|
// <Sync xmlns="AirSync:">
|
|
|
|
// <Collections>
|
|
|
|
// <Collection>
|
|
|
|
// <SyncKey>1388757902</SyncKey>
|
|
|
|
// <CollectionId>vcard/personal</CollectionId>
|
|
|
|
// <GetChanges/>
|
|
|
|
// <WindowSize>25</WindowSize>
|
|
|
|
// <Options>
|
|
|
|
// <BodyPreference xmlns="AirSyncBase:">
|
|
|
|
// <Type>1</Type>
|
|
|
|
// <TruncationSize>32768</TruncationSize>
|
|
|
|
// </BodyPreference>
|
|
|
|
// </Options>
|
|
|
|
// <Commands>
|
|
|
|
// <Add>
|
|
|
|
// <ClientId>16</ClientId>
|
|
|
|
// <ApplicationData>
|
|
|
|
// <Body xmlns="AirSyncBase:">
|
|
|
|
// <Type>1</Type>
|
|
|
|
// <Data/>
|
|
|
|
// </Body>
|
|
|
|
// <CompanyName xmlns="Contacts:">Goo Inc.</CompanyName>
|
|
|
|
// <Email1Address xmlns="Contacts:">annie@broccoli.com</Email1Address>
|
|
|
|
// <FileAs xmlns="Contacts:">Broccoli, Annie</FileAs>
|
|
|
|
// <FirstName xmlns="Contacts:">Annie</FirstName>
|
|
|
|
// <LastName xmlns="Contacts:">Broccoli</LastName>
|
|
|
|
// <Picture xmlns="Contacts:"/>
|
|
|
|
// </ApplicationData>
|
|
|
|
// </Add>
|
|
|
|
// </Commands>
|
|
|
|
// </Collection>
|
|
|
|
// </Collections>
|
|
|
|
// </Sync>
|
|
|
|
//
|
|
|
|
- (void) processSyncAddCommand: (id <DOMElement>) theDocumentElement
|
|
|
|
inCollection: (id) theCollection
|
|
|
|
withType: (SOGoMicrosoftActiveSyncFolderType) theFolderType
|
|
|
|
inBuffer: (NSMutableString *) theBuffer
|
|
|
|
{
|
2014-11-14 15:13:14 +01:00
|
|
|
NSMutableDictionary *folderMetadata, *dateCache, *syncCache, *allValues;
|
2014-01-10 20:12:53 +01:00
|
|
|
NSString *clientId, *serverId;
|
2014-01-10 22:48:39 +01:00
|
|
|
NSArray *additions;
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
id anAddition, sogoObject, o;
|
2014-02-11 02:16:43 +01:00
|
|
|
BOOL is_new;
|
2014-01-10 20:12:53 +01:00
|
|
|
int i;
|
|
|
|
|
|
|
|
additions = (id)[theDocumentElement getElementsByTagName: @"Add"];
|
|
|
|
if ([additions count])
|
|
|
|
{
|
|
|
|
for (i = 0; i < [additions count]; i++)
|
|
|
|
{
|
|
|
|
anAddition = [additions objectAtIndex: i];
|
2014-02-11 02:16:43 +01:00
|
|
|
is_new = YES;
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-01-10 21:29:57 +01:00
|
|
|
clientId = [[(id)[anAddition getElementsByTagName: @"ClientId"] lastObject] textValue];
|
2014-01-10 22:48:39 +01:00
|
|
|
allValues = [NSMutableDictionary dictionaryWithDictionary: [[(id)[anAddition getElementsByTagName: @"ApplicationData"] lastObject] applicationData]];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
|
|
|
switch (theFolderType)
|
|
|
|
{
|
|
|
|
case ActiveSyncContactFolder:
|
|
|
|
{
|
|
|
|
serverId = [NSString stringWithFormat: @"%@.vcf", [theCollection globallyUniqueObjectId]];
|
|
|
|
sogoObject = [[SOGoContactGCSEntry alloc] initWithName: serverId
|
|
|
|
inContainer: theCollection];
|
|
|
|
o = [sogoObject vCard];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ActiveSyncEventFolder:
|
|
|
|
{
|
2014-02-11 02:16:43 +01:00
|
|
|
// Before adding a new appointment, we check if one is already present with the same UID. If that's
|
|
|
|
// the case, let's just update it. This can happen if for example, an iOS based device receives the
|
|
|
|
// invitation email and choses "Add to calendar" BEFORE actually syncing the calendar. That would
|
|
|
|
// create a duplicate on the server.
|
|
|
|
if ([allValues objectForKey: @"UID"])
|
2014-02-17 14:46:05 +01:00
|
|
|
serverId = [allValues objectForKey: @"UID"];
|
2014-02-11 02:16:43 +01:00
|
|
|
else
|
2014-02-17 14:46:05 +01:00
|
|
|
serverId = [theCollection globallyUniqueObjectId];
|
2014-02-17 16:01:44 +01:00
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
sogoObject = [theCollection lookupName: [serverId sanitizedServerIdWithType: theFolderType]
|
2014-02-11 02:16:43 +01:00
|
|
|
inContext: context
|
|
|
|
acquire: NO];
|
|
|
|
|
|
|
|
// If object isn't found, we 'create' a new one
|
|
|
|
if ([sogoObject isKindOfClass: [NSException class]])
|
|
|
|
{
|
2014-02-17 14:46:05 +01:00
|
|
|
sogoObject = [[SOGoAppointmentObject alloc] initWithName: [serverId sanitizedServerIdWithType: theFolderType]
|
2014-02-11 02:16:43 +01:00
|
|
|
inContainer: theCollection];
|
|
|
|
o = [sogoObject component: YES secure: NO];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
o = [sogoObject component: NO secure: NO];
|
|
|
|
is_new = NO;
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ActiveSyncTaskFolder:
|
|
|
|
{
|
|
|
|
serverId = [NSString stringWithFormat: @"%@.ics", [theCollection globallyUniqueObjectId]];
|
|
|
|
sogoObject = [[SOGoTaskObject alloc] initWithName: serverId
|
|
|
|
inContainer: theCollection];
|
|
|
|
o = [sogoObject component: YES secure: NO];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ActiveSyncMailFolder:
|
|
|
|
default:
|
|
|
|
{
|
2015-01-22 19:31:31 +01:00
|
|
|
// FIXME - what to do?
|
|
|
|
[self errorWithFormat: @"Fatal error occured - tried to call -processSyncAddCommand: ... on a mail folder. We abort."];
|
2014-02-17 14:46:05 +01:00
|
|
|
abort();
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-17 16:01:44 +01:00
|
|
|
[o takeActiveSyncValues: allValues inContext: context];
|
2014-02-11 02:16:43 +01:00
|
|
|
[sogoObject setIsNew: is_new];
|
2014-01-10 20:12:53 +01:00
|
|
|
[sogoObject saveComponent: o];
|
|
|
|
|
|
|
|
// Everything is fine, lets generate our response
|
|
|
|
[theBuffer appendString: @"<Add>"];
|
|
|
|
[theBuffer appendFormat: @"<ClientId>%@</ClientId>", clientId];
|
|
|
|
[theBuffer appendFormat: @"<ServerId>%@</ServerId>", serverId];
|
|
|
|
[theBuffer appendFormat: @"<Status>%d</Status>", 1];
|
|
|
|
[theBuffer appendString: @"</Add>"];
|
2014-11-14 15:13:14 +01:00
|
|
|
|
|
|
|
// Update syncCache
|
|
|
|
folderMetadata = [self _folderMetadataForKey: [self _getNameInCache: theCollection withType: theFolderType]];
|
|
|
|
|
|
|
|
syncCache = [folderMetadata objectForKey: @"SyncCache"];
|
|
|
|
dateCache = [folderMetadata objectForKey: @"DateCache"];
|
|
|
|
|
|
|
|
[syncCache setObject: [folderMetadata objectForKey: @"SyncKey"] forKey: serverId];
|
|
|
|
[dateCache setObject: [NSCalendarDate date] forKey: serverId];
|
|
|
|
|
|
|
|
[self _setFolderMetadata: folderMetadata forKey: [self _getNameInCache: theCollection withType: theFolderType]];
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// <?xml version="1.0"?>
|
|
|
|
// <!DOCTYPE ActiveSync PUBLIC "-//MICROSOFT//DTD ActiveSync//EN" "http://www.microsoft.com/">
|
|
|
|
// <Sync xmlns="AirSync:">
|
|
|
|
// <Collections>
|
|
|
|
// <Collection>
|
|
|
|
// <SyncKey>1387546048</SyncKey>
|
|
|
|
// <CollectionId>vtodo/personal</CollectionId>
|
|
|
|
// <GetChanges/>
|
|
|
|
// <WindowSize>25</WindowSize>
|
|
|
|
// <Options>
|
|
|
|
// <BodyPreference xmlns="AirSyncBase:">
|
|
|
|
// <Type>1</Type>
|
|
|
|
// <TruncationSize>32768</TruncationSize>
|
|
|
|
// </BodyPreference>
|
|
|
|
// </Options>
|
|
|
|
// <Commands>
|
|
|
|
// <Change>
|
|
|
|
// <ServerId>36C5-52B36280-1-27B38F40.ics</ServerId>
|
|
|
|
// <ApplicationData>
|
|
|
|
// <Body xmlns="AirSyncBase:">
|
|
|
|
// <Type>1</Type>
|
|
|
|
// <Data/>
|
|
|
|
// </Body>
|
|
|
|
// <Subject xmlns="Tasks:">foobar1</Subject>
|
|
|
|
// <Importance xmlns="Tasks:">1</Importance>
|
|
|
|
// <Complete xmlns="Tasks:">0</Complete>
|
|
|
|
// <Sensitivity xmlns="Tasks:">0</Sensitivity>
|
|
|
|
// <ReminderSet xmlns="Tasks:">0</ReminderSet>
|
|
|
|
// </ApplicationData>
|
|
|
|
// </Change>
|
|
|
|
// </Commands>
|
|
|
|
// </Collection>
|
|
|
|
// </Collections>
|
|
|
|
// </Sync>
|
|
|
|
//
|
|
|
|
- (void) processSyncChangeCommand: (id <DOMElement>) theDocumentElement
|
|
|
|
inCollection: (id) theCollection
|
|
|
|
withType: (SOGoMicrosoftActiveSyncFolderType) theFolderType
|
|
|
|
inBuffer: (NSMutableString *) theBuffer
|
|
|
|
{
|
|
|
|
NSDictionary *allChanges;
|
|
|
|
NSString *serverId;
|
|
|
|
NSArray *changes;
|
|
|
|
id aChange, o, sogoObject;
|
|
|
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
changes = (id)[theDocumentElement getElementsByTagName: @"Change"];
|
|
|
|
|
|
|
|
if ([changes count])
|
|
|
|
{
|
|
|
|
for (i = 0; i < [changes count]; i++)
|
|
|
|
{
|
|
|
|
aChange = [changes objectAtIndex: i];
|
|
|
|
|
|
|
|
serverId = [[(id)[aChange getElementsByTagName: @"ServerId"] lastObject] textValue];
|
|
|
|
allChanges = [[(id)[aChange getElementsByTagName: @"ApplicationData"] lastObject] applicationData];
|
|
|
|
|
|
|
|
// Fetch the object and apply the changes
|
2014-02-17 14:46:05 +01:00
|
|
|
sogoObject = [theCollection lookupName: [serverId sanitizedServerIdWithType: theFolderType]
|
2014-01-10 20:12:53 +01:00
|
|
|
inContext: context
|
|
|
|
acquire: NO];
|
|
|
|
|
2014-01-13 22:24:15 +01:00
|
|
|
// Object was removed inbetween sync/commands?
|
|
|
|
if ([sogoObject isKindOfClass: [NSException class]])
|
|
|
|
{
|
|
|
|
// FIXME - return status == 8
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
switch (theFolderType)
|
|
|
|
{
|
|
|
|
case ActiveSyncContactFolder:
|
|
|
|
{
|
|
|
|
o = [sogoObject vCard];
|
2014-02-17 16:01:44 +01:00
|
|
|
[o takeActiveSyncValues: allChanges inContext: context];
|
2014-01-10 20:12:53 +01:00
|
|
|
[sogoObject saveComponent: o];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ActiveSyncEventFolder:
|
|
|
|
case ActiveSyncTaskFolder:
|
|
|
|
{
|
|
|
|
o = [sogoObject component: NO secure: NO];
|
2014-02-17 16:01:44 +01:00
|
|
|
[o takeActiveSyncValues: allChanges inContext: context];
|
2014-01-10 20:12:53 +01:00
|
|
|
[sogoObject saveComponent: o];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ActiveSyncMailFolder:
|
|
|
|
default:
|
|
|
|
{
|
2014-02-17 16:01:44 +01:00
|
|
|
[sogoObject takeActiveSyncValues: allChanges inContext: context];
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-29 16:13:18 +01:00
|
|
|
[theBuffer appendString: @"<Change>"];
|
|
|
|
[theBuffer appendFormat: @"<ServerId>%@</ServerId>", serverId];
|
|
|
|
[theBuffer appendFormat: @"<Status>%d</Status>", 1];
|
|
|
|
[theBuffer appendString: @"</Change>"];
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// <?xml version="1.0"?>
|
|
|
|
// <!DOCTYPE ActiveSync PUBLIC "-//MICROSOFT//DTD ActiveSync//EN" "http://www.microsoft.com/">
|
|
|
|
// <Sync xmlns="AirSync:">
|
|
|
|
// <Collections>
|
|
|
|
// <Collection>
|
|
|
|
// <SyncKey>1388764784</SyncKey>
|
|
|
|
// <CollectionId>vtodo/personal</CollectionId>
|
|
|
|
// <GetChanges/>
|
|
|
|
// <WindowSize>25</WindowSize>
|
|
|
|
// <Options>
|
|
|
|
// <BodyPreference xmlns="AirSyncBase:">
|
|
|
|
// <Type>1</Type>
|
|
|
|
// <TruncationSize>32768</TruncationSize>
|
|
|
|
// </BodyPreference>
|
|
|
|
// </Options>
|
|
|
|
// <Commands>
|
|
|
|
// <Delete>
|
|
|
|
// <ServerId>2CB5-52B36080-1-1C1D0240.ics</ServerId>
|
|
|
|
// </Delete>
|
|
|
|
// </Commands>
|
|
|
|
// </Collection>
|
|
|
|
// </Collections>
|
|
|
|
// </Sync>
|
|
|
|
//
|
|
|
|
- (void) processSyncDeleteCommand: (id <DOMElement>) theDocumentElement
|
|
|
|
inCollection: (id) theCollection
|
|
|
|
withType: (SOGoMicrosoftActiveSyncFolderType) theFolderType
|
|
|
|
inBuffer: (NSMutableString *) theBuffer
|
|
|
|
{
|
|
|
|
NSArray *deletions;
|
|
|
|
NSString *serverId;
|
|
|
|
|
|
|
|
id aDelete, sogoObject;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
deletions = (id)[theDocumentElement getElementsByTagName: @"Delete"];
|
|
|
|
|
|
|
|
if ([deletions count])
|
|
|
|
{
|
|
|
|
for (i = 0; i < [deletions count]; i++)
|
|
|
|
{
|
|
|
|
aDelete = [deletions objectAtIndex: i];
|
|
|
|
|
|
|
|
serverId = [[(id)[aDelete getElementsByTagName: @"ServerId"] lastObject] textValue];
|
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
sogoObject = [theCollection lookupName: [serverId sanitizedServerIdWithType: theFolderType]
|
2014-01-10 20:12:53 +01:00
|
|
|
inContext: context
|
|
|
|
acquire: NO];
|
|
|
|
|
2014-03-11 18:21:05 +01:00
|
|
|
if (![sogoObject isKindOfClass: [NSException class]])
|
|
|
|
[sogoObject delete];
|
2014-10-29 16:13:18 +01:00
|
|
|
|
|
|
|
[theBuffer appendString: @"<Delete>"];
|
|
|
|
[theBuffer appendFormat: @"<ServerId>%@</ServerId>", serverId];
|
|
|
|
[theBuffer appendFormat: @"<Status>%d</Status>", 1];
|
|
|
|
[theBuffer appendString: @"</Delete>"];
|
2014-11-14 15:13:14 +01:00
|
|
|
|
|
|
|
// update syncCache
|
|
|
|
NSMutableDictionary *folderMetadata, *dateCache, *syncCache;
|
|
|
|
folderMetadata = [self _folderMetadataForKey: [self _getNameInCache: theCollection withType: theFolderType]];
|
|
|
|
|
|
|
|
syncCache = [folderMetadata objectForKey: @"SyncCache"];
|
|
|
|
dateCache = [folderMetadata objectForKey: @"DateCache"];
|
|
|
|
|
|
|
|
[syncCache removeObjectForKey: serverId];
|
|
|
|
[dateCache removeObjectForKey: serverId];
|
|
|
|
|
|
|
|
[self _setFolderMetadata: folderMetadata forKey: [self _getNameInCache: theCollection withType: theFolderType]];
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// <Fetch>
|
|
|
|
// <ServerId>91</ServerId>
|
|
|
|
// </Fetch>
|
|
|
|
//
|
|
|
|
- (void) processSyncFetchCommand: (id <DOMElement>) theDocumentElement
|
|
|
|
inCollection: (id) theCollection
|
|
|
|
withType: (SOGoMicrosoftActiveSyncFolderType) theFolderType
|
|
|
|
inBuffer: (NSMutableString *) theBuffer
|
|
|
|
{
|
|
|
|
NSString *serverId;
|
|
|
|
id o;
|
|
|
|
|
|
|
|
serverId = [[(id)[theDocumentElement getElementsByTagName: @"ServerId"] lastObject] textValue];
|
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
o = [theCollection lookupName: [serverId sanitizedServerIdWithType: theFolderType]
|
2014-01-10 20:12:53 +01:00
|
|
|
inContext: context
|
|
|
|
acquire: NO];
|
|
|
|
|
|
|
|
// FIXME - error handling
|
|
|
|
[theBuffer appendString: @"<Fetch>"];
|
|
|
|
[theBuffer appendFormat: @"<ServerId>%@</ServerId>", serverId];
|
|
|
|
[theBuffer appendFormat: @"<Status>%d</Status>", 1];
|
|
|
|
[theBuffer appendString: @"<ApplicationData>"];
|
2014-02-17 16:01:44 +01:00
|
|
|
[theBuffer appendString: [o activeSyncRepresentationInContext: context]];
|
2014-01-10 20:12:53 +01:00
|
|
|
[theBuffer appendString: @"</ApplicationData>"];
|
|
|
|
[theBuffer appendString: @"</Fetch>"];
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// The method handles <GetChanges/>
|
|
|
|
//
|
|
|
|
- (void) processSyncGetChanges: (id <DOMElement>) theDocumentElement
|
|
|
|
inCollection: (id) theCollection
|
2014-02-17 14:46:05 +01:00
|
|
|
withWindowSize: (unsigned int) theWindowSize
|
2014-12-22 17:50:51 +01:00
|
|
|
withMaxSyncResponseSize: (unsigned int) theMaxSyncResponseSize
|
2014-01-10 20:12:53 +01:00
|
|
|
withSyncKey: (NSString *) theSyncKey
|
2014-01-16 21:13:09 +01:00
|
|
|
withFolderType: (SOGoMicrosoftActiveSyncFolderType) theFolderType
|
2014-01-20 16:13:16 +01:00
|
|
|
withFilterType: (NSCalendarDate *) theFilterType
|
2014-01-10 20:12:53 +01:00
|
|
|
inBuffer: (NSMutableString *) theBuffer
|
2014-02-17 14:46:05 +01:00
|
|
|
lastServerKey: (NSString **) theLastServerKey
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
{
|
2014-06-25 21:05:25 +02:00
|
|
|
NSMutableDictionary *folderMetadata, *dateCache, *syncCache;
|
2015-03-23 22:23:29 +01:00
|
|
|
NSString *davCollectionTagToStore;
|
2014-12-04 17:27:10 +01:00
|
|
|
NSAutoreleasePool *pool;
|
2014-01-22 17:02:12 +01:00
|
|
|
NSMutableString *s;
|
2014-02-17 14:46:05 +01:00
|
|
|
|
|
|
|
BOOL more_available;
|
|
|
|
int i, max;
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-06-25 21:05:25 +02:00
|
|
|
s = [NSMutableString string];
|
|
|
|
|
|
|
|
more_available = NO;
|
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
folderMetadata = [self _folderMetadataForKey: [self _getNameInCache: theCollection withType: theFolderType]];
|
|
|
|
|
|
|
|
// If this is a new sync operation, DateCache and SyncCache needs to be deleted
|
|
|
|
if ([theSyncKey isEqualToString: @"-1"])
|
|
|
|
{
|
|
|
|
[folderMetadata setObject: [NSMutableDictionary dictionary] forKey: @"SyncCache"];
|
|
|
|
[folderMetadata setObject: [NSMutableDictionary dictionary] forKey: @"DateCache"];
|
|
|
|
}
|
|
|
|
|
|
|
|
syncCache = [folderMetadata objectForKey: @"SyncCache"];
|
|
|
|
dateCache = [folderMetadata objectForKey: @"DateCache"];
|
|
|
|
|
|
|
|
if ((theFolderType == ActiveSyncMailFolder || theFolderType == ActiveSyncEventFolder || theFolderType == ActiveSyncTaskFolder) &&
|
2014-12-22 17:50:51 +01:00
|
|
|
!([folderMetadata objectForKey: @"MoreAvailable"]) && // previous sync operation reached the windowSize or maximumSyncReponseSize
|
2014-11-14 15:13:14 +01:00
|
|
|
!([theSyncKey isEqualToString: @"-1"]) && // new sync operation
|
|
|
|
theFilterType)
|
2014-06-25 21:05:25 +02:00
|
|
|
{
|
|
|
|
NSArray *allKeys;
|
|
|
|
NSString *key;
|
2014-11-14 15:13:14 +01:00
|
|
|
|
2014-06-25 21:05:25 +02:00
|
|
|
int softdelete_count;
|
|
|
|
|
|
|
|
softdelete_count = 0;
|
|
|
|
|
|
|
|
allKeys = [dateCache allKeys];
|
|
|
|
for (i = 0; i < [allKeys count]; i++)
|
|
|
|
{
|
|
|
|
key = [allKeys objectAtIndex: i];
|
|
|
|
|
|
|
|
if ([[dateCache objectForKey:key] compare: theFilterType] == NSOrderedAscending)
|
|
|
|
{
|
|
|
|
[s appendString: @"<SoftDelete xmlns=\"AirSync:\">"];
|
|
|
|
[s appendFormat: @"<ServerId xmlns=\"AirSync:\">%@</ServerId>", key];
|
|
|
|
[s appendString: @"</SoftDelete>"];
|
2014-11-14 15:13:14 +01:00
|
|
|
|
2014-06-25 21:05:25 +02:00
|
|
|
[syncCache removeObjectForKey: key];
|
|
|
|
[dateCache removeObjectForKey: key];
|
|
|
|
|
|
|
|
softdelete_count++;
|
|
|
|
}
|
|
|
|
|
2014-12-22 17:50:51 +01:00
|
|
|
if (softdelete_count >= theWindowSize || (theMaxSyncResponseSize > 0 && [s length] >= theMaxSyncResponseSize))
|
2014-06-25 21:05:25 +02:00
|
|
|
{
|
|
|
|
[folderMetadata setObject: [NSNumber numberWithBool: YES] forKey: @"MoreAvailable"];
|
2014-11-14 15:13:14 +01:00
|
|
|
[self _setFolderMetadata: folderMetadata forKey: [self _getNameInCache: theCollection withType: theFolderType]];
|
2014-06-25 21:05:25 +02:00
|
|
|
|
|
|
|
more_available = YES;
|
|
|
|
*theLastServerKey = theSyncKey;
|
|
|
|
|
|
|
|
// Since WindowSize is reached don't even try to add more to the response, let's just
|
|
|
|
// jump to the end and return the response immediately
|
|
|
|
goto return_response;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
[folderMetadata removeObjectForKey: @"MoreAvailable"];
|
2014-11-14 15:13:14 +01:00
|
|
|
[self _setFolderMetadata: folderMetadata forKey: [self _getNameInCache: theCollection withType: theFolderType]];
|
2014-06-25 21:05:25 +02:00
|
|
|
}
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
//
|
|
|
|
// No changes in the collection - 2.2.2.19.1.1 Empty Sync Request.
|
|
|
|
// We check this and we don't generate any commands if we don't have to.
|
|
|
|
//
|
2014-06-25 21:05:25 +02:00
|
|
|
if ([theSyncKey isEqualToString: [theCollection davCollectionTag]] && !([s length]))
|
2014-01-10 20:12:53 +01:00
|
|
|
return;
|
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
more_available = NO;
|
|
|
|
|
2015-03-23 22:23:29 +01:00
|
|
|
davCollectionTagToStore = [theCollection davCollectionTag];
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
switch (theFolderType)
|
|
|
|
{
|
2014-01-20 16:13:16 +01:00
|
|
|
// Handle all the GCS components
|
2014-01-10 20:12:53 +01:00
|
|
|
case ActiveSyncContactFolder:
|
|
|
|
case ActiveSyncEventFolder:
|
|
|
|
case ActiveSyncTaskFolder:
|
|
|
|
{
|
2014-01-20 16:13:16 +01:00
|
|
|
id sogoObject, componentObject;
|
|
|
|
NSString *uid, *component_name;
|
|
|
|
NSDictionary *component;
|
|
|
|
NSArray *allComponents;
|
|
|
|
|
|
|
|
BOOL updated;
|
2014-11-14 15:13:14 +01:00
|
|
|
int deleted, return_count;
|
2014-01-20 16:13:16 +01:00
|
|
|
|
|
|
|
if (theFolderType == ActiveSyncContactFolder)
|
|
|
|
component_name = @"vcard";
|
|
|
|
else if (theFolderType == ActiveSyncEventFolder)
|
|
|
|
component_name = @"vevent";
|
|
|
|
else
|
|
|
|
component_name = @"vtodo";
|
|
|
|
|
|
|
|
allComponents = [theCollection syncTokenFieldsWithProperties: nil matchingSyncToken: theSyncKey fromDate: theFilterType];
|
2014-11-14 15:13:14 +01:00
|
|
|
allComponents = [allComponents sortedArrayUsingDescriptors: [NSArray arrayWithObjects: [[NSSortDescriptor alloc] initWithKey: @"c_lastmodified" ascending:YES], nil]];
|
2014-12-04 17:27:10 +01:00
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
// Check for the WindowSize
|
|
|
|
max = [allComponents count];
|
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
return_count = 0;
|
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
for (i = 0; i < max; i++)
|
2014-01-10 20:12:53 +01:00
|
|
|
{
|
2014-12-04 17:27:10 +01:00
|
|
|
pool = [[NSAutoreleasePool alloc] init];
|
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
// Check for the WindowSize and slice accordingly
|
2014-12-22 17:50:51 +01:00
|
|
|
if (return_count >= theWindowSize || (theMaxSyncResponseSize > 0 && [s length] >= theMaxSyncResponseSize))
|
2014-11-14 15:13:14 +01:00
|
|
|
{
|
|
|
|
more_available = YES;
|
|
|
|
|
|
|
|
// -1 to make sure that we miss no event in case there are more with the same c_lastmodified
|
2014-12-04 17:27:10 +01:00
|
|
|
*theLastServerKey = [[NSString alloc] initWithFormat: @"%d", [[component objectForKey: @"c_lastmodified"] intValue] - 1];
|
2014-11-14 15:13:14 +01:00
|
|
|
|
2014-12-04 17:27:10 +01:00
|
|
|
DESTROY(pool);
|
2014-11-14 15:13:14 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-01-20 16:13:16 +01:00
|
|
|
component = [allComponents objectAtIndex: i];
|
|
|
|
deleted = [[component objectForKey: @"c_deleted"] intValue];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-01-20 16:13:16 +01:00
|
|
|
if (!deleted && ![[component objectForKey: @"c_component"] isEqualToString: component_name])
|
2014-12-22 17:50:51 +01:00
|
|
|
{
|
|
|
|
DESTROY(pool);
|
|
|
|
continue;
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
uid = [[component objectForKey: @"c_name"] sanitizedServerIdWithType: theFolderType];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
|
|
|
if (deleted)
|
|
|
|
{
|
2014-11-14 15:13:14 +01:00
|
|
|
if ([syncCache objectForKey: uid])
|
|
|
|
{
|
|
|
|
[s appendString: @"<Delete xmlns=\"AirSync:\">"];
|
|
|
|
[s appendFormat: @"<ServerId xmlns=\"AirSync:\">%@</ServerId>", uid];
|
|
|
|
[s appendString: @"</Delete>"];
|
|
|
|
|
|
|
|
[syncCache removeObjectForKey: uid];
|
|
|
|
[dateCache removeObjectForKey: uid];
|
|
|
|
return_count++;
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
updated = YES;
|
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
if (![syncCache objectForKey: uid])
|
2014-01-10 20:12:53 +01:00
|
|
|
updated = NO;
|
2014-11-14 15:13:14 +01:00
|
|
|
else if ([[component objectForKey: @"c_lastmodified"] intValue] == [[syncCache objectForKey: uid] intValue])
|
2014-12-22 17:50:51 +01:00
|
|
|
{
|
|
|
|
DESTROY(pool);
|
|
|
|
continue;
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
return_count++;
|
2014-12-22 17:50:51 +01:00
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
sogoObject = [theCollection lookupName: [uid sanitizedServerIdWithType: theFolderType]
|
|
|
|
inContext: context
|
|
|
|
acquire: 0];
|
|
|
|
|
|
|
|
if (theFolderType == ActiveSyncContactFolder)
|
|
|
|
componentObject = [sogoObject vCard];
|
|
|
|
else
|
|
|
|
componentObject = [sogoObject component: NO secure: NO];
|
|
|
|
|
|
|
|
//
|
|
|
|
// We do NOT synchronize NEW events that are in fact, invitations
|
|
|
|
// to events. This is due to the fact that Outlook 2013 creates
|
|
|
|
// "phantom" events in the calendar that are mapped to invitations mails.
|
|
|
|
// If we synchronize these events too, it'll interfere with the whole thing
|
|
|
|
// and prevent Outlook from properly calling MeetingResponse.
|
|
|
|
//
|
|
|
|
if (!updated && theFolderType == ActiveSyncEventFolder)
|
|
|
|
{
|
|
|
|
iCalPersonPartStat partstat;
|
|
|
|
iCalPerson *attendee;
|
|
|
|
NSString *email;
|
|
|
|
|
|
|
|
email = [[[context activeUser] allEmails] objectAtIndex: 0];
|
|
|
|
attendee = [componentObject findAttendeeWithEmail: email];
|
|
|
|
|
|
|
|
if (attendee)
|
|
|
|
{
|
|
|
|
partstat = [attendee participationStatus];
|
|
|
|
|
|
|
|
if (partstat == iCalPersonPartStatNeedsAction)
|
2015-01-08 21:56:16 +01:00
|
|
|
{
|
|
|
|
DESTROY(pool);
|
|
|
|
continue;
|
|
|
|
}
|
2014-02-17 14:46:05 +01:00
|
|
|
}
|
|
|
|
}
|
2014-11-14 15:13:14 +01:00
|
|
|
|
|
|
|
[syncCache setObject: [component objectForKey: @"c_lastmodified"] forKey: uid];
|
2014-12-22 18:39:58 +01:00
|
|
|
|
|
|
|
// No need to set dateCache for Contacts
|
|
|
|
if ((theFolderType == ActiveSyncEventFolder || theFolderType == ActiveSyncTaskFolder))
|
|
|
|
{
|
|
|
|
NSCalendarDate *d;
|
|
|
|
|
|
|
|
if ([[component objectForKey: @"c_cycleenddate"] intValue])
|
|
|
|
d = [NSCalendarDate dateWithTimeIntervalSince1970: [[component objectForKey: @"c_cycleenddate"] intValue]];
|
|
|
|
else if ([[component objectForKey: @"c_enddate"] intValue])
|
|
|
|
d = [NSCalendarDate dateWithTimeIntervalSince1970: [[component objectForKey: @"c_enddate"] intValue]];
|
|
|
|
else
|
|
|
|
d = [NSCalendarDate distantFuture];
|
|
|
|
|
|
|
|
[dateCache setObject: d forKey: uid];
|
|
|
|
}
|
2014-02-17 14:46:05 +01:00
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
if (updated)
|
2014-01-22 17:02:12 +01:00
|
|
|
[s appendString: @"<Change xmlns=\"AirSync:\">"];
|
2014-01-10 20:12:53 +01:00
|
|
|
else
|
2014-12-22 18:39:58 +01:00
|
|
|
[s appendString: @"<Add xmlns=\"AirSync:\">"];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-01-22 17:02:12 +01:00
|
|
|
[s appendFormat: @"<ServerId xmlns=\"AirSync:\">%@</ServerId>", uid];
|
|
|
|
[s appendString: @"<ApplicationData xmlns=\"AirSync:\">"];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-02-17 16:01:44 +01:00
|
|
|
[s appendString: [componentObject activeSyncRepresentationInContext: context]];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-01-22 17:02:12 +01:00
|
|
|
[s appendString: @"</ApplicationData>"];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
|
|
|
if (updated)
|
2014-01-22 17:02:12 +01:00
|
|
|
[s appendString: @"</Change>"];
|
2014-01-10 20:12:53 +01:00
|
|
|
else
|
2014-01-22 17:02:12 +01:00
|
|
|
[s appendString: @"</Add>"];
|
2014-11-14 15:13:14 +01:00
|
|
|
|
|
|
|
return_count++;
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
2015-01-07 15:29:31 +01:00
|
|
|
|
|
|
|
DESTROY(pool);
|
2015-01-08 21:56:16 +01:00
|
|
|
} // for (i = 0; i < max; i++) ...
|
2014-06-10 17:04:27 +02:00
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
if (more_available)
|
|
|
|
{
|
|
|
|
[folderMetadata setObject: [NSNumber numberWithBool: YES] forKey: @"MoreAvailable"];
|
|
|
|
[folderMetadata setObject: *theLastServerKey forKey: @"SyncKey"];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
[folderMetadata removeObjectForKey: @"MoreAvailable"];
|
2015-03-23 22:23:29 +01:00
|
|
|
[folderMetadata setObject: davCollectionTagToStore forKey: @"SyncKey"];
|
2014-11-14 15:13:14 +01:00
|
|
|
}
|
|
|
|
|
2014-06-10 17:04:27 +02:00
|
|
|
[self _setFolderMetadata: folderMetadata
|
|
|
|
forKey: [NSString stringWithFormat: @"%@/%@", component_name, [theCollection nameInContainer]]];
|
2014-12-04 17:27:10 +01:00
|
|
|
|
|
|
|
RELEASE(*theLastServerKey);
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ActiveSyncMailFolder:
|
|
|
|
default:
|
|
|
|
{
|
2014-05-15 21:03:24 +02:00
|
|
|
SOGoSyncCacheObject *lastCacheObject, *aCacheObject;
|
|
|
|
NSMutableArray *allCacheObjects, *sortedBySequence;
|
|
|
|
|
2014-01-20 16:13:16 +01:00
|
|
|
SOGoMailObject *mailObject;
|
2014-01-10 20:12:53 +01:00
|
|
|
NSArray *allMessages;
|
2014-03-06 20:16:08 +01:00
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
int j, k, return_count;
|
|
|
|
BOOL found_in_cache;
|
2014-03-06 20:16:08 +01:00
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
allMessages = [theCollection syncTokenFieldsWithProperties: nil matchingSyncToken: theSyncKey fromDate: theFilterType];
|
2014-02-17 14:46:05 +01:00
|
|
|
max = [allMessages count];
|
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
allCacheObjects = [NSMutableArray array];
|
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
for (i = 0; i < max; i++)
|
2014-01-10 20:12:53 +01:00
|
|
|
{
|
2014-05-15 21:03:24 +02:00
|
|
|
[allCacheObjects addObject: [SOGoSyncCacheObject syncCacheObjectWithUID: [[[allMessages objectAtIndex: i] allKeys] lastObject]
|
|
|
|
sequence: [[[allMessages objectAtIndex: i] allValues] lastObject]]];
|
|
|
|
}
|
|
|
|
|
|
|
|
sortedBySequence = [[NSMutableArray alloc] initWithDictionary: syncCache];
|
|
|
|
[sortedBySequence sortUsingSelector: @selector(compareSequence:)];
|
|
|
|
[sortedBySequence autorelease];
|
|
|
|
|
|
|
|
[allCacheObjects sortUsingSelector: @selector(compareSequence:)];
|
|
|
|
|
|
|
|
//NSLog(@"sortedBySequence (%d) - lastObject: %@", [sortedBySequence count], [sortedBySequence lastObject]);
|
|
|
|
//NSLog(@"allCacheObjects (%d) - lastObject: %@", [allCacheObjects count], [allCacheObjects lastObject]);
|
|
|
|
|
|
|
|
lastCacheObject = [sortedBySequence lastObject];
|
|
|
|
|
|
|
|
if ([folderMetadata objectForKey: @"MoreAvailable"] && lastCacheObject)
|
|
|
|
{
|
|
|
|
for (j = 0; j < [allCacheObjects count]; j++)
|
2014-01-10 20:12:53 +01:00
|
|
|
{
|
2014-05-15 21:03:24 +02:00
|
|
|
if ([[lastCacheObject uid] isEqual: [[allCacheObjects objectAtIndex: j] uid]])
|
|
|
|
{
|
|
|
|
// Found out where we're at, let's continue from there...
|
|
|
|
found_in_cache = YES;
|
|
|
|
break;
|
|
|
|
}
|
2014-03-06 20:16:08 +01:00
|
|
|
}
|
|
|
|
}
|
2014-05-15 21:03:24 +02:00
|
|
|
else
|
|
|
|
found_in_cache = NO;
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
if (found_in_cache)
|
|
|
|
k = j+1;
|
|
|
|
else
|
2014-03-06 20:16:08 +01:00
|
|
|
{
|
2014-05-15 21:03:24 +02:00
|
|
|
k = 0;
|
|
|
|
j = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
//NSLog(@"found in cache: %d k = %d", found_in_cache, k);
|
|
|
|
|
|
|
|
return_count = 0;
|
|
|
|
|
|
|
|
for (; k < [allCacheObjects count]; k++)
|
|
|
|
{
|
2014-12-04 17:27:10 +01:00
|
|
|
pool = [[NSAutoreleasePool alloc] init];
|
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
// Check for the WindowSize and slice accordingly
|
2014-12-22 17:50:51 +01:00
|
|
|
if (return_count >= theWindowSize || (theMaxSyncResponseSize > 0 && [s length] >= theMaxSyncResponseSize))
|
2014-03-19 16:31:54 +01:00
|
|
|
{
|
2014-05-15 21:03:24 +02:00
|
|
|
NSString *lastSequence;
|
|
|
|
more_available = YES;
|
|
|
|
|
|
|
|
lastSequence = ([[aCacheObject sequence] isEqual: [NSNull null]] ? @"1" : [aCacheObject sequence]);
|
2014-12-04 17:27:10 +01:00
|
|
|
*theLastServerKey = [[NSString alloc] initWithFormat: @"%@-%@", [aCacheObject uid], lastSequence];
|
2014-05-15 21:03:24 +02:00
|
|
|
//NSLog(@"Reached windowSize - lastUID will be: %@", *theLastServerKey);
|
2014-12-04 17:27:10 +01:00
|
|
|
DESTROY(pool);
|
2014-05-15 21:03:24 +02:00
|
|
|
break;
|
2014-03-19 16:31:54 +01:00
|
|
|
}
|
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
aCacheObject = [allCacheObjects objectAtIndex: k];
|
|
|
|
|
|
|
|
// If found in cache, it's either a Change or a Delete
|
|
|
|
if ([syncCache objectForKey: [aCacheObject uid]])
|
|
|
|
{
|
|
|
|
if ([[aCacheObject sequence] isEqual: [NSNull null]])
|
|
|
|
{
|
|
|
|
// Deleted
|
|
|
|
[s appendString: @"<Delete xmlns=\"AirSync:\">"];
|
|
|
|
[s appendFormat: @"<ServerId xmlns=\"AirSync:\">%@</ServerId>", [aCacheObject uid]];
|
|
|
|
[s appendString: @"</Delete>"];
|
|
|
|
|
|
|
|
[syncCache removeObjectForKey: [aCacheObject uid]];
|
2014-05-27 20:44:57 +02:00
|
|
|
[dateCache removeObjectForKey: [aCacheObject uid]];
|
2014-05-15 21:03:24 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Changed
|
|
|
|
outlook_hack:
|
|
|
|
mailObject = [theCollection lookupName: [aCacheObject uid]
|
|
|
|
inContext: context
|
|
|
|
acquire: 0];
|
|
|
|
|
|
|
|
[s appendString: @"<Change xmlns=\"AirSync:\">"];
|
|
|
|
[s appendFormat: @"<ServerId xmlns=\"AirSync:\">%@</ServerId>", [aCacheObject uid]];
|
|
|
|
[s appendString: @"<ApplicationData xmlns=\"AirSync:\">"];
|
|
|
|
[s appendString: [mailObject activeSyncRepresentationInContext: context]];
|
|
|
|
[s appendString: @"</ApplicationData>"];
|
|
|
|
[s appendString: @"</Change>"];
|
|
|
|
|
|
|
|
[syncCache setObject: [aCacheObject sequence] forKey: [aCacheObject uid]];
|
|
|
|
}
|
|
|
|
|
|
|
|
return_count++;
|
|
|
|
}
|
2014-03-06 20:16:08 +01:00
|
|
|
else
|
|
|
|
{
|
2014-05-15 21:03:24 +02:00
|
|
|
// Added
|
|
|
|
if (![[aCacheObject sequence] isEqual: [NSNull null]])
|
|
|
|
{
|
|
|
|
NSString *key;
|
|
|
|
|
|
|
|
// We check for Outlook stupidity to avoid creating duplicates - see the comment
|
|
|
|
// in SOGoActiveSyncDispatcher.m: -processMoveItems:inResponse: for more details.
|
|
|
|
key = [NSString stringWithFormat: @"%@+%@+%@+%@",
|
|
|
|
[[context activeUser] login],
|
|
|
|
[context objectForKey: @"DeviceType"],
|
|
|
|
[theCollection displayName],
|
|
|
|
[aCacheObject uid]];
|
|
|
|
|
|
|
|
if ([[SOGoCache sharedCache] valueForKey: key])
|
|
|
|
{
|
|
|
|
[[SOGoCache sharedCache] removeValueForKey: key];
|
|
|
|
goto outlook_hack;
|
|
|
|
}
|
|
|
|
|
|
|
|
mailObject = [theCollection lookupName: [aCacheObject uid]
|
|
|
|
inContext: context
|
|
|
|
acquire: 0];
|
|
|
|
|
|
|
|
[s appendString: @"<Add xmlns=\"AirSync:\">"];
|
|
|
|
[s appendFormat: @"<ServerId xmlns=\"AirSync:\">%@</ServerId>", [aCacheObject uid]];
|
|
|
|
[s appendString: @"<ApplicationData xmlns=\"AirSync:\">"];
|
|
|
|
[s appendString: [mailObject activeSyncRepresentationInContext: context]];
|
|
|
|
[s appendString: @"</ApplicationData>"];
|
|
|
|
[s appendString: @"</Add>"];
|
|
|
|
|
|
|
|
[syncCache setObject: [aCacheObject sequence] forKey: [aCacheObject uid]];
|
|
|
|
[dateCache setObject: [NSCalendarDate date] forKey: [aCacheObject uid]];
|
|
|
|
return_count++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//NSLog(@"skipping old deleted UID: %@", [aCacheObject uid]);
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
2014-05-27 20:44:57 +02:00
|
|
|
|
2014-12-04 17:27:10 +01:00
|
|
|
DESTROY(pool);
|
|
|
|
} // for (; k < ...)
|
2014-05-27 20:44:57 +02:00
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
if (more_available)
|
2014-06-10 17:04:27 +02:00
|
|
|
{
|
|
|
|
[folderMetadata setObject: [NSNumber numberWithBool: YES] forKey: @"MoreAvailable"];
|
|
|
|
[folderMetadata setObject: *theLastServerKey forKey: @"SyncKey"];
|
|
|
|
}
|
2014-05-15 21:03:24 +02:00
|
|
|
else
|
2014-06-10 17:04:27 +02:00
|
|
|
{
|
|
|
|
[folderMetadata removeObjectForKey: @"MoreAvailable"];
|
2015-03-23 22:23:29 +01:00
|
|
|
[folderMetadata setObject: davCollectionTagToStore forKey: @"SyncKey"];
|
2014-06-10 17:04:27 +02:00
|
|
|
}
|
2014-05-15 21:03:24 +02:00
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
[self _setFolderMetadata: folderMetadata forKey: [self _getNameInCache: theCollection withType: theFolderType]];
|
2014-12-04 17:27:10 +01:00
|
|
|
RELEASE(*theLastServerKey);
|
|
|
|
|
2014-05-15 21:03:24 +02:00
|
|
|
} // default:
|
2014-01-10 20:12:53 +01:00
|
|
|
break;
|
|
|
|
} // switch (folderType) ...
|
|
|
|
|
2014-06-25 21:05:25 +02:00
|
|
|
return_response:
|
|
|
|
|
2014-01-22 17:02:12 +01:00
|
|
|
if ([s length])
|
|
|
|
{
|
|
|
|
[theBuffer appendString: @"<Commands>"];
|
|
|
|
[theBuffer appendString: s];
|
|
|
|
[theBuffer appendString: @"</Commands>"];
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// We have something like this:
|
|
|
|
//
|
|
|
|
// <Commands>
|
|
|
|
// <Fetch>
|
|
|
|
// <ServerId>91</ServerId>
|
|
|
|
// </Fetch>
|
|
|
|
// </Commands>
|
|
|
|
//
|
|
|
|
- (void) processSyncCommands: (id <DOMElement>) theDocumentElement
|
|
|
|
inCollection: (id) theCollection
|
|
|
|
withType: (SOGoMicrosoftActiveSyncFolderType) theFolderType
|
|
|
|
inBuffer: (NSMutableString *) theBuffer
|
|
|
|
processed: (BOOL *) processed
|
|
|
|
{
|
|
|
|
id <DOMNodeList> aCommandDetails;
|
|
|
|
id <DOMElement> aCommand, element;
|
|
|
|
NSArray *allCommands;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
allCommands = (id)[theDocumentElement getElementsByTagName: @"Commands"];
|
|
|
|
|
|
|
|
for (i = 0; i < [allCommands count]; i++)
|
|
|
|
{
|
|
|
|
aCommand = [allCommands objectAtIndex: i];
|
|
|
|
aCommandDetails = [aCommand childNodes];
|
|
|
|
|
|
|
|
for (j = 0; j < [(id)aCommandDetails count]; j++)
|
|
|
|
{
|
|
|
|
element = [aCommandDetails objectAtIndex: j];
|
|
|
|
|
|
|
|
if ([element nodeType] == DOM_ELEMENT_NODE)
|
|
|
|
{
|
|
|
|
if ([[element tagName] isEqualToString: @"Add"])
|
|
|
|
{
|
|
|
|
// Add
|
2015-01-15 17:55:04 +01:00
|
|
|
[self processSyncAddCommand: element
|
2014-01-10 20:12:53 +01:00
|
|
|
inCollection: theCollection
|
|
|
|
withType: theFolderType
|
|
|
|
inBuffer: theBuffer];
|
|
|
|
*processed = YES;
|
|
|
|
}
|
|
|
|
else if ([[element tagName] isEqualToString: @"Change"])
|
|
|
|
{
|
|
|
|
// Change
|
2015-01-15 17:55:04 +01:00
|
|
|
[self processSyncChangeCommand: element
|
2014-01-10 20:12:53 +01:00
|
|
|
inCollection: theCollection
|
|
|
|
withType: theFolderType
|
|
|
|
inBuffer: theBuffer];
|
|
|
|
*processed = YES;
|
|
|
|
}
|
|
|
|
else if ([[element tagName] isEqualToString: @"Delete"])
|
|
|
|
{
|
|
|
|
// Delete
|
2015-01-15 17:55:04 +01:00
|
|
|
[self processSyncDeleteCommand: element
|
2014-01-10 20:12:53 +01:00
|
|
|
inCollection: theCollection
|
|
|
|
withType: theFolderType
|
|
|
|
inBuffer: theBuffer];
|
2014-10-29 16:13:18 +01:00
|
|
|
*processed = YES;
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
else if ([[element tagName] isEqualToString: @"Fetch"])
|
|
|
|
{
|
|
|
|
// Fetch
|
2015-01-15 17:55:04 +01:00
|
|
|
[self processSyncFetchCommand: element
|
2014-01-10 20:12:53 +01:00
|
|
|
inCollection: theCollection
|
|
|
|
withType: theFolderType
|
|
|
|
inBuffer: theBuffer];
|
2014-01-14 16:09:10 +01:00
|
|
|
*processed = YES;
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
- (void) processSyncCollection: (id <DOMElement>) theDocumentElement
|
|
|
|
inBuffer: (NSMutableString *) theBuffer
|
2014-02-04 17:19:33 +01:00
|
|
|
changeDetected: (BOOL *) changeDetected
|
2014-12-22 17:50:51 +01:00
|
|
|
maxSyncResponseSize: (int) theMaxSyncResponseSize
|
2014-01-10 20:12:53 +01:00
|
|
|
{
|
2015-03-30 15:49:44 +02:00
|
|
|
NSString *collectionId, *realCollectionId, *syncKey, *davCollectionTag, *bodyPreferenceType, *mimeSupport, *lastServerKey, *syncKeyInCache;
|
2014-01-10 20:12:53 +01:00
|
|
|
SOGoMicrosoftActiveSyncFolderType folderType;
|
2014-01-14 17:41:26 +01:00
|
|
|
id collection, value;
|
2014-01-28 19:51:21 +01:00
|
|
|
|
|
|
|
NSMutableString *changeBuffer, *commandsBuffer;
|
2014-01-10 20:12:53 +01:00
|
|
|
BOOL getChanges, first_sync;
|
2014-11-14 15:13:14 +01:00
|
|
|
unsigned int windowSize, v, status;
|
2015-03-30 15:49:44 +02:00
|
|
|
NSMutableDictionary *folderMetadata, *folderOptions;
|
2014-01-28 19:51:21 +01:00
|
|
|
|
|
|
|
changeBuffer = [NSMutableString string];
|
|
|
|
commandsBuffer = [NSMutableString string];
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
collectionId = [[(id)[theDocumentElement getElementsByTagName: @"CollectionId"] lastObject] textValue];
|
|
|
|
realCollectionId = [collectionId realCollectionIdWithFolderType: &folderType];
|
2014-05-27 20:44:57 +02:00
|
|
|
realCollectionId = [self globallyUniqueIDToIMAPFolderName: realCollectionId type: folderType];
|
2014-01-10 20:12:53 +01:00
|
|
|
collection = [self collectionFromId: realCollectionId type: folderType];
|
|
|
|
|
2014-01-28 19:51:21 +01:00
|
|
|
syncKey = davCollectionTag = [[(id)[theDocumentElement getElementsByTagName: @"SyncKey"] lastObject] textValue];
|
2014-10-29 19:20:03 +01:00
|
|
|
|
|
|
|
if (collection == nil)
|
|
|
|
{
|
|
|
|
// Collection not found - next folderSync will do the cleanup
|
|
|
|
//NSLog(@"Sync Collection not found %@ %@", collectionId, realCollectionId);
|
2014-11-26 21:27:36 +01:00
|
|
|
//Outlook doesn't like following response
|
|
|
|
//[theBuffer appendString: @"<Collection>"];
|
|
|
|
//[theBuffer appendFormat: @"<SyncKey>%@</SyncKey>", syncKey];
|
|
|
|
//[theBuffer appendFormat: @"<CollectionId>%@</CollectionId>", collectionId];
|
|
|
|
//[theBuffer appendFormat: @"<Status>%d</Status>", 8];
|
|
|
|
//[theBuffer appendString: @"</Collection>"];
|
2014-10-29 19:20:03 +01:00
|
|
|
return;
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-02-17 14:46:05 +01:00
|
|
|
// We check for a window size, default to 100 if not specfied or out of bounds
|
|
|
|
windowSize = [[[(id)[theDocumentElement getElementsByTagName: @"WindowSize"] lastObject] textValue] intValue];
|
|
|
|
|
|
|
|
if (windowSize == 0 || windowSize > 512)
|
|
|
|
windowSize = 100;
|
2014-04-10 02:12:19 +02:00
|
|
|
|
|
|
|
// We check if we must overwrite the windowSize with a system preference. This can be useful
|
|
|
|
// if the user population has large mailboxes and slow connectivity
|
|
|
|
if ((v = [[SOGoSystemDefaults sharedSystemDefaults] maximumSyncWindowSize]))
|
|
|
|
windowSize = v;
|
2014-02-17 14:46:05 +01:00
|
|
|
|
|
|
|
lastServerKey = nil;
|
2014-11-14 15:13:14 +01:00
|
|
|
status = 1;
|
2014-02-17 14:46:05 +01:00
|
|
|
|
2014-01-14 17:41:26 +01:00
|
|
|
// From the documention, if GetChanges is missing, we must assume it's a YES.
|
|
|
|
// See http://msdn.microsoft.com/en-us/library/gg675447(v=exchg.80).aspx for all details.
|
|
|
|
value = [theDocumentElement getElementsByTagName: @"GetChanges"];
|
|
|
|
getChanges = YES;
|
|
|
|
|
2014-01-16 21:13:09 +01:00
|
|
|
if ([value count] && [[[value lastObject] textValue] length])
|
2014-01-14 17:41:26 +01:00
|
|
|
getChanges = [[[value lastObject] textValue] boolValue];
|
2014-01-16 21:13:09 +01:00
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
first_sync = NO;
|
|
|
|
|
2015-03-30 15:49:44 +02:00
|
|
|
folderMetadata = [self _folderMetadataForKey: [self _getNameInCache: collection withType: folderType]];
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
if ([syncKey isEqualToString: @"0"])
|
|
|
|
{
|
|
|
|
davCollectionTag = @"-1";
|
|
|
|
first_sync = YES;
|
2014-02-04 17:19:33 +01:00
|
|
|
*changeDetected = YES;
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
2015-03-30 15:49:44 +02:00
|
|
|
else if ((![syncKey isEqualToString: @"-1"]) && !([folderMetadata objectForKey: @"SyncCache"]))
|
2014-11-14 15:13:14 +01:00
|
|
|
{
|
|
|
|
//NSLog(@"Reset folder: %@", [collection nameInContainer]);
|
|
|
|
davCollectionTag = @"0";
|
|
|
|
first_sync = YES;
|
|
|
|
*changeDetected = YES;
|
|
|
|
|
2015-03-30 15:49:44 +02:00
|
|
|
if (!([folderMetadata objectForKey: @"displayName"]))
|
2014-12-08 16:45:34 +01:00
|
|
|
status = 12; // need folderSync
|
2014-11-14 15:13:14 +01:00
|
|
|
else
|
|
|
|
status = 3; // do a complete resync
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
|
|
|
|
// We check our sync preferences and we stash them
|
|
|
|
bodyPreferenceType = [[(id)[[(id)[theDocumentElement getElementsByTagName: @"BodyPreference"] lastObject] getElementsByTagName: @"Type"] lastObject] textValue];
|
|
|
|
|
|
|
|
if (!bodyPreferenceType)
|
2015-03-30 15:49:44 +02:00
|
|
|
{
|
|
|
|
bodyPreferenceType = [[folderMetadata objectForKey: @"FolderOptions"] objectForKey: @"BodyPreferenceType"];
|
|
|
|
|
|
|
|
// By default, send MIME mails. See #3146 for details.
|
|
|
|
if (!bodyPreferenceType)
|
|
|
|
bodyPreferenceType = @"4";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
mimeSupport = [[(id)[theDocumentElement getElementsByTagName: @"MIMESupport"] lastObject] textValue];
|
|
|
|
|
|
|
|
if (!mimeSupport)
|
|
|
|
mimeSupport = [[folderMetadata objectForKey: @"FolderOptions"] objectForKey: @"MIMESupport"];
|
|
|
|
|
|
|
|
if (!mimeSupport)
|
|
|
|
mimeSupport = @"0";
|
|
|
|
|
|
|
|
if ([mimeSupport isEqualToString: @"1"] && [bodyPreferenceType isEqualToString: @"4"])
|
|
|
|
bodyPreferenceType = @"2";
|
|
|
|
else if ([mimeSupport isEqualToString: @"2"] && [bodyPreferenceType isEqualToString: @"4"])
|
|
|
|
bodyPreferenceType = @"4";
|
|
|
|
else if ([mimeSupport isEqualToString: @"0"] && [bodyPreferenceType isEqualToString: @"4"])
|
|
|
|
bodyPreferenceType = @"2";
|
|
|
|
|
|
|
|
|
|
|
|
// Avoid writing to cache if there is nothing to change.
|
|
|
|
if (![[[folderMetadata objectForKey: @"FolderOptions"] objectForKey: @"BodyPreferenceType"] isEqualToString: bodyPreferenceType] ||
|
|
|
|
![[[folderMetadata objectForKey: @"FolderOptions"] objectForKey: @"MIMESupport"] isEqualToString: mimeSupport])
|
|
|
|
{
|
|
|
|
folderOptions = [[NSDictionary alloc] initWithObjectsAndKeys: mimeSupport, @"MIMESupport", bodyPreferenceType, @"BodyPreferenceType", nil];
|
|
|
|
[folderMetadata setObject: folderOptions forKey: @"FolderOptions"];
|
|
|
|
[self _setFolderMetadata: folderMetadata forKey: [self _getNameInCache: collection withType: folderType]];
|
|
|
|
}
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
|
|
|
|
[context setObject: bodyPreferenceType forKey: @"BodyPreferenceType"];
|
|
|
|
|
|
|
|
// We generate the commands, if any, for the response. We might also have
|
|
|
|
// generated some in processSyncCommand:inResponse: as we could have
|
|
|
|
// received a Fetch command
|
|
|
|
if (getChanges && !first_sync)
|
|
|
|
{
|
|
|
|
[self processSyncGetChanges: theDocumentElement
|
|
|
|
inCollection: collection
|
2014-02-17 14:46:05 +01:00
|
|
|
withWindowSize: windowSize
|
2014-12-22 17:50:51 +01:00
|
|
|
withMaxSyncResponseSize: theMaxSyncResponseSize
|
2014-01-10 20:12:53 +01:00
|
|
|
withSyncKey: syncKey
|
2014-01-16 21:13:09 +01:00
|
|
|
withFolderType: folderType
|
2014-01-20 16:13:16 +01:00
|
|
|
withFilterType: [NSCalendarDate dateFromFilterType: [[(id)[theDocumentElement getElementsByTagName: @"FilterType"] lastObject] textValue]]
|
2014-02-17 14:46:05 +01:00
|
|
|
inBuffer: changeBuffer
|
|
|
|
lastServerKey: &lastServerKey];
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// We process the commands from the request
|
|
|
|
//
|
|
|
|
if (!first_sync)
|
|
|
|
{
|
|
|
|
NSMutableString *s;
|
|
|
|
BOOL processed;
|
|
|
|
|
|
|
|
s = [NSMutableString string];
|
|
|
|
processed = NO;
|
|
|
|
|
|
|
|
[self processSyncCommands: theDocumentElement
|
|
|
|
inCollection: collection
|
|
|
|
withType: folderType
|
|
|
|
inBuffer: s
|
|
|
|
processed: &processed];
|
|
|
|
|
2014-10-16 15:08:50 +02:00
|
|
|
// Windows phons don't empty Responses tags - such as: <Responses></Responses>.
|
|
|
|
// We onnly generate this tag when the command has generated a response.
|
|
|
|
if (processed && [s length])
|
2014-01-28 19:51:21 +01:00
|
|
|
[commandsBuffer appendFormat: @"<Responses>%@</Responses>", s];
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
|
2015-01-28 21:03:49 +01:00
|
|
|
folderMetadata = [self _folderMetadataForKey: [self _getNameInCache: collection withType: folderType]];
|
|
|
|
|
2014-01-28 19:51:21 +01:00
|
|
|
// If we got any changes or if we have applied any commands
|
|
|
|
// let's regenerate our SyncKey based on the collection tag.
|
|
|
|
if ([changeBuffer length] || [commandsBuffer length])
|
2014-02-04 17:19:33 +01:00
|
|
|
{
|
2014-02-17 14:46:05 +01:00
|
|
|
if (lastServerKey)
|
2014-05-15 21:03:24 +02:00
|
|
|
davCollectionTag = lastServerKey;
|
2014-10-29 19:20:03 +01:00
|
|
|
else
|
|
|
|
{
|
2014-11-14 15:13:14 +01:00
|
|
|
// Use the SyncKey saved by processSyncGetChanges - if processSyncGetChanges is not called (because of getChanges=false)
|
|
|
|
// SyncKey has the value of the previous sync operation.
|
2015-01-28 21:03:49 +01:00
|
|
|
davCollectionTag = [folderMetadata objectForKey: @"SyncKey"];
|
2014-10-29 19:20:03 +01:00
|
|
|
|
2014-11-14 15:13:14 +01:00
|
|
|
if (!davCollectionTag)
|
2014-10-29 19:20:03 +01:00
|
|
|
davCollectionTag = [collection davCollectionTag];
|
|
|
|
}
|
|
|
|
|
2014-02-04 17:19:33 +01:00
|
|
|
*changeDetected = YES;
|
|
|
|
}
|
2014-05-15 21:03:24 +02:00
|
|
|
else
|
|
|
|
{
|
2015-01-28 21:03:49 +01:00
|
|
|
// Make sure that client is updated with the right syncKey. - This keeps vtodo's and vevent's syncKey in sync.
|
|
|
|
syncKeyInCache = [folderMetadata objectForKey: @"SyncKey"];
|
2015-02-26 23:55:36 +01:00
|
|
|
if (syncKeyInCache && !([davCollectionTag isEqualToString:syncKeyInCache]) && ![davCollectionTag isEqualToString: @"-1"])
|
2015-01-28 21:03:49 +01:00
|
|
|
{
|
|
|
|
davCollectionTag = syncKeyInCache;
|
|
|
|
*changeDetected = YES;
|
|
|
|
}
|
2014-05-15 21:03:24 +02:00
|
|
|
}
|
2014-01-28 19:51:21 +01:00
|
|
|
|
|
|
|
// Generate the response buffer
|
|
|
|
[theBuffer appendString: @"<Collection>"];
|
|
|
|
|
|
|
|
if (folderType == ActiveSyncMailFolder)
|
|
|
|
[theBuffer appendString: @"<Class>Email</Class>"];
|
|
|
|
else if (folderType == ActiveSyncContactFolder)
|
|
|
|
[theBuffer appendString: @"<Class>Contacts</Class>"];
|
|
|
|
else if (folderType == ActiveSyncEventFolder)
|
|
|
|
[theBuffer appendString: @"<Class>Calendar</Class>"];
|
|
|
|
else if (folderType == ActiveSyncTaskFolder)
|
|
|
|
[theBuffer appendString: @"<Class>Tasks</Class>"];
|
|
|
|
|
|
|
|
[theBuffer appendFormat: @"<SyncKey>%@</SyncKey>", davCollectionTag];
|
|
|
|
[theBuffer appendFormat: @"<CollectionId>%@</CollectionId>", collectionId];
|
2014-11-14 15:13:14 +01:00
|
|
|
[theBuffer appendFormat: @"<Status>%d</Status>", status];
|
|
|
|
|
|
|
|
// MoreAvailable breaks Windows Mobile devices if not between <Status> and <Commands>
|
|
|
|
// https://social.msdn.microsoft.com/Forums/en-US/040b254e-f47e-4cc1-a397-6d8393cdb819/airsyncmoreavailable-breaks-windows-mobile-devices-what-am-i-doing-wrong?forum=os_exchangeprotocols
|
2015-01-28 21:03:49 +01:00
|
|
|
if ([folderMetadata objectForKey: @"MoreAvailable"])
|
2014-11-14 15:13:14 +01:00
|
|
|
[theBuffer appendString: @"<MoreAvailable/>"];
|
2014-01-28 19:51:21 +01:00
|
|
|
|
|
|
|
[theBuffer appendString: commandsBuffer];
|
2014-10-29 16:13:18 +01:00
|
|
|
[theBuffer appendString: changeBuffer];
|
2014-01-28 19:51:21 +01:00
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
[theBuffer appendString: @"</Collection>"];
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Initial folder sync:
|
|
|
|
//
|
|
|
|
// <?xml version="1.0"?>
|
|
|
|
// <!DOCTYPE ActiveSync PUBLIC "-//MICROSOFT//DTD ActiveSync//EN" "http://www.microsoft.com/">
|
|
|
|
// <Sync xmlns="AirSync:">
|
|
|
|
// <Collections>
|
|
|
|
// <Collection>
|
|
|
|
// <SyncKey>0</SyncKey>
|
|
|
|
// <CollectionId>folderINBOX</CollectionId>
|
|
|
|
// </Collection>
|
|
|
|
// </Collections>
|
|
|
|
// </Sync>
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// Following this will be a GetItemEstimate call. Following our response to the GetItemEstimate, we'll
|
|
|
|
// have a new Sync call like this:
|
|
|
|
//
|
|
|
|
// <?xml version="1.0"?>
|
|
|
|
// <!DOCTYPE ActiveSync PUBLIC "-//MICROSOFT//DTD ActiveSync//EN" "http://www.microsoft.com/">
|
|
|
|
// <Sync xmlns="AirSync:">
|
|
|
|
// <Collections>
|
|
|
|
// <Collection>
|
|
|
|
// <SyncKey>1</SyncKey>
|
|
|
|
// <CollectionId>folderINBOX</CollectionId>
|
|
|
|
// <DeletesAsMoves>1</DeletesAsMoves>
|
|
|
|
// <GetChanges/>
|
|
|
|
// <WindowSize>50</WindowSize>
|
|
|
|
// <Options>
|
|
|
|
// <FilterType>5</FilterType> -- http://msdn.microsoft.com/en-us/library/gg709713(v=exchg.80).aspx
|
|
|
|
// <BodyPreference xmlns="AirSyncBase:"> -- http://msdn.microsoft.com/en-us/library/ee218197(v=exchg.80).aspx
|
|
|
|
// <Type>2</Type> --
|
|
|
|
// <TruncationSize>51200</TruncationSize>
|
|
|
|
// </BodyPreference>
|
|
|
|
// <BodyPreference xmlns="AirSyncBase:">
|
|
|
|
// <Type>4</Type>
|
|
|
|
// </BodyPreference>
|
|
|
|
// </Options>
|
|
|
|
// </Collection>
|
|
|
|
// </Collections>
|
|
|
|
// </Sync>
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// When adding a new task, we might have something like this:
|
|
|
|
//
|
|
|
|
// <?xml version="1.0"?>
|
|
|
|
// <!DOCTYPE ActiveSync PUBLIC "-//MICROSOFT//DTD ActiveSync//EN" "http://www.microsoft.com/">
|
|
|
|
// <Sync xmlns="AirSync:">
|
|
|
|
// <Collections>
|
|
|
|
// <Collection>
|
|
|
|
// <SyncKey>1</SyncKey>
|
|
|
|
// <CollectionId>personal</CollectionId>
|
|
|
|
// <DeletesAsMoves/>
|
|
|
|
// <GetChanges/> -- http://msdn.microsoft.com/en-us/library/gg675447(v=exchg.80).aspx
|
|
|
|
// <WindowSize>5</WindowSize> -- http://msdn.microsoft.com/en-us/library/gg650865(v=exchg.80).aspx
|
|
|
|
// <Options>
|
|
|
|
// <BodyPreference xmlns="AirSyncBase:"> -- http://msdn.microsoft.com/en-us/library/ee218197(v=exchg.80).aspx
|
|
|
|
// <Type>1</Type>
|
|
|
|
// <TruncationSize>400000</TruncationSize>
|
|
|
|
// </BodyPreference>
|
|
|
|
// </Options>
|
|
|
|
// <Commands>
|
|
|
|
// <Add>
|
|
|
|
// <ClientId>new_task_1386614771261</ClientId>
|
|
|
|
// <ApplicationData>
|
|
|
|
// <Body xmlns="AirSyncBase:">
|
|
|
|
// <Type>1</Type>
|
|
|
|
// <EstimatedDataSize>6</EstimatedDataSize>
|
|
|
|
// <Data>tomate</Data>
|
|
|
|
// </Body>
|
|
|
|
// <Subject xmlns="Tasks:">test 1</Subject>
|
|
|
|
// <Importance xmlns="Tasks:">1</Importance>
|
|
|
|
// <UTCDueDate xmlns="Tasks:">2013-12-09T19:00:00.000Z</UTCDueDate>
|
|
|
|
// <Complete xmlns="Tasks:">0</Complete>
|
|
|
|
// <ReminderSet xmlns="Tasks:">0</ReminderSet>
|
|
|
|
// <DueDate xmlns="Tasks:">2013-12-09T19:00:00.000Z</DueDate>
|
|
|
|
// </ApplicationData>
|
|
|
|
// </Add>
|
|
|
|
// </Commands>
|
|
|
|
// </Collection>
|
|
|
|
// </Collections>
|
|
|
|
// </Sync>
|
|
|
|
//
|
|
|
|
// The algorithm here is pretty simple:
|
|
|
|
//
|
|
|
|
// 1. extract the list of collections
|
|
|
|
// 2. for each collection
|
|
|
|
// 2.1. extract the metadata (id, synckey, etc.)
|
|
|
|
// 2.2. extract the list of commands
|
|
|
|
// 2.3. for each command
|
|
|
|
// 2.3.1 process the command (add/change/delete/fetch)
|
|
|
|
// 2.3.2 build a response during the processsing
|
|
|
|
//
|
|
|
|
//
|
|
|
|
- (void) processSync: (id <DOMElement>) theDocumentElement
|
|
|
|
inResponse: (WOResponse *) theResponse
|
|
|
|
{
|
2014-02-11 02:16:43 +01:00
|
|
|
SOGoSystemDefaults *defaults;
|
2014-01-10 20:12:53 +01:00
|
|
|
id <DOMElement> aCollection;
|
2014-02-04 17:19:33 +01:00
|
|
|
NSMutableString *output, *s;
|
2014-02-11 02:16:43 +01:00
|
|
|
NSArray *allCollections;
|
2014-01-10 20:12:53 +01:00
|
|
|
NSData *d;
|
|
|
|
|
2014-12-22 17:50:51 +01:00
|
|
|
int i, j, defaultInterval, heartbeatInterval, internalInterval, maxSyncResponseSize;
|
2014-02-04 17:19:33 +01:00
|
|
|
BOOL changeDetected;
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-12-22 17:50:51 +01:00
|
|
|
changeDetected = NO;
|
|
|
|
|
|
|
|
maxSyncResponseSize = [[SOGoSystemDefaults sharedSystemDefaults] maximumSyncResponseSize];
|
|
|
|
|
2014-01-10 20:12:53 +01:00
|
|
|
// We initialize our output buffer
|
2014-12-04 17:27:10 +01:00
|
|
|
output = [[NSMutableString alloc] init];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-02-04 17:19:33 +01:00
|
|
|
[output appendString: @"<?xml version=\"1.0\" encoding=\"utf-8\"?>"];
|
|
|
|
[output appendString: @"<!DOCTYPE ActiveSync PUBLIC \"-//MICROSOFT//DTD ActiveSync//EN\" \"http://www.microsoft.com/\">"];
|
|
|
|
[output appendString: @"<Sync xmlns=\"AirSync:\">"];
|
2014-12-22 14:36:55 +01:00
|
|
|
|
|
|
|
//
|
|
|
|
// We don't support yet empty Sync requests. See: http://msdn.microsoft.com/en-us/library/ee203280(v=exchg.80).aspx
|
|
|
|
// We return '13' - see http://msdn.microsoft.com/en-us/library/gg675457(v=exchg.80).aspx
|
|
|
|
//
|
|
|
|
if (!theDocumentElement || [[(id)[theDocumentElement getElementsByTagName: @"Partial"] lastObject] textValue])
|
|
|
|
{
|
|
|
|
[output appendString: @"<Status>13</Status>"];
|
|
|
|
[output appendString: @"</Sync>"];
|
|
|
|
d = [[output dataUsingEncoding: NSUTF8StringEncoding] xml2wbxml];
|
|
|
|
[theResponse setContent: d];
|
|
|
|
return;
|
|
|
|
}
|
2014-02-11 02:16:43 +01:00
|
|
|
|
|
|
|
defaults = [SOGoSystemDefaults sharedSystemDefaults];
|
2014-02-04 17:19:33 +01:00
|
|
|
heartbeatInterval = [[[(id)[theDocumentElement getElementsByTagName: @"HeartbeatInterval"] lastObject] textValue] intValue];
|
2014-02-11 02:16:43 +01:00
|
|
|
defaultInterval = [defaults maximumSyncInterval];
|
|
|
|
internalInterval = [defaults internalSyncInterval];
|
2014-02-04 17:19:33 +01:00
|
|
|
|
2015-01-28 21:03:49 +01:00
|
|
|
// If the request doesn't contain "HeartbeatInterval" there is no reason to delay the response.
|
|
|
|
if (heartbeatInterval == 0)
|
|
|
|
heartbeatInterval = internalInterval = 1;
|
|
|
|
|
2014-02-04 17:19:33 +01:00
|
|
|
// We check to see if our heartbeat interval falls into the supported ranges.
|
2014-02-11 02:16:43 +01:00
|
|
|
if (heartbeatInterval > defaultInterval || heartbeatInterval < 1)
|
2014-02-04 17:19:33 +01:00
|
|
|
{
|
|
|
|
// Interval is too long, inform the client.
|
2014-02-11 02:16:43 +01:00
|
|
|
heartbeatInterval = defaultInterval;
|
2014-02-04 17:19:33 +01:00
|
|
|
|
2014-02-11 02:16:43 +01:00
|
|
|
// Outlook doesn't like this...
|
|
|
|
//[output appendFormat: @"<Limit>%d</Limit>", defaultInterval];
|
2014-02-04 17:19:33 +01:00
|
|
|
//[output appendFormat: @"<Status>%d</Status>", 14];
|
|
|
|
}
|
|
|
|
|
|
|
|
[output appendString: @"<Collections>"];
|
|
|
|
|
2014-01-13 22:24:15 +01:00
|
|
|
allCollections = (id)[theDocumentElement getElementsByTagName: @"Collection"];
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-02-04 17:19:33 +01:00
|
|
|
// We enter our loop detection change
|
2015-01-28 21:03:49 +01:00
|
|
|
for (i = 0; i < (heartbeatInterval/internalInterval); i++)
|
2014-01-10 20:12:53 +01:00
|
|
|
{
|
2014-02-04 17:19:33 +01:00
|
|
|
s = [NSMutableString string];
|
|
|
|
|
|
|
|
for (j = 0; j < [allCollections count]; j++)
|
|
|
|
{
|
|
|
|
aCollection = [allCollections objectAtIndex: j];
|
|
|
|
|
2014-12-22 17:50:51 +01:00
|
|
|
[self processSyncCollection: aCollection
|
|
|
|
inBuffer: s
|
|
|
|
changeDetected: &changeDetected
|
|
|
|
maxSyncResponseSize: maxSyncResponseSize];
|
2015-05-04 15:11:52 +02:00
|
|
|
|
|
|
|
if (maxSyncResponseSize > 0 && [s length] >= maxSyncResponseSize)
|
|
|
|
break;
|
2014-02-04 17:19:33 +01:00
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
|
2014-02-04 17:19:33 +01:00
|
|
|
if (changeDetected)
|
|
|
|
{
|
2015-01-22 19:31:31 +01:00
|
|
|
[self logWithFormat: @"Change detected, we push the content."];
|
2014-02-04 17:19:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2015-01-28 21:03:49 +01:00
|
|
|
else if (heartbeatInterval > 1)
|
2014-02-04 17:19:33 +01:00
|
|
|
{
|
2015-01-22 19:31:31 +01:00
|
|
|
[self logWithFormat: @"Sleeping %d seconds while detecting changes...", internalInterval];
|
2014-02-11 02:16:43 +01:00
|
|
|
sleep(internalInterval);
|
2014-02-04 17:19:33 +01:00
|
|
|
}
|
2015-01-28 21:03:49 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
|
2015-02-26 23:48:06 +01:00
|
|
|
|
|
|
|
// Only send a response if there are changes or MS-ASProtocolVersion is either 2.5 or 12.0 oterwise send an empty response.
|
|
|
|
if (changeDetected || [[[context request] headerForKey: @"MS-ASProtocolVersion"] isEqualToString: @"2.5"] || [[[context request] headerForKey: @"MS-ASProtocolVersion"] isEqualToString: @"12.0"])
|
2014-12-22 14:36:55 +01:00
|
|
|
{
|
|
|
|
// We always return the last generated response.
|
|
|
|
// If we only return <Sync><Collections/></Sync>,
|
|
|
|
// iOS powered devices will simply crash.
|
|
|
|
[output appendString: s];
|
|
|
|
|
|
|
|
[output appendString: @"</Collections></Sync>"];
|
2014-02-17 17:28:06 +01:00
|
|
|
|
2014-12-22 14:36:55 +01:00
|
|
|
d = [output dataUsingEncoding: NSUTF8StringEncoding];
|
|
|
|
d = [d xml2wbxml];
|
|
|
|
[theResponse setContent: d];
|
|
|
|
}
|
2014-12-04 17:27:10 +01:00
|
|
|
|
|
|
|
// Avoid overloading the autorelease pool here, as Sync command can
|
|
|
|
// generate fairly large responses.
|
|
|
|
RELEASE(output);
|
2014-01-10 20:12:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@end
|