Synnefo » Pithos iOS Client

//

//  OpenStackAccount.m

//  OpenStack

//

//  Created by Mike Mayo on 10/1/10.

//  The OpenStack project is provided under the Apache 2.0 license.

//

#import "OpenStackAccount.h"

#import "Keychain.h"

#import "Provider.h"

#import "Archiver.h"

#import "OpenStackRequest.h"

#import "NSObject+Conveniences.h"

#import "AccountManager.h"

#import "APICallback.h"

static NSArray *accounts = nil;

@implementation OpenStackAccount

@synthesize uuid, provider, username, filesURL, manager,

            bytesUsed, policyQuota, containers, hasBeenRefreshed, flaggedForDelete,

            shared, sharingAccount, userCatalog, ignoreSSLErrors;

+ (void)initialize {

    accounts = [[Archiver retrieve:@"accounts"] retain];

    if (accounts == nil) {

        accounts = [[NSArray alloc] init];

        [Archiver persist:accounts key:@"accounts"];

    }

}

#pragma mark - Constructors

- (id)init {

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

        uuid = [[NSString alloc] initWithString:[OpenStackAccount stringWithUUID]];

        self.userCatalog = [NSMutableDictionary dictionary];

        manager = [[AccountManager alloc] init];

        manager.account = self;

    }

    return self;

}

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

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

        self.uuid = [self decode:coder key:@"uuid"];

        self.provider = [self decode:coder key:@"provider"];

        self.username = [self decode:coder key:@"username"];

        self.bytesUsed = [self decode:coder key:@"bytesUsed"];

        self.policyQuota = [self decode:coder key:@"policyQuota"];

//        containers = [self decode:coder key:@"containers"];

        self.userCatalog = [self decode:coder key:@"userCatalog"];

        if (!userCatalog) {

            self.userCatalog = [NSMutableDictionary dictionary];

        }

        self.ignoreSSLErrors = [coder decodeBoolForKey:@"ignoreSSLErrors"];

        manager = [[AccountManager alloc] init];

        manager.account = self;

    }

    return self;

}

#pragma mark - Serialization

- (id)copyWithZone:(NSZone *)zone {

    OpenStackAccount *copy = [[[self class] allocWithZone:zone] init];

    copy.uuid = [[self.uuid copy] autorelease];

    copy.provider = [[self.provider copy] autorelease];

    copy.username = [[self.username copy] autorelease];

    copy.apiKey = [[self.apiKey copy] autorelease];

    copy.authToken = [[self.authToken copy] autorelease];

    copy.bytesUsed = [[self.bytesUsed copy] autorelease];

    copy.policyQuota = [[self.policyQuota copy] autorelease];

    copy.userCatalog = [[self.userCatalog copy] autorelease];

    copy.ignoreSSLErrors = self.ignoreSSLErrors;

    copy.manager = [[[AccountManager alloc] init] autorelease];

    copy.manager.account = copy;

    return copy;

}

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

    [coder encodeObject:uuid forKey:@"uuid"];

    [coder encodeObject:provider forKey:@"provider"];

    [coder encodeObject:username forKey:@"username"];

    [coder encodeObject:bytesUsed forKey:@"bytesUsed"];

    [coder encodeObject:policyQuota forKey:@"policyQuota"];

//    [coder encodeObject:containers forKey:@"containers"];

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

    [coder encodeBool:ignoreSSLErrors forKey:@"ignoreSSLErrors"];

}

- (id)decode:(NSCoder *)coder key:(NSString *)key {

    @try {

        return [coder decodeObjectForKey:key];

    }

    @catch (NSException *exception) {

        return nil;

    }

}

#pragma mark - Properties

- (NSURL *)filesURL {

    return [self.provider.authEndpointURL URLByAppendingPathComponent:self.username];

}

- (void)setShared:(BOOL)aShared {

    if (shared != aShared) {

        self.containers = nil;

    }

    shared = aShared;

}

- (void)setSharingAccount:(NSString *)aSharingAccount {

    if ((aSharingAccount && ![aSharingAccount isEqualToString:sharingAccount]) || (!aSharingAccount && sharingAccount)) {

        self.containers = nil;

    }

    [sharingAccount release];

    sharingAccount = [aSharingAccount retain];

}

// the API key and auth token are stored in the Keychain, so overriding the

// getter and setter to abstract the encryption away and make it easy to use

- (NSString *)apiKeyKeychainKey {

    return [NSString stringWithFormat:@"%@-apiKey", self.uuid];

}

- (NSString *)apiKey {

    return [Keychain getStringForKey:[self apiKeyKeychainKey]];

}

- (void)setApiKey:(NSString *)newAPIKey {

    [Keychain setString:newAPIKey forKey:[self apiKeyKeychainKey]];

}

- (NSString *)authTokenKeychainKey {

    return [NSString stringWithFormat:@"%@-authToken", self.uuid];

}

- (NSString *)authToken {

    NSString *authToken = [Keychain getStringForKey:[self authTokenKeychainKey]];

    if (!authToken) {

        authToken = @"";

    }

    return authToken;

}

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

    [Keychain setString:newAuthToken forKey:[self authTokenKeychainKey]];

}

#pragma mark - Class Actions

+ (NSArray *)accounts {

    if (accounts == nil) {

        accounts = [[Archiver retrieve:@"accounts"] retain];

    }

    return accounts;

}

+ (void)persist:(NSArray *)accountArray {

    accounts = [[NSArray arrayWithArray:accountArray] retain];

    [Archiver persist:accounts key:@"accounts"];

    [accounts release];

    accounts = nil;

}

#pragma mark - Actions

- (void)persist {

    if (!flaggedForDelete) {

        NSMutableArray *accountArr = [NSMutableArray arrayWithArray:[OpenStackAccount accounts]];

        BOOL accountPresent = NO;

        for (int i = 0; i < [accountArr count]; i++) {

            OpenStackAccount *account = [accountArr objectAtIndex:i];

            if ([account.uuid isEqualToString:self.uuid]) {

                accountPresent = YES;

                [accountArr replaceObjectAtIndex:i withObject:self];

                break;

            }

        }

        if (!accountPresent) {

            [accountArr insertObject:self atIndex:0];

        }

        [Archiver persist:[NSArray arrayWithArray:accountArr] key:@"accounts"];

        [accounts release];

        accounts = nil;

    }

}

- (NSArray *)pithosSortedContainers {

    NSMutableArray *pithosSortedContainers = [NSMutableArray array];

    if ([self.containers objectForKey:@"pithos"])

        [pithosSortedContainers addObject:[self.containers objectForKey:@"pithos"]];

    if ([self.containers objectForKey:@"trash"])

        [pithosSortedContainers addObject:[self.containers objectForKey:@"trash"]];

    NSMutableDictionary *otherContainers = [NSMutableDictionary dictionaryWithDictionary:self.containers];

    [otherContainers removeObjectForKey:@"pithos"];

    [otherContainers removeObjectForKey:@"trash"];

    [pithosSortedContainers addObjectsFromArray:[[otherContainers allValues] sortedArrayUsingSelector:@selector(compare:)]];

    return pithosSortedContainers;

}

- (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 - Memory Management

- (void)dealloc {

    [uuid release];

    [manager release];

    [provider release];

    [username release];

    [containers release];

    [sharingAccount release];

    [bytesUsed release];

    [policyQuota release];

    [userCatalog release];

    [super dealloc];

}

@end