P4ObjectLayer_AppDelegate.m #1

//
//  P4ObjectLayer_AppDelegate.m
//  P4ObjectLayer
//
//  Created by Michael Bishop on 7/20/10.
//  Copyright Numerical Garden, LLC 2010 . All rights reserved.
//

#import "P4ObjectLayer_AppDelegate.h"
#import "P4SpecManager.h"
#import "P4ConnectionPool.h"
#import "P4Port.h"

@interface P4ObjectLayer_AppDelegate ()

-(void)loadSpecsForPort:(NSString*)p4port username:(NSString*)username;

@end


@implementation P4ObjectLayer_AppDelegate

@synthesize window, clients, users, changes, jobs, port;

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    //    [[P4ConnectionPool sharedPool] setNetworkDelay:0.025];
    
    port = [[P4Port portWithPortString:@"public.perforce.com:1666"] retain];
//    port = [[P4Port portWithP4Port:@"localhost:1999"] retain];

    [port refreshWithCompletion:^(NSError*e)
    {        
        if ( e )
        {
            [NSApp presentError:e];
            return;
        }
        
        [self loadSpecsForPort:port.portString username:@"michael_bishop"];
//        [self loadSpecsForPort:port.portString username:@"mbishop"];
    }];
    
}

-(void)loadSpecsForPort:(NSString*)p4port username:(NSString*)username
{
    P4SpecManager * manager = [P4SpecManager managerWithPortString:p4port username:username];
    
    [manager refreshSpecDefinitionsWithCompletion:^(NSError * error)
    {
        if ( error )
        {
            [NSApp presentError:error];
            return;
        }
        
        self.users = [manager specListOfType:@"user" completion:^(NSArray * userList, NSError* error)
                      {
                          if ( error )
                              NSLog(@"Error when refreshing users: %@", error);
                          //         NSLog( @"Userlist is: %@", speclist );
                          self.users = userList;
                          id value = [[userList objectAtIndex:0] valueForKey:@"userPeek"];
                          NSLog(@"userPeek = %@", value);
                      }];
        
        NSFetchRequest * request = [manager fetchRequestForType:@"client"];
//        [request setPredicate:[NSPredicate predicateWithFormat:@"owner == 'michael_bishop' AND client BEGINSWITH 'm'"]];
        [request setPredicate:[NSPredicate predicateWithFormat:@"client BEGINSWITH 'm'"]];
        
        self.clients = [manager executeFetchRequest:request incrementalUpdateBlock:nil completionBlock:^(NSArray * clientList, NSError* error)
                        {
                            if ( error )
                                NSLog(@"Error when refreshing clients: %@", error);
                            //         NSLog( @"Userlist is: %@", speclist );
                            self.clients = clientList;
                        }];
        
//        self.clients = [manager specListOfType:@"client" completion:^(NSArray * clientList, NSError* error)
//                        {
//                            if ( error )
//                                NSLog(@"Error when refreshing clients: %@", error);
//                            //         NSLog( @"Userlist is: %@", speclist );
//                            self.clients = clientList;
//                        }];
        self.changes = [manager specListOfType:@"change" completion:^(NSArray * clientList, NSError* error)
                        {
                            if ( error )
                                NSLog(@"Error when refreshing changes: %@", error);
                            //         NSLog( @"Userlist is: %@", speclist );
                            self.changes = clientList;
                        }];
        self.jobs = [manager specListOfType:@"job" completion:^(NSArray * specList, NSError* error)
                     {
                         if ( error )
                             NSLog(@"Error when refreshing changes: %@", error);
                         //         NSLog( @"Userlist is: %@", speclist );
                         self.jobs = specList;
                     }];
    }];
    
}

/**
    Returns the support directory for the application, used to store the Core Data
    store file.  This code uses a directory named "P4ObjectLayer" for
    the content, either in the NSApplicationSupportDirectory location or (if the
    former cannot be found), the system's temporary directory.
 */

- (NSString *)applicationSupportDirectory {

    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES);
    NSString *basePath = ([paths count] > 0) ? [paths objectAtIndex:0] : NSTemporaryDirectory();
    return [basePath stringByAppendingPathComponent:@"P4ObjectLayer"];
}


/**
    Creates, retains, and returns the managed object model for the application 
    by merging all of the models found in the application bundle.
 */
 
- (NSManagedObjectModel *)managedObjectModel {

    if (managedObjectModel) return managedObjectModel;
	
    managedObjectModel = [[NSManagedObjectModel mergedModelFromBundles:nil] retain];    
    return managedObjectModel;
}


/**
    Returns the persistent store coordinator for the application.  This 
    implementation will create and return a coordinator, having added the 
    store for the application to it.  (The directory for the store is created, 
    if necessary.)
 */

- (NSPersistentStoreCoordinator *) persistentStoreCoordinator {

    if (persistentStoreCoordinator) return persistentStoreCoordinator;

    NSManagedObjectModel *mom = [self managedObjectModel];
    if (!mom) {
        NSAssert(NO, @"Managed object model is nil");
        NSLog(@"%@:%@ No model to generate a store from", [self class], NSStringFromSelector(_cmd));
        return nil;
    }

    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSString *applicationSupportDirectory = [self applicationSupportDirectory];
    NSError *error = nil;
    
    if ( ![fileManager fileExistsAtPath:applicationSupportDirectory isDirectory:NULL] ) {
		if (![fileManager createDirectoryAtPath:applicationSupportDirectory withIntermediateDirectories:NO attributes:nil error:&error]) {
            NSAssert(NO, ([NSString stringWithFormat:@"Failed to create App Support directory %@ : %@", applicationSupportDirectory,error]));
            NSLog(@"Error creating application support directory at %@ : %@",applicationSupportDirectory,error);
            return nil;
		}
    }
    
    NSURL *url = [NSURL fileURLWithPath: [applicationSupportDirectory stringByAppendingPathComponent: @"storedata"]];
    persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel: mom];
    if (![persistentStoreCoordinator addPersistentStoreWithType:NSXMLStoreType 
                                                configuration:nil 
                                                URL:url 
                                                options:nil 
                                                error:&error]){
        [[NSApplication sharedApplication] presentError:error];
        [persistentStoreCoordinator release], persistentStoreCoordinator = nil;
        return nil;
    }    

    return persistentStoreCoordinator;
}

/**
    Returns the managed object context for the application (which is already
    bound to the persistent store coordinator for the application.) 
 */
 
- (NSManagedObjectContext *) managedObjectContext {

    if (managedObjectContext) return managedObjectContext;

    NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
    if (!coordinator) {
        NSMutableDictionary *dict = [NSMutableDictionary dictionary];
        [dict setValue:@"Failed to initialize the store" forKey:NSLocalizedDescriptionKey];
        [dict setValue:@"There was an error building up the data file." forKey:NSLocalizedFailureReasonErrorKey];
        NSError *error = [NSError errorWithDomain:@"YOUR_ERROR_DOMAIN" code:9999 userInfo:dict];
        [[NSApplication sharedApplication] presentError:error];
        return nil;
    }
    managedObjectContext = [[NSManagedObjectContext alloc] init];
    [managedObjectContext setPersistentStoreCoordinator: coordinator];

    return managedObjectContext;
}

/**
    Returns the NSUndoManager for the application.  In this case, the manager
    returned is that of the managed object context for the application.
 */
 
- (NSUndoManager *)windowWillReturnUndoManager:(NSWindow *)window {
    return [[self managedObjectContext] undoManager];
}


/**
    Performs the save action for the application, which is to send the save:
    message to the application's managed object context.  Any encountered errors
    are presented to the user.
 */
 
- (IBAction) saveAction:(id)sender {

    NSError *error = nil;
    
    if (![[self managedObjectContext] commitEditing]) {
        NSLog(@"%@:%@ unable to commit editing before saving", [self class],  NSStringFromSelector(_cmd));
    }

    if (![[self managedObjectContext] save:&error]) {
        [[NSApplication sharedApplication] presentError:error];
    }
}

- (IBAction)refresh:(id)sender
{
    if ( sender == self.clients )
    {
        P4SpecManager * manager = [P4SpecManager managerWithPortString:@"localhost:1666" username:@"mbishop"];
        self.clients = [manager specListOfType:@"client" completion:^(NSArray * speclist, NSError* error)
                        {
                            if ( error )
                                NSLog(@"Error when refreshing clients: %@", error);
                            NSLog( @"Clientlist is: %@", speclist );
                            self.clients = speclist;
                        }];
    }
}


/**
    Implementation of the applicationShouldTerminate: method, used here to
    handle the saving of changes in the application managed object context
    before the application terminates.
 */
 
- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender {

    for (P4SpecManager * manager in [P4SpecManager allOpenManagers])
    {
        NSError * error = nil;
        if ( ![manager flushCache:&error] )
        {
            NSLog(@"%@:%@ spec manager %@ unable to commit editing to terminate", manager, [self class], _cmd);
            [sender presentError:error];
            return NSTerminateCancel;
        }
    }
    
    return NSTerminateNow;
    
//    if (!managedObjectContext) return NSTerminateNow;
//
//    if (![managedObjectContext commitEditing]) {
//        NSLog(@"%@:%s unable to commit editing to terminate", [self class], _cmd);
//        return NSTerminateCancel;
//    }
//
//    if (![managedObjectContext hasChanges]) return NSTerminateNow;
//
//    NSError *error = nil;
//    if (![managedObjectContext save:&error]) {
//    
//        // This error handling simply presents error information in a panel with an 
//        // "Ok" button, which does not include any attempt at error recovery (meaning, 
//        // attempting to fix the error.)  As a result, this implementation will 
//        // present the information to the user and then follow up with a panel asking 
//        // if the user wishes to "Quit Anyway", without saving the changes.
//
//        // Typically, this process should be altered to include application-specific 
//        // recovery steps.  
//                
//        BOOL result = [sender presentError:error];
//        if (result) return NSTerminateCancel;
//
//        NSString *question = NSLocalizedString(@"Could not save changes while quitting.  Quit anyway?", @"Quit without saves error question message");
//        NSString *info = NSLocalizedString(@"Quitting now will lose any changes you have made since the last successful save", @"Quit without saves error question info");
//        NSString *quitButton = NSLocalizedString(@"Quit anyway", @"Quit anyway button title");
//        NSString *cancelButton = NSLocalizedString(@"Cancel", @"Cancel button title");
//        NSAlert *alert = [[NSAlert alloc] init];
//        [alert setMessageText:question];
//        [alert setInformativeText:info];
//        [alert addButtonWithTitle:quitButton];
//        [alert addButtonWithTitle:cancelButton];
//
//        NSInteger answer = [alert runModal];
//        [alert release];
//        alert = nil;
//        
//        if (answer == NSAlertAlternateReturn) return NSTerminateCancel;
//
//    }
//
//    return NSTerminateNow;
}


/**
    Implementation of dealloc, to release the retained variables.
 */
 
- (void)dealloc {

    [window release];
    [managedObjectContext release];
    [persistentStoreCoordinator release];
    [managedObjectModel release];
	
    [super dealloc];
}


@end