3805 lines
124 KiB
Objective-C
3805 lines
124 KiB
Objective-C
/*
|
|
Copyright (C) 2007-2019 Inverse inc.
|
|
Copyright (C) 2004-2005 SKYRIX Software AG
|
|
|
|
This file is part of SOGo.
|
|
|
|
SOGo is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU Lesser General Public License as published by the
|
|
Free Software Foundation; either version 2, or (at your option) any
|
|
later version.
|
|
|
|
SOGo 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 Lesser General Public
|
|
License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with OGo; see the file COPYING. If not, write to the
|
|
Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
02111-1307, USA.
|
|
*/
|
|
|
|
#import <Foundation/NSCalendarDate.h>
|
|
|
|
#import <NGObjWeb/NSException+HTTP.h>
|
|
#import <NGObjWeb/SoObject+SoDAV.h>
|
|
#import <NGObjWeb/WOApplication.h>
|
|
#import <NGObjWeb/WOContext+SoObjects.h>
|
|
#import <NGExtensions/NSString+misc.h>
|
|
#import <GDLContentStore/GCSFolder.h>
|
|
#import <EOControl/EOQualifier.h>
|
|
#import <NGCards/iCalAlarm.h>
|
|
#import <NGCards/iCalFreeBusy.h>
|
|
#import <NGCards/iCalDateTime.h>
|
|
#import <NGCards/iCalRecurrenceCalculator.h>
|
|
#import <NGCards/iCalTimeZone.h>
|
|
#import <NGCards/iCalTimeZonePeriod.h>
|
|
#import <NGCards/iCalToDo.h>
|
|
#import <NGCards/NSString+NGCards.h>
|
|
#import <NGExtensions/NSCalendarDate+misc.h>
|
|
#import <NGExtensions/NGCalendarDateRange.h>
|
|
#import <NGExtensions/NSNull+misc.h>
|
|
#import <NGExtensions/NSObject+Logs.h>
|
|
#import <SaxObjC/XMLNamespaces.h>
|
|
|
|
#import <SOGo/DOMNode+SOGo.h>
|
|
#import <SOGo/NSArray+Utilities.h>
|
|
#import <SOGo/NSDictionary+Utilities.h>
|
|
#import <SOGo/NSObject+DAV.h>
|
|
#import <SOGo/NSString+Utilities.h>
|
|
#import <SOGo/SOGoBuild.h>
|
|
#import <SOGo/SOGoCache.h>
|
|
#import <SOGo/SOGoDomainDefaults.h>
|
|
#import <SOGo/SOGoPermissions.h>
|
|
#import <SOGo/SOGoUser.h>
|
|
#import <SOGo/SOGoUserSettings.h>
|
|
#import <SOGo/SOGoUserFolder.h>
|
|
#import <SOGo/SOGoUserManager.h>
|
|
#import <SOGo/SOGoWebDAVAclManager.h>
|
|
#import <SOGo/SOGoWebDAVValue.h>
|
|
#import <SOGo/WORequest+SOGo.h>
|
|
#import <SOGo/WOResponse+SOGo.h>
|
|
#import <SOGo/SOGoSource.h>
|
|
|
|
#import "iCalCalendar+SOGo.h"
|
|
#import "iCalRepeatableEntityObject+SOGo.h"
|
|
#import "iCalEvent+SOGo.h"
|
|
#import "iCalPerson+SOGo.h"
|
|
#import "SOGoAppointmentObject.h"
|
|
#import "SOGoAppointmentFolders.h"
|
|
#import "SOGoFreeBusyObject.h"
|
|
#import "SOGoTaskObject.h"
|
|
#import "SOGoWebAppointmentFolder.h"
|
|
|
|
#define defaultColor @"#AAAAAA"
|
|
|
|
@interface SOGoGCSFolder (SOGoPrivate)
|
|
|
|
- (void) appendObject: (NSDictionary *) object
|
|
properties: (NSString **) properties
|
|
count: (unsigned int) propertiesCount
|
|
withBaseURL: (NSString *) baseURL
|
|
toBuffer: (NSMutableString *) r;
|
|
|
|
@end
|
|
|
|
@implementation SOGoAppointmentFolder
|
|
|
|
static NSNumber *sharedYes = nil;
|
|
static Class iCalEventK = nil;
|
|
|
|
+ (void) initialize
|
|
{
|
|
static BOOL didInit = NO;
|
|
|
|
if (!didInit)
|
|
{
|
|
didInit = YES;
|
|
sharedYes = [[NSNumber numberWithBool: YES] retain];
|
|
[iCalEntityObject initializeSOGoExtensions];
|
|
|
|
iCalEventK = [iCalEvent class];
|
|
}
|
|
}
|
|
|
|
+ (SOGoWebDAVAclManager *) webdavAclManager
|
|
{
|
|
static SOGoWebDAVAclManager *aclManager = nil;
|
|
NSString *nsI;
|
|
|
|
if (!aclManager)
|
|
{
|
|
nsI = @"urn:inverse:params:xml:ns:inverse-dav";
|
|
|
|
aclManager = [SOGoWebDAVAclManager new];
|
|
[aclManager registerDAVPermission: davElement (@"read", XMLNS_WEBDAV)
|
|
abstract: YES
|
|
withEquivalent: SoPerm_WebDAVAccess
|
|
asChildOf: davElement (@"all", XMLNS_WEBDAV)];
|
|
[aclManager
|
|
registerDAVPermission: davElement (@"read-current-user-privilege-set", XMLNS_WEBDAV)
|
|
abstract: YES
|
|
withEquivalent: SoPerm_WebDAVAccess
|
|
asChildOf: davElement (@"read", XMLNS_WEBDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"read-free-busy", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: SOGoCalendarPerm_ReadFreeBusy
|
|
asChildOf: davElement (@"all", XMLNS_WEBDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"write", XMLNS_WEBDAV)
|
|
abstract: YES
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"all", XMLNS_WEBDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"bind", XMLNS_WEBDAV)
|
|
abstract: NO
|
|
withEquivalent: SoPerm_AddDocumentsImagesAndFiles
|
|
asChildOf: davElement (@"write", XMLNS_WEBDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"schedule",
|
|
XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"bind", XMLNS_WEBDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"schedule-post",
|
|
XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-post-vevent", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-post", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-post-vtodo", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-post", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-post-vjournal", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-post", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-post-vfreebusy", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-post", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"schedule-deliver",
|
|
XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-deliver-vevent", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-deliver", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-deliver-vtodo", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-deliver", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-deliver-vjournal", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-deliver", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-deliver-vfreebusy", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-deliver", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"schedule-respond",
|
|
XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-respond-vevent", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-respond", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission:
|
|
davElement (@"schedule-respond-vtodo", XMLNS_CALDAV)
|
|
abstract: NO
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"schedule-respond", XMLNS_CALDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"unbind", XMLNS_WEBDAV)
|
|
abstract: NO
|
|
withEquivalent: SoPerm_DeleteObjects
|
|
asChildOf: davElement (@"write", XMLNS_WEBDAV)];
|
|
[aclManager
|
|
registerDAVPermission: davElement (@"write-properties", XMLNS_WEBDAV)
|
|
abstract: NO
|
|
withEquivalent: SoPerm_ChangePermissions /* hackish */
|
|
asChildOf: davElement (@"write", XMLNS_WEBDAV)];
|
|
[aclManager
|
|
registerDAVPermission: davElement (@"write-content", XMLNS_WEBDAV)
|
|
abstract: NO
|
|
withEquivalent: SoPerm_AddDocumentsImagesAndFiles
|
|
asChildOf: davElement (@"write", XMLNS_WEBDAV)];
|
|
|
|
/* read-acl and write-acl are defined in RFC3744 */
|
|
[aclManager registerDAVPermission: davElement (@"admin", nsI)
|
|
abstract: YES
|
|
withEquivalent: nil
|
|
asChildOf: davElement (@"all", XMLNS_WEBDAV)];
|
|
[aclManager registerDAVPermission: davElement (@"read-acl", XMLNS_WEBDAV)
|
|
abstract: YES
|
|
withEquivalent: SOGoPerm_ReadAcls
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
[aclManager registerDAVPermission: davElement (@"write-acl", XMLNS_WEBDAV)
|
|
abstract: YES
|
|
withEquivalent: SoPerm_ChangePermissions
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
/* Default permissions for calendars. These are very important so that DAV client can
|
|
detect permission changes on calendars and reload all items, if necessary */
|
|
|
|
/* Public ones */
|
|
[aclManager registerDAVPermission: davElement (@"viewwhole-public-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ViewWholePublicRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"viewdant-public-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ViewDAndTOfPublicRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"modify-public-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ModifyPublicRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"respondto-public-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_RespondToPublicRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
/* Private ones */
|
|
[aclManager registerDAVPermission: davElement (@"viewwhole-private-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ViewWholePrivateRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"viewdant-private-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ViewDAndTOfPrivateRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"modify-private-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ModifyPrivateRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"respondto-private-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_RespondToPrivateRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
/* Condifential ones */
|
|
[aclManager registerDAVPermission: davElement (@"viewwhole-confidential-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ViewWholeConfidentialRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"viewdant-confidential-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ViewDAndTOfConfidentialRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"modify-confidential-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_ModifyConfidentialRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
|
|
[aclManager registerDAVPermission: davElement (@"respondto-confidential-records", nsI)
|
|
abstract: YES
|
|
withEquivalent: SOGoCalendarPerm_RespondToConfidentialRecords
|
|
asChildOf: davElement (@"admin", nsI)];
|
|
}
|
|
|
|
return aclManager;
|
|
}
|
|
|
|
- (id) initWithName: (NSString *) name
|
|
inContainer: (id) newContainer
|
|
{
|
|
SOGoUser *user;
|
|
if ((self = [super initWithName: name inContainer: newContainer]))
|
|
{
|
|
user = [context activeUser];
|
|
timeZone = [[user userDefaults] timeZone];
|
|
aclMatrix = [NSMutableDictionary new];
|
|
stripFields = nil;
|
|
uidToFilename = nil;
|
|
memset (userCanAccessObjectsClassifiedAs, NO,
|
|
iCalAccessClassCount * sizeof (BOOL));
|
|
|
|
davCalendarStartTimeLimit = [[user domainDefaults] davCalendarStartTimeLimit];
|
|
davTimeLimitSeconds = davCalendarStartTimeLimit * 86400;
|
|
/* 86400 / 2 = 43200. We hardcode that value in order to avoid
|
|
integer and float confusion. */
|
|
davTimeHalfLimitSeconds = davCalendarStartTimeLimit * 43200;
|
|
componentSet = nil;
|
|
|
|
baseCalDAVURL = nil;
|
|
basePublicCalDAVURL = nil;
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void) dealloc
|
|
{
|
|
[aclMatrix release];
|
|
[stripFields release];
|
|
[uidToFilename release];
|
|
[componentSet release];
|
|
[baseCalDAVURL release];
|
|
[basePublicCalDAVURL release];
|
|
[super dealloc];
|
|
}
|
|
|
|
- (Class) objectClassForComponentName: (NSString *) componentName
|
|
{
|
|
Class objectClass;
|
|
|
|
if ([componentName isEqualToString: @"vevent"])
|
|
objectClass = [SOGoAppointmentObject class];
|
|
else if ([componentName isEqualToString: @"vtodo"])
|
|
objectClass = [SOGoTaskObject class];
|
|
else
|
|
objectClass = Nil;
|
|
|
|
return objectClass;
|
|
}
|
|
|
|
- (NSString *) calendarColor
|
|
{
|
|
NSString *color;
|
|
|
|
color = [self folderPropertyValueInCategory: @"FolderColors"];
|
|
if (!color)
|
|
color = defaultColor;
|
|
|
|
return color;
|
|
}
|
|
|
|
- (void) setCalendarColor: (NSString *) newColor
|
|
{
|
|
if (![newColor length])
|
|
newColor = nil;
|
|
|
|
[self setFolderPropertyValue: newColor
|
|
inCategory: @"FolderColors"];
|
|
}
|
|
|
|
- (BOOL) showCalendarAlarms
|
|
{
|
|
NSNumber *showAlarms;
|
|
|
|
showAlarms = [self folderPropertyValueInCategory: @"FolderShowAlarms"];
|
|
|
|
return (showAlarms ? [showAlarms boolValue] : YES);
|
|
}
|
|
|
|
- (void) setShowCalendarAlarms: (BOOL) new
|
|
{
|
|
NSNumber *showAlarms;
|
|
|
|
if (new)
|
|
showAlarms = nil;
|
|
else
|
|
showAlarms = [NSNumber numberWithBool: NO];
|
|
|
|
[self setFolderPropertyValue: showAlarms
|
|
inCategory: @"FolderShowAlarms"];
|
|
}
|
|
|
|
- (BOOL) showCalendarTasks
|
|
{
|
|
NSNumber *showTasks;
|
|
|
|
showTasks = [self folderPropertyValueInCategory: @"FolderShowTasks"];
|
|
|
|
return (showTasks ? [showTasks boolValue] : YES);
|
|
}
|
|
|
|
- (void) setShowCalendarTasks: (BOOL) new
|
|
{
|
|
NSNumber *showTasks;
|
|
|
|
/* the default value is "YES", so we keep only those with a value of "NO"... */
|
|
if (new)
|
|
showTasks = nil;
|
|
else
|
|
showTasks = [NSNumber numberWithBool: NO];
|
|
|
|
[self setFolderPropertyValue: showTasks
|
|
inCategory: @"FolderShowTasks"];
|
|
}
|
|
|
|
- (BOOL) subscribeUserOrGroup: (NSString *) theIdentifier
|
|
reallyDo: (BOOL) reallyDo
|
|
response: (WOResponse *) theResponse
|
|
{
|
|
NSMutableDictionary *moduleSettings, *folderShowAlarms, *freeBusyExclusions;
|
|
NSString *subscriptionPointer, *domain;
|
|
NSMutableArray *allUsers;
|
|
SOGoUserSettings *us;
|
|
SOGoUser *sogoUser;
|
|
NSDictionary *dict;
|
|
BOOL rc;
|
|
int i;
|
|
|
|
rc = [super subscribeUserOrGroup: theIdentifier reallyDo: reallyDo response: theResponse];
|
|
|
|
if (rc)
|
|
{
|
|
#warning Duplicated code from SOGoGCSFolder subscribeUserOrGroup
|
|
domain = [[context activeUser] domain];
|
|
dict = [[SOGoUserManager sharedUserManager] contactInfosForUserWithUIDorEmail: theIdentifier
|
|
inDomain: domain];
|
|
|
|
if (dict && [[dict objectForKey: @"isGroup"] boolValue])
|
|
{
|
|
id <SOGoSource> source;
|
|
|
|
source = [[SOGoUserManager sharedUserManager] sourceWithID: [dict objectForKey: @"SOGoSource"]];
|
|
if ([source conformsToProtocol:@protocol(SOGoMembershipSource)])
|
|
{
|
|
NSArray *members;
|
|
|
|
members = [(id<SOGoMembershipSource>)(source) membersForGroupWithUID: [dict objectForKey: @"c_uid"]];
|
|
allUsers = [NSMutableArray arrayWithArray: members];
|
|
|
|
// We remove the active user from the group (if present) in order to
|
|
// not subscribe him to their own resource!
|
|
[allUsers removeObject: [context activeUser]];
|
|
}
|
|
else
|
|
{
|
|
[self errorWithFormat: @"Inconsistency error - got group identifier (%@) from a source (%@) that does not support groups (%@).", theIdentifier, [dict objectForKey: @"SOGoSource"], NSStringFromClass([source class])];
|
|
return NO;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sogoUser = [SOGoUser userWithLogin: theIdentifier roles: nil];
|
|
if (sogoUser)
|
|
allUsers = [NSArray arrayWithObject: sogoUser];
|
|
else
|
|
allUsers = [NSArray array];
|
|
}
|
|
|
|
for (i = 0; i < [allUsers count]; i++)
|
|
{
|
|
sogoUser = [allUsers objectAtIndex: i];
|
|
us = [sogoUser userSettings];
|
|
moduleSettings = [us objectForKey: [container nameInContainer]];
|
|
if (!(moduleSettings
|
|
&& [moduleSettings isKindOfClass: [NSMutableDictionary class]]))
|
|
{
|
|
moduleSettings = [NSMutableDictionary dictionary];
|
|
[us setObject: moduleSettings forKey: [container nameInContainer]];
|
|
}
|
|
|
|
subscriptionPointer = [self folderReference];
|
|
|
|
folderShowAlarms = [moduleSettings objectForKey: @"FolderShowAlarms"];
|
|
freeBusyExclusions = [moduleSettings objectForKey: @"FreeBusyExclusions"];
|
|
|
|
if (reallyDo)
|
|
{
|
|
if (!(folderShowAlarms
|
|
&& [folderShowAlarms isKindOfClass: [NSMutableDictionary class]]))
|
|
{
|
|
folderShowAlarms = [NSMutableDictionary dictionary];
|
|
[moduleSettings setObject: folderShowAlarms
|
|
forKey: @"FolderShowAlarms"];
|
|
}
|
|
|
|
// By default, we disable alarms on subscribed calendars
|
|
[folderShowAlarms setObject: [NSNumber numberWithBool: NO]
|
|
forKey: subscriptionPointer];
|
|
}
|
|
else
|
|
{
|
|
[folderShowAlarms removeObjectForKey: subscriptionPointer];
|
|
[freeBusyExclusions removeObjectForKey: subscriptionPointer];
|
|
}
|
|
|
|
[us synchronize];
|
|
|
|
rc = YES;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
//
|
|
// If the user is the owner of the calendar, by default we include the freebusy information.
|
|
//
|
|
// If the user is NOT the owner of the calendar, by default we exclude the freebusy information.
|
|
//
|
|
// We must include the freebusy information of other users if we are actually looking at their freebusy information
|
|
// but we aren't necessarily subscribed to their calendars.
|
|
//
|
|
- (BOOL) includeInFreeBusy
|
|
{
|
|
NSNumber *excludeFromFreeBusy;
|
|
NSString *userLogin, *ownerInContext;
|
|
BOOL is_owner;
|
|
|
|
userLogin = [[context activeUser] login];
|
|
ownerInContext = [[self container] ownerInContext: context];
|
|
is_owner = [userLogin isEqualToString: ownerInContext];
|
|
|
|
if (is_owner)
|
|
excludeFromFreeBusy
|
|
= [self folderPropertyValueInCategory: @"FreeBusyExclusions"
|
|
forUser: [context activeUser]];
|
|
else
|
|
excludeFromFreeBusy
|
|
= [self folderPropertyValueInCategory: @"FreeBusyExclusions"
|
|
forUser: [SOGoUser userWithLogin: ownerInContext]];
|
|
|
|
// User has no setting for freebusy inclusion/exclusion,
|
|
// * include it if it's a personal folder;
|
|
// * exclude it if it's a subscription.
|
|
if (!excludeFromFreeBusy)
|
|
{
|
|
if ([self isSubscription])
|
|
return NO;
|
|
else
|
|
return YES;
|
|
}
|
|
|
|
return ![excludeFromFreeBusy boolValue];
|
|
}
|
|
|
|
- (void) setIncludeInFreeBusy: (BOOL) newInclude
|
|
{
|
|
NSNumber *excludeFromFreeBusy;
|
|
|
|
excludeFromFreeBusy = [NSNumber numberWithBool: !newInclude];
|
|
|
|
[self setFolderPropertyValue: excludeFromFreeBusy
|
|
inCategory: @"FreeBusyExclusions"];
|
|
}
|
|
|
|
- (BOOL) _notificationValueForKey: (NSString *) theKey
|
|
defaultDomainKey: (NSString *) theDomainKey
|
|
{
|
|
SOGoUser *ownerUser;
|
|
NSNumber *notify;
|
|
|
|
ownerUser = [SOGoUser userWithLogin: self->owner];
|
|
notify = [self folderPropertyValueInCategory: theKey
|
|
forUser: ownerUser];
|
|
|
|
if (!notify && theDomainKey)
|
|
notify = [NSNumber numberWithBool: [[[context activeUser] domainDefaults]
|
|
boolForKey: theDomainKey]];
|
|
|
|
return [notify boolValue];
|
|
}
|
|
|
|
//
|
|
// We MUST keep the 'NO' value here, because we will always
|
|
// fallback to the domain defaults otherwise.
|
|
//
|
|
- (void) _setNotificationValue: (BOOL) b
|
|
forKey: (NSString *) theKey
|
|
{
|
|
[self setFolderPropertyValue: [NSNumber numberWithBool: b]
|
|
inCategory: theKey];
|
|
}
|
|
|
|
- (BOOL) notifyOnPersonalModifications
|
|
{
|
|
return [self _notificationValueForKey: @"NotifyOnPersonalModifications"
|
|
defaultDomainKey: @"SOGoNotifyOnPersonalModifications"];
|
|
}
|
|
|
|
- (void) setNotifyOnPersonalModifications: (BOOL) b
|
|
{
|
|
[self _setNotificationValue: b forKey: @"NotifyOnPersonalModifications"];
|
|
}
|
|
|
|
- (BOOL) notifyOnExternalModifications
|
|
{
|
|
return [self _notificationValueForKey: @"NotifyOnExternalModifications"
|
|
defaultDomainKey: @"SOGoNotifyOnExternalModifications"];
|
|
}
|
|
|
|
- (void) setNotifyOnExternalModifications: (BOOL) b
|
|
{
|
|
[self _setNotificationValue: b forKey: @"NotifyOnExternalModifications"];
|
|
}
|
|
|
|
- (BOOL) notifyUserOnPersonalModifications
|
|
{
|
|
return [self _notificationValueForKey: @"NotifyUserOnPersonalModifications"
|
|
defaultDomainKey: nil];
|
|
}
|
|
|
|
- (void) setNotifyUserOnPersonalModifications: (BOOL) b
|
|
{
|
|
[self _setNotificationValue: b forKey: @"NotifyUserOnPersonalModifications"];
|
|
|
|
}
|
|
|
|
- (NSString *) notifiedUserOnPersonalModifications
|
|
{
|
|
SOGoUser *ownerUser;
|
|
|
|
ownerUser = [SOGoUser userWithLogin: self->owner];
|
|
|
|
return [self folderPropertyValueInCategory: @"NotifiedUserOnPersonalModifications"
|
|
forUser: ownerUser];
|
|
}
|
|
|
|
- (void) setNotifiedUserOnPersonalModifications: (NSString *) theUser
|
|
{
|
|
[self setFolderPropertyValue: theUser
|
|
inCategory: @"NotifiedUserOnPersonalModifications"];
|
|
}
|
|
|
|
/* selection */
|
|
|
|
- (NSArray *) calendarUIDs
|
|
{
|
|
/* this is used for group calendars (this folder just returns itself) */
|
|
NSString *s;
|
|
s = [[self container] nameInContainer];
|
|
// [self logWithFormat:@"CAL UID: %@", s];
|
|
return [s isNotNull] ? [NSArray arrayWithObjects:&s count:1] : nil;
|
|
}
|
|
|
|
/* fetching */
|
|
|
|
- (NSString *) _sqlStringRangeFrom: (NSCalendarDate *) _startDate
|
|
to: (NSCalendarDate *) _endDate
|
|
cycle: (BOOL) _isCycle
|
|
{
|
|
NSString *format;
|
|
unsigned int start, end;
|
|
|
|
start = (unsigned int) [_startDate timeIntervalSince1970];
|
|
end = (unsigned int) [_endDate timeIntervalSince1970];
|
|
|
|
// vTODOs don't necessarily have start/end dates
|
|
if (_isCycle)
|
|
format = (@"(c_startdate = NULL OR c_startdate <= %u)"
|
|
@" AND (c_cycleenddate = NULL OR c_cycleenddate >= %u)");
|
|
else
|
|
format = (@"(c_startdate = NULL OR c_startdate <= %u)"
|
|
@" AND (c_enddate = NULL OR c_enddate >= %u)");
|
|
|
|
return [NSString stringWithFormat: format, end, start];
|
|
}
|
|
|
|
- (NSString *) aclSQLListingFilter
|
|
{
|
|
NSString *filter;
|
|
NSMutableArray *grantedClasses, *deniedClasses;
|
|
NSNumber *classNumber;
|
|
unsigned int grantedCount;
|
|
iCalAccessClass currentClass;
|
|
WOContext *localContext;
|
|
|
|
/* FIXME: The stored context from initialisation may have changed
|
|
by setContext by other operations in OpenChange library,
|
|
so we keep tighly to use the current session one. Without
|
|
this, the login is set to nil and a NSException is raised
|
|
at [SOGoAppointmentFolder:roleForComponentsWithAccessClass:forUser]
|
|
inside [SOGoAppointmentFolder:initializeQuickTablesAclsInContext]. */
|
|
localContext = [[WOApplication application] context];
|
|
[self initializeQuickTablesAclsInContext: localContext];
|
|
grantedClasses = [NSMutableArray arrayWithCapacity: 3];
|
|
deniedClasses = [NSMutableArray arrayWithCapacity: 3];
|
|
for (currentClass = 0;
|
|
currentClass < iCalAccessClassCount; currentClass++)
|
|
{
|
|
classNumber = [NSNumber numberWithInt: currentClass];
|
|
if (userCanAccessObjectsClassifiedAs[currentClass])
|
|
[grantedClasses addObject: classNumber];
|
|
else
|
|
[deniedClasses addObject: classNumber];
|
|
}
|
|
grantedCount = [grantedClasses count];
|
|
if (grantedCount == 3)
|
|
{
|
|
// User have access to all three classifications
|
|
filter = @"";
|
|
}
|
|
else if (grantedCount == 2)
|
|
{
|
|
// User has access to all but one of the classifications
|
|
filter = [NSString stringWithFormat: @"c_classification != %@",
|
|
[deniedClasses objectAtIndex: 0]];
|
|
}
|
|
else if (grantedCount == 1)
|
|
{
|
|
// User has access to only one classification
|
|
filter = [NSString stringWithFormat: @"c_classification = %@",
|
|
[grantedClasses objectAtIndex: 0]];
|
|
}
|
|
else
|
|
{
|
|
// User has access to no classification
|
|
filter = nil;
|
|
}
|
|
|
|
return filter;
|
|
}
|
|
|
|
- (NSString *) componentSQLFilter
|
|
{
|
|
NSString *filter;
|
|
|
|
if ([self showCalendarTasks])
|
|
filter = nil;
|
|
else
|
|
filter = @"c_component != 'vtodo'";
|
|
|
|
return filter;
|
|
}
|
|
|
|
- (BOOL) _checkIfWeCanRememberRecords: (NSArray *) fields
|
|
{
|
|
return ([fields containsObject: @"c_name"]
|
|
&& [fields containsObject: @"c_version"]
|
|
&& [fields containsObject: @"c_lastmodified"]
|
|
&& [fields containsObject: @"c_creationdate"]
|
|
&& [fields containsObject: @"c_component"]);
|
|
}
|
|
|
|
- (void) _rememberRecords: (NSArray *) records
|
|
{
|
|
NSEnumerator *recordsEnum;
|
|
NSDictionary *currentRecord;
|
|
|
|
recordsEnum = [records objectEnumerator];
|
|
while ((currentRecord = [recordsEnum nextObject]))
|
|
[childRecords setObject: currentRecord
|
|
forKey: [currentRecord objectForKey: @"c_name"]];
|
|
}
|
|
|
|
#warning filters should make use of EOQualifier
|
|
- (NSArray *) bareFetchFields: (NSArray *) fields
|
|
from: (NSCalendarDate *) startDate
|
|
to: (NSCalendarDate *) endDate
|
|
title: (NSString *) title
|
|
component: (NSString *) component
|
|
additionalFilters: (NSString *) filters
|
|
{
|
|
EOQualifier *qualifier;
|
|
GCSFolder *folder;
|
|
NSMutableArray *baseWhere;
|
|
NSString *where, *privacySQLString;
|
|
NSArray *records;
|
|
|
|
folder = [self ocsFolder];
|
|
|
|
baseWhere = [NSMutableArray arrayWithCapacity: 32];
|
|
if (startDate && endDate)
|
|
[baseWhere addObject: [self _sqlStringRangeFrom: startDate to: endDate
|
|
cycle: NO]];
|
|
|
|
if ([title length])
|
|
[baseWhere
|
|
addObject: [NSString stringWithFormat: @"c_title isCaseInsensitiveLike: '%%%@%%'",
|
|
[title asSafeSQLString]]];
|
|
|
|
if (component)
|
|
{
|
|
if ([component isEqualToString: @"vtodo"] && ![self showCalendarTasks])
|
|
return [NSArray array];
|
|
else
|
|
[baseWhere addObject: [NSString stringWithFormat: @"c_component = '%@'",
|
|
component]];
|
|
}
|
|
else if (![self showCalendarTasks])
|
|
[baseWhere addObject: @"c_component != 'vtodo'"];
|
|
|
|
if ([filters length])
|
|
[baseWhere addObject: filters];
|
|
|
|
privacySQLString = [self aclSQLListingFilter];
|
|
if (privacySQLString)
|
|
{
|
|
if ([privacySQLString length])
|
|
[baseWhere addObject: privacySQLString];
|
|
|
|
/* sql is empty when we fetch everything (all parameters are nil) */
|
|
if ([baseWhere count] > 0)
|
|
{
|
|
where = [baseWhere componentsJoinedByString: @" AND "];
|
|
qualifier = [EOQualifier qualifierWithQualifierFormat: where];
|
|
}
|
|
else
|
|
qualifier = nil;
|
|
|
|
/* fetch non-recurrent apts first */
|
|
records = [folder fetchFields: fields matchingQualifier: qualifier];
|
|
}
|
|
else
|
|
records = [NSArray array];
|
|
|
|
if ([self _checkIfWeCanRememberRecords: fields])
|
|
[self _rememberRecords: records];
|
|
|
|
return records;
|
|
}
|
|
|
|
/**
|
|
* Set the timezone of the event start and end dates to the user's timezone.
|
|
* @param theRecord a dictionary with the attributes of the event.
|
|
* @return a copy of theRecord with adjusted dates.
|
|
*/
|
|
- (NSMutableDictionary *) _fixupRecord: (NSDictionary *) theRecord
|
|
{
|
|
NSMutableDictionary *record;
|
|
static NSString *fields[] = { @"c_startdate", @"startDate",
|
|
@"c_enddate", @"endDate" };
|
|
unsigned int count;
|
|
NSCalendarDate *date;
|
|
NSNumber *dateValue;
|
|
BOOL isAllDay;
|
|
NSInteger offset;
|
|
|
|
isAllDay = [[theRecord objectForKey: @"c_isallday"] boolValue];
|
|
record = [[theRecord mutableCopy] autorelease];
|
|
for (count = 0; count < 2; count++)
|
|
{
|
|
dateValue = [theRecord objectForKey: fields[count * 2]];
|
|
if (dateValue)
|
|
{
|
|
date = [NSCalendarDate dateWithTimeIntervalSince1970: [dateValue unsignedIntValue]];
|
|
if (date)
|
|
{
|
|
[date setTimeZone: timeZone];
|
|
if (isAllDay)
|
|
{
|
|
// Since there's no timezone associated to all-day events,
|
|
// their time must be adjusted for the user's timezone.
|
|
offset = [timeZone secondsFromGMTForDate: date];
|
|
date = (NSCalendarDate*)[date dateByAddingYears:0 months:0 days:0 hours:0 minutes:0
|
|
seconds:-offset];
|
|
[record setObject: [NSNumber numberWithInt: [dateValue intValue] - offset] forKey: fields[count * 2]];
|
|
}
|
|
[record setObject: date forKey: fields[count * 2 + 1]];
|
|
}
|
|
}
|
|
else
|
|
[self logWithFormat: @"missing '%@' in record?", fields[count * 2]];
|
|
}
|
|
|
|
return record;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
- (NSArray *) _fixupRecords: (NSArray *) theRecords
|
|
{
|
|
// TODO: is the result supposed to be sorted by date?
|
|
NSMutableArray *ma;
|
|
unsigned count, max;
|
|
id row;
|
|
|
|
if (theRecords)
|
|
{
|
|
max = [theRecords count];
|
|
ma = [NSMutableArray arrayWithCapacity: max];
|
|
for (count = 0; count < max; count++)
|
|
{
|
|
row = [self _fixupRecord: [theRecords objectAtIndex: count]];
|
|
if (row)
|
|
[ma addObject: row];
|
|
}
|
|
}
|
|
else
|
|
ma = nil;
|
|
|
|
return ma;
|
|
}
|
|
|
|
/**
|
|
* Adjust the timezone of the start and end dates to the user's timezone.
|
|
* The event is recurrent and the dates must first be adjusted with respect to
|
|
* the event's timezone.
|
|
* @param theRecord
|
|
* @param theCycle
|
|
* @param theFirstCycle
|
|
* @param theEventTimeZone
|
|
* @see fixupRecord:
|
|
* @return a copy of theRecord with adjusted dates.
|
|
*/
|
|
- (NSMutableDictionary *) fixupCycleRecord: (NSDictionary *) theRecord
|
|
cycleRange: (NGCalendarDateRange *) theCycle
|
|
firstInstanceCalendarDateRange: (NGCalendarDateRange *) theFirstCycle
|
|
withEventTimeZone: (iCalTimeZone *) theEventTimeZone
|
|
{
|
|
NSMutableDictionary *record;
|
|
NSNumber *dateSecs;
|
|
id date;
|
|
int secondsOffsetFromGMT;
|
|
|
|
record = [[theRecord mutableCopy] autorelease];
|
|
|
|
date = [theCycle startDate];
|
|
if (theEventTimeZone)
|
|
{
|
|
secondsOffsetFromGMT = (int) [[theEventTimeZone periodForDate: date] secondsOffsetFromGMT];
|
|
date = [date dateByAddingYears: 0 months: 0 days: 0 hours: 0 minutes: 0 seconds: -secondsOffsetFromGMT];
|
|
}
|
|
[date setTimeZone: timeZone];
|
|
[record setObject: date forKey: @"startDate"];
|
|
dateSecs = [NSNumber numberWithInt: [date timeIntervalSince1970]];
|
|
[record setObject: dateSecs forKey: @"c_startdate"];
|
|
|
|
if ([[record valueForKey: @"c_isallday"] boolValue])
|
|
{
|
|
// Refer to all-day recurrence id by their GMT-based start date
|
|
date = [theCycle startDate];
|
|
secondsOffsetFromGMT = (int) [[date timeZone] secondsFromGMTForDate: date];
|
|
date = [date dateByAddingYears: 0 months: 0 days: 0 hours: 0 minutes: 0 seconds: secondsOffsetFromGMT];
|
|
dateSecs = [NSNumber numberWithInt: [date timeIntervalSince1970]];
|
|
}
|
|
[record setObject: dateSecs forKey: @"c_recurrence_id"];
|
|
|
|
date = [record valueForKey: @"c_enddate"];
|
|
if ([date isNotNull])
|
|
{
|
|
date = [theCycle endDate];
|
|
if (theEventTimeZone)
|
|
{
|
|
secondsOffsetFromGMT = (int) [[theEventTimeZone periodForDate: date] secondsOffsetFromGMT];
|
|
date = [date dateByAddingYears: 0 months: 0 days: 0 hours: 0 minutes: 0 seconds: -secondsOffsetFromGMT];
|
|
}
|
|
[date setTimeZone: timeZone];
|
|
[record setObject: date forKey: @"endDate"];
|
|
dateSecs = [NSNumber numberWithInt: [date timeIntervalSince1970]];
|
|
[record setObject: dateSecs forKey: @"c_enddate"];
|
|
}
|
|
else
|
|
[record removeObjectForKey: @"endDate"];
|
|
|
|
return record;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
- (int) _indexOfRecordMatchingDate: (NSCalendarDate *) matchDate
|
|
inArray: (NSArray *) recordArray
|
|
{
|
|
int count, max, recordIndex;
|
|
NSDictionary *currentRecord;
|
|
|
|
recordIndex = -1;
|
|
count = 0;
|
|
max = [recordArray count];
|
|
while (recordIndex == -1 && count < max)
|
|
{
|
|
currentRecord = [recordArray objectAtIndex: count];
|
|
if ([[currentRecord objectForKey: @"startDate"]
|
|
compare: matchDate] == NSOrderedSame)
|
|
recordIndex = count;
|
|
else
|
|
count++;
|
|
}
|
|
|
|
return recordIndex;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
- (void) _fixExceptionRecord: (NSMutableDictionary *) recRecord
|
|
fromRow: (NSDictionary *) row
|
|
{
|
|
NSArray *objects;
|
|
static NSArray *fields = nil;
|
|
|
|
if (!fields)
|
|
{
|
|
fields = [NSArray arrayWithObjects: @"c_name", nil];
|
|
[fields retain];
|
|
}
|
|
|
|
objects = [row objectsForKeys: fields notFoundMarker: @""];
|
|
[recRecord setObjects: objects forKeys: fields];
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
- (void) _computeAlarmForRow: (NSMutableDictionary *) row
|
|
master: (iCalEntityObject *) master
|
|
{
|
|
iCalEntityObject *component;
|
|
iCalAlarm *alarm;
|
|
|
|
if (![master recurrenceId])
|
|
{
|
|
component = [master copy];
|
|
|
|
[component setStartDate: [NSCalendarDate dateWithTimeIntervalSince1970: [[row objectForKey: @"c_startdate"] intValue]]];
|
|
|
|
if ([component isKindOfClass: [iCalEvent class]])
|
|
{
|
|
[(iCalEvent *)component setEndDate: [NSCalendarDate dateWithTimeIntervalSince1970: [[row objectForKey: @"c_enddate"] intValue]]];
|
|
}
|
|
else
|
|
{
|
|
[(iCalToDo *)component setDue: [NSCalendarDate dateWithTimeIntervalSince1970: [[row objectForKey: @"c_enddate"] intValue]]];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
component = master;
|
|
RETAIN(component);
|
|
}
|
|
|
|
// Check if we have any alarm, that could happen for recurrence exceptions with no
|
|
// alarm defined.
|
|
if ([[component alarms] count])
|
|
{
|
|
alarm = [component firstSupportedAlarm];
|
|
[row setObject: [NSNumber numberWithInt: [[alarm nextAlarmDate] timeIntervalSince1970]]
|
|
forKey: @"c_nextalarm"];
|
|
}
|
|
|
|
RELEASE(component);
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
- (void) _appendCycleException: (iCalRepeatableEntityObject *) component
|
|
firstInstanceCalendarDateRange: (NGCalendarDateRange *) fir
|
|
fromRow: (NSDictionary *) row
|
|
forRange: (NGCalendarDateRange *) dateRange
|
|
withTimeZone: (NSTimeZone *) tz
|
|
toArray: (NSMutableArray *) ma
|
|
{
|
|
NGCalendarDateRange *recurrenceIdRange;
|
|
NSCalendarDate *recurrenceId, *masterEndDate, *endDate;
|
|
NSMutableDictionary *newRecord;
|
|
NGCalendarDateRange *newRecordRange;
|
|
NSNumber *dateSecs;
|
|
id master;
|
|
|
|
int recordIndex, secondsOffsetFromGMT;
|
|
NSTimeInterval delta;
|
|
|
|
newRecord = nil;
|
|
recurrenceId = [component recurrenceId];
|
|
|
|
if (!recurrenceId)
|
|
{
|
|
[self errorWithFormat: @"ignored component with an empty EXCEPTION-ID"];
|
|
return;
|
|
}
|
|
|
|
if (tz)
|
|
{
|
|
// The following adjustment is necessary for floating all-day events.
|
|
// For example, the recurrence-id 20120523T000000Z for timezone -0400
|
|
// will become 20120523T000400Z
|
|
secondsOffsetFromGMT = [tz secondsFromGMTForDate: recurrenceId];
|
|
recurrenceId = (NSCalendarDate *) [recurrenceId dateByAddingYears:0 months:0 days:0 hours:0 minutes:0
|
|
seconds:-secondsOffsetFromGMT];
|
|
[recurrenceId setTimeZone: tz];
|
|
}
|
|
|
|
if ([component isKindOfClass: [iCalEvent class]])
|
|
{
|
|
master = [[[component parent] events] objectAtIndex: 0];
|
|
masterEndDate = [master endDate];
|
|
endDate = [(iCalEvent*) component endDate];
|
|
}
|
|
else
|
|
{
|
|
master = [[[component parent] todos] objectAtIndex: 0];
|
|
masterEndDate = [master due];
|
|
endDate = [(iCalToDo*) component due];
|
|
}
|
|
|
|
if (![master startDate])
|
|
{
|
|
[self errorWithFormat: @"ignored component with no DTSTART"];
|
|
return;
|
|
}
|
|
|
|
delta = [masterEndDate timeIntervalSinceDate: [master startDate]];
|
|
recurrenceIdRange = [NGCalendarDateRange calendarDateRangeWithStartDate: recurrenceId
|
|
endDate: [recurrenceId dateByAddingYears:0 months:0 days:0 hours:0 minutes:0 seconds: delta]];
|
|
if ([dateRange doesIntersectWithDateRange: recurrenceIdRange])
|
|
{
|
|
// The recurrence exception intersects with the date range;
|
|
// find the occurence and replace it with the new record
|
|
recordIndex = [self _indexOfRecordMatchingDate: recurrenceId inArray: ma];
|
|
if (recordIndex > -1)
|
|
{
|
|
if ([dateRange containsDate: [component startDate]] ||
|
|
(endDate && [dateRange containsDate: endDate]))
|
|
{
|
|
// We must pass nil to :container here in order to avoid re-entrancy issues.
|
|
newRecord = [self _fixupRecord: [component quickRecordFromContent: nil container: nil nameInContainer: nil]];
|
|
[ma replaceObjectAtIndex: recordIndex withObject: newRecord];
|
|
}
|
|
else
|
|
// The range doesn't cover the exception; remove it from the records
|
|
[ma removeObjectAtIndex: recordIndex];
|
|
}
|
|
else
|
|
[self errorWithFormat:
|
|
@"missing exception record for recurrence-id %@ (uid %@)",
|
|
recurrenceId, [component uid]];
|
|
}
|
|
else
|
|
{
|
|
// The recurrence id of the exception is outside the date range;
|
|
// simply add the exception to the records array.
|
|
// We must pass nil to :container here in order to avoid re-entrancy issues.
|
|
newRecord = [self _fixupRecord: [component quickRecordFromContent: nil container: nil nameInContainer: nil]];
|
|
if ([newRecord objectForKey: @"startDate"] && [newRecord objectForKey: @"endDate"]) {
|
|
newRecordRange = [NGCalendarDateRange
|
|
calendarDateRangeWithStartDate: [newRecord objectForKey: @"startDate"]
|
|
endDate: [newRecord objectForKey: @"endDate"]];
|
|
if ([dateRange doesIntersectWithDateRange: newRecordRange])
|
|
[ma addObject: newRecord];
|
|
else
|
|
newRecord = nil;
|
|
} else {
|
|
[self warnWithFormat: @"Recurrence %@ without dtstart or dtend. Ignoring", recurrenceId];
|
|
newRecord = nil;
|
|
}
|
|
}
|
|
|
|
if (newRecord)
|
|
{
|
|
recurrenceId = [component recurrenceId];
|
|
dateSecs = [NSNumber numberWithInt: [recurrenceId timeIntervalSince1970]];
|
|
|
|
[newRecord setObject: dateSecs forKey: @"c_recurrence_id"];
|
|
[newRecord setObject: [NSNumber numberWithInt: 1] forKey: @"c_iscycle"];
|
|
|
|
// We identified the record as an exception.
|
|
[newRecord setObject: [NSNumber numberWithInt: 1] forKey: @"isException"];
|
|
|
|
[self _fixExceptionRecord: newRecord fromRow: row];
|
|
}
|
|
|
|
// We finally adjust the c_nextalarm
|
|
[self _computeAlarmForRow: (id)row
|
|
master: component];
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
- (void) _appendCycleExceptionsFromRow: (NSDictionary *) row
|
|
firstInstanceCalendarDateRange: (NGCalendarDateRange *) fir
|
|
forRange: (NGCalendarDateRange *) dateRange
|
|
withTimeZone: (NSTimeZone *) tz
|
|
withCalendar: (iCalCalendar *) calendar
|
|
toArray: (NSMutableArray *) ma
|
|
{
|
|
NSArray *components;
|
|
NSString *content;
|
|
|
|
unsigned int count, max;
|
|
|
|
content = [row objectForKey: @"c_content"];
|
|
|
|
if (!calendar && [content isNotNull])
|
|
{
|
|
calendar = [iCalCalendar parseSingleFromSource: content];
|
|
}
|
|
|
|
if (calendar)
|
|
{
|
|
components = [calendar allObjects];
|
|
max = [components count];
|
|
for (count = 1; count < max; count++) // skip master event
|
|
[self _appendCycleException: [components objectAtIndex: count]
|
|
firstInstanceCalendarDateRange: fir
|
|
fromRow: row
|
|
forRange: dateRange
|
|
withTimeZone: tz
|
|
toArray: ma];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculate and return the occurrences of the recurrent event for the given
|
|
* period.
|
|
* @param theRecord the event definition.
|
|
* @param theRange the period to look in.
|
|
* @param theRecords the array into which are copied the resulting occurrences.
|
|
* @see [iCalRepeatableEntityObject+SOGo doesOccurOnDate:]
|
|
*/
|
|
- (void) flattenCycleRecord: (NSDictionary *) theRecord
|
|
forRange: (NGCalendarDateRange *) theRange
|
|
intoArray: (NSMutableArray *) theRecords
|
|
withCalendar: (iCalCalendar *) calendar
|
|
|
|
{
|
|
NSMutableDictionary *row, *fixedRow;
|
|
NSMutableArray *records, *ranges;
|
|
NSDictionary *cycleinfo;
|
|
NGCalendarDateRange *firstRange, *recurrenceRange, *oneRange;
|
|
NSArray *rules, *exRules, *rDates, *exDates;
|
|
NSArray *components;
|
|
NSString *content;
|
|
NSCalendarDate *checkStartDate, *checkEndDate, *firstStartDate, *firstEndDate;
|
|
NSTimeZone *allDayTimeZone;
|
|
iCalDateTime *dtstart;
|
|
iCalRepeatableEntityObject *component;
|
|
iCalTimeZone *eventTimeZone;
|
|
unsigned count, max;
|
|
NSInteger offset;
|
|
id tz;
|
|
|
|
content = [theRecord objectForKey: @"c_cycleinfo"];
|
|
if (![content isNotNull])
|
|
{
|
|
// If c_iscycle is set but c_cycleinfo is null, that means we're dealing with a vcalendar that
|
|
// contains ONLY one or more vevent with recurrence-id set for each of them. This can happen if
|
|
// an organizer invites an attendee only to one or many occurences of a repetitive event.
|
|
iCalCalendar *c;
|
|
NSDictionary *record;
|
|
|
|
c = [iCalCalendar parseSingleFromSource: [theRecord objectForKey: @"c_content"]];
|
|
components = [self _fixupRecords:
|
|
[c quickRecordsFromContent: [theRecord objectForKey: @"c_content"]
|
|
container: nil
|
|
nameInContainer: [theRecord objectForKey: @"c_name"]]];
|
|
max = [components count];
|
|
for (count = 0; count < max; count++)
|
|
{
|
|
record = [components objectAtIndex: count];
|
|
oneRange = [NGCalendarDateRange calendarDateRangeWithStartDate: [record objectForKey: @"startDate"]
|
|
endDate: [record objectForKey: @"endDate"]];
|
|
if ([theRange doesIntersectWithDateRange: oneRange])
|
|
{
|
|
[theRecords addObject: record];
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
cycleinfo = [content propertyList];
|
|
if (!cycleinfo)
|
|
{
|
|
[self errorWithFormat:@"cyclic record doesn't have cycleinfo -> %@",
|
|
theRecord];
|
|
return;
|
|
}
|
|
rules = [cycleinfo objectForKey: @"rules"];
|
|
exRules = [cycleinfo objectForKey: @"exRules"];
|
|
rDates = [cycleinfo objectForKey: @"rDates"];
|
|
exDates = [cycleinfo objectForKey: @"exDates"];
|
|
eventTimeZone = nil;
|
|
allDayTimeZone = nil;
|
|
tz = nil;
|
|
|
|
row = [self _fixupRecord: theRecord];
|
|
[row removeObjectForKey: @"c_cycleinfo"];
|
|
[row setObject: sharedYes forKey: @"isRecurrentEvent"];
|
|
|
|
content = [theRecord objectForKey: @"c_content"];
|
|
|
|
if (!calendar && [content isNotNull])
|
|
{
|
|
calendar = [iCalCalendar parseSingleFromSource: content];
|
|
}
|
|
|
|
if (calendar)
|
|
{
|
|
if ([[theRecord objectForKey: @"c_component"] isEqualToString: @"vtodo"])
|
|
components = [calendar todos];
|
|
else
|
|
components = [calendar events];
|
|
|
|
if ([components count])
|
|
{
|
|
// Retrieve the range of the first/master event
|
|
component = [components objectAtIndex: 0];
|
|
dtstart = (iCalDateTime *) [component uniqueChildWithTag: @"dtstart"];
|
|
firstRange = [component firstOccurenceRange]; // ignores timezone
|
|
|
|
eventTimeZone = [dtstart timeZone];
|
|
if (eventTimeZone)
|
|
{
|
|
// Adjust the range to check with respect to the event timezone (extracted from the start date)
|
|
checkStartDate = [eventTimeZone computedDateForDate: [theRange startDate]];
|
|
checkEndDate = [eventTimeZone computedDateForDate: [theRange endDate]];
|
|
recurrenceRange = [NGCalendarDateRange calendarDateRangeWithStartDate: checkStartDate
|
|
endDate: checkEndDate];
|
|
|
|
}
|
|
else
|
|
{
|
|
recurrenceRange = theRange;
|
|
if ([[theRecord objectForKey: @"c_isallday"] boolValue])
|
|
{
|
|
// The event lasts all-day and has no timezone (floating); we convert the range of the first event
|
|
// to the user's timezone
|
|
allDayTimeZone = timeZone;
|
|
offset = [allDayTimeZone secondsFromGMTForDate: [firstRange startDate]];
|
|
firstStartDate = [[firstRange startDate] dateByAddingYears:0 months:0 days:0 hours:0 minutes:0
|
|
seconds:-offset];
|
|
firstEndDate = [[firstRange endDate] dateByAddingYears:0 months:0 days:0 hours:0 minutes:0
|
|
seconds:-offset];
|
|
[firstStartDate setTimeZone: allDayTimeZone];
|
|
[firstEndDate setTimeZone: allDayTimeZone];
|
|
firstRange = [NGCalendarDateRange calendarDateRangeWithStartDate: firstStartDate
|
|
endDate: firstEndDate];
|
|
}
|
|
}
|
|
|
|
#warning this code is ugly: we should not mix objects with different types as \
|
|
it reduces readability
|
|
tz = eventTimeZone ? eventTimeZone : allDayTimeZone;
|
|
if (tz)
|
|
{
|
|
// Adjust the recurrence and exception dates
|
|
exDates = [component exceptionDatesWithTimeZone: tz];
|
|
rDates = [component recurrenceDatesWithTimeZone: tz];
|
|
|
|
// Adjust the recurrence rules "until" dates
|
|
rules = [component recurrenceRulesWithTimeZone: tz];
|
|
exRules = [component exceptionRulesWithTimeZone: tz];
|
|
}
|
|
|
|
// Calculate the occurrences for the given range
|
|
records = [NSMutableArray array];
|
|
ranges =
|
|
[NSMutableArray arrayWithArray:
|
|
[iCalRecurrenceCalculator recurrenceRangesWithinCalendarDateRange: recurrenceRange
|
|
firstInstanceCalendarDateRange: firstRange
|
|
recurrenceRules: rules
|
|
exceptionRules: exRules
|
|
recurrenceDates: rDates
|
|
exceptionDates: exDates]];
|
|
|
|
// Add the master occurrence when dealing with RDATES.
|
|
// However, the master event must not be flagged with X-MOZ-FAKED-MASTER.
|
|
if ([component hasRecurrenceDates] &&
|
|
![[[component uniqueChildWithTag: @"x-moz-faked-master"]
|
|
flattenedValuesForKey: @""] isEqualToString: @"1"] &&
|
|
[recurrenceRange doesIntersectWithDateRange: firstRange])
|
|
{
|
|
[ranges insertObject: firstRange atIndex: 0];
|
|
}
|
|
|
|
max = [ranges count];
|
|
for (count = 0; count < max; count++)
|
|
{
|
|
oneRange = [ranges objectAtIndex: count];
|
|
fixedRow = [self fixupCycleRecord: row
|
|
cycleRange: oneRange
|
|
firstInstanceCalendarDateRange: firstRange
|
|
withEventTimeZone: eventTimeZone];
|
|
|
|
// We now adjust the c_nextalarm based on each occurences. For each of them, we use the master event
|
|
// alarm information since exceptions to recurrence rules might have their own, while that is not the
|
|
// case for standard occurences.
|
|
if ([component hasAlarms])
|
|
{
|
|
[self _computeAlarmForRow: fixedRow
|
|
master: component];
|
|
}
|
|
|
|
[records addObject: fixedRow];
|
|
}
|
|
|
|
[self _appendCycleExceptionsFromRow: row
|
|
firstInstanceCalendarDateRange: firstRange
|
|
forRange: theRange
|
|
withTimeZone: allDayTimeZone
|
|
withCalendar: calendar
|
|
toArray: records];
|
|
|
|
[theRecords addObjectsFromArray: records];
|
|
} // if ([components count]) ...
|
|
}
|
|
else
|
|
[self errorWithFormat:@"cyclic record doesn't have content -> %@", theRecord];
|
|
}
|
|
|
|
//
|
|
// TODO: is the result supposed to be sorted by date?
|
|
//
|
|
- (NSArray *) _flattenCycleRecords: (NSArray *) _records
|
|
fetchRange: (NGCalendarDateRange *) _r
|
|
{
|
|
NSMutableArray *ma;
|
|
NSDictionary *row;
|
|
unsigned int count, max;
|
|
|
|
max = [_records count];
|
|
ma = [NSMutableArray arrayWithCapacity: max];
|
|
|
|
_r = [NGCalendarDateRange calendarDateRangeWithStartDate: [_r startDate]
|
|
endDate: [_r endDate]];
|
|
|
|
for (count = 0; count < max; count++)
|
|
{
|
|
row = [_records objectAtIndex: count];
|
|
[self flattenCycleRecord: row forRange: _r intoArray: ma withCalendar: nil];
|
|
}
|
|
|
|
return ma;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
- (void) _buildStripFieldsFromFields: (NSArray *) fields
|
|
{
|
|
stripFields = [[NSMutableArray alloc] initWithCapacity: [fields count]];
|
|
[stripFields setArray: fields];
|
|
|
|
// What we keep....
|
|
[stripFields removeObjectsInArray: [NSArray arrayWithObjects: @"c_name",
|
|
@"c_uid", @"c_startdate",
|
|
@"c_enddate", @"c_isallday",
|
|
@"c_iscycle", @"c_isopaque",
|
|
@"c_cycleinfo",
|
|
@"c_cycleenddate",
|
|
@"c_classification",
|
|
@"c_component", nil]];
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
- (void) _fixupProtectedInformation: (NSEnumerator *) ma
|
|
inFields: (NSArray *) fields
|
|
forUser: (NSString *) uid
|
|
{
|
|
NSMutableDictionary *currentRecord;
|
|
NSString *roles[] = {nil, nil, nil};
|
|
iCalAccessClass accessClass;
|
|
NSString *fullRole, *role;
|
|
|
|
if (!stripFields)
|
|
[self _buildStripFieldsFromFields: fields];
|
|
|
|
#warning we do not take the participation status into account
|
|
while ((currentRecord = [ma nextObject]))
|
|
{
|
|
accessClass = [[currentRecord objectForKey: @"c_classification"] intValue];
|
|
role = roles[accessClass];
|
|
if (!role)
|
|
{
|
|
fullRole = [self roleForComponentsWithAccessClass: accessClass
|
|
forUser: uid];
|
|
if ([fullRole length] > 9)
|
|
role = [fullRole substringFromIndex: 9];
|
|
roles[accessClass] = role;
|
|
}
|
|
if ([role isEqualToString: @"DAndTViewer"])
|
|
[currentRecord removeObjectsForKeys: stripFields];
|
|
}
|
|
}
|
|
|
|
/* TODO: this method should make use of bareFetchFields instead and only keep
|
|
its "intelligence" part for handling protected infos and recurrent
|
|
events... */
|
|
- (NSArray *) fetchFields: (NSArray *) _fields
|
|
from: (NSCalendarDate *) _startDate
|
|
to: (NSCalendarDate *) _endDate
|
|
title: (NSString *) title
|
|
component: (id) _component
|
|
additionalFilters: (NSString *) filters
|
|
includeProtectedInformation: (BOOL) _includeProtectedInformation
|
|
{
|
|
EOQualifier *qualifier;
|
|
GCSFolder *folder;
|
|
NSMutableArray *fields, *ma;
|
|
NSMutableDictionary *currentRecord;
|
|
NSArray *records;
|
|
NSEnumerator *matchingRecords;
|
|
NSMutableArray *baseWhere;
|
|
NSString *where, *dateSqlString, *privacySQLString, *currentLogin;
|
|
NSCalendarDate *endDate;
|
|
NGCalendarDateRange *r;
|
|
BOOL rememberRecords, canCycle;
|
|
SOGoUser *ownerUser;
|
|
|
|
ownerUser = [SOGoUser userWithLogin: self->owner roles: nil];
|
|
rememberRecords = [self _checkIfWeCanRememberRecords: _fields];
|
|
canCycle = [_component isEqualToString: @"vevent"] || [_component isEqualToString: @"vtodo"];
|
|
// if (rememberRecords)
|
|
// NSLog (@"we will remember those records!");
|
|
|
|
folder = [self ocsFolder];
|
|
if (!folder)
|
|
{
|
|
[self errorWithFormat:@"(%s): missing folder for fetch!",
|
|
__PRETTY_FUNCTION__];
|
|
return nil;
|
|
}
|
|
|
|
baseWhere = [NSMutableArray arrayWithCapacity: 32];
|
|
if (_component)
|
|
{
|
|
if ([_component isEqualToString: @"vtodo"] && ![self showCalendarTasks])
|
|
return [NSArray array];
|
|
else
|
|
[baseWhere addObject: [NSString stringWithFormat: @"c_component = '%@'",
|
|
_component]];
|
|
}
|
|
else if (![self showCalendarTasks])
|
|
[baseWhere addObject: @"c_component != 'vtodo'"];
|
|
|
|
if (_startDate)
|
|
{
|
|
if (_endDate)
|
|
endDate = _endDate;
|
|
else
|
|
endDate = [NSCalendarDate distantFuture];
|
|
r = [NGCalendarDateRange calendarDateRangeWithStartDate: _startDate
|
|
endDate: endDate];
|
|
dateSqlString = [self _sqlStringRangeFrom: _startDate to: endDate
|
|
cycle: NO];
|
|
}
|
|
else
|
|
{
|
|
r = nil;
|
|
dateSqlString = nil;
|
|
}
|
|
|
|
privacySQLString = [self aclSQLListingFilter];
|
|
|
|
// Check for access to classification and also make sure the user is still active
|
|
if (privacySQLString && ownerUser)
|
|
{
|
|
if ([privacySQLString length])
|
|
[baseWhere addObject: privacySQLString];
|
|
|
|
if ([title length])
|
|
{
|
|
if ([filters length])
|
|
{
|
|
if ([filters isEqualToString:@"title_Category_Location"] || [filters isEqualToString:@"entireContent"])
|
|
{
|
|
[baseWhere addObject: [NSString stringWithFormat: @"(c_title isCaseInsensitiveLike: '%%%@%%' OR c_category isCaseInsensitiveLike: '%%%@%%' OR c_location isCaseInsensitiveLike: '%%%@%%')",
|
|
[title asSafeSQLString],
|
|
[title asSafeSQLString],
|
|
[title asSafeSQLString]]];
|
|
}
|
|
}
|
|
else
|
|
[baseWhere addObject: [NSString stringWithFormat: @"c_title isCaseInsensitiveLike: '%%%@%%'",
|
|
[title asSafeSQLString]]];
|
|
}
|
|
|
|
/* prepare mandatory fields */
|
|
|
|
fields = [NSMutableArray arrayWithArray: _fields];
|
|
[fields addObjectUniquely: @"c_name"];
|
|
[fields addObjectUniquely: @"c_uid"];
|
|
[fields addObjectUniquely: @"c_startdate"];
|
|
[fields addObjectUniquely: @"c_enddate"];
|
|
[fields addObjectUniquely: @"c_isallday"];
|
|
|
|
if (canCycle)
|
|
{
|
|
if (dateSqlString)
|
|
[baseWhere addObject: dateSqlString];
|
|
[baseWhere addObject: @"c_iscycle = 0"];
|
|
}
|
|
|
|
where = [baseWhere componentsJoinedByString: @" AND "];
|
|
|
|
/* fetch non-recurrent apts first */
|
|
qualifier = [EOQualifier qualifierWithQualifierFormat: where];
|
|
records = [folder fetchFields: fields matchingQualifier: qualifier];
|
|
|
|
if (records)
|
|
{
|
|
records = [self _fixupRecords: records];
|
|
ma = [NSMutableArray arrayWithArray: records];
|
|
}
|
|
else
|
|
ma = nil;
|
|
|
|
// Fetch recurrent apts now. We support the following scenarios:
|
|
// "All events" - so the start and end date is nil
|
|
// "All future events" - start is defined, date is nil
|
|
if (canCycle)
|
|
{
|
|
unsigned int delta;
|
|
|
|
delta = 1;
|
|
|
|
// If we don't have a start date, we use the current date - 1 year
|
|
if (!_startDate)
|
|
{
|
|
_startDate = [[NSCalendarDate date] dateByAddingYears: -1 months: 0 days: 0 hours: 0 minutes: 0 seconds: 0];
|
|
delta++;
|
|
}
|
|
|
|
// We if we don't have an end date, we use the start date + 1 year
|
|
if (!_endDate)
|
|
{
|
|
endDate = [_startDate dateByAddingYears: delta months: 0 days: 0 hours: 0 minutes: 0 seconds: 0];
|
|
}
|
|
|
|
r = [NGCalendarDateRange calendarDateRangeWithStartDate: _startDate
|
|
endDate: endDate];
|
|
|
|
// we know the last element of "baseWhere" is the c_iscycle condition
|
|
[baseWhere removeLastObject];
|
|
|
|
// replace the date range
|
|
if (r)
|
|
{
|
|
if (dateSqlString)
|
|
[baseWhere removeLastObject];
|
|
dateSqlString = [self _sqlStringRangeFrom: _startDate
|
|
to: endDate
|
|
cycle: YES];
|
|
[baseWhere addObject: dateSqlString];
|
|
}
|
|
[baseWhere addObject: @"c_iscycle = 1"];
|
|
where = [baseWhere componentsJoinedByString: @" AND "];
|
|
qualifier = [EOQualifier qualifierWithQualifierFormat: where];
|
|
records = [folder fetchFields: fields matchingQualifier: qualifier];
|
|
if (records)
|
|
{
|
|
if (r)
|
|
records = [self _flattenCycleRecords: records fetchRange: r];
|
|
if (ma)
|
|
[ma addObjectsFromArray: records];
|
|
else
|
|
ma = [NSMutableArray arrayWithArray: records];
|
|
}
|
|
}
|
|
|
|
if (!ma)
|
|
{
|
|
[self errorWithFormat: @"(%s): fetch failed!", __PRETTY_FUNCTION__];
|
|
return nil;
|
|
}
|
|
|
|
currentLogin = [[context activeUser] login];
|
|
if (![currentLogin isEqualToString: self->owner])
|
|
{
|
|
|
|
if (!_includeProtectedInformation)
|
|
[self _fixupProtectedInformation: [ma objectEnumerator]
|
|
inFields: _fields
|
|
forUser: currentLogin];
|
|
}
|
|
|
|
// Add owner to each record. It will be used when generating freebusy.
|
|
matchingRecords = [ma objectEnumerator];
|
|
while ((currentRecord = [matchingRecords nextObject]))
|
|
{
|
|
[currentRecord setObject: ownerUser forKey: @"owner"];
|
|
}
|
|
|
|
if (rememberRecords)
|
|
[self _rememberRecords: ma];
|
|
}
|
|
else
|
|
ma = [NSMutableArray array];
|
|
|
|
return ma;
|
|
}
|
|
|
|
#warning we should use the EOFetchSpecification for that!!! (see doPROPFIND:)
|
|
|
|
#warning components in calendar-data query are ignored
|
|
|
|
- (NSString *) _nodeTagForProperty: (NSString *) property
|
|
{
|
|
NSString *namespace, *nodeName, *nsRep;
|
|
NSRange nsEnd;
|
|
|
|
nsEnd = [property rangeOfString: @"}"];
|
|
namespace
|
|
= [property substringFromRange: NSMakeRange (1, nsEnd.location - 1)];
|
|
nodeName = [property substringFromIndex: nsEnd.location + 1];
|
|
if ([namespace isEqualToString: XMLNS_CALDAV])
|
|
nsRep = @"C";
|
|
else
|
|
nsRep = @"D";
|
|
|
|
return [NSString stringWithFormat: @"%@:%@", nsRep, nodeName];
|
|
}
|
|
|
|
- (NSCalendarDate *) _getMaxStartDate
|
|
{
|
|
NSCalendarDate *now, *rc;
|
|
|
|
if (davCalendarStartTimeLimit > 0 && ![[context activeUser] isSuperUser])
|
|
{
|
|
now = [NSCalendarDate date];
|
|
rc = [now addTimeInterval: -davTimeLimitSeconds];
|
|
}
|
|
else
|
|
rc = nil;
|
|
|
|
return rc;
|
|
}
|
|
|
|
- (void) _enforceTimeLimitOnFilter: (NSMutableDictionary *) filter
|
|
withStartDate: (NSCalendarDate *) startDate
|
|
andEndDate: (NSCalendarDate *) endDate
|
|
{
|
|
NSCalendarDate *now;
|
|
int interval, intervalStart, intervalEnd;
|
|
|
|
if (davCalendarStartTimeLimit > 0 && ![[context activeUser] isSuperUser])
|
|
{
|
|
interval = ([endDate timeIntervalSinceDate: startDate] / 86400);
|
|
if (interval > davCalendarStartTimeLimit)
|
|
{
|
|
now = [NSCalendarDate date];
|
|
if ([now compare: startDate] == NSOrderedDescending
|
|
&& [now compare: endDate] == NSOrderedAscending)
|
|
{
|
|
intervalStart = [now timeIntervalSinceDate: startDate] / 86400;
|
|
intervalEnd = [endDate timeIntervalSinceDate: now] / 86400;
|
|
if (intervalStart > davCalendarStartTimeLimit / 2)
|
|
{
|
|
startDate = [now addTimeInterval: -davTimeHalfLimitSeconds];
|
|
[filter setObject: startDate forKey: @"start"];
|
|
}
|
|
if (intervalEnd > davCalendarStartTimeLimit / 2)
|
|
{
|
|
endDate = [now addTimeInterval: davTimeHalfLimitSeconds];
|
|
[filter setObject: endDate forKey: @"end"];
|
|
}
|
|
}
|
|
else if ([now compare: endDate] == NSOrderedDescending)
|
|
{
|
|
startDate = [endDate addTimeInterval: -davTimeLimitSeconds];
|
|
[filter setObject: startDate forKey: @"start"];
|
|
}
|
|
else if ([now compare: startDate] == NSOrderedAscending)
|
|
{
|
|
endDate = [startDate addTimeInterval: davTimeLimitSeconds];
|
|
[filter setObject: endDate forKey: @"end"];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void) _appendTimeRange: (id <DOMElement>) timeRangeElement
|
|
toFilter: (NSMutableDictionary *) filter
|
|
{
|
|
NSCalendarDate *startDate, *endDate;
|
|
|
|
startDate = [[timeRangeElement attribute: @"start"] asCalendarDate];
|
|
if (!startDate)
|
|
startDate = [NSCalendarDate distantPast];
|
|
[filter setObject: startDate forKey: @"start"];
|
|
|
|
endDate = [[timeRangeElement attribute: @"end"] asCalendarDate];
|
|
if (!endDate)
|
|
endDate = [NSCalendarDate distantFuture];
|
|
[filter setObject: endDate forKey: @"end"];
|
|
|
|
[self _enforceTimeLimitOnFilter: filter
|
|
withStartDate: startDate andEndDate: endDate];
|
|
}
|
|
|
|
- (void) _addDateRangeLimitToFilter: (NSMutableDictionary *) filter
|
|
{
|
|
NSCalendarDate *now;
|
|
|
|
now = [NSCalendarDate date];
|
|
[filter setObject: [now addTimeInterval: davTimeHalfLimitSeconds]
|
|
forKey: @"start"];
|
|
[filter setObject: [now addTimeInterval: -davTimeHalfLimitSeconds]
|
|
forKey: @"end"];
|
|
}
|
|
|
|
#warning This method lacks support for timeranges
|
|
- (void) _appendPropertyFilter: (id <DOMElement>) propFilter
|
|
toFilter: (NSMutableDictionary *) filter
|
|
{
|
|
NSString *propName, *textMatch;
|
|
id <DOMNodeList> matches;
|
|
|
|
propName = [[propFilter attribute: @"name"] lowercaseString];
|
|
matches = [propFilter getElementsByTagName: @"text-match"];
|
|
if ([matches length])
|
|
textMatch = [[matches objectAtIndex: 0] textValue];
|
|
else
|
|
{
|
|
matches = [propFilter getElementsByTagName: @"is-not-defined"];
|
|
if ([matches length])
|
|
textMatch = @"NULL";
|
|
else
|
|
textMatch = @"";
|
|
}
|
|
|
|
[filter setObject: textMatch forKey: propName];
|
|
}
|
|
|
|
- (NSDictionary *) _parseCalendarFilter: (id <DOMElement>) filterElement
|
|
{
|
|
NSMutableDictionary *filterData;
|
|
id <DOMElement> parentNode;
|
|
id <DOMNodeList> elements;
|
|
NSString *componentName;
|
|
NSCalendarDate *maxStart;
|
|
|
|
parentNode = (id <DOMElement>) [filterElement parentNode];
|
|
|
|
// This parses time-range filters.
|
|
//
|
|
// <C:filter>
|
|
// <C:comp-filter name="VCALENDAR">
|
|
// <C:comp-filter name="VEVENT">
|
|
// <C:time-range start="20060104T000000Z"
|
|
// end="20060105T000000Z"/>
|
|
// </C:comp-filter>
|
|
// </C:comp-filter>
|
|
// </C:filter>
|
|
//
|
|
//
|
|
// We currently ignore filters based on just the component type.
|
|
// For example, this is ignored:
|
|
//
|
|
// <c:calendar-query xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">
|
|
// <d:prop>
|
|
// <d:getetag />
|
|
// <c:calendar-data />
|
|
// </d:prop>
|
|
// <c:filter>
|
|
// <c:comp-filter name="VCALENDAR" />
|
|
// </c:filter>
|
|
// </c:calendar-query>
|
|
//
|
|
if ([[parentNode tagName] isEqualToString: @"comp-filter"]
|
|
&& [[parentNode attribute: @"name"] isEqualToString: @"VCALENDAR"])
|
|
{
|
|
componentName = [[filterElement attribute: @"name"] lowercaseString];
|
|
filterData = [NSMutableDictionary dictionary];
|
|
[filterData setObject: componentName forKey: @"name"];
|
|
elements = [filterElement getElementsByTagName: @"time-range"];
|
|
if ([elements length])
|
|
[self _appendTimeRange: [elements objectAtIndex: 0]
|
|
toFilter: filterData];
|
|
|
|
elements = [filterElement getElementsByTagName: @"prop-filter"];
|
|
if ([elements length])
|
|
[self _appendPropertyFilter: [elements objectAtIndex: 0]
|
|
toFilter: filterData];
|
|
|
|
if (![filterData objectForKey: @"start"])
|
|
{
|
|
maxStart = [self _getMaxStartDate];
|
|
if (maxStart)
|
|
[self _addDateRangeLimitToFilter: filterData];
|
|
}
|
|
[filterData setObject: [NSNumber numberWithBool: NO] forKey: @"iscycle"];
|
|
}
|
|
else
|
|
filterData = nil;
|
|
|
|
return filterData;
|
|
}
|
|
|
|
- (NSDictionary *) _makeCyclicFilterFrom: (NSDictionary *) filter
|
|
{
|
|
NSMutableDictionary *rc;
|
|
NSNumber *start;
|
|
|
|
rc = [NSMutableDictionary dictionaryWithDictionary: filter];
|
|
start = [rc objectForKey: @"start"];
|
|
if (start)
|
|
[rc setObject: start forKey: @"cycleenddate"];
|
|
[rc removeObjectForKey: @"start"];
|
|
[rc removeObjectForKey: @"end"];
|
|
[rc setObject: sharedYes forKey: @"iscycle"];
|
|
|
|
return rc;
|
|
}
|
|
|
|
- (NSArray *) _parseCalendarFilters: (id <DOMElement>) parentNode
|
|
{
|
|
id <DOMNodeList> children;
|
|
id <DOMElement>element;
|
|
NSMutableArray *filters;
|
|
NSDictionary *filter;
|
|
unsigned int count, max;
|
|
|
|
// NSLog (@"parseCalendarFilter: %@", [NSDate date]);
|
|
|
|
filters = [NSMutableArray array];
|
|
children = [parentNode getElementsByTagName: @"comp-filter"];
|
|
max = [children length];
|
|
for (count = 0; count < max; count++)
|
|
{
|
|
element = [children objectAtIndex: count];
|
|
filter = [self _parseCalendarFilter: element];
|
|
if (filter)
|
|
{
|
|
[filters addObject: filter];
|
|
[filters addObject: [self _makeCyclicFilterFrom: filter]];
|
|
}
|
|
}
|
|
// NSLog (@"/parseCalendarFilter: %@", [NSDate date]);
|
|
|
|
return filters;
|
|
}
|
|
|
|
- (NSString *) _additionalFilterKey: (NSString *) key
|
|
value: (NSString *) value
|
|
{
|
|
NSString *filterString;
|
|
|
|
if ([value length])
|
|
{
|
|
if ([value isEqualToString: @"NULL"])
|
|
filterString = [NSString stringWithFormat: @"(%@ = '')", key];
|
|
else
|
|
filterString
|
|
= [NSString stringWithFormat: @"(%@ like '%%%@%%')", key, value];
|
|
}
|
|
else
|
|
filterString = [NSString stringWithFormat: @"(%@ != '')", key];
|
|
|
|
return filterString;
|
|
}
|
|
|
|
/* This method enables the mapping between comp-filter attributes and SQL
|
|
fields in the quick table. Probably unused most of the time but should be
|
|
completed one day for full CalDAV compliance. */
|
|
- (NSString *) _composeAdditionalFilters: (NSDictionary *) filter
|
|
{
|
|
NSString *additionalFilter;
|
|
NSEnumerator *keys;
|
|
NSString *currentKey, *keyField, *filterString;
|
|
static NSArray *fields = nil;
|
|
NSMutableArray *filters;
|
|
NSCalendarDate *cEndDate;
|
|
NSNumber *cycle;
|
|
|
|
#warning the list of fields should be taken from the .ocs description file
|
|
if (!fields)
|
|
{
|
|
fields = [NSArray arrayWithObject: @"c_uid"];
|
|
[fields retain];
|
|
}
|
|
|
|
filters = [NSMutableArray array];
|
|
keys = [[filter allKeys] objectEnumerator];
|
|
while ((currentKey = [keys nextObject]))
|
|
{
|
|
keyField = [NSString stringWithFormat: @"c_%@", currentKey];
|
|
if ([fields containsObject: keyField])
|
|
{
|
|
filterString
|
|
= [self _additionalFilterKey: keyField
|
|
value: [filter objectForKey: currentKey]];
|
|
[filters addObject: filterString];
|
|
}
|
|
}
|
|
|
|
// Exception for iscycle
|
|
cycle = [filter objectForKey: @"iscycle"];
|
|
if (cycle)
|
|
{
|
|
filterString = [NSString stringWithFormat: @"(c_iscycle = '%d')",
|
|
[cycle intValue]];
|
|
[filters addObject: filterString];
|
|
|
|
if ([cycle intValue])
|
|
{
|
|
cEndDate = [filter objectForKey: @"cycleenddate"];
|
|
if (cEndDate)
|
|
{
|
|
filterString = [NSString stringWithFormat:
|
|
@"(c_cycleenddate = NULL OR c_cycleenddate >= %d)",
|
|
(int) [cEndDate timeIntervalSince1970]];
|
|
[filters addObject: filterString];
|
|
}
|
|
}
|
|
}
|
|
|
|
if ([filters count])
|
|
additionalFilter = [filters componentsJoinedByString: @" AND "];
|
|
else
|
|
additionalFilter = nil;
|
|
|
|
return additionalFilter;
|
|
}
|
|
|
|
- (NSString *) davCalendarColor
|
|
{
|
|
NSString *color;
|
|
|
|
color = [[self calendarColor] uppercaseString];
|
|
|
|
// return color;
|
|
return [NSString stringWithFormat: @"%@FF", color];
|
|
}
|
|
|
|
- (NSException *) setDavCalendarColor: (NSString *) newColor
|
|
{
|
|
NSException *error;
|
|
NSString *realColor;
|
|
|
|
if ([newColor length] == 9
|
|
&& [newColor hasPrefix: @"#"])
|
|
{
|
|
realColor = [newColor substringToIndex: 7];
|
|
[self setCalendarColor: realColor];
|
|
error = nil;
|
|
}
|
|
else
|
|
error = [NSException exceptionWithHTTPStatus: 400
|
|
reason: @"Bad color format (should be '#XXXXXXXX')."];
|
|
|
|
return error;
|
|
}
|
|
|
|
- (NSString *) davCalendarOrder
|
|
{
|
|
unsigned int order;
|
|
|
|
order = [[container subFolders] indexOfObject: self];
|
|
|
|
return [NSString stringWithFormat: @"%d", order+1];
|
|
}
|
|
|
|
- (NSException *) setDavCalendarOrder: (NSString *) newColor
|
|
{
|
|
/* we fail silently */
|
|
return nil;
|
|
}
|
|
|
|
- (NSString *) davCalendarTimeZone
|
|
{
|
|
SOGoUser *ownerUser;
|
|
NSString *ownerTimeZone;
|
|
iCalCalendar *tzCal;
|
|
iCalTimeZone *tz;
|
|
NSString *prodID;
|
|
|
|
ownerUser = [SOGoUser userWithLogin: [self ownerInContext: context]];
|
|
ownerTimeZone = [[ownerUser userDefaults] timeZoneName];
|
|
tz = [iCalTimeZone timeZoneForName: ownerTimeZone];
|
|
|
|
tzCal = [iCalCalendar groupWithTag: @"vcalendar"];
|
|
[tzCal setVersion: @"2.0"];
|
|
prodID = [NSString stringWithFormat:
|
|
@"-//Inverse inc./SOGo %@//EN", SOGoVersion];
|
|
[tzCal setProdID: prodID];
|
|
[tzCal addChild: tz];
|
|
|
|
return [tzCal versitString];
|
|
}
|
|
|
|
- (NSException *) setDavCalendarTimeZone: (NSString *) newTimeZone
|
|
{
|
|
/* we fail silently */
|
|
return nil;
|
|
}
|
|
|
|
- (void) _appendComponentProperties: (NSDictionary *) properties
|
|
matchingFilters: (NSArray *) filters
|
|
toResponse: (WOResponse *) response
|
|
{
|
|
NSArray *apts;
|
|
NSMutableArray *fields;
|
|
NSDictionary *currentFilter;
|
|
NSEnumerator *filterList;
|
|
NSString *additionalFilters, *baseURL, *currentField;
|
|
NSMutableString *buffer;
|
|
NSString **propertiesArray;
|
|
NSEnumerator *addFields;
|
|
unsigned int count, max, propertiesCount;
|
|
|
|
fields = [NSMutableArray arrayWithObjects: @"c_name", @"c_component", nil];
|
|
addFields = [[properties allValues] objectEnumerator];
|
|
while ((currentField = [addFields nextObject]))
|
|
if ([currentField length])
|
|
[fields addObjectUniquely: currentField];
|
|
baseURL = [self davURLAsString];
|
|
|
|
propertiesArray = [[properties allKeys] asPointersOfObjects];
|
|
propertiesCount = [properties count];
|
|
|
|
// NSLog (@"start");
|
|
filterList = [filters objectEnumerator];
|
|
while ((currentFilter = [filterList nextObject]))
|
|
{
|
|
additionalFilters = [self _composeAdditionalFilters: currentFilter];
|
|
/* TODO: we should invoke bareFetchField:... twice and compute the
|
|
recurrent events properly instead of using _makeCyclicFilterFrom: */
|
|
apts = [self bareFetchFields: fields
|
|
from: [currentFilter objectForKey: @"start"]
|
|
to: [currentFilter objectForKey: @"end"]
|
|
title: [currentFilter objectForKey: @"title"]
|
|
component: [currentFilter objectForKey: @"name"]
|
|
additionalFilters: additionalFilters];
|
|
// NSLog(@"adding properties");
|
|
max = [apts count];
|
|
buffer = [NSMutableString stringWithCapacity: max * 512];
|
|
for (count = 0; count < max; count++)
|
|
[self appendObject: [apts objectAtIndex: count]
|
|
properties: propertiesArray
|
|
count: propertiesCount
|
|
withBaseURL: baseURL
|
|
toBuffer: buffer];
|
|
// NSLog(@"done 1");
|
|
[response appendContentString: buffer];
|
|
// NSLog(@"done 2");
|
|
}
|
|
// NSLog (@"stop");
|
|
|
|
NSZoneFree (NULL, propertiesArray);
|
|
}
|
|
|
|
/* This table is meant to match SQL fields to the properties that requires
|
|
them. The fields may NOT be processed directly. This list is not complete
|
|
but is at least sufficient for processing requests from Lightning. */
|
|
- (NSDictionary *) davSQLFieldsTable
|
|
{
|
|
static NSMutableDictionary *davSQLFieldsTable = nil;
|
|
|
|
if (!davSQLFieldsTable)
|
|
{
|
|
davSQLFieldsTable = [[super davSQLFieldsTable] mutableCopy];
|
|
[davSQLFieldsTable setObject: @"c_content"
|
|
forKey: @"{" XMLNS_CALDAV @"}calendar-data"];
|
|
}
|
|
|
|
return davSQLFieldsTable;
|
|
}
|
|
|
|
- (id) davCalendarQuery: (id) queryContext
|
|
{
|
|
WOResponse *r;
|
|
id <DOMDocument> document;
|
|
id <DOMElement> documentElement, propElement;
|
|
|
|
r = [context response];
|
|
[r prepareDAVResponse];
|
|
[r appendContentString: @"<D:multistatus xmlns:D=\"DAV:\""
|
|
@" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"];
|
|
|
|
document = [[context request] contentAsDOMDocument];
|
|
documentElement = (id <DOMElement>) [document documentElement];
|
|
propElement = [(NGDOMNodeWithChildren *) documentElement
|
|
firstElementWithTag: @"prop" inNamespace: XMLNS_WEBDAV];
|
|
|
|
[self _appendComponentProperties: [self parseDAVRequestedProperties: propElement]
|
|
matchingFilters: [self _parseCalendarFilters: documentElement]
|
|
toResponse: r];
|
|
[r appendContentString:@"</D:multistatus>"];
|
|
|
|
return r;
|
|
}
|
|
|
|
- (WOResponse *) davCalendarMultiget: (WOContext *) queryContext
|
|
{
|
|
return [self performMultigetInContext: queryContext
|
|
inNamespace: @"urn:ietf:params:xml:ns:caldav"];
|
|
}
|
|
|
|
- (NSString *) additionalWebdavSyncFilters
|
|
{
|
|
NSCalendarDate *startDate;
|
|
NSString *filter;
|
|
NSMutableArray *filters;
|
|
int startDateSecs;
|
|
|
|
filters = [NSMutableArray arrayWithCapacity: 8];
|
|
startDate = [self _getMaxStartDate];
|
|
if (startDate)
|
|
{
|
|
startDateSecs = (int) [startDate timeIntervalSince1970];
|
|
filter = [NSString stringWithFormat: @"(c_enddate = NULL"
|
|
@" OR (c_enddate >= %d AND c_iscycle = 0)"
|
|
@" OR (c_cycleenddate >= %d AND c_iscycle = 1))",
|
|
startDateSecs, startDateSecs];
|
|
[filters addObject: filter];
|
|
}
|
|
|
|
if (![self showCalendarTasks])
|
|
[filters addObject: @"c_component != 'vtodo'"];
|
|
|
|
return [filters componentsJoinedByString: @" AND "];
|
|
}
|
|
|
|
- (Class) objectClassForContent: (NSString *) content
|
|
{
|
|
iCalCalendar *calendar;
|
|
NSArray *elements;
|
|
NSString *firstTag;
|
|
Class objectClass;
|
|
|
|
objectClass = Nil;
|
|
|
|
calendar = [iCalCalendar parseSingleFromSource: content];
|
|
if (calendar)
|
|
{
|
|
elements = [calendar allObjects];
|
|
if ([elements count])
|
|
{
|
|
firstTag = [[[elements objectAtIndex: 0] tag] uppercaseString];
|
|
if ([firstTag isEqualToString: @"VEVENT"])
|
|
objectClass = [SOGoAppointmentObject class];
|
|
else if ([firstTag isEqualToString: @"VTODO"])
|
|
objectClass = [SOGoTaskObject class];
|
|
}
|
|
}
|
|
|
|
return objectClass;
|
|
}
|
|
|
|
- (BOOL) requestNamedIsHandledLater: (NSString *) name
|
|
{
|
|
return [name isEqualToString: @"OPTIONS"];
|
|
}
|
|
|
|
- (id) lookupName: (NSString *)_key
|
|
inContext: (id)_ctx
|
|
acquire: (BOOL)_flag
|
|
{
|
|
id obj;
|
|
NSString *url;
|
|
BOOL handledLater;
|
|
WORequest *rq;
|
|
|
|
/* first check attributes directly bound to the application */
|
|
handledLater = [self requestNamedIsHandledLater: _key];
|
|
if (handledLater)
|
|
obj = nil;
|
|
else
|
|
{
|
|
obj = [super lookupName:_key inContext:_ctx acquire:NO];
|
|
if (!obj)
|
|
{
|
|
rq = [_ctx request];
|
|
if ([self isValidContentName:_key]
|
|
&& [rq handledByDefaultHandler])
|
|
{
|
|
url = [[rq uri] urlWithoutParameters];
|
|
if ([url hasSuffix: @"AsTask"])
|
|
obj = [SOGoTaskObject objectWithName: _key
|
|
inContainer: self];
|
|
else if ([url hasSuffix: @"AsAppointment"])
|
|
obj = [SOGoAppointmentObject objectWithName: _key
|
|
inContainer: self];
|
|
[obj setIsNew: YES];
|
|
}
|
|
}
|
|
if (!obj)
|
|
obj = [NSException exceptionWithHTTPStatus:404 /* Not Found */];
|
|
}
|
|
|
|
if (obj)
|
|
[[SOGoCache sharedCache] registerObject: obj
|
|
withName: _key
|
|
inContainer: container];
|
|
|
|
return obj;
|
|
}
|
|
|
|
- (NSDictionary *) freebusyResponseForRecipient: (iCalPerson *) recipient
|
|
withUser: (SOGoUser *) user
|
|
andCalendarData: (NSString *) calendarData
|
|
{
|
|
NSDictionary *response;
|
|
NSMutableArray *content;
|
|
|
|
content = [NSMutableArray array];
|
|
|
|
[content addObject: davElementWithContent (@"recipient",
|
|
XMLNS_CALDAV, [recipient email])];
|
|
if (user)
|
|
{
|
|
[content addObject: davElementWithContent (@"request-status", XMLNS_CALDAV,
|
|
@"2.0;Success")];
|
|
[content addObject: davElementWithContent (@"calendar-data", XMLNS_CALDAV,
|
|
[calendarData safeStringByEscapingXMLString])];
|
|
}
|
|
else
|
|
[content addObject:
|
|
davElementWithContent (@"request-status", XMLNS_CALDAV,
|
|
@"3.7;Invalid Calendar User")];
|
|
response = davElementWithContent (@"response", XMLNS_CALDAV, content);
|
|
|
|
return response;
|
|
}
|
|
|
|
- (NSDictionary *) caldavFreeBusyRequestOnRecipient: (iCalPerson *) recipient
|
|
withUID: (NSString *) uid
|
|
andOrganizer: (iCalPerson *) organizer
|
|
from: (NSCalendarDate *) start
|
|
to: (NSCalendarDate *) to
|
|
{
|
|
SOGoUser *user;
|
|
NSString *login, *contactId, *calendarData;
|
|
SOGoFreeBusyObject *freebusy;
|
|
|
|
login = [recipient uid];
|
|
if ([login length])
|
|
{
|
|
user = [SOGoUser userWithLogin: login];
|
|
freebusy = [[user homeFolderInContext: context]
|
|
freeBusyObject: @"freebusy.ifb"
|
|
inContext: context];
|
|
calendarData = [freebusy contentAsStringWithMethod: @"REPLY"
|
|
andUID: uid
|
|
andOrganizer: organizer
|
|
andContact: nil
|
|
from: start to: to];
|
|
}
|
|
else if ((contactId = [recipient contactIDInContext: context]))
|
|
{
|
|
user = [context activeUser];
|
|
freebusy = [[user homeFolderInContext: context]
|
|
freeBusyObject: @"freebusy.ifb"
|
|
inContext: context];
|
|
calendarData = [freebusy contentAsStringWithMethod: @"REPLY"
|
|
andUID: uid
|
|
andOrganizer: organizer
|
|
andContact: contactId
|
|
from: start to: to];
|
|
}
|
|
else
|
|
{
|
|
user = nil;
|
|
calendarData = nil;
|
|
}
|
|
|
|
return [self freebusyResponseForRecipient: recipient
|
|
withUser: user
|
|
andCalendarData: calendarData];
|
|
}
|
|
|
|
- (NSDictionary *) caldavFreeBusyRequest: (iCalFreeBusy *) freebusy
|
|
{
|
|
NSDictionary *responseElement;
|
|
NSMutableArray *elements;
|
|
NSString *uid;
|
|
iCalPerson *recipient, *organizer;
|
|
NSEnumerator *allRecipients;
|
|
NSCalendarDate *startDate, *endDate;
|
|
|
|
elements = [NSMutableArray array];
|
|
[freebusy fillStartDate: &startDate andEndDate: &endDate];
|
|
uid = [freebusy uid];
|
|
organizer = [freebusy organizer];
|
|
allRecipients = [[freebusy attendees] objectEnumerator];
|
|
while ((recipient = [allRecipients nextObject]))
|
|
[elements addObject: [self caldavFreeBusyRequestOnRecipient: recipient
|
|
withUID: uid
|
|
andOrganizer: organizer
|
|
from: startDate
|
|
to: endDate]];
|
|
responseElement = davElementWithContent (@"schedule-response",
|
|
XMLNS_CALDAV, elements);
|
|
|
|
return responseElement;
|
|
}
|
|
|
|
#warning we should merge this code with the code from the iTIP interpreter in MailPartViewer
|
|
- (NSDictionary *) caldavEventRequest: (iCalEvent *) event
|
|
withContent: (NSString *) iCalString
|
|
from: (NSString *) originator
|
|
to: (NSArray *) recipients
|
|
{
|
|
NSDictionary *responseElement;
|
|
NSArray *elements;
|
|
NSString *method, *filename;
|
|
SOGoAppointmentObject *apt;
|
|
|
|
filename = [NSString stringWithFormat: @"%@.ics", [event uid]];
|
|
apt = [SOGoAppointmentObject objectWithName: filename
|
|
andContent: iCalString
|
|
inContainer: self];
|
|
method = [[event parent] method];
|
|
if ([method isEqualToString: @"REQUEST"])
|
|
elements = [apt postCalDAVEventRequestTo: recipients from: originator];
|
|
else if ([method isEqualToString: @"REPLY"])
|
|
elements = [apt postCalDAVEventReplyTo: recipients from: originator];
|
|
else if ([method isEqualToString: @"CANCEL"])
|
|
elements = [apt postCalDAVEventCancelTo: recipients from: originator];
|
|
else
|
|
elements = nil;
|
|
|
|
if (elements)
|
|
responseElement = davElementWithContent (@"schedule-response",
|
|
XMLNS_CALDAV, elements);
|
|
else
|
|
responseElement = nil;
|
|
|
|
return responseElement;
|
|
}
|
|
|
|
- (WOResponse *) _caldavScheduleResponse: (NSDictionary *) tags
|
|
{
|
|
WOResponse *response;
|
|
|
|
response = [context response];
|
|
if (tags)
|
|
{
|
|
// WARNING
|
|
// don't touch unless you're going to re-test caldav sync
|
|
// with an iPhone AND lightning
|
|
[response setStatus: 200];
|
|
[response appendContentString: @"<?xml version=\"1.0\""
|
|
@" encoding=\"utf-8\"?>"];
|
|
[response setHeader: @"application/xml; charset=utf-8"
|
|
forKey: @"Content-Type"];
|
|
[response appendContentString:
|
|
[tags asWebDavStringWithNamespaces: nil]];
|
|
}
|
|
else
|
|
[response setStatus: 415];
|
|
|
|
return response;
|
|
}
|
|
|
|
- (WOResponse *) caldavScheduleRequest: (NSString *) iCalString
|
|
from: (NSString *) originator
|
|
to: (NSArray *) recipients
|
|
{
|
|
NSString *tag;
|
|
iCalCalendar *calendar;
|
|
iCalEntityObject *element;
|
|
NSDictionary *tags;
|
|
|
|
#warning needs to handle errors
|
|
calendar = [iCalCalendar parseSingleFromSource: iCalString];
|
|
element = [[calendar allObjects] objectAtIndex: 0];
|
|
tag = [[element tag] uppercaseString];
|
|
if ([tag isEqualToString: @"VFREEBUSY"])
|
|
tags = [self caldavFreeBusyRequest: (iCalFreeBusy *) element];
|
|
else if ([tag isEqualToString: @"VEVENT"])
|
|
tags = [self caldavEventRequest: (iCalEvent *) element
|
|
withContent: iCalString
|
|
from: originator to: recipients];
|
|
else
|
|
tags = nil;
|
|
|
|
return [self _caldavScheduleResponse: tags];
|
|
}
|
|
|
|
- (id) davPOSTRequest: (WORequest *) request
|
|
withContentType: (NSString *) cType
|
|
inContext: (WOContext *) localContext
|
|
{
|
|
id obj;
|
|
NSString *originator;
|
|
NSArray *recipients;
|
|
|
|
if ([cType hasPrefix: @"text/calendar"])
|
|
{
|
|
originator = [request headerForKey: @"originator"];
|
|
|
|
if ([[originator lowercaseString] hasPrefix: @"mailto:"])
|
|
originator = [originator substringFromIndex: 7];
|
|
|
|
recipients = [[request headerForKey: @"recipient"]
|
|
componentsSeparatedByString: @","];
|
|
obj = [self caldavScheduleRequest: [request contentAsString]
|
|
from: originator to: [recipients trimmedComponents]];
|
|
}
|
|
else
|
|
obj = [super davPOSTRequest: request withContentType: cType
|
|
inContext: localContext];
|
|
|
|
return obj;
|
|
}
|
|
|
|
- (NSArray *) groupDavResourceType
|
|
{
|
|
return [NSArray arrayWithObjects: @"vevent-collection",
|
|
@"vtodo-collection", nil];
|
|
}
|
|
|
|
- (NSArray *) davResourceType
|
|
{
|
|
NSMutableArray *colType;
|
|
NSArray *gdRT, *gdVEventCol, *gdVTodoCol;
|
|
WORequest *request;
|
|
|
|
colType = [NSMutableArray arrayWithCapacity: 10];
|
|
[colType addObject: @"collection"];
|
|
[colType addObject: [NSArray arrayWithObjects: @"calendar", XMLNS_CALDAV, nil]];
|
|
|
|
/* iPhone compatibility: we can only return a caldav "calendar"
|
|
resourcetype. Anything else will prevent the iPhone from querying the
|
|
collection. */
|
|
request = [context request];
|
|
if (!([request isIPhone] || [request isICal4]))
|
|
{
|
|
gdRT = (NSArray *) [self groupDavResourceType];
|
|
gdVEventCol = [NSArray arrayWithObjects: [gdRT objectAtIndex: 0],
|
|
XMLNS_GROUPDAV, nil];
|
|
[colType addObject: gdVEventCol];
|
|
if ([self showCalendarTasks])
|
|
{
|
|
gdVTodoCol = [NSArray arrayWithObjects: [gdRT objectAtIndex: 1],
|
|
XMLNS_GROUPDAV, nil];
|
|
[colType addObject: gdVTodoCol];
|
|
}
|
|
if ([nameInContainer isEqualToString: @"personal"])
|
|
[colType addObject: [NSArray arrayWithObjects: @"schedule-outbox",
|
|
XMLNS_CALDAV, nil]];
|
|
}
|
|
|
|
return colType;
|
|
}
|
|
|
|
- (SOGoWebDAVValue *) davCalendarComponentSet
|
|
{
|
|
NSMutableArray *components;
|
|
|
|
if (!componentSet)
|
|
{
|
|
components = [[NSMutableArray alloc] initWithCapacity: 2];
|
|
/* Totally hackish.... we use the "n1" prefix because we know our
|
|
extensions will assign that one to ..:caldav but we really need to
|
|
handle element attributes */
|
|
[components addObject: [SOGoWebDAVValue
|
|
valueForObject: @"<n1:comp name=\"VEVENT\"/>"
|
|
attributes: nil]];
|
|
|
|
// See bugs #2878 and #2879
|
|
[components addObject: [SOGoWebDAVValue
|
|
valueForObject: @"<n1:comp name=\"VFREEBUSY\"/>"
|
|
attributes: nil]];
|
|
|
|
if ([self showCalendarTasks])
|
|
[components addObject: [SOGoWebDAVValue
|
|
valueForObject: @"<n1:comp name=\"VTODO\"/>"
|
|
attributes: nil]];
|
|
componentSet
|
|
= [davElementWithContent (@"supported-calendar-component-set",
|
|
XMLNS_CALDAV,
|
|
components)
|
|
asWebDAVValue];
|
|
[componentSet retain];
|
|
[components release];
|
|
}
|
|
|
|
return componentSet;
|
|
}
|
|
|
|
- (NSString *) davDescription
|
|
{
|
|
return @"";
|
|
}
|
|
|
|
/*
|
|
RFC5842 states:
|
|
|
|
3.1. DAV:resource-id Property
|
|
|
|
The DAV:resource-id property is a REQUIRED property that enables
|
|
clients to determine whether two bindings are to the same resource.
|
|
The value of DAV:resource-id is a URI, and may use any registered URI
|
|
scheme that guarantees the uniqueness of the value across all
|
|
resources for all time (e.g., the urn:uuid: URN namespace defined in
|
|
[RFC4122] or the opaquelocktoken: URI scheme defined in [RFC4918]).
|
|
|
|
<!ELEMENT resource-id (href)>
|
|
|
|
...
|
|
|
|
so we must STRIP any username prefix, to make the ID global.
|
|
|
|
*/
|
|
- (NSString *) davResourceId
|
|
{
|
|
NSString *name, *prefix;
|
|
|
|
prefix = [NSString stringWithFormat: @"%@_", [self ownerInContext: context]];
|
|
name = [self nameInContainer];
|
|
|
|
if ([name hasPrefix: prefix])
|
|
{
|
|
name = [name substringFromIndex: [prefix length]];
|
|
}
|
|
|
|
return [NSString stringWithFormat: @"urn:uuid:%@:calendars:%@",
|
|
[self ownerInContext: context], name];
|
|
}
|
|
|
|
- (NSArray *) davScheduleCalendarTransparency
|
|
{
|
|
const NSString *opacity;
|
|
|
|
opacity = ([self includeInFreeBusy] ? @"opaque" : @"transparent");
|
|
|
|
return [NSArray arrayWithObject: [NSArray arrayWithObjects: opacity,
|
|
XMLNS_CALDAV,
|
|
nil]];
|
|
}
|
|
|
|
- (NSException *) setDavScheduleCalendarTransparency: (id) newName
|
|
{
|
|
NSException *error;
|
|
|
|
error = nil;
|
|
|
|
if ([newName rangeOfString: @"opaque"].location != NSNotFound)
|
|
[self setIncludeInFreeBusy: YES];
|
|
else if ([newName rangeOfString: @"transparent"].location != NSNotFound)
|
|
[self setIncludeInFreeBusy: NO];
|
|
else
|
|
error = [NSException exceptionWithHTTPStatus: 400
|
|
reason: @"Bad transparency value."];
|
|
|
|
return error;
|
|
}
|
|
|
|
- (NSString *) davCalendarShowAlarms
|
|
{
|
|
return [self davBooleanForResult: [self showCalendarAlarms]];
|
|
}
|
|
|
|
- (NSException *) setDavCalendarShowAlarms: (id) newBoolean
|
|
{
|
|
NSException *error;
|
|
|
|
if ([self isValidDAVBoolean: newBoolean])
|
|
{
|
|
[self setShowCalendarAlarms: [self resultForDAVBoolean: newBoolean]];
|
|
error = nil;
|
|
}
|
|
else
|
|
error = [NSException exceptionWithHTTPStatus: 400
|
|
reason: @"Bad boolean value."];
|
|
|
|
return error;
|
|
}
|
|
|
|
- (NSString *) davNotifyOnPersonalModifications
|
|
{
|
|
return [self davBooleanForResult: [self notifyOnPersonalModifications]];
|
|
}
|
|
|
|
- (NSException *) setDavNotifyOnPersonalModifications: (NSString *) newBoolean
|
|
{
|
|
NSException *error;
|
|
|
|
if ([self isValidDAVBoolean: newBoolean])
|
|
{
|
|
[self setNotifyOnPersonalModifications:
|
|
[self resultForDAVBoolean: newBoolean]];
|
|
error = nil;
|
|
}
|
|
else
|
|
error = [NSException exceptionWithHTTPStatus: 400
|
|
reason: @"Bad boolean value."];
|
|
|
|
return error;
|
|
}
|
|
|
|
- (NSString *) davNotifyOnExternalModifications
|
|
{
|
|
return [self davBooleanForResult: [self notifyOnExternalModifications]];
|
|
}
|
|
|
|
- (NSException *) setDavNotifyOnExternalModifications: (NSString *) newBoolean
|
|
{
|
|
NSException *error;
|
|
|
|
if ([self isValidDAVBoolean: newBoolean])
|
|
{
|
|
[self setNotifyOnExternalModifications:
|
|
[self resultForDAVBoolean: newBoolean]];
|
|
error = nil;
|
|
}
|
|
else
|
|
error = [NSException exceptionWithHTTPStatus: 400
|
|
reason: @"Bad boolean value."];
|
|
|
|
return error;
|
|
}
|
|
|
|
- (NSString *) davNotifyUserOnPersonalModifications
|
|
{
|
|
return [self davBooleanForResult: [self notifyUserOnPersonalModifications]];
|
|
}
|
|
|
|
- (NSException *) setDavNotifyUserOnPersonalModifications: (NSString *) newBoolean
|
|
{
|
|
NSException *error;
|
|
|
|
if ([self isValidDAVBoolean: newBoolean])
|
|
{
|
|
[self setNotifyUserOnPersonalModifications:
|
|
[self resultForDAVBoolean: newBoolean]];
|
|
error = nil;
|
|
}
|
|
else
|
|
error = [NSException exceptionWithHTTPStatus: 400
|
|
reason: @"Bad boolean value."];
|
|
|
|
return error;
|
|
}
|
|
|
|
- (NSString *) davNotifiedUserOnPersonalModifications
|
|
{
|
|
return [self notifiedUserOnPersonalModifications];
|
|
}
|
|
|
|
- (NSException *) setDavNotifiedUserOnPersonalModifications: (NSString *) theUser
|
|
{
|
|
[self setNotifiedUserOnPersonalModifications: theUser];
|
|
|
|
return nil;
|
|
}
|
|
|
|
/* vevent UID handling */
|
|
|
|
- (NSString *) resourceNameForEventUID: (NSString *) uid
|
|
inFolder: (GCSFolder *) folder
|
|
{
|
|
static NSArray *nameFields = nil;
|
|
EOQualifier *qualifier;
|
|
NSArray *records;
|
|
NSString *filename;
|
|
unsigned int count;
|
|
|
|
filename = nil;
|
|
|
|
if (!nameFields)
|
|
nameFields = [[NSArray alloc] initWithObjects: @"c_name", nil];
|
|
|
|
if (uid && folder)
|
|
{
|
|
qualifier = [EOQualifier qualifierWithQualifierFormat: @"c_uid = %@",
|
|
[uid asSafeSQLString]];
|
|
records = [folder fetchFields: nameFields matchingQualifier: qualifier];
|
|
count = [records count];
|
|
if (count)
|
|
{
|
|
filename = [[records objectAtIndex:0] valueForKey: @"c_name"];
|
|
if (count > 1)
|
|
[self errorWithFormat:
|
|
@"The storage contains more than file with UID '%@'",
|
|
uid];
|
|
}
|
|
}
|
|
|
|
return filename;
|
|
}
|
|
|
|
- (NSString *) resourceNameForEventUID: (NSString *) uid
|
|
{
|
|
/* caches UIDs */
|
|
GCSFolder *folder;
|
|
NSString *rname;
|
|
|
|
rname = nil;
|
|
if (uid)
|
|
{
|
|
if (!uidToFilename)
|
|
uidToFilename = [NSMutableDictionary new];
|
|
rname = [uidToFilename objectForKey: uid];
|
|
if (!rname)
|
|
{
|
|
folder = [self ocsFolder];
|
|
rname = [self resourceNameForEventUID: uid inFolder: folder];
|
|
if (rname)
|
|
[uidToFilename setObject: rname forKey: uid];
|
|
}
|
|
}
|
|
|
|
return rname;
|
|
}
|
|
|
|
- (NSArray *) subscriptionRoles
|
|
{
|
|
return [NSArray arrayWithObjects:
|
|
SOGoRole_ObjectCreator,
|
|
SOGoRole_ObjectEraser,
|
|
SOGoCalendarRole_PublicResponder,
|
|
SOGoCalendarRole_PublicModifier,
|
|
SOGoCalendarRole_PublicViewer,
|
|
SOGoCalendarRole_PublicDAndTViewer,
|
|
SOGoCalendarRole_PrivateResponder,
|
|
SOGoCalendarRole_PrivateModifier,
|
|
SOGoCalendarRole_PrivateViewer,
|
|
SOGoCalendarRole_PrivateDAndTViewer,
|
|
SOGoCalendarRole_ConfidentialResponder,
|
|
SOGoCalendarRole_ConfidentialModifier,
|
|
SOGoCalendarRole_ConfidentialViewer,
|
|
SOGoCalendarRole_ConfidentialDAndTViewer, nil];
|
|
}
|
|
|
|
- (NSString *) roleForComponentsWithAccessClass: (iCalAccessClass) accessClass
|
|
forUser: (NSString *) uid
|
|
{
|
|
NSString *accessRole, *ownerLogin, *prefix, *currentRole, *suffix;
|
|
NSEnumerator *acls;
|
|
NSMutableDictionary *userRoles;
|
|
|
|
accessRole = nil;
|
|
|
|
if (accessClass == iCalAccessPublic)
|
|
prefix = @"Public";
|
|
else if (accessClass == iCalAccessPrivate)
|
|
prefix = @"Private";
|
|
else
|
|
prefix = @"Confidential";
|
|
|
|
userRoles = [aclMatrix objectForKey: uid];
|
|
if (!userRoles)
|
|
{
|
|
userRoles = [NSMutableDictionary dictionaryWithCapacity: 3];
|
|
[aclMatrix setObject: userRoles forKey: uid];
|
|
}
|
|
|
|
accessRole = [userRoles objectForKey: prefix];
|
|
if (!accessRole)
|
|
{
|
|
ownerLogin = [self ownerInContext: context];
|
|
if ([ownerLogin isEqualToString: uid])
|
|
accessRole = @"";
|
|
else
|
|
{
|
|
acls = [[self aclsForUser: uid] objectEnumerator];
|
|
currentRole = [acls nextObject];
|
|
while (currentRole && !accessRole)
|
|
if ([currentRole hasPrefix: prefix])
|
|
{
|
|
suffix = [currentRole substringFromIndex: [prefix length]];
|
|
accessRole = [NSString stringWithFormat: @"Component%@", suffix];
|
|
}
|
|
else
|
|
currentRole = [acls nextObject];
|
|
if (!accessRole)
|
|
accessRole = @"";
|
|
}
|
|
[userRoles setObject: accessRole forKey: prefix];
|
|
}
|
|
|
|
return accessRole;
|
|
}
|
|
|
|
- (void) initializeQuickTablesAclsInContext: (WOContext *) localContext
|
|
{
|
|
NSString *login, *role, *permission;
|
|
iCalAccessClass currentClass;
|
|
unsigned int permStrIndex;
|
|
|
|
[super initializeQuickTablesAclsInContext: localContext];
|
|
/* We assume "userCanAccessAllObjects" will be set after calling the super method. */
|
|
if (!userCanAccessAllObjects)
|
|
{
|
|
login = [[localContext activeUser] login];
|
|
permStrIndex = [@"Component" length];
|
|
}
|
|
|
|
for (currentClass = 0; currentClass < iCalAccessClassCount; currentClass++)
|
|
{
|
|
if (userCanAccessAllObjects)
|
|
userCanAccessObjectsClassifiedAs[currentClass] = YES;
|
|
else
|
|
{
|
|
role = [self roleForComponentsWithAccessClass: currentClass
|
|
forUser: login];
|
|
if ([role length])
|
|
{
|
|
permission = [role substringFromIndex: permStrIndex];
|
|
userCanAccessObjectsClassifiedAs[currentClass]
|
|
= ([permission isEqualToString: @"Viewer"]
|
|
|| [permission isEqualToString: @"DAndTViewer"]
|
|
|| [permission isEqualToString: @"Modifier"]
|
|
|| [permission isEqualToString: @"Responder"]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
- (NSArray *) fetchFreeBusyInfosFrom: (NSCalendarDate *) _startDate
|
|
to: (NSCalendarDate *) _endDate
|
|
{
|
|
static NSArray *infos = nil; // TODO: move to a plist file
|
|
|
|
if (!infos)
|
|
infos = [[NSArray alloc] initWithObjects: @"c_content", @"c_partmails", @"c_partstates",
|
|
@"c_isopaque", @"c_status", @"c_cycleinfo", @"c_orgmail", nil];
|
|
|
|
// We MUST include the protected information when checking for freebusy info as
|
|
// we rely on the c_partmails/c_partstates fields for many operations.
|
|
return [self fetchFields: infos
|
|
from: _startDate to: _endDate
|
|
title: nil
|
|
component: @"vevent"
|
|
additionalFilters: nil
|
|
includeProtectedInformation: YES];
|
|
}
|
|
|
|
- (NSArray *) fetchCoreInfosFrom: (NSCalendarDate *) _startDate
|
|
to: (NSCalendarDate *) _endDate
|
|
title: (NSString *) title
|
|
component: (id) _component
|
|
{
|
|
return [self fetchCoreInfosFrom: _startDate to: _endDate title: title
|
|
component: _component additionalFilters: nil];
|
|
}
|
|
|
|
- (NSArray *) fetchCoreInfosFrom: (NSCalendarDate *) _startDate
|
|
to: (NSCalendarDate *) _endDate
|
|
title: (NSString *) title
|
|
component: (id) _component
|
|
additionalFilters: (NSString *) filters
|
|
{
|
|
static NSArray *infos = nil; // TODO: move to a plist file
|
|
|
|
if (!infos)
|
|
infos = [[NSArray alloc] initWithObjects: @"c_name", @"c_content",
|
|
@"c_creationdate", @"c_lastmodified",
|
|
@"c_version", @"c_component", @"c_title",
|
|
@"c_location", @"c_orgmail", @"c_status",
|
|
@"c_category", @"c_classification", @"c_isallday",
|
|
@"c_isopaque", @"c_participants", @"c_partmails",
|
|
@"c_partstates", @"c_sequence", @"c_priority",
|
|
@"c_cycleinfo", @"c_iscycle", @"c_nextalarm", @"c_description", nil];
|
|
|
|
return [self fetchFields: infos from: _startDate to: _endDate title: title
|
|
component: _component
|
|
additionalFilters: filters
|
|
includeProtectedInformation: NO];
|
|
}
|
|
|
|
- (NSArray *) fetchAlarmInfosFrom: (NSNumber *) _startUTCDate
|
|
to: (NSNumber *) _endUTCDate
|
|
{
|
|
static NSArray *nameFields = nil;
|
|
EOQualifier *qualifier;
|
|
GCSFolder *folder;
|
|
NSArray *records;
|
|
NSString *sql;
|
|
|
|
if (!nameFields)
|
|
nameFields = [[NSArray alloc] initWithObjects: @"c_name", @"c_nextalarm", @"c_iscycle", nil];
|
|
|
|
folder = [self ocsFolder];
|
|
if (!folder)
|
|
{
|
|
[self errorWithFormat:@"(%s): missing folder for fetch!",
|
|
__PRETTY_FUNCTION__];
|
|
return nil;
|
|
}
|
|
|
|
sql = [NSString stringWithFormat: @"((c_nextalarm <= %u) AND (c_nextalarm >= %u)) OR ((c_nextalarm > 0) AND (c_nextalarm <= %u) AND (c_enddate > %u))",
|
|
[_endUTCDate unsignedIntValue], [_startUTCDate unsignedIntValue], [_startUTCDate unsignedIntValue], [_startUTCDate unsignedIntValue]];
|
|
qualifier = [EOQualifier qualifierWithQualifierFormat: sql];
|
|
records = [folder fetchFields: nameFields matchingQualifier: qualifier];
|
|
|
|
return records;
|
|
}
|
|
|
|
/* URL generation */
|
|
|
|
- (NSString *) baseURLForAptWithUID: (NSString *)_uid
|
|
inContext: (id)_ctx
|
|
{
|
|
// TODO: who calls this?
|
|
NSString *url;
|
|
|
|
if ([_uid length] == 0)
|
|
return nil;
|
|
|
|
url = [self baseURLInContext:_ctx];
|
|
if (![url hasSuffix: @"/"])
|
|
url = [url stringByAppendingString: @"/"];
|
|
|
|
// TODO: this should run a query to determine the uid!
|
|
return [url stringByAppendingString:_uid];
|
|
}
|
|
|
|
- (NSString *) _baseCalDAVURL
|
|
{
|
|
NSString *davURL;
|
|
|
|
if (!baseCalDAVURL)
|
|
{
|
|
davURL = [[self realDavURL] absoluteString];
|
|
if ([davURL hasSuffix: @"/"])
|
|
baseCalDAVURL = [davURL substringToIndex: [davURL length] - 1];
|
|
else
|
|
baseCalDAVURL = davURL;
|
|
[baseCalDAVURL retain];
|
|
}
|
|
|
|
return baseCalDAVURL;
|
|
}
|
|
|
|
- (NSString *) _basePublicCalDAVURL
|
|
{
|
|
NSString *davURL;
|
|
|
|
if (!basePublicCalDAVURL)
|
|
{
|
|
davURL = [[self publicDavURL] absoluteString];
|
|
if ([davURL hasSuffix: @"/"])
|
|
basePublicCalDAVURL = [davURL substringToIndex: [davURL length] - 1];
|
|
else
|
|
basePublicCalDAVURL = davURL;
|
|
[basePublicCalDAVURL retain];
|
|
}
|
|
|
|
return basePublicCalDAVURL;
|
|
}
|
|
|
|
- (NSString *) calDavURL
|
|
{
|
|
return [NSString stringWithFormat: @"%@/", [self _baseCalDAVURL]];
|
|
}
|
|
|
|
- (NSString *) webDavICSURL
|
|
{
|
|
return [NSString stringWithFormat: @"%@.ics", [self _baseCalDAVURL]];
|
|
}
|
|
|
|
- (NSString *) webDavXMLURL
|
|
{
|
|
return [NSString stringWithFormat: @"%@.xml", [self _baseCalDAVURL]];
|
|
}
|
|
|
|
- (NSString *) publicCalDavURL
|
|
{
|
|
return [NSString stringWithFormat: @"%@/", [self _basePublicCalDAVURL]];
|
|
}
|
|
|
|
- (NSString *) publicWebDavICSURL
|
|
{
|
|
return [NSString stringWithFormat: @"%@.ics", [self _basePublicCalDAVURL]];
|
|
}
|
|
|
|
- (NSString *) publicWebDavXMLURL
|
|
{
|
|
return [NSString stringWithFormat: @"%@.xml", [self _basePublicCalDAVURL]];
|
|
}
|
|
|
|
/* folder management */
|
|
- (BOOL) create
|
|
{
|
|
BOOL rc;
|
|
SOGoUserSettings *userSettings;
|
|
NSMutableDictionary *calendarSettings;
|
|
SOGoUser *ownerUser;
|
|
|
|
rc = [super create];
|
|
if (rc)
|
|
{
|
|
ownerUser = [SOGoUser userWithLogin: [self ownerInContext: context]];
|
|
userSettings = [ownerUser userSettings];
|
|
calendarSettings = [userSettings objectForKey: @"Calendar"];
|
|
if (!calendarSettings)
|
|
{
|
|
calendarSettings = [NSMutableDictionary dictionary];
|
|
[userSettings setObject: calendarSettings forKey: @"Calendar"];
|
|
}
|
|
[userSettings synchronize];
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
- (void) removeFolderSettings: (NSMutableDictionary *) moduleSettings
|
|
withReference: (NSString *) reference
|
|
{
|
|
NSMutableArray *refArray;
|
|
NSMutableDictionary *refDict;
|
|
|
|
refDict = [moduleSettings objectForKey: @"FreeBusyExclusions"];
|
|
[refDict removeObjectForKey: reference];
|
|
|
|
refDict = [moduleSettings objectForKey: @"FolderColors"];
|
|
[refDict removeObjectForKey: reference];
|
|
|
|
refDict = [moduleSettings objectForKey: @"FolderShowAlarms"];
|
|
[refDict removeObjectForKey: reference];
|
|
|
|
refDict = [moduleSettings objectForKey: @"FolderShowTasks"];
|
|
[refDict removeObjectForKey: reference];
|
|
|
|
refDict = [moduleSettings objectForKey: @"FolderSynchronize"];
|
|
[refDict removeObjectForKey: reference];
|
|
|
|
refDict = [moduleSettings objectForKey: @"NotifyOnExternalModifications"];
|
|
[refDict removeObjectForKey: reference];
|
|
|
|
refDict = [moduleSettings objectForKey: @"NotifyOnPersonalModifications"];
|
|
[refDict removeObjectForKey: reference];
|
|
|
|
refDict = [moduleSettings objectForKey: @"NotifyUserOnPersonalModifications"];
|
|
[refDict removeObjectForKey: reference];
|
|
|
|
refArray = [moduleSettings objectForKey: @"FoldersOrder"];
|
|
[refArray removeObject: nameInContainer];
|
|
|
|
refArray = [moduleSettings objectForKey: @"InactiveFolders"];
|
|
[refArray removeObject: nameInContainer];
|
|
|
|
[super removeFolderSettings: moduleSettings
|
|
withReference: reference];
|
|
}
|
|
|
|
- (id) lookupHomeFolderForUID: (NSString *) _uid
|
|
inContext: (id)_ctx
|
|
{
|
|
// TODO: DUP to SOGoGroupFolder
|
|
NSException *error = nil;
|
|
NSArray *path;
|
|
id ctx, result;
|
|
|
|
if (![_uid isNotNull])
|
|
return nil;
|
|
|
|
/* create subcontext, so that we don't destroy our environment */
|
|
|
|
if ((ctx = [context createSubContext]) == nil) {
|
|
[self errorWithFormat:@"could not create SOPE subcontext!"];
|
|
return nil;
|
|
}
|
|
|
|
/* build path */
|
|
|
|
path = _uid != nil ? [NSArray arrayWithObjects:&_uid count:1] : nil;
|
|
|
|
/* traverse path */
|
|
|
|
result = [[ctx application] traversePathArray:path inContext:ctx
|
|
error:&error acquire:NO];
|
|
if (error != nil) {
|
|
[self errorWithFormat: @"folder lookup failed (c_uid=%@): %@",
|
|
_uid, error];
|
|
return nil;
|
|
}
|
|
|
|
[self debugWithFormat:@"Note: got folder for uid %@ path %@: %@",
|
|
_uid, [path componentsJoinedByString:@"=>"], result];
|
|
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// This method returns an array containing all the calendar folders
|
|
// of a specific user, excluding her/his subscriptions.
|
|
//
|
|
- (NSArray *) lookupCalendarFoldersForUID: (NSString *) theUID
|
|
{
|
|
NSArray *aFolders;
|
|
SOGoUser *theUser;
|
|
NSEnumerator *e;
|
|
NSMutableArray *aUserFolders;
|
|
SOGoAppointmentFolders *aParent;
|
|
SOGoFolder *aFolder;
|
|
|
|
aUserFolders = [NSMutableArray arrayWithCapacity: 16];
|
|
|
|
theUser = [SOGoUser userWithLogin: theUID];
|
|
aParent = [theUser calendarsFolderInContext: context];
|
|
|
|
if ([aParent isKindOfClass: [NSException class]])
|
|
return nil;
|
|
|
|
aFolders = [aParent subFolders];
|
|
e = [aFolders objectEnumerator];
|
|
while ((aFolder = [e nextObject]))
|
|
{
|
|
if (![aFolder isSubscription])
|
|
[aUserFolders addObject: aFolder];
|
|
}
|
|
|
|
return aUserFolders;
|
|
}
|
|
|
|
- (NSArray *) lookupCalendarFoldersForUIDs: (NSArray *) _uids
|
|
inContext: (id)_ctx
|
|
{
|
|
/* Note: can return NSNull objects in the array! */
|
|
NSMutableArray *folders;
|
|
NSEnumerator *e;
|
|
NSString *uid, *ownerLogin;
|
|
SOGoUser *user;
|
|
id folder;
|
|
|
|
ownerLogin = [self ownerInContext: context];
|
|
|
|
if ([_uids count] == 0) return nil;
|
|
folders = [NSMutableArray arrayWithCapacity:16];
|
|
e = [_uids objectEnumerator];
|
|
while ((uid = [e nextObject]))
|
|
{
|
|
if ([uid isEqualToString: ownerLogin])
|
|
folder = self;
|
|
else
|
|
{
|
|
user = [SOGoUser userWithLogin: uid];
|
|
folder = [user personalCalendarFolderInContext: context];
|
|
if (![folder isNotNull])
|
|
[self logWithFormat:@"Note: did not find folder for uid: '%@'", uid];
|
|
}
|
|
|
|
if (folder)
|
|
[folders addObject: folder];
|
|
}
|
|
|
|
return folders;
|
|
}
|
|
|
|
- (NSArray *) lookupFreeBusyObjectsForUIDs: (NSArray *) _uids
|
|
inContext: (id) _ctx
|
|
{
|
|
/* Note: can return NSNull objects in the array! */
|
|
NSMutableArray *objs;
|
|
NSEnumerator *e;
|
|
NSString *uid;
|
|
|
|
if ([_uids count] == 0) return nil;
|
|
objs = [NSMutableArray arrayWithCapacity:16];
|
|
e = [_uids objectEnumerator];
|
|
while ((uid = [e nextObject]))
|
|
{
|
|
id obj;
|
|
|
|
obj = [self lookupHomeFolderForUID:uid inContext:nil];
|
|
if ([obj isNotNull])
|
|
{
|
|
obj = [obj lookupName: @"freebusy.ifb" inContext: nil acquire: NO];
|
|
if ([obj isKindOfClass: [NSException class]])
|
|
obj = nil;
|
|
}
|
|
if (![obj isNotNull])
|
|
[self logWithFormat: @"Note: did not find freebusy.ifb for uid: '%@'",
|
|
uid];
|
|
|
|
/* Note: intentionally add 'null' folders to allow a mapping */
|
|
if (!obj)
|
|
obj = [NSNull null];
|
|
[objs addObject: obj];
|
|
}
|
|
|
|
return objs;
|
|
}
|
|
|
|
- (NSArray *) uidsFromICalPersons: (NSArray *) _persons
|
|
{
|
|
/* Note: can return NSNull objects in the array! */
|
|
NSMutableArray *uids;
|
|
SOGoUserManager *um;
|
|
unsigned i, count;
|
|
iCalPerson *person;
|
|
NSString *email;
|
|
NSString *uid;
|
|
|
|
if (_persons)
|
|
{
|
|
count = [_persons count];
|
|
uids = [NSMutableArray arrayWithCapacity:count + 1];
|
|
um = [SOGoUserManager sharedUserManager];
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
person = [_persons objectAtIndex:i];
|
|
email = [person rfc822Email];
|
|
if ([email isNotNull])
|
|
uid = [um getUIDForEmail:email];
|
|
else
|
|
uid = nil;
|
|
|
|
if (!uid)
|
|
uid = (NSString *) [NSNull null];
|
|
[uids addObject: uid];
|
|
}
|
|
}
|
|
else
|
|
uids = nil;
|
|
|
|
return uids;
|
|
}
|
|
|
|
- (NSArray *) lookupCalendarFoldersForICalPerson: (NSArray *) _persons
|
|
inContext: (id) _ctx
|
|
{
|
|
/* Note: can return NSNull objects in the array! */
|
|
NSArray *uids, *folders;
|
|
|
|
uids = [self uidsFromICalPersons: _persons];
|
|
if (uids)
|
|
folders = [self lookupCalendarFoldersForUIDs: uids
|
|
inContext: _ctx];
|
|
else
|
|
folders = nil;
|
|
|
|
return folders;
|
|
}
|
|
|
|
/* folder type */
|
|
|
|
- (NSString *) folderType
|
|
{
|
|
return @"Appointment";
|
|
}
|
|
|
|
- (BOOL) isActive
|
|
{
|
|
SOGoUserSettings *settings;
|
|
NSArray *inactiveFolders;
|
|
|
|
settings = [[context activeUser] userSettings];
|
|
inactiveFolders
|
|
= [[settings objectForKey: @"Calendar"] objectForKey: @"InactiveFolders"];
|
|
|
|
return (![inactiveFolders containsObject: nameInContainer]);
|
|
}
|
|
|
|
- (BOOL) isWebCalendar
|
|
{
|
|
return ([self isKindOfClass: [SOGoWebAppointmentFolder class]]);
|
|
}
|
|
|
|
- (NSString *) importComponent: (iCalEntityObject *) event
|
|
timezone: (iCalTimeZone *) timezone
|
|
{
|
|
SOGoAppointmentObject *object;
|
|
NSMutableString *content;
|
|
NSString *uid;
|
|
|
|
// We first look if the event has any / or + in its UID. If that's the case
|
|
// we generate a new UID based on a GUID
|
|
uid = [event uid];
|
|
|
|
if (![uid length] ||
|
|
[uid rangeOfCharacterFromSet: [NSCharacterSet characterSetWithCharactersInString: @"+/"]].location != NSNotFound)
|
|
{
|
|
uid = [self globallyUniqueObjectId];
|
|
[event setUid: uid];
|
|
}
|
|
else
|
|
{
|
|
// We also look if there's an event with the same UID in our calendar. If not,
|
|
// let's reuse what is in the event, otherwise generate a new GUID and use it.
|
|
object = [self lookupName: uid
|
|
inContext: context
|
|
acquire: NO];
|
|
|
|
if (object && ![object isKindOfClass: [NSException class]])
|
|
{
|
|
uid = [self globallyUniqueObjectId];
|
|
[event setUid: uid];
|
|
}
|
|
}
|
|
|
|
// If the UID isn't ending with the ".ics" extension, let's add it to avoid
|
|
// confusing broken CalDAV client (like Nokia N9 and Korganizer) that relies
|
|
// on this (see #2308)
|
|
if (![[uid lowercaseString] hasSuffix: @".ics"])
|
|
uid = [NSString stringWithFormat: @"%@.ics", uid];
|
|
|
|
object = [SOGoAppointmentObject objectWithName: uid
|
|
inContainer: self];
|
|
[object setIsNew: YES];
|
|
content = [NSMutableString stringWithString: @"BEGIN:VCALENDAR\n"];
|
|
[content appendFormat: @"PRODID:-//Inverse inc./SOGo %@//EN\n", SOGoVersion];
|
|
|
|
if (timezone)
|
|
[content appendFormat: @"%@\n", [timezone versitString]];
|
|
[content appendFormat: @"%@\nEND:VCALENDAR", [event versitString]];
|
|
|
|
return ([object saveCalendar: [iCalCalendar parseSingleFromSource: content]] == nil) ? uid : nil;
|
|
}
|
|
|
|
/**
|
|
* Import all components of a vCalendar.
|
|
* @param calendar the calendar to import
|
|
* @return the number of components imported
|
|
*/
|
|
- (int) importCalendar: (iCalCalendar *) calendar
|
|
{
|
|
NSArray *vtimezones;
|
|
NSMutableArray *components;
|
|
NSMutableDictionary *timezones, *uids;
|
|
NSString *uid, *originalUid;
|
|
iCalEntityObject *element;
|
|
iCalTimeZone *timezone;
|
|
iCalCalendar *masterCalendar;
|
|
iCalEvent *event;
|
|
NSAutoreleasePool *pool;
|
|
|
|
int imported, count, i;
|
|
|
|
imported = 0;
|
|
|
|
if (calendar)
|
|
{
|
|
// Build a hash with the timezones includes in the calendar
|
|
vtimezones = [calendar timezones];
|
|
count = [vtimezones count];
|
|
timezones = [NSMutableDictionary dictionaryWithCapacity: count];
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
timezone = (iCalTimeZone *)[vtimezones objectAtIndex: i];
|
|
[timezones setValue: timezone
|
|
forKey: [timezone tzId]];
|
|
}
|
|
|
|
// Parse events/todos/journals and import them
|
|
uids = [NSMutableDictionary dictionary];
|
|
components = [[calendar events] mutableCopy];
|
|
[components autorelease];
|
|
[components addObjectsFromArray: [calendar todos]];
|
|
// [components addObjectsFromArray: [calendar journals]];
|
|
// [components addObjectsFromArray: [calendar freeBusys]];
|
|
count = [components count];
|
|
|
|
pool = [[NSAutoreleasePool alloc] init];
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
if (i % 10 == 0)
|
|
{
|
|
DESTROY(pool);
|
|
pool = [[NSAutoreleasePool alloc] init];
|
|
}
|
|
|
|
timezone = nil;
|
|
element = [components objectAtIndex: i];
|
|
|
|
if ([element isKindOfClass: iCalEventK])
|
|
{
|
|
event = (iCalEvent *)element;
|
|
timezone = [event adjustInContext: self->context withTimezones: timezones];
|
|
|
|
if ([event recurrenceId])
|
|
{
|
|
// Event is an occurrence of a repeating event
|
|
if ((uid = [uids valueForKey: [event uid]]))
|
|
{
|
|
SOGoAppointmentObject *master = [self lookupName: uid
|
|
inContext: context
|
|
acquire: NO];
|
|
if (master)
|
|
{
|
|
// Associate the occurrence to the master event and skip the actual import process
|
|
masterCalendar = [master calendar: NO secure: NO];
|
|
[masterCalendar addToEvents: event];
|
|
if (timezone)
|
|
[masterCalendar addTimeZone: timezone];
|
|
[master saveCalendar: masterCalendar];
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
originalUid = [element uid];
|
|
if ((uid = [self importComponent: element
|
|
timezone: timezone]))
|
|
{
|
|
imported++;
|
|
[uids setValue: uid forKey: originalUid];
|
|
}
|
|
}
|
|
|
|
DESTROY(pool);
|
|
}
|
|
|
|
return imported;
|
|
}
|
|
|
|
/* acls */
|
|
|
|
/* Compare two permissions to set first the highest access right, if unknown, then
|
|
do nothing */
|
|
static NSComparisonResult _comparePermissions (id perm1, id perm2, void *context)
|
|
{
|
|
static NSDictionary *permMap = nil;
|
|
NSNumber *num_1, *num_2;
|
|
|
|
if (!permMap)
|
|
{
|
|
NSMutableArray *numberObjs;
|
|
NSUInteger i, max = 16;
|
|
|
|
numberObjs = [NSMutableArray arrayWithCapacity: max];
|
|
for (i = 0; i < max; i++)
|
|
[numberObjs addObject: [NSNumber numberWithInteger: i]];
|
|
|
|
/* Build the map to compare easily */
|
|
permMap = [[NSDictionary alloc] initWithObjects: numberObjs
|
|
forKeys: [NSArray arrayWithObjects:
|
|
SOGoRole_ObjectEraser,
|
|
SOGoRole_ObjectCreator,
|
|
SOGoRole_ObjectEditor,
|
|
SOGoCalendarRole_ConfidentialModifier,
|
|
SOGoCalendarRole_ConfidentialResponder,
|
|
SOGoCalendarRole_ConfidentialViewer,
|
|
SOGoCalendarRole_ConfidentialDAndTViewer,
|
|
SOGoCalendarRole_PrivateModifier,
|
|
SOGoCalendarRole_PrivateResponder,
|
|
SOGoCalendarRole_PrivateViewer,
|
|
SOGoCalendarRole_PrivateDAndTViewer,
|
|
SOGoCalendarRole_PublicModifier,
|
|
SOGoCalendarRole_PublicResponder,
|
|
SOGoCalendarRole_PublicViewer,
|
|
SOGoCalendarRole_PublicDAndTViewer,
|
|
SOGoCalendarRole_FreeBusyReader, nil]];
|
|
[permMap retain];
|
|
}
|
|
|
|
num_1 = [permMap objectForKey: perm1];
|
|
if (!num_1)
|
|
num_1 = [NSNumber numberWithInteger: 255];
|
|
num_2 = [permMap objectForKey: perm2];
|
|
if (!num_2)
|
|
num_2 = [NSNumber numberWithInteger: 255];
|
|
|
|
return [num_1 compare: num_2];
|
|
}
|
|
|
|
- (NSArray *) aclsForUser: (NSString *) uid
|
|
forObjectAtPath: (NSArray *) objectPathArray
|
|
{
|
|
NSMutableArray *aclsForUser;
|
|
NSArray *superAcls;
|
|
|
|
superAcls = [super aclsForUser: uid forObjectAtPath: objectPathArray];
|
|
if ([uid isEqualToString: [self defaultUserID]])
|
|
{
|
|
if (superAcls)
|
|
{
|
|
aclsForUser = [superAcls mutableCopy];
|
|
[aclsForUser autorelease];
|
|
}
|
|
else
|
|
aclsForUser = [NSMutableArray array];
|
|
[aclsForUser addObject: SoRole_Authenticated];
|
|
}
|
|
else
|
|
{
|
|
/* Sort setting the highest access right first, so in the case
|
|
of a user member of several groups, the highest access right
|
|
is checked first, for instance, in
|
|
[SOGoAppointmentFolder:roleForComponentsWithAccessClass:forUser] */
|
|
aclsForUser = (NSMutableArray *) [superAcls sortedArrayUsingFunction: _comparePermissions
|
|
context: NULL];
|
|
}
|
|
|
|
return aclsForUser;
|
|
}
|
|
|
|
/* caldav-proxy */
|
|
- (SOGoAppointmentProxyPermission) proxyPermissionForUserWithLogin: (NSString *) login
|
|
{
|
|
SOGoAppointmentProxyPermission permission;
|
|
NSArray *roles;
|
|
static NSArray *readRoles = nil;
|
|
static NSArray *writeRoles = nil;
|
|
|
|
if (!readRoles)
|
|
{
|
|
readRoles = [NSArray arrayWithObjects:
|
|
SOGoCalendarRole_ConfidentialViewer,
|
|
SOGoCalendarRole_ConfidentialDAndTViewer,
|
|
SOGoCalendarRole_PrivateViewer,
|
|
SOGoCalendarRole_PrivateDAndTViewer,
|
|
SOGoCalendarRole_PublicViewer,
|
|
SOGoCalendarRole_PublicDAndTViewer,
|
|
nil];
|
|
[readRoles retain];
|
|
}
|
|
if (!writeRoles)
|
|
{
|
|
writeRoles = [NSArray arrayWithObjects:
|
|
SOGoRole_ObjectCreator,
|
|
SOGoRole_ObjectEraser,
|
|
SOGoCalendarRole_ConfidentialModifier,
|
|
SOGoCalendarRole_ConfidentialResponder,
|
|
SOGoCalendarRole_PrivateModifier,
|
|
SOGoCalendarRole_PrivateResponder,
|
|
SOGoCalendarRole_PublicModifier,
|
|
SOGoCalendarRole_PublicResponder,
|
|
nil];
|
|
[writeRoles retain];
|
|
}
|
|
|
|
permission = SOGoAppointmentProxyPermissionNone;
|
|
roles = [self aclsForUser: login];
|
|
if ([roles count])
|
|
{
|
|
if ([roles firstObjectCommonWithArray: readRoles])
|
|
permission = SOGoAppointmentProxyPermissionRead;
|
|
if ([roles firstObjectCommonWithArray: writeRoles])
|
|
permission = SOGoAppointmentProxyPermissionWrite;
|
|
}
|
|
|
|
return permission;
|
|
}
|
|
|
|
- (NSArray *) aclUsersWithProxyWriteAccess: (BOOL) write
|
|
{
|
|
NSMutableArray *users;
|
|
NSArray *aclUsers;
|
|
NSString *aclUser;
|
|
SOGoAppointmentProxyPermission permission;
|
|
int count, max;
|
|
|
|
permission = (write
|
|
? SOGoAppointmentProxyPermissionWrite
|
|
: SOGoAppointmentProxyPermissionRead);
|
|
aclUsers = [self aclUsers];
|
|
max = [aclUsers count];
|
|
users = [NSMutableArray arrayWithCapacity: max];
|
|
for (count = 0; count < max; count++)
|
|
{
|
|
aclUser = [aclUsers objectAtIndex: count];
|
|
if ([self proxyPermissionForUserWithLogin: aclUser]
|
|
== permission)
|
|
[users addObject: aclUser];
|
|
}
|
|
|
|
return users;
|
|
}
|
|
|
|
- (NSNumber *) activeTasks
|
|
{
|
|
NSArray *tasksList;
|
|
NSMutableArray *fields;
|
|
NSNumber *activeTasks;
|
|
|
|
fields = [NSMutableArray arrayWithObjects: @"c_component", @"c_status", nil];
|
|
|
|
tasksList = [self bareFetchFields: fields
|
|
from: nil
|
|
to: nil
|
|
title: nil
|
|
component: @"vtodo"
|
|
additionalFilters: @"c_status != 1 AND c_status != 3"];
|
|
|
|
activeTasks = [NSNumber numberWithInt:[tasksList count]];
|
|
|
|
return activeTasks;
|
|
}
|
|
|
|
- (void) findEntityForClosestAlarm: (id *) theEntity
|
|
timezone: (NSTimeZone *) theTimeZone
|
|
startDate: (NSCalendarDate **) theStartDate
|
|
endDate: (NSCalendarDate **) theEndDate
|
|
{
|
|
// If the event is recurring, we MUST find the right occurence.
|
|
if ([*theEntity hasRecurrenceRules])
|
|
{
|
|
NSCalendarDate *startDate, *endDate;
|
|
NSMutableDictionary *quickRecord;
|
|
NSCalendarDate *start, *end;
|
|
NGCalendarDateRange *range;
|
|
NSMutableArray *alarms;
|
|
iCalDateTime *date;
|
|
iCalTimeZone *tz;
|
|
|
|
BOOL b, isEvent;
|
|
|
|
isEvent = [*theEntity isKindOfClass: [iCalEvent class]];
|
|
b = NO;
|
|
|
|
if (isEvent)
|
|
b = [*theEntity isAllDay];
|
|
|
|
// We build a fake "quick record". Our record must include some mandatory info, like @"c_startdate" and @"c_enddate"
|
|
quickRecord = [NSMutableDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithBool: b], @"c_isallday",
|
|
[NSNumber numberWithBool: [*theEntity isRecurrent]], @"c_iscycle",
|
|
nil];
|
|
startDate = [*theEntity startDate];
|
|
endDate = (isEvent ? [*theEntity endDate] : [*theEntity due]);
|
|
|
|
if ([startDate isNotNull])
|
|
{
|
|
if (b)
|
|
{
|
|
// An all-day event usually doesn't have a timezone associated to its
|
|
// start date; however, if it does, we convert it to GMT.
|
|
date = (iCalDateTime*) [*theEntity uniqueChildWithTag: @"dtstart"];
|
|
tz = [(iCalDateTime*) date timeZone];
|
|
if (tz)
|
|
startDate = [tz computedDateForDate: startDate];
|
|
}
|
|
[quickRecord setObject: [*theEntity quickRecordDateAsNumber: startDate
|
|
withOffset: 0
|
|
forAllDay: b]
|
|
forKey: @"c_startdate"];
|
|
}
|
|
|
|
if ([endDate isNotNull])
|
|
{
|
|
if (b)
|
|
{
|
|
// An all-day event usually doesn't have a timezone associated to its
|
|
// end date; however, if it does, we convert it to GMT.
|
|
date = (isEvent ? (iCalDateTime*) [*theEntity uniqueChildWithTag: @"dtend"] : (iCalDateTime*) [*theEntity uniqueChildWithTag: @"due"]);
|
|
tz = [(iCalDateTime*) date timeZone];
|
|
if (tz)
|
|
endDate = [tz computedDateForDate: endDate];
|
|
}
|
|
[quickRecord setObject: [*theEntity quickRecordDateAsNumber: endDate
|
|
withOffset: ((b) ? -1 : 0)
|
|
forAllDay: b]
|
|
forKey: @"c_enddate"];
|
|
}
|
|
|
|
|
|
if ([*theEntity isRecurrent])
|
|
{
|
|
NSCalendarDate *date;
|
|
|
|
date = [*theEntity lastPossibleRecurrenceStartDate];
|
|
if (!date)
|
|
{
|
|
/* this could also be *nil*, but in the end it makes the fetchspecs
|
|
more complex - thus we set it to a "reasonable" distant future */
|
|
date = iCalDistantFuture;
|
|
}
|
|
[quickRecord setObject: [*theEntity quickRecordDateAsNumber: date
|
|
withOffset: 0 forAllDay: NO]
|
|
forKey: @"c_cycleenddate"];
|
|
[quickRecord setObject: [*theEntity cycleInfo] forKey: @"c_cycleinfo"];
|
|
}
|
|
|
|
alarms = [NSMutableArray array];
|
|
start = [NSCalendarDate date];
|
|
end = [start addYear:1 month:0 day:0 hour:0 minute:0 second:0];
|
|
range = [NGCalendarDateRange calendarDateRangeWithStartDate: start
|
|
endDate: end];
|
|
|
|
[self flattenCycleRecord: quickRecord
|
|
forRange: range
|
|
intoArray: alarms
|
|
withCalendar: [*theEntity parent]];
|
|
|
|
if ([alarms count])
|
|
{
|
|
NSDictionary *anAlarm;
|
|
id o;
|
|
|
|
// Take the first alarm since it's the 'closest' one
|
|
anAlarm = [alarms objectAtIndex: 0];
|
|
|
|
// We grab the last one and we use that info. The logic is simple.
|
|
// 1. grab the RECURRENCE-ID, if found in our master event, use that
|
|
// 2. if not found, use the master's event info but adjust the start/end date
|
|
if ((o = [[*theEntity parent] eventWithRecurrenceID: [anAlarm objectForKey: @"c_recurrence_id"]]))
|
|
{
|
|
*theEntity = o;
|
|
*theStartDate = [*theEntity startDate];
|
|
*theEndDate = [*theEntity endDate];
|
|
}
|
|
else
|
|
{
|
|
*theStartDate = [NSCalendarDate dateWithTimeIntervalSince1970: [[anAlarm objectForKey: @"c_startdate"] intValue]];
|
|
*theEndDate = [NSCalendarDate dateWithTimeIntervalSince1970: [[anAlarm objectForKey: @"c_enddate"] intValue]];
|
|
}
|
|
|
|
[*theStartDate setTimeZone: theTimeZone];
|
|
[*theEndDate setTimeZone: theTimeZone];
|
|
}
|
|
} // if ([event hasRecurrenceRules]) ...
|
|
}
|
|
|
|
@end /* SOGoAppointmentFolder */
|