754 lines
30 KiB
Objective-C
754 lines
30 KiB
Objective-C
/* SOGoUserHomePage.m - this file is part of SOGo
|
|
*
|
|
* Copyright (C) 2007-2017 Inverse inc.
|
|
*
|
|
* This file is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This file 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#import <NGObjWeb/NSException+HTTP.h>
|
|
#import <NGObjWeb/WOCookie.h>
|
|
#import <NGObjWeb/WORequest.h>
|
|
#import <NGObjWeb/WOResponse.h>
|
|
#import <NGExtensions/NSCalendarDate+misc.h>
|
|
#import <NGExtensions/NSObject+Logs.h>
|
|
|
|
#import <Appointments/SOGoFreeBusyObject.h>
|
|
|
|
#import <Mailer/SOGoMailAccount.h>
|
|
#import <Mailer/SOGoMailAccounts.h>
|
|
|
|
#import <SOGo/SOGoCache.h>
|
|
#import <SOGo/SOGoCASSession.h>
|
|
#if defined(SAML2_CONFIG)
|
|
#import <SOGo/SOGoSAML2Session.h>
|
|
#endif
|
|
#import <SOGo/SOGoDomainDefaults.h>
|
|
#import <SOGo/SOGoUserManager.h>
|
|
#import <SOGo/SOGoWebAuthenticator.h>
|
|
#import <SOGo/SOGoUser.h>
|
|
#import <SOGo/SOGoUserFolder.h>
|
|
#import <SOGo/SOGoUserProfile.h>
|
|
#import <SOGo/SOGoSession.h>
|
|
#import <SOGo/SOGoSystemDefaults.h>
|
|
#import <SOGo/NSCalendarDate+SOGo.h>
|
|
#import <SOGo/NSDictionary+Utilities.h>
|
|
#import <SOGoUI/UIxComponent.h>
|
|
|
|
#import <SBJson/NSObject+SBJSON.h>
|
|
|
|
#define INTERVALSECONDS 900 /* 15 minutes */
|
|
#define PADDING 8
|
|
#define HALFPADDING PADDING/2
|
|
|
|
@interface SOGoUserHomePage : UIxComponent
|
|
|
|
@end
|
|
|
|
@implementation SOGoUserHomePage
|
|
|
|
- (id <WOActionResults>) defaultAction
|
|
{
|
|
SOGoUserFolder *co;
|
|
NSString *loginModule;
|
|
SOGoSystemDefaults *sd;
|
|
SOGoDomainDefaults *dd;
|
|
SOGoUserDefaults *ud;
|
|
BOOL moduleIsValid;
|
|
NSArray *filters;
|
|
NSURL *moduleURL;
|
|
|
|
sd = [SOGoSystemDefaults sharedSystemDefaults];
|
|
dd = [[context activeUser] domainDefaults];
|
|
ud = [[context activeUser] userDefaults];
|
|
|
|
loginModule = [ud loginModule];
|
|
moduleIsValid = ([loginModule isEqualToString: @"Calendar"] ||
|
|
[loginModule isEqualToString: @"Contacts"] ||
|
|
[loginModule isEqualToString: @"Mail"]);
|
|
if (!moduleIsValid)
|
|
{
|
|
[self errorWithFormat: @"login module '%@' not accepted (must be "
|
|
@"'Calendar', 'Contacts' or 'Mail')", loginModule];
|
|
}
|
|
if (!moduleIsValid || ![[context activeUser] canAccessModule: loginModule])
|
|
{
|
|
loginModule = @"Contacts";
|
|
}
|
|
|
|
// We check if we must write the Sieve scripts to the server
|
|
// upon first login if no user preferences are found, and the SOGo
|
|
// admin has defined SOGoSieveFilters in the domain or system settings
|
|
if ([dd sieveScriptsEnabled] && [[[ud source] values] count] == 0 &&
|
|
((filters = [[dd source] objectForKey: @"SOGoSieveFilters"]) || (filters = [[sd source] objectForKey: @"SOGoSieveFilters"])))
|
|
{
|
|
SOGoMailAccount *account;
|
|
SOGoMailAccounts *folder;
|
|
|
|
[ud setSieveFilters: filters];
|
|
[ud synchronize];
|
|
|
|
folder = [[self clientObject] mailAccountsFolder: @"Mail"
|
|
inContext: context];
|
|
account = [folder lookupName: @"0" inContext: context acquire: NO];
|
|
[account updateFilters];
|
|
}
|
|
|
|
co = [self clientObject];
|
|
moduleURL = [NSURL URLWithString: loginModule
|
|
relativeToURL: [co soURL]];
|
|
|
|
return [self redirectToLocation: [moduleURL absoluteString]];
|
|
}
|
|
|
|
- (NSDictionary *) _freeBusyFromStartDate: (NSCalendarDate *) startDate
|
|
toEndDate: (NSCalendarDate *) endDate
|
|
forFreeBusy: (SOGoFreeBusyObject *) fb
|
|
andContact: (NSString *) uid
|
|
{
|
|
NSCalendarDate *start, *end;
|
|
NSMutableDictionary *freeBusy, *dayData, *hourData;
|
|
NSArray *records;
|
|
NSArray *emails, *partstates;
|
|
NSCalendarDate *currentDate, *currentStartDate, *currentEndDate;
|
|
NSDictionary *record;
|
|
NSString *dayKey, *hourKey, *minuteKey;
|
|
NSEnumerator *freeBusyList, *dayList, *hourList;
|
|
SOGoUser *user;
|
|
int quarter, lastQuarter, recordCount, recordMax, count, i, type, maxBookings, isResource;
|
|
|
|
// We "copy" the start/end date because -fetchFreeBusyInfosFrom will mess
|
|
// with the timezone and we don't want that to properly calculate the delta
|
|
// DO NOT USE -copy HERE - it'll simply return [self retain].
|
|
start = [NSCalendarDate dateWithYear: [startDate yearOfCommonEra]
|
|
month: [startDate monthOfYear]
|
|
day: [startDate dayOfMonth]
|
|
hour: [startDate hourOfDay]
|
|
minute: [startDate minuteOfHour]
|
|
second: [startDate secondOfMinute]
|
|
timeZone: [startDate timeZone]];
|
|
|
|
end = [NSCalendarDate dateWithYear: [endDate yearOfCommonEra]
|
|
month: [endDate monthOfYear]
|
|
day: [endDate dayOfMonth]
|
|
hour: [endDate hourOfDay]
|
|
minute: [endDate minuteOfHour]
|
|
second: [endDate secondOfMinute]
|
|
timeZone: [endDate timeZone]];
|
|
|
|
freeBusy = [NSMutableDictionary dictionary];
|
|
user = [SOGoUser userWithLogin: [[self clientObject] ownerInContext: context] roles: nil];
|
|
maxBookings = [user numberOfSimultaneousBookings];
|
|
isResource = [user isResource];
|
|
|
|
// Fetch freebusy information if the user is NOT a resource or if multiplebookings isn't unlimited
|
|
if (!isResource || maxBookings != 0)
|
|
{
|
|
records = [fb fetchFreeBusyInfosFrom: start to: end forContact: uid];
|
|
recordMax = [records count];
|
|
for (recordCount = 0; recordCount < recordMax; recordCount++)
|
|
{
|
|
record = [records objectAtIndex: recordCount];
|
|
user = [record objectForKey: @"owner"];
|
|
if ([[record objectForKey: @"c_isopaque"] boolValue])
|
|
{
|
|
type = 0;
|
|
|
|
// If the event has NO organizer (which means it's the user that has created it) OR
|
|
// If we are the organizer of the event THEN we are automatically busy
|
|
if ([[record objectForKey: @"c_orgmail"] length] == 0 ||
|
|
[user hasEmail: [record objectForKey: @"c_orgmail"]])
|
|
{
|
|
type = 1;
|
|
}
|
|
else
|
|
{
|
|
// We check if the user has accepted/declined or needs action
|
|
// on the current event.
|
|
emails = [[record objectForKey: @"c_partmails"] componentsSeparatedByString: @"\n"];
|
|
|
|
for (i = 0; i < [emails count]; i++)
|
|
{
|
|
if ([user hasEmail: [emails objectAtIndex: i]])
|
|
{
|
|
// We now fetch the c_partstates array and get the participation
|
|
// status of the user for the event
|
|
partstates = [[record objectForKey: @"c_partstates"] componentsSeparatedByString: @"\n"];
|
|
if (i < [partstates count])
|
|
{
|
|
// 0: needs action (considered busy)
|
|
// 1: accepted (busy)
|
|
// 2: declined (free)
|
|
// 3: tentative (free)
|
|
// 4: delegated (free)
|
|
type = ([[partstates objectAtIndex: i] intValue] < 2 ? 1 : 0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (type == 1)
|
|
{
|
|
// User is busy for this event
|
|
currentStartDate = [record objectForKey: @"startDate"];
|
|
currentEndDate = [record objectForKey: @"endDate"];
|
|
if ([currentStartDate earlierDate: startDate] == currentStartDate)
|
|
currentStartDate = startDate;
|
|
dayKey = [currentStartDate shortDateString];
|
|
dayData = [freeBusy objectForKey: dayKey];
|
|
if (!dayData)
|
|
{
|
|
dayData = [NSMutableDictionary dictionary];
|
|
[freeBusy setObject: dayData forKey: dayKey];
|
|
}
|
|
|
|
currentDate = [NSCalendarDate dateWithYear: [currentStartDate yearOfCommonEra]
|
|
month: [currentStartDate monthOfYear]
|
|
day: [currentStartDate dayOfMonth]
|
|
hour: [currentStartDate hourOfDay]
|
|
minute: 0
|
|
second: 0
|
|
timeZone: [currentStartDate timeZone]];
|
|
|
|
// Increment counters for quarters of first hour
|
|
hourKey = [NSString stringWithFormat: @"%u", (unsigned int)[currentDate hourOfDay]];
|
|
hourData = [dayData objectForKey: hourKey];
|
|
if (!hourData)
|
|
{
|
|
hourData = [NSMutableDictionary dictionaryWithObjectsAndKeys:
|
|
[NSNumber numberWithInt: 0], @"0",
|
|
[NSNumber numberWithInt: 0], @"15",
|
|
[NSNumber numberWithInt: 0], @"30",
|
|
[NSNumber numberWithInt: 0], @"45",
|
|
nil];
|
|
[dayData setObject: hourData forKey: hourKey];
|
|
}
|
|
quarter = (int)([currentStartDate minuteOfHour] / 15 + 0.5);
|
|
if ([currentEndDate timeIntervalSinceDate: currentDate] < 3600)
|
|
lastQuarter = (int)([currentEndDate minuteOfHour] / 15 + 0.5);
|
|
else
|
|
lastQuarter = 4;
|
|
for (i = 0; i < lastQuarter; i++) {
|
|
if (i >= quarter)
|
|
{
|
|
minuteKey = [NSString stringWithFormat: @"%u", i*15];
|
|
count = [[hourData objectForKey: minuteKey] intValue] + 1;
|
|
[hourData setObject: [NSNumber numberWithInt: count] forKey: minuteKey];
|
|
}
|
|
}
|
|
currentDate = [currentDate dateByAddingYears:0 months:0 days:0 hours:1 minutes:0 seconds:0];
|
|
|
|
// Increment counters of fully busy hours
|
|
while ([currentDate compare: currentEndDate] == NSOrderedAscending &&
|
|
[currentEndDate timeIntervalSinceDate: currentDate] >= 3600) // 1 hour
|
|
{
|
|
if ([currentDate hourOfDay] == 0)
|
|
{
|
|
// New day
|
|
dayKey = [currentDate shortDateString];
|
|
dayData = [freeBusy objectForKey: dayKey];
|
|
if (!dayData)
|
|
{
|
|
dayData = [NSMutableDictionary dictionary];
|
|
[freeBusy setObject: dayData forKey: dayKey];
|
|
}
|
|
}
|
|
hourKey = [NSString stringWithFormat: @"%u", (unsigned int)[currentDate hourOfDay]];
|
|
hourData = [dayData objectForKey: hourKey];
|
|
if (!hourData)
|
|
{
|
|
hourData = [NSMutableDictionary dictionaryWithObjectsAndKeys:
|
|
[NSNumber numberWithInt: 1], @"0",
|
|
[NSNumber numberWithInt: 1], @"15",
|
|
[NSNumber numberWithInt: 1], @"30",
|
|
[NSNumber numberWithInt: 1], @"45",
|
|
nil];
|
|
[dayData setObject: hourData forKey: hourKey];
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
minuteKey = [NSString stringWithFormat: @"%u", i*15];
|
|
count = [[hourData objectForKey: minuteKey] intValue] + 1;
|
|
[hourData setObject: [NSNumber numberWithInt: count] forKey: minuteKey];
|
|
}
|
|
}
|
|
currentDate = [currentDate dateByAddingYears:0 months:0 days:0 hours:1 minutes:0 seconds:0];
|
|
}
|
|
|
|
// Increment counters for quarters of last hour
|
|
if ([currentEndDate timeIntervalSinceDate: currentDate] > 0)
|
|
{
|
|
hourKey = [NSString stringWithFormat: @"%u", (unsigned int)[currentDate hourOfDay]];
|
|
hourData = [dayData objectForKey: hourKey];
|
|
if (!hourData)
|
|
{
|
|
hourData = [NSMutableDictionary dictionaryWithObjectsAndKeys:
|
|
[NSNumber numberWithInt: 0], @"0",
|
|
[NSNumber numberWithInt: 0], @"15",
|
|
[NSNumber numberWithInt: 0], @"30",
|
|
[NSNumber numberWithInt: 0], @"45",
|
|
nil];
|
|
[dayData setObject: hourData forKey: hourKey];
|
|
}
|
|
quarter = (int)([currentEndDate minuteOfHour] / 15 + 0.5);
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
if (i < quarter)
|
|
{
|
|
minuteKey = [NSString stringWithFormat: @"%u", i*15];
|
|
if (isResource)
|
|
count = [[hourData objectForKey: minuteKey] intValue] + 1;
|
|
else
|
|
count = 1;
|
|
[hourData setObject: [NSNumber numberWithInt: count] forKey: minuteKey];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (maxBookings > 0)
|
|
{
|
|
// Reset the freebusy for the periods that are bellow the maximum number of bookings
|
|
freeBusyList = [freeBusy objectEnumerator];
|
|
while ((dayData = [freeBusyList nextObject]))
|
|
{
|
|
dayList = [dayData objectEnumerator];
|
|
while ((hourData = [dayList nextObject]))
|
|
{
|
|
hourList = [hourData keyEnumerator];
|
|
while ((minuteKey = [hourList nextObject]))
|
|
{
|
|
count = [[hourData objectForKey: minuteKey] intValue];
|
|
if (count < maxBookings)
|
|
i = 0;
|
|
else
|
|
i = 1;
|
|
if (i != count)
|
|
[hourData setObject: [NSNumber numberWithInt: i] forKey: minuteKey];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return freeBusy;
|
|
}
|
|
|
|
- (id <WOActionResults>) readFreeBusyAction
|
|
{
|
|
SOGoFreeBusyObject *freebusy;
|
|
NSCalendarDate *startDate, *endDate;
|
|
NSDictionary *jsonResponse;
|
|
NSString *queryDay, *uid;
|
|
NSTimeZone *uTZ;
|
|
SOGoUser *user;
|
|
unsigned int httpStatus;
|
|
|
|
user = [context activeUser];
|
|
uTZ = [[user userDefaults] timeZone];
|
|
httpStatus = 200;
|
|
|
|
uid = [self queryParameterForKey: @"uid"];
|
|
queryDay = [self queryParameterForKey: @"sday"];
|
|
if ([queryDay length] == 8)
|
|
{
|
|
startDate = [NSCalendarDate dateFromShortDateString: queryDay
|
|
andShortTimeString: @"0000"
|
|
inTimeZone: uTZ];
|
|
queryDay = [self queryParameterForKey: @"eday"];
|
|
if ([queryDay length] == 8)
|
|
{
|
|
endDate = [NSCalendarDate dateFromShortDateString: queryDay
|
|
andShortTimeString: @"2359"
|
|
inTimeZone: uTZ];
|
|
|
|
if ([startDate earlierDate: endDate] == endDate)
|
|
{
|
|
httpStatus = 403;
|
|
jsonResponse = [NSDictionary dictionaryWithObjectsAndKeys:
|
|
@"failure", @"status",
|
|
@"Start date is later than end date.", @"message",
|
|
nil];
|
|
}
|
|
else
|
|
{
|
|
freebusy = [self clientObject];
|
|
jsonResponse = [self _freeBusyFromStartDate: startDate
|
|
toEndDate: endDate
|
|
forFreeBusy: freebusy
|
|
andContact: uid];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
httpStatus = 403;
|
|
jsonResponse = [NSDictionary dictionaryWithObjectsAndKeys:
|
|
@"failure", @"status",
|
|
@"Invalid end date.", @"message",
|
|
nil];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
httpStatus = 403;
|
|
jsonResponse = [NSDictionary dictionaryWithObjectsAndKeys:
|
|
@"failure", @"status",
|
|
@"Invalid start date.", @"message",
|
|
nil];
|
|
}
|
|
|
|
return [self responseWithStatus: httpStatus
|
|
andJSONRepresentation: jsonResponse];
|
|
}
|
|
|
|
- (NSString *) _logoutRedirectURL
|
|
{
|
|
NSString *redirectURL;
|
|
SOGoSystemDefaults *sd;
|
|
id container;
|
|
|
|
sd = [SOGoSystemDefaults sharedSystemDefaults];
|
|
if ([[sd authenticationType] isEqualToString: @"cas"])
|
|
{
|
|
redirectURL = [SOGoCASSession CASURLWithAction: @"logout"
|
|
andParameters: nil];
|
|
}
|
|
#if defined(SAML2_CONFIG)
|
|
else if ([[sd authenticationType] isEqualToString: @"saml2"])
|
|
{
|
|
NSString *username, *password, *domain, *value;
|
|
SOGoSAML2Session *saml2Session;
|
|
SOGoWebAuthenticator *auth;
|
|
LassoServer *server;
|
|
LassoLogout *logout;
|
|
NSArray *creds;
|
|
|
|
auth = [[self clientObject] authenticatorInContext: context];
|
|
value = [[context request] cookieValueForKey: [auth cookieNameInContext: context]];
|
|
creds = [auth parseCredentials: value];
|
|
|
|
value = [SOGoSession valueForSessionKey: [creds lastObject]];
|
|
|
|
domain = nil;
|
|
|
|
[SOGoSession decodeValue: value
|
|
usingKey: [creds objectAtIndex: 0]
|
|
login: &username
|
|
domain: &domain
|
|
password: &password];
|
|
|
|
saml2Session = [SOGoSAML2Session SAML2SessionWithIdentifier: password
|
|
inContext: context];
|
|
|
|
server = [SOGoSAML2Session lassoServerInContext: context];
|
|
|
|
logout = lasso_logout_new(server);
|
|
|
|
lasso_profile_set_session_from_dump(LASSO_PROFILE(logout), [[saml2Session session] UTF8String]);
|
|
lasso_profile_set_identity_from_dump(LASSO_PROFILE(logout), [[saml2Session session] UTF8String]);
|
|
lasso_logout_init_request(logout, NULL, LASSO_HTTP_METHOD_REDIRECT);
|
|
lasso_logout_build_request_msg(logout);
|
|
redirectURL = [NSString stringWithFormat: @"%s", LASSO_PROFILE(logout)->msg_url];
|
|
|
|
// We destroy our cache entry, the session will be taken care by the caller
|
|
[[SOGoCache sharedCache] removeSAML2LoginDumpsForIdentifier: password];
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
container = [[self clientObject] container];
|
|
redirectURL = [container baseURLInContext: context];
|
|
}
|
|
|
|
return redirectURL;
|
|
}
|
|
|
|
- (WOCookie *) _logoutCookieWithDate: (NSCalendarDate *) date
|
|
{
|
|
SOGoWebAuthenticator *auth;
|
|
NSString *cookieName, *appName;
|
|
WOCookie *cookie;
|
|
|
|
cookie = nil;
|
|
|
|
auth = [[self clientObject] authenticatorInContext: context];
|
|
if ([auth respondsToSelector: @selector (cookieNameInContext:)])
|
|
{
|
|
cookieName = [auth cookieNameInContext: context];
|
|
if ([cookieName length])
|
|
{
|
|
cookie = [WOCookie cookieWithName: cookieName value: @"discard"];
|
|
appName = [[context request] applicationName];
|
|
[cookie setPath: [NSString stringWithFormat: @"/%@/", appName]];
|
|
[cookie setExpires: [date yesterday]];
|
|
}
|
|
}
|
|
|
|
return cookie;
|
|
}
|
|
|
|
- (id <WOActionResults>) logoffAction
|
|
{
|
|
NSString *userName, *value;
|
|
SOGoWebAuthenticator *auth;
|
|
WOResponse *response;
|
|
NSCalendarDate *date;
|
|
WOCookie *cookie;
|
|
NSArray *creds;
|
|
|
|
userName = [[context activeUser] login];
|
|
[self logWithFormat: @"user '%@' logged off", userName];
|
|
|
|
response = [self redirectToLocation: [self _logoutRedirectURL]];
|
|
|
|
date = [NSCalendarDate calendarDate];
|
|
[date setTimeZone: [NSTimeZone timeZoneForSecondsFromGMT: 0]];
|
|
|
|
// We cleanup the memecached/database session cache. We do this before
|
|
// invoking _logoutCookieWithDate: in order to obtain its value.
|
|
auth = [[self clientObject] authenticatorInContext: context];
|
|
if ([auth respondsToSelector: @selector (cookieNameInContext:)])
|
|
{
|
|
value = [[context request] cookieValueForKey: [auth cookieNameInContext: context]];
|
|
creds = [auth parseCredentials: value];
|
|
|
|
if ([creds count] > 1)
|
|
[SOGoSession deleteValueForSessionKey: [creds objectAtIndex: 1]];
|
|
}
|
|
|
|
cookie = [self _logoutCookieWithDate: date];
|
|
if (cookie)
|
|
[response addCookie: cookie];
|
|
|
|
// We remove the XSRF cookie
|
|
cookie = [WOCookie cookieWithName: @"XSRF-TOKEN" value: @"discard"];
|
|
[cookie setPath: [NSString stringWithFormat: @"/%@/", [[context request] applicationName]]];
|
|
[cookie setExpires: [date yesterday]];
|
|
[response addCookie: cookie];
|
|
|
|
[response setHeader: [date rfc822DateString] forKey: @"Last-Modified"];
|
|
[response setHeader: @"no-store, no-cache, must-revalidate,"
|
|
@" max-age=0, post-check=0, pre-check=0"
|
|
forKey: @"Cache-Control"];
|
|
[response setHeader: @"no-cache" forKey: @"Pragma"];
|
|
|
|
|
|
return response;
|
|
}
|
|
|
|
- (NSMutableArray *) _usersForResults: (NSArray *) users
|
|
inDomain: (NSString *) domain
|
|
{
|
|
NSString *uid;
|
|
NSDictionary *contact;
|
|
NSString *contactInfo, *owner;
|
|
NSMutableArray *jsonResponse;
|
|
NSMutableDictionary *jsonLine;
|
|
NSArray *allUsers;
|
|
int count, max;
|
|
BOOL activeUserIsInDomain;
|
|
|
|
owner = [[self clientObject] ownerInContext: context];
|
|
activeUserIsInDomain = ([domain length] == 0 || [[[context activeUser] domain] isEqualToString: domain]);
|
|
|
|
// We sort our array - this is pretty useful for the Web
|
|
// interface of SOGo.
|
|
allUsers = [users sortedArrayUsingSelector: @selector (caseInsensitiveDisplayNameCompare:)];
|
|
|
|
max = [allUsers count];
|
|
jsonResponse = [NSMutableArray arrayWithCapacity: max];
|
|
for (count = 0; count < max; count++)
|
|
{
|
|
contact = [allUsers objectAtIndex: count];
|
|
uid = [contact objectForKey: @"c_uid"];
|
|
|
|
// We do NOT return the owner from which the search is performed
|
|
if (!activeUserIsInDomain || ![uid isEqualToString: owner])
|
|
{
|
|
jsonLine = [NSMutableDictionary dictionary];
|
|
if ([domain length])
|
|
uid = [NSString stringWithFormat: @"%@@%@", uid, domain];
|
|
[jsonLine setObject: uid forKey: @"uid"];
|
|
[jsonLine setObject: [contact objectForKey: @"cn"] forKey: @"cn"];
|
|
[jsonLine setObject: [contact objectForKey: @"c_email"] forKey: @"c_email"];
|
|
[jsonLine setObject: [NSNumber numberWithBool: [[contact objectForKey: @"isGroup"] boolValue]] forKey: @"isGroup"];
|
|
contactInfo = [contact objectForKey: @"c_info"];
|
|
if (contactInfo)
|
|
[jsonLine setObject: contactInfo forKey: @"c_info"];
|
|
[jsonResponse addObject: jsonLine];
|
|
}
|
|
}
|
|
|
|
return jsonResponse;
|
|
}
|
|
|
|
/**
|
|
* @api {get} /so/:username/usersSearch?search=:search Search for users
|
|
* @apiVersion 1.0.0
|
|
* @apiName GetUsersSearch
|
|
* @apiGroup Common
|
|
* @apiExample {curl} Example usage:
|
|
* curl -i http://localhost/SOGo/so/sogo1/usersSearch?search=john
|
|
*
|
|
* @apiParam {String} search Substring to match against username or email address
|
|
*
|
|
* @apiSuccess (Success 200) {Object[]} users List of matching users
|
|
* @apiSuccess (Success 200) {String} users.uid User ID
|
|
* @apiSuccess (Success 200) {String} users.c_email Main email address
|
|
* @apiSuccess (Success 200) {String} users.cn Common name
|
|
* @apiSuccess (Success 200) {Number} users.isGroup 1 if the user is a group
|
|
* @apiError (Error 400) {Object} error The error message
|
|
*/
|
|
- (id <WOActionResults>) usersSearchAction
|
|
{
|
|
NSMutableArray *users;
|
|
NSArray *currentUsers;
|
|
NSDictionary *message;
|
|
NSString *contact, *domain, *uidDomain;
|
|
NSEnumerator *visibleDomains;
|
|
id <WOActionResults> result;
|
|
SOGoUserManager *um;
|
|
SOGoSystemDefaults *sd;
|
|
|
|
contact = [self queryParameterForKey: @"search"];
|
|
if ([contact length])
|
|
{
|
|
um = [SOGoUserManager sharedUserManager];
|
|
sd = [SOGoSystemDefaults sharedSystemDefaults];
|
|
domain = [[context activeUser] domain];
|
|
uidDomain = [sd enableDomainBasedUID]? domain : nil;
|
|
users = [self _usersForResults: [um fetchUsersMatching: contact
|
|
inDomain: domain]
|
|
inDomain: uidDomain];
|
|
if ([domain length])
|
|
{
|
|
// Add results from visible domains
|
|
visibleDomains = [[sd visibleDomainsForDomain: domain] objectEnumerator];
|
|
while ((domain = [visibleDomains nextObject]))
|
|
{
|
|
currentUsers = [self _usersForResults: [um fetchUsersMatching: contact
|
|
inDomain: domain]
|
|
inDomain: uidDomain];
|
|
[users addObjectsFromArray: currentUsers];
|
|
}
|
|
}
|
|
result = [self responseWithStatus: 200
|
|
andJSONRepresentation: [NSDictionary dictionaryWithObject: users forKey: @"users"]];
|
|
}
|
|
else
|
|
{
|
|
message = [NSDictionary dictionaryWithObject: [self labelForKey: @"Missing search parameter"]
|
|
forKey: @"error"];
|
|
result = [self responseWithStatus: 400 andJSONRepresentation: message];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
- (WOResponse *) _foldersResponseForResults: (NSArray *) folders
|
|
{
|
|
WOResponse *response;
|
|
|
|
response = [context response];
|
|
[response setStatus: 200];
|
|
[response setHeader: @"text/plain; charset=utf-8"
|
|
forKey: @"Content-Type"];
|
|
|
|
[response appendContentString: [[NSDictionary dictionaryWithObject: folders
|
|
forKey: @"folders"] JSONRepresentation]];
|
|
|
|
return response;
|
|
}
|
|
|
|
/**
|
|
* @api {get} /so/:username/foldersSearch?type=:type Search for folders
|
|
* @apiVersion 1.0.0
|
|
* @apiName GetFoldersSearch
|
|
* @apiGroup Common
|
|
* @apiExample {curl} Example usage:
|
|
* curl -i http://localhost/SOGo/so/sogo1/foldersSearch?type=contact
|
|
*
|
|
* @apiParam {String} type Either 'calendar' or 'contact'. If nothing is specifed, its both.
|
|
*
|
|
* @apiSuccess (Success 200) {Object[]} folders List of matching folders
|
|
* @apiSuccess (Success 200) {String} folders.name Path of folder
|
|
* @apiSuccess (Success 200) {String} folders.displayName Human readable name
|
|
* @apiSuccess (Success 200) {String} folders.owner Username of owner
|
|
* @apiSuccess (Success 200) {String} folders.type Either 'calendar' or 'contact'
|
|
* @apiError (Error 400) {Object} error The error message
|
|
*/
|
|
- (id <WOActionResults>) foldersSearchAction
|
|
{
|
|
NSString *folderType;
|
|
NSMutableArray *folders;
|
|
id <WOActionResults> result;
|
|
SOGoUserFolder *userFolder;
|
|
|
|
|
|
folderType = [self queryParameterForKey: @"type"];
|
|
folders = [NSMutableArray array];
|
|
userFolder = [self clientObject];
|
|
|
|
if ([folderType length])
|
|
{
|
|
[folders addObjectsFromArray: [userFolder foldersOfType: folderType
|
|
forUID: [userFolder ownerInContext: context]]];
|
|
}
|
|
else
|
|
{
|
|
[folders addObjectsFromArray: [userFolder foldersOfType: @"calendar"
|
|
forUID: [userFolder ownerInContext: context]]];
|
|
[folders addObjectsFromArray: [userFolder foldersOfType: @"contact"
|
|
forUID: [userFolder ownerInContext: context]]];
|
|
}
|
|
|
|
result = [self _foldersResponseForResults: folders];
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @api {get} /so/:username/date Get current day
|
|
* @apiVersion 1.0.0
|
|
* @apiName GetCurrentDate
|
|
* @apiGroup Common
|
|
* @apiExample {curl} Example usage:
|
|
* curl -i http://localhost/SOGo/so/sogo1/date
|
|
*
|
|
* @apiSuccess (Success 200) {String} weekday Full weekday name according to user's locale
|
|
* @apiSuccess (Success 200) {String} month Full month name according to user's locale
|
|
* @apiSuccess (Success 200) {String} day Day of month as two digit decimal number (leading zero)
|
|
* @apiSuccess (Success 200) {String} year Year as a decimal number with century
|
|
* @apiSuccess (Success 200) {Object} abbr Abbreviations
|
|
* @apiSuccess (Success 200) {String} abbr.weekday Abbreviated weekday name according to user's locale
|
|
* @apiSuccess (Success 200) {String} abbr.month Abbreviated month name according to user's locale
|
|
*/
|
|
- (id <WOActionResults>) dateAction
|
|
{
|
|
return [self responseWithStatus: 200 andJSONRepresentation: [[context activeUser] currentDay]];
|
|
}
|
|
|
|
- (id) recoverAction
|
|
{
|
|
return [self responseWithStatus: 200
|
|
andString: @"Full recovery in place."];
|
|
}
|
|
|
|
@end
|