Synnefo » Pithos MacOS Client

//

//  PithosAccount.m

//  pithos-macos

//

// Copyright 2012 GRNET S.A. All rights reserved.

//

// Redistribution and use in source and binary forms, with or

// without modification, are permitted provided that the following

// conditions are met:

// 

//   1. Redistributions of source code must retain the above

//      copyright notice, this list of conditions and the following

//      disclaimer.

// 

//   2. Redistributions in binary form must reproduce the above

//      copyright notice, this list of conditions and the following

//      disclaimer in the documentation and/or other materials

//      provided with the distribution.

// 

// THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

// 

// The views and conclusions contained in the software and

// documentation are those of the authors and should not be

// interpreted as representing official policies, either expressed

// or implied, of GRNET S.A.

#import "PithosAccount.h"

#import "PithosSyncDaemon.h"

#import "ASIPithos.h"

#import "ASIPithosRequest.h"

#import "PithosAccountNode.h"

#import "PithosSharingAccountsNode.h"

#import "PithosUtilities.h"

#import "pithos_macosAppDelegate.h"

static NSString *defaultAuthURLString = @"https://accounts.okeanos.grnet.gr/identity/v2.0";

static NSString *defaultManualURLString = @"https://pithos.okeanos.grnet.gr";

@interface NSString(Additions)

- (BOOL)isValidURL;

- (NSString *)stringByRemovingTrailingSlashes;

@end

@implementation NSString(Additions)

- (BOOL)isValidURL {

    NSURL *URL = [NSURL URLWithString:self];

    return (URL && URL.scheme && URL.host);

}

- (NSString *)stringByRemovingTrailingSlashes {

    NSString *stringWithRemovedTrailingSlashes = [self copy];

    while ([stringWithRemovedTrailingSlashes hasSuffix:@"/"]) {

        stringWithRemovedTrailingSlashes = [stringWithRemovedTrailingSlashes substringToIndex:(stringWithRemovedTrailingSlashes.length - 1)];

    }

    return stringWithRemovedTrailingSlashes;

}

@end

@implementation PithosAccount

@synthesize uniqueName, active, name, clientVersion;

@synthesize syncActive, syncDirectoryPath, syncAccountsDictionary, syncSkipHidden, syncLastCompleted, syncDaemon;

@synthesize authURLString, pithosObjectStoreURLString, astakosAccountURLString, astakosWebloginURLString, manual;

@synthesize authToken, authUser, userCatalog;

@synthesize ignoreSSLErrors;

@synthesize pithos, accountNode, sharingAccountsNode;

@synthesize tokensURL, storageURLPrefix, loginURL, userCatalogURL, publicURLPrefix;

#pragma mark -

#pragma mark Object Lifecycle

+ (id)pithosAccount {

    PithosAccount *pithosAccount = [[self alloc] init];

    pithosAccount.uniqueName = [NSString stringWithFormat:@"pithosAccount-%f", [NSDate timeIntervalSinceReferenceDate]];

    pithosAccount.clientVersion = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleVersion"];

    pithosAccount.syncSkipHidden = YES;

    pithosAccount.authURLString = defaultAuthURLString;

    return pithosAccount;

}

- (NSString *)description {

    return [NSString stringWithFormat:@"uniqueName: %@, active: %d, name: %@, clientVersion: %@, syncActive: %d, syncDirectoryPath: %@, syncAccountsDictionary: %@, syncSkipHidden: %d, syncLastCompleted: %@, authURLString: %@, pithosObjectStoreURLString:%@ , astakosAccountURLString: %@, astakosWebloginURLString: %@, manual: %d, authToken: %@, authUser: %@",

            uniqueName, active, name, clientVersion, syncActive, syncDirectoryPath, syncAccountsDictionary, syncSkipHidden, syncLastCompleted, authURLString, pithosObjectStoreURLString, astakosAccountURLString, astakosWebloginURLString, manual, authToken, authUser];

}

#pragma mark -

#pragma mark Properties

- (NSString *)name {

    if (![name length]) {

        NSDictionary *pithosAccountsDictionary = [(pithos_macosAppDelegate *)[[NSApplication sharedApplication] delegate] pithosAccountsDictionary];

        NSString *namePrefix = @"okeanos";

        NSUInteger nameSuffix = 1;

        name = @"okeanos";

        NSString *documentsDirectoryPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];

        NSFileManager *fileManager = [NSFileManager defaultManager];

        while ([pithosAccountsDictionary objectForKey:name] || 

               [fileManager fileExistsAtPath:[documentsDirectoryPath stringByAppendingPathComponent:name]]) {

            name = [NSString stringWithFormat:@"%@%ld", namePrefix, ++nameSuffix];

        }

    }

    return name;

}

- (void)setName:(NSString *)aName {

    NSMutableDictionary *pithosAccountsDictionary = [(pithos_macosAppDelegate *)[[NSApplication sharedApplication] delegate] pithosAccountsDictionary];

    if (![self.name isEqualToString:aName] && [aName length] && ![pithosAccountsDictionary objectForKey:aName]) {

        [pithosAccountsDictionary setObject:self forKey:aName];

        [pithosAccountsDictionary removeObjectForKey:name];

        name = aName;

    }

}

- (BOOL)syncActive {

    if (active)

        return syncActive;

    else

        return NO;

}

- (void)setSyncActive:(BOOL)aSyncActive {

    syncActive = aSyncActive;

    if (syncDaemon && !self.syncActive)

        [syncDaemon resetDaemon];

}

- (NSString *)syncDirectoryPath {

    if (![syncDirectoryPath length]) {

        syncDirectoryPath = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0] 

                              stringByAppendingPathComponent:self.name];

    }

    return syncDirectoryPath;

}

- (void)setSyncDirectoryPath:(NSString *)aSyncDirectoryPath {

    if (![self.syncDirectoryPath isEqualToString:aSyncDirectoryPath] && [aSyncDirectoryPath length]) {

        BOOL isDirectory;

        if (![[NSFileManager defaultManager] fileExistsAtPath:aSyncDirectoryPath isDirectory:&isDirectory] || isDirectory) {

            syncDirectoryPath = aSyncDirectoryPath;

        } else {

            return;

        }

        @synchronized(self) {

            resetSyncDaemonLocalState = YES;

            syncLastCompleted = nil;

        }

    }

}

- (NSMutableDictionary *)syncAccountsDictionary {

    if (!syncAccountsDictionary) {

        syncAccountsDictionary = [NSMutableDictionary dictionaryWithObject:[NSMutableDictionary dictionaryWithObject:[NSMutableSet set] 

                                                                                                              forKey:@"pithos"]

                                                                    forKey:@""];

    }        

    return syncAccountsDictionary;

}

- (void)setSyncAccountsDictionary:(NSMutableDictionary *)aSyncAccountsDictionary {

    if (aSyncAccountsDictionary && ![self.syncAccountsDictionary isEqualToDictionary:aSyncAccountsDictionary]) {

        syncAccountsDictionary = [[NSMutableDictionary alloc] initWithCapacity:[aSyncAccountsDictionary count]];

        for (NSString *accountName in aSyncAccountsDictionary) {

            NSDictionary *aSyncContainersDictionary = [aSyncAccountsDictionary objectForKey:accountName];

            NSMutableDictionary *syncContainersDictionary = [NSMutableDictionary dictionary];

            for (NSString *containerName in aSyncContainersDictionary) {

                if (![accountName isEqualToString:@""] || ![[containerName lowercaseString] isEqualToString:@"shared with me"])

                    [syncContainersDictionary setObject:[NSMutableSet setWithSet:[aSyncContainersDictionary objectForKey:containerName]] 

                                                 forKey:containerName];

            }

            if ([syncContainersDictionary count])

                [syncAccountsDictionary setObject:syncContainersDictionary forKey:accountName];

        }

        @synchronized(self) {

            resetSyncDaemonLocalState = YES;

            syncLastCompleted = nil;

        }

    }

}

- (NSDate *)syncLastCompleted {

    if (self.syncDaemon.lastCompletedSync && ![self.syncDaemon.lastCompletedSync isEqualToDate:syncLastCompleted]) {

        syncLastCompleted = [self.syncDaemon.lastCompletedSync copy];

    }

    return syncLastCompleted;

}

- (PithosSyncDaemon *)syncDaemon {

    @synchronized(self) {

        if (self.syncActive && !syncDaemon)

            syncDaemon = [[PithosSyncDaemon alloc] initWithDirectoryPath:self.syncDirectoryPath 

                                                           pithosAccount:self 

                                                      accountsDictionary:self.syncAccountsDictionary 

                                                              skipHidden:self.syncSkipHidden 

                                                         resetLocalState:resetSyncDaemonLocalState];

        resetSyncDaemonLocalState = NO;

    }

    return syncDaemon;

}

- (void)setAuthURLString:(NSString *)anAuthURLString {

    NSString *tmpURLString = [anAuthURLString stringByRemovingTrailingSlashes];

    if (![authURLString isEqualToString:tmpURLString]) {

        authURLString = tmpURLString;

        @synchronized(self) {

            updatePithos = YES;

            resetSyncDaemonLocalState = YES;

            syncLastCompleted = nil;

        }

    }

}

- (void)setPithosObjectStoreURLString:(NSString *)aPithosObjectStoreURLString {

    NSString *tmpURLString = [aPithosObjectStoreURLString stringByRemovingTrailingSlashes];

    if (![pithosObjectStoreURLString isEqualToString:tmpURLString]) {

        pithosObjectStoreURLString = tmpURLString;

        @synchronized(self) {

            updatePithos = YES;

        }

    }

}

- (void)setAstakosAccountURLString:(NSString *)anAstakosAccountURLString {

    NSString *tmpURLString = [anAstakosAccountURLString stringByRemovingTrailingSlashes];

    if (![astakosAccountURLString isEqualToString:tmpURLString]) {

        astakosAccountURLString = tmpURLString;

        @synchronized(self) {

            updatePithos = YES;

        }

    }

}

- (void)setAstakosWebloginURLString:(NSString *)anAstakosWebloginURLString {

    NSString *tmpURLString = [anAstakosWebloginURLString stringByRemovingTrailingSlashes];

    if (![astakosWebloginURLString isEqualToString:tmpURLString]) {

        astakosWebloginURLString = tmpURLString;

    }

}

- (void)setAuthToken:(NSString *)anAuthToken {

    if (anAuthToken.length && ![anAuthToken isEqualToString:authToken]) {

        authToken = anAuthToken;

        @synchronized(self) {

            updatePithos = YES;

        }

    }

}

- (void)setAuthUser:(NSString *)anAuthUser {

    if (anAuthUser.length && ![anAuthUser isEqualToString:authUser]) {

        authUser = anAuthUser;

        @synchronized(self) {

            updatePithos = YES;

            resetSyncDaemonLocalState = YES;

            syncLastCompleted = nil;

        }

    }

}

- (void)setIgnoreSSLErrors:(BOOL)anIgnoreSSLErrors {

    if (anIgnoreSSLErrors != ignoreSSLErrors) {

        ignoreSSLErrors = anIgnoreSSLErrors;

        @synchronized(self) {

            updatePithos = YES;

        }

    }

}

- (NSMutableDictionary *)userCatalog {

    if (!userCatalog) {

        userCatalog = [NSMutableDictionary dictionary];

    }

    return userCatalog;

}

- (ASIPithos *)pithos {

    @synchronized(self) {

        if (!pithos || updatePithos) {

            pithos = [ASIPithos pithos];

            pithos.authToken = authToken;

            pithos.authUser = authUser;

            pithos.ignoreSSLErrors = ignoreSSLErrors;

            pithos.tokensURL = self.tokensURL;

            pithos.storageURLPrefix = self.storageURLPrefix;

            pithos.userCatalogURL = self.userCatalogURL;

            pithos.publicURLPrefix = self.publicURLPrefix;

            updatePithos = NO;

        }

    }

    return pithos;

}

- (PithosAccountNode *)accountNode {

    if (!accountNode) {

        accountNode = [[PithosAccountNode alloc] initWithPithosAccountManager:self andPithos:self.pithos];

        accountNode.childrenUpdatedNotificationName = nil;

        accountNode.inheritChildrenUpdatedNotificationName = YES;

    }

    return accountNode;

}

- (PithosSharingAccountsNode *)sharingAccountsNode {

    if (!sharingAccountsNode) {

        sharingAccountsNode = [[PithosSharingAccountsNode alloc] initWithPithosAccountManager:self andPithos:self.pithos];

        sharingAccountsNode.childrenUpdatedNotificationName = nil;

        sharingAccountsNode.inheritChildrenUpdatedNotificationName = YES;

    }

    return sharingAccountsNode;

}

- (NSString *)tokensURL {

    return [authURLString stringByAppendingString:@"/tokens"];

}

- (NSString *)storageURLPrefix {

    return [pithosObjectStoreURLString copy];

}

- (NSString *)loginURL {

    return [astakosWebloginURLString stringByAppendingString:@"/login"];

}

- (NSString *)publicURLPrefix {

    return [pithosObjectStoreURLString copy];

}

- (NSString *)userCatalogURL {

    return [astakosAccountURLString stringByAppendingString:@"/user_catalogs"];

}

#pragma mark -

#pragma mark Actions

- (void)updateWithAuthURLString:(NSString *)anAuthURLString

     pithosObjectStoreURLString:(NSString *)aPithosObjectStoreURLString

        astakosAccountURLString:(NSString *)anAstakosAccountURLString

       astakosWebloginURLString:(NSString *)anAstakosWebloginURLString

                         manual:(BOOL)aManual

                      authToken:(NSString *)anAuthToken

                      authUser:(NSString *)anAuthUser

                ignoreSSLErrors:(BOOL)anIgnoreSSLErrors {

    self.authURLString = anAuthURLString;

    self.pithosObjectStoreURLString = aPithosObjectStoreURLString;

    self.astakosAccountURLString = anAstakosAccountURLString;

    self.astakosWebloginURLString = anAstakosWebloginURLString;

    self.manual = aManual;

    self.authToken = anAuthToken;

    self.authUser = anAuthUser;

    self.ignoreSSLErrors = anIgnoreSSLErrors;

    DLog(@"Account updated: %@", self);

    if (!authToken.length || !authUser.length) {

        self.active = NO;

        self.syncActive = NO;

    } else  {

        [self updateUserCatalogForDisplaynames:nil UUIDs:[NSArray arrayWithObject:authUser]];

        self.active = YES;

        if (syncDaemon) {

            self.syncDaemon.pithos = self.pithos;

            if (self.syncActive)

                [self.syncDaemon startDaemon];

        }

        if (accountNode)

            self.accountNode.pithos = self.pithos;

        if (sharingAccountsNode)

            self.sharingAccountsNode.pithos = self.pithos;

        if (accountNode) {

            if (self.accountNode.children) {

            }

            [self.accountNode refreshInfo];

        }

        if (sharingAccountsNode && self.sharingAccountsNode.children) {

        }

    }

}

- (void)updateSyncWithSyncActive:(BOOL)aSyncActive 

               syncDirectoryPath:(NSString *)aSyncDirectoryPath 

          syncAccountsDictionary:(NSMutableDictionary *)aSyncAccountsDictionary 

                  syncSkipHidden:(BOOL)aSyncSkipHidden {

    self.syncAccountsDictionary = aSyncAccountsDictionary;

    self.syncDirectoryPath = aSyncDirectoryPath;

    self.syncSkipHidden = aSyncSkipHidden;

    self.syncActive = aSyncActive;

    if (syncDaemon) {

        self.syncDaemon.accountsDictionary = self.syncAccountsDictionary;

        self.syncDaemon.directoryPath = self.syncDirectoryPath;

        self.syncDaemon.skipHidden = self.syncSkipHidden;

        if (self.syncActive)

            [self.syncDaemon startDaemon];

    }    

}

- (NSMutableDictionary *)servicesFromServiceCatalogRequest:(ASIPithosRequest *)serviceCatalogRequest {

    NSMutableDictionary *services = [NSMutableDictionary dictionary];

    if (serviceCatalogRequest.responseStatusCode == 200) {

        BOOL pithosObjectStoreFound = NO;

        BOOL astakosAccountFound = NO;

        BOOL astakosWebloginFound = NO;

        NSArray *serviceCatalog = [serviceCatalogRequest serviceCatalog];

        for (NSDictionary *service in serviceCatalog) {

            NSString *serviceName = [service objectForKey:@"name"];

            if (!pithosObjectStoreFound && [serviceName isEqualToString:@"pithos_object-store"]) {

                [services setObject:[[[service objectForKey:@"endpoints"] objectAtIndex:0] objectForKey:@"publicURL"]

                             forKey:@"PithosObjectStoreURLString"];

                pithosObjectStoreFound = YES;

            } else if (!astakosAccountFound && [serviceName isEqualToString:@"astakos_account"]) {

                [services setObject:[[[service objectForKey:@"endpoints"] objectAtIndex:0] objectForKey:@"publicURL"]

                             forKey:@"AstakosAccountURLString"];

                astakosAccountFound = YES;

            } else if (!astakosWebloginFound && [serviceName isEqualToString:@"astakos_weblogin"]) {

                [services setObject:[[[service objectForKey:@"endpoints"] objectAtIndex:0] objectForKey:@"SNF:webloginURL"]

                             forKey:@"AstakosWebloginURLString"];

                astakosWebloginFound = YES;

            }

            if (pithosObjectStoreFound && astakosAccountFound && astakosWebloginFound)

                break;

        }

    }

    return services;

}

- (void)updateServicesFromServiceCatalogRequest:(ASIPithosRequest *)serviceCatalogRequest {

    if (serviceCatalogRequest.responseStatusCode == 200) {

        NSMutableDictionary *services = [self servicesFromServiceCatalogRequest:serviceCatalogRequest];

        self.pithosObjectStoreURLString = [services objectForKey:@"PithosObjectStoreURLString"];

        self.astakosAccountURLString = [services objectForKey:@"AstakosAccountURLString"];

        self.astakosWebloginURLString = [services objectForKey:@"AstakosWebloginURLString"];

        self.manual = NO;

        if (authToken.length) {

            NSDictionary *token = [serviceCatalogRequest token];

            self.authToken = [token objectForKey:@"id"];

            self.authUser = [[token objectForKey:@"tenant"] objectForKey:@"id"];

        }

    } else if (serviceCatalogRequest.responseStatusCode == 404) {

        self.pithosObjectStoreURLString = [[[NSURL URLWithString:authURLString] URLByAppendingPathComponent:@"v1"] description];

        self.astakosAccountURLString = [self.authURLString copy];

        self.astakosWebloginURLString = [self.authURLString copy];

        self.manual = YES;

    }

}

- (ASIPithosRequest *)updateUserCatalogForDisplaynames:(NSArray *)displaynames UUIDs:(NSArray *)UUIDs {

    ASIPithosRequest *userCatalogRequest = [ASIPithosRequest userCatalogRequestWithPithos:self.pithos

                                                                             displaynames:displaynames

                                                                                    UUIDs:UUIDs];

    [PithosUtilities startAndWaitForRequest:userCatalogRequest];

    if (userCatalogRequest.error || ((userCatalogRequest.responseStatusCode != 200) && (userCatalogRequest.responseStatusCode != 404))) {

        // Don't show alert on 404, since it can be a pre-UUID server.

        [PithosUtilities httpRequestErrorAlertWithRequest:userCatalogRequest];

    } else if (userCatalogRequest.responseStatusCode == 200) {

        NSDictionary *catalogs = [userCatalogRequest catalogs];

        NSDictionary *displaynameCatalog = [catalogs objectForKey:@"displayname_catalog"];

        for (NSString *displayname in displaynameCatalog) {

            [self.userCatalog setObject:displayname forKey:[displaynameCatalog objectForKey:displayname]];

        }

        if (UUIDs) {

            NSDictionary *UUIDCatalog = [catalogs objectForKey:@"uuid_catalog"];

            for (NSString *UUID in UUIDs) {

                NSString *displayname = [UUIDCatalog objectForKey:UUID];

                if (displayname) {

                    [self.userCatalog setObject:displayname forKey:UUID];

                } else {

                    [self.userCatalog removeObjectForKey:UUID];

                }

            }

        }

    }

    return userCatalogRequest;

}

- (NSString *)displaynameForUUID:(NSString *)UUID safe:(BOOL)safe {

    NSString *displayName = [userCatalog objectForKey:UUID];

    if (safe && !displayName) {

        return UUID;

    } else {

        return displayName;

    }

}

- (NSString *)displaynameForUUID:(NSString *)UUID {

    return [self displaynameForUUID:UUID safe:NO];

}

#pragma mark -

#pragma mark NSCoding

- (id)initWithCoder:(NSCoder *)decoder {

    if ((self = [super init])) {

        self.uniqueName = [decoder decodeObjectForKey:@"uniqueName"];

        self.active = [decoder decodeBoolForKey:@"active"];

        name = [decoder decodeObjectForKey:@"name"];

        self.clientVersion = [decoder decodeObjectForKey:@"clientVersion"];

        self.syncActive = [decoder decodeBoolForKey:@"syncActive"];

        self.syncDirectoryPath = [decoder decodeObjectForKey:@"syncDirectoryPath"];

        self.syncAccountsDictionary = [decoder decodeObjectForKey:@"syncAccountsDictionary"];

        self.syncSkipHidden = [decoder decodeBoolForKey:@"syncSkipHidden"];

        self.syncLastCompleted = [decoder decodeObjectForKey:@"syncLastCompleted"];

        self.authURLString = [decoder decodeObjectForKey:@"authURLString"];

        self.pithosObjectStoreURLString = [decoder decodeObjectForKey:@"pithosObjectStoreURLString"];

        self.astakosAccountURLString = [decoder decodeObjectForKey:@"astakosAccountURLString"];

        self.astakosWebloginURLString = [decoder decodeObjectForKey:@"astakosWebloginURLString"];

        self.manual = [decoder decodeBoolForKey:@"manual"];

        // Support for older versions.

        if (!authURLString && !pithosObjectStoreURLString && !astakosAccountURLString && !astakosWebloginURLString) {

            NSString *tmpURLString = [decoder decodeObjectForKey:@"serverURL"];

            if (!tmpURLString ||

                [[[NSURL URLWithString:tmpURLString] URLByAppendingPathComponent:@""] isEqual:[[NSURL URLWithString:defaultManualURLString] URLByAppendingPathComponent:@""]]) {

                self.authURLString = defaultAuthURLString;

                self.manual = NO;

            } else {

                self.pithosObjectStoreURLString = [tmpURLString stringByAppendingString:@"/v1"];

                self.astakosAccountURLString = tmpURLString;

                self.astakosWebloginURLString = tmpURLString;

                self.manual = YES;

            }

        }

        self.authToken = [decoder decodeObjectForKey:@"authToken"];

        self.authUser = [decoder decodeObjectForKey:@"authUser"];

        self.userCatalog = [decoder decodeObjectForKey:@"userCatalog"];

        if (![authUser length] || ![authToken length])

            self.active = NO;

        NSString *currentVersion = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleVersion"];

        if (!clientVersion || ![clientVersion isEqualToString:currentVersion]) {

            resetSyncDaemonLocalState = YES;

            self.clientVersion = currentVersion;

        } else {

            resetSyncDaemonLocalState = NO;

        }

    }

    return self;

}

- (void)encodeWithCoder:(NSCoder *)encoder {

    [encoder encodeObject:uniqueName forKey:@"uniqueName"];

    [encoder encodeBool:active forKey:@"active"];

    [encoder encodeObject:name forKey:@"name"];

    [encoder encodeObject:clientVersion forKey:@"clientVersion"];

    [encoder encodeBool:syncActive forKey:@"syncActive"];

    [encoder encodeObject:syncDirectoryPath forKey:@"syncDirectoryPath"];

    [encoder encodeObject:syncAccountsDictionary forKey:@"syncAccountsDictionary"];

    [encoder encodeBool:syncSkipHidden forKey:@"syncSkipHidden"];

    [encoder encodeObject:self.syncLastCompleted forKey:@"syncLastCompleted"];

    [encoder encodeObject:authURLString forKey:@"authURLString"];

    [encoder encodeObject:pithosObjectStoreURLString forKey:@"pithosObjectStoreURLString"];

    [encoder encodeObject:astakosAccountURLString forKey:@"astakosAccountURLString"];

    [encoder encodeObject:astakosWebloginURLString forKey:@"astakosWebloginURLString"];

    [encoder encodeBool:manual forKey:@"manual"];

    [encoder encodeObject:authToken forKey:@"authToken"];

    [encoder encodeObject:authUser forKey:@"authUser"];

    [encoder encodeObject:userCatalog forKey:@"userCatalog"];

}

@end