/* 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 #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #import #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 source; source = [[SOGoUserManager sharedUserManager] sourceWithID: [dict objectForKey: @"SOGoSource"]]; if ([source conformsToProtocol:@protocol(SOGoMembershipSource)]) { NSArray *members; members = [(id)(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 ) 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 ) propFilter toFilter: (NSMutableDictionary *) filter { NSString *propName, *textMatch; id 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 ) filterElement { NSMutableDictionary *filterData; id parentNode; id elements; NSString *componentName; NSCalendarDate *maxStart; parentNode = (id ) [filterElement parentNode]; // This parses time-range filters. // // // // // // // // // // // We currently ignore filters based on just the component type. // For example, this is ignored: // // // // // // // // // // // 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 ) parentNode { id children; id 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 document; id documentElement, propElement; r = [context response]; [r prepareDAVResponse]; [r appendContentString: @""]; document = [[context request] contentAsDOMDocument]; documentElement = (id ) [document documentElement]; propElement = [(NGDOMNodeWithChildren *) documentElement firstElementWithTag: @"prop" inNamespace: XMLNS_WEBDAV]; [self _appendComponentProperties: [self parseDAVRequestedProperties: propElement] matchingFilters: [self _parseCalendarFilters: documentElement] toResponse: r]; [r appendContentString:@""]; 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: @""]; [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: @"" attributes: nil]]; // See bugs #2878 and #2879 [components addObject: [SOGoWebDAVValue valueForObject: @"" attributes: nil]]; if ([self showCalendarTasks]) [components addObject: [SOGoWebDAVValue valueForObject: @"" 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]). ... 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 */