/Volumes/ATTACHE/Droppler/DropKit/DropIODrop.m

Go to the documentation of this file.

//
//  DropIODrop.m
//  DropIO
//
//  Created by Chris Patterson on 11/10/08.
//  Copyright 2008 Chris Patterson. All rights reserved.
//

#import "DropIO.h"
#import "DropIODrop.h"

#define kAssetsPerPage 30

@implementation DropIODrop

@synthesize name;
@synthesize password;

@synthesize adminPassword;
@synthesize guestPassword;
@synthesize adminToken;
@synthesize guestToken;

@synthesize email;
@synthesize voicemail;
@synthesize conference;

@synthesize rss;
@synthesize fax;
@synthesize hiddenUploadUrl;

@synthesize expirationLength;
@synthesize currentBytes;
@synthesize maxBytes;

@synthesize assetCount;

@synthesize guestsCanAdd;
@synthesize guestsCanDelete;
@synthesize guestsCanComment;

@synthesize premiumCode;

@synthesize assets;

@synthesize title;
@synthesize sortOrder;
@synthesize page;

- (id) init
{
        if ((self = [super init]) != nil)
        {
                sortOrder = AssetSortOrder_Type;
                page = 1;
        }
        return self;
}

- (void) dealloc
{
        [self unloadAssets];
        
        [name release];
        [password release];
        [adminPassword release];
        [guestPassword release];
        [adminToken release];
        [guestToken release];
        
        [email release];
        [voicemail release];
        [conference release];
        
        [rss release];
        [fax release];
        [hiddenUploadUrl release];
        
        [expirationLength release];
        [currentBytes release];
        [maxBytes release];
        
        [assetCount release];
        
        [guestsCanAdd release];
        [guestsCanDelete release];
        [guestsCanComment release];

        [premiumCode release];
        
        [title release];

        [super dealloc];
}

// Accessors returning above properties as NSURLs

- (NSURL*) emailURL                     // returns a "mailto:" URL.
{
        if (email == nil)
                return nil;
        
        return [NSURL URLWithString:[NSString stringWithFormat:@"mailto:%@", email]];
}

- (NSURL*) voicemailURL         // returns a "tel:" URL.
{
        if (voicemail == nil)
                return nil;
        NSString* voicemailUrlStr = [voicemail stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
        voicemailUrlStr = [NSString stringWithFormat:@"tel:+1-%@", voicemailUrlStr];
        voicemailUrlStr = [voicemailUrlStr stringByReplacingOccurrencesOfString:@" x " withString:@",,"];
                
        return [NSURL URLWithString:voicemailUrlStr];
}

- (NSURL*) conferenceURL        // returns a "tel:" URL.
{
        if (conference == nil)
                return nil;
        
        NSString* conferenceUrlStr = [conference stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
        conferenceUrlStr = [NSString stringWithFormat:@"tel:+1-%@", conferenceUrlStr];
        conferenceUrlStr = [conferenceUrlStr stringByReplacingOccurrencesOfString:@" x " withString:@",,"];
        
        return [NSURL URLWithString:conferenceUrlStr];
}

- (NSURL*) rssURL
{
        if (rss == nil)
                return nil;
        
        return [NSURL URLWithString:rss];
}

- (NSURL*) faxURL
{
        if (fax == nil)
                return nil;
        
        return [NSURL URLWithString:fax];
}

- (NSURL*) hiddenUploadURL
{
        if (hiddenUploadUrl == nil)
                return nil;
        
        return [NSURL URLWithString:hiddenUploadUrl];
}

- (NSURL*) dropcastURL
{
        // returns an "itpc:" URL from the rss URL.
        if (rss == nil)
                return nil;
        
        // Convert RSS url in format: "http://drop.io/path/dropName.rss"
        // to dropcast url in format: "itpc://drop.io/path/dropName/podcast.rss"
        NSString* dropcast = [[rss stringByReplacingOccurrencesOfString:@"http://" 
                                                                                                                 withString:@"itpc://"]
                                                           stringByReplacingOccurrencesOfString:@".rss"
                                                                                                                 withString:@"/podcast.rss"];
        
        return [NSURL URLWithString:dropcast];
}

- (NSURL*) feedURLForFormat:(DropFeedFormat)format
{
        switch (format)
        {
                case kDropFeedFormat_RSS:
                        return [self rssURL];
                
                case kDropFeedFormat_Dropcast:
                        return [self dropcastURL];
                        
                default:
                        break;
        }
        
        return nil;
}

- (NSURL*) dropURL
{
        NSString* token = [self bestTokenIncludingPassword:YES];
        
        return [DropIO URLForDropNamed:name withToken:token];
}

// Asset Accessors

- (NSURL*) URLForAssetsPage:(NSUInteger)assetsPage
{
        // Returns a URL in the form:
        // "http://api.drop.io/drops/" + dropname + "/assets?api_key=" + apikey + "&version=1.0&token=" + admin_or_guest_token + "&page=" + page
        // API returns 30 assets per page. To get all assets, call this method incrementing page until number of assets equals drop.assetCount.

        if (![DropIO checkAPIKey])
                return nil;
        
        NSString* token = [self bestTokenIncludingPassword:YES];
        
        NSString* urlStr = [NSString stringWithFormat:kDropIOAssetsUrlFormat, 
                                                name, 
                                                kDropIOParamKey_APIKey,  [DropIO APIKey], 
                                                kDropIOParamKey_Version, kDropIOParamValue_Version_Latest,
                                                kDropIOParamKey_Format,  kDropIOParamValue_Format_XML,
                                                kDropIOParamKey_Token,   token, 
                                                kDropIOParamKey_Page,    assetsPage];
        return [NSURL URLWithString:urlStr];
}

- (NSURL*) URLForAssetNamed:(NSString*)assetName
{
        // Returns a URL in the form:
        // "http://api.drop.io/drops/" + dropName + "/assets/" + assetName + ?api_key=" + apikey + "&version=1.0&token=" + admin_or_guest_token
        
        if (![DropIO checkAPIKey])
                return nil;
        
        NSString* token = [self bestTokenIncludingPassword:YES];
        
        NSString* urlStr = [NSString stringWithFormat:kDropIOAssetUrlFormat, 
                                                name, 
                                                assetName, 
                                                kDropIOParamKey_APIKey,  [DropIO APIKey], 
                                                kDropIOParamKey_Version, kDropIOParamValue_Version_Latest,
                                                kDropIOParamKey_Format,  kDropIOParamValue_Format_XML,
                                                kDropIOParamKey_Token,   token];
        return [NSURL URLWithString:urlStr];
}

- (void) loadAssets
{
        // clear any previous DropIOError
        [DropIO setLastError:nil];
        
        if (![DropIO checkAPIKey])
                return;

        NSInteger remainingAssets = [[self assetCount] integerValue];
        if (assets == nil)
        {
                assets = [[NSMutableArray alloc] initWithCapacity:remainingAssets];
        }
        else
        {
                remainingAssets -= [assets count];
        }
        
        NSLog(@"Loading %d assets for drop named: %@", remainingAssets, [self name]);
        
//      while (remainingAssets > 0)
//      {
                NSError* error = nil;
                NSArray* props = [DropIO parseResponseFromURL:[self URLForAssetsPage:page++]
                                                                                 fromNodeName:@"asset"
                                                                                         toObject:@"NSMutableDictionary"
                                                                                   parseError:&error];
                if ((props != nil) && ([props count] > 0))
                {
                        for (NSMutableDictionary* propDict in props)
                        {
                                // Don't create duplicate assets if we've already loaded some
                                // Check for asset with this name already in the asset array
                                NSString* assetName = [propDict objectForKey:kDropIOParamKey_Name];
                                DropIOAsset* asset = [self findAssetNamed:assetName loadIfMissing:NO];
                                
                                // Didn't find it, so create it.
                                if (asset == nil)
                                {
                                        asset = [DropIOAsset assetWithProperties:propDict];
                                        [asset setDrop:self];
                                        [asset setValue:[[self URLForAssetNamed:[asset name]] absoluteString] forKey:kDropIOParamKey_AssetAPIUrl];
                                        [assets addObject:asset];
                                        remainingAssets--;
                                }
                        }
                }
//              else
//                      break;
//      }
        
        [self sortAssets];
}

- (void) unloadAssets
{
        [assets release];
        assets = nil;
        self.assetCount = [NSNumber numberWithInteger:0];
        page = 1;
}

- (void) reloadAssets
{
        [self unloadAssets];
        
        // Reset assetCount from API
        DropIODrop* tempDrop = [DropIO findDropAtAPIURL:[self dropURL] error:nil];
        if (tempDrop != nil)
                self.assetCount = tempDrop.assetCount;
        
        [self loadAssets];
}


- (BOOL) areAssetsLoaded
{
        return (assets != nil);
}

- (DropIOAsset*) findAssetNamed:(NSString*)assetName loadIfMissing:(BOOL)loadFlag
{
        DropIOAsset* foundAsset = nil;
        
        if ([self areAssetsLoaded])
        {
                for (DropIOAsset* thisAsset in assets)
                {
                        if ([[thisAsset name] isEqualToString:assetName])
                        {
                                foundAsset = thisAsset;
                                break;
                        }
                }
        }
        
        if ((foundAsset == nil) && loadFlag)
        {
                if ([DropIO checkAPIKey])
                {
                        NSError* error = nil;
                        NSURL* assetURL = [self URLForAssetNamed:assetName];
                        NSArray* props = [DropIO parseResponseFromURL:assetURL
                                                                                         fromNodeName:@"asset"
                                                                                                 toObject:@"NSMutableDictionary"
                                                                                           parseError:&error];
                        if (props != nil && [props count] > 0)
                        {
                                foundAsset = [DropIOAsset assetWithProperties:[props objectAtIndex:0]];
                                [foundAsset setDrop:self];
                                [foundAsset setValue:[assetURL absoluteString] forKey:kDropIOParamKey_AssetAPIUrl];
                                
                                if (assets == nil)
                                        assets = [[NSMutableArray arrayWithObject:foundAsset] retain];
                                else
                                        [assets addObject:foundAsset];
                        }
                }
        }
        
        return foundAsset;
}

- (DropIOAsset*) assetAtIndex:(NSInteger)index
{
        NSInteger totalAssetCount  = [[self assetCount] integerValue];
        NSInteger loadedAssetCount = 0;
        if (assets != nil)
                loadedAssetCount = [assets count];
        
        if (index < loadedAssetCount)
                return [assets objectAtIndex:index];
        else
        if (index < totalAssetCount)
        {
                // need to load more assets...
                NSInteger newPage = (loadedAssetCount / kAssetsPerPage) + 1 ;
                if (newPage >= page)
                {
                        page = newPage;
                        [self loadAssets];
                        loadedAssetCount = [assets count];
                        if (index < loadedAssetCount)
                                return [assets objectAtIndex:index];
                }
                else
                {
                        // uh-oh -- this shouldn't happen
                        NSLog(@"API Error: only got %d assets when %d expected in page %d for drop \"%@\".", loadedAssetCount, totalAssetCount, page, name);
                }
        }
        return nil; // asset not loaded...
}

// Asset sort functions:

NSComparisonResult sortAssetsByTitle(id firstAsset, id secondAsset, void* context)
{
        return [[[firstAsset title] lowercaseString] compare:[[secondAsset title] lowercaseString]];
}

NSComparisonResult sortAssetsByDate(id firstAsset, id secondAsset, void* context)
{
        return [[firstAsset createdAt] compare:[secondAsset createdAt]];
}

NSComparisonResult sortAssetsByType(id firstAsset, id secondAsset, void* context)
{
        NSComparisonResult result = [[secondAsset type] compare:[firstAsset type]];
        if (result == NSOrderedSame)
                result = sortAssetsByTitle(firstAsset, secondAsset, context);
        return result;
}

- (void) sortAssets
{
        NSInteger (*compareFunc)(id, id, void *) = nil;
        switch (sortOrder)
        {
                case AssetSortOrder_Date:       compareFunc = sortAssetsByDate; break;
                case AssetSortOrder_Type:       compareFunc = sortAssetsByType; break;
                case AssetSortOrder_Title:      compareFunc = sortAssetsByTitle;break;
                default:                                                compareFunc = sortAssetsByType; break;
        }
        NSAutoreleasePool* sortPool = [[NSAutoreleasePool alloc] init];
        [assets sortUsingFunction:compareFunc context:nil];
        [sortPool release];
}

// Basic bottleneck method for drop.io RESTful operations
- (DropIOAsset*) assetOperation:(NSString*)opString atUrl:(NSString*)urlStr withParameters:(NSDictionary*)params
{
        // clear any previous DropIOError
        [DropIO setLastError:nil];
        
        if (![DropIO checkAPIKey])
                return nil;
        
        // Create an HTTP URL request pointing to the drop.io API URL.
        NSMutableURLRequest* dropReq = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString:urlStr]];
        [dropReq setHTTPMethod:opString];       
        [dropReq setHTTPPostBody:params];       // Method added by NSMutableURLRequest(httpFormEncoding) category, defined above.
        
        // Send the request and get the drop XML response synchronously (for now).
        NSURLResponse* dropResp = nil;
        NSError* error = nil;
        NSData* dropXmlData = [NSURLConnection sendSynchronousRequest:dropReq 
                                                                                                returningResponse:&dropResp 
                                                                                                                        error:&error];
        if (error != nil)
        {
                NSLog(@"HTTP %@ Error: %@", opString, error);
                [DropIO setLastError:error];
                return nil;
        }
        
        // Parse the XML into DropIOAsset object
        NSArray* propArray = [DropIO parseResponse:dropXmlData
                                                                  fromNodeName:@"asset"
                                                                          toObject:@"NSMutableDictionary"
                                                                        parseError:&error];
        if (propArray == nil || [propArray count] == 0)
                return nil;
        
        return [DropIOAsset assetWithProperties:[propArray objectAtIndex:0]];
}

// Asset Creation
- (DropIOAsset*) assetWithParameters:(NSDictionary*)params
{
        DropIOAsset* asset = [self assetOperation:@"POST" 
                                                                                atUrl:[NSString stringWithFormat:kDropIONewAssetUrlFormat, [self name]]
                                                           withParameters:params];
        if (asset != nil)
        {
                [self addAsset:asset];
        }
        return asset;
}

- (void) addAsset:(DropIOAsset*)asset
{
        [asset setDrop:self];
        [asset setValue:[[self URLForAssetNamed:[asset name]] absoluteString] forKey:kDropIOParamKey_AssetAPIUrl];
        [assets addObject:asset];

        NSInteger maxAssets = [[self assetCount] integerValue];
        self.assetCount = [NSNumber numberWithInteger:++maxAssets];
        
        [self sortAssets];
}

- (void) removeAsset:(DropIOAsset*)asset
{
        // No need to check canDelete method; let API return its error.
        [asset delete];
}

- (void) removeAssetAtIndex:(NSInteger)index
{
        DropIOAsset* assetToRemove = (DropIOAsset*)[assets objectAtIndex:index];
        if (assetToRemove != nil)
                [self removeAsset:assetToRemove];
}

- (NSInteger) countAssetsOfType:(NSString*)assetType
{
        NSInteger count = 0;
        for (DropIOAsset* asset in assets)
        {
                if ([assetType isEqualToString:asset.type])
                        count++;
        }
        return count;
}

- (DropIONote*) noteWithTitle:(NSString*)noteTitle contents:(NSString*)text
{
        if (![DropIO checkAPIKey])
                return nil;
        
        NSString* token = [self bestTokenIncludingPassword:NO];
        
        NSMutableDictionary* params = [NSMutableDictionary dictionaryWithCapacity:6];
        [params setObject:kDropIOParamValue_Format_XML          forKey:kDropIOParamKey_Format];
        [params setObject:kDropIOParamValue_Version_Latest      forKey:kDropIOParamKey_Version];
        [params setObject:[DropIO APIKey]                                       forKey:kDropIOParamKey_APIKey];
        [params setObject:noteTitle                                                     forKey:kDropIOParamKey_Title];
        [params setObject:text                                                          forKey:kDropIOParamKey_Contents];
        [params setObject:token                                                         forKey:kDropIOParamKey_Token];
        
        return (DropIONote*)[self assetWithParameters:params];
}

- (DropIOLink*) linkWithTitle:(NSString*)linkTitle url:(NSURL*)linkURL description:(NSString*)linkDesc
{
        if (![DropIO checkAPIKey])
                return nil;
        
        NSString* token = [self bestTokenIncludingPassword:NO];
        
        NSString* linkUrlStr = [linkURL absoluteString];
        
        NSMutableDictionary* params = [NSMutableDictionary dictionaryWithCapacity:7];
        [params setObject:kDropIOParamValue_Format_XML          forKey:kDropIOParamKey_Format];
        [params setObject:kDropIOParamValue_Version_Latest      forKey:kDropIOParamKey_Version];
        [params setObject:[DropIO APIKey]                                       forKey:kDropIOParamKey_APIKey];
        [params setObject:linkTitle                                                     forKey:kDropIOParamKey_Title];
        [params setObject:linkUrlStr                                            forKey:kDropIOParamKey_Url];
        [params setObject:token                                                         forKey:kDropIOParamKey_Token];
        if (linkDesc != nil)
                [params setObject:linkDesc                                              forKey:kDropIOParamKey_Description];
        
        return (DropIOLink*)[self assetWithParameters:params];
}

- (DropIOImage*) imageWithName:(NSString*)imgName UIImage:(UIImage*)uiImage 
{
        // Must do an HTTP file upload to the URL http://assets.drop.io/upload
        
        if (![DropIO checkAPIKey])
                return nil;
        
        NSString* token = [self bestTokenIncludingPassword:NO];
        
        NSMutableDictionary* params = [NSMutableDictionary dictionaryWithCapacity:5];
        [params setObject:kDropIOParamValue_Version_Latest      forKey:kDropIOParamKey_Version];
        [params setObject:[DropIO APIKey]                                       forKey:kDropIOParamKey_APIKey];
        [params setObject:token                                                         forKey:kDropIOParamKey_Token];
        [params setObject:[self name]                                           forKey:kDropIOParamKey_DropName];
        
        // clear any previous DropIOError
        [DropIO setLastError:nil];
        
        NSLog(@"Uploading image named \"%@\" with params %@", imgName, params);
        
        // Create an HTTP POST URL request pointing to the drop.io API URL.
        NSString* boundary              = @"DropplerFileUpload";
        NSString* contentType   = [NSString stringWithFormat:@"multipart/form-data; boundary=%@", boundary];
        
        NSMutableURLRequest* uploadReq = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString:kDropIOFileUploadUrl]];
        [uploadReq setHTTPMethod:@"POST"];
        [uploadReq setValue:contentType forHTTPHeaderField:@"Content-Type"];
        
        NSData* pngData = UIImagePNGRepresentation(uiImage);
        NSMutableData *postBody = [NSMutableData dataWithCapacity:[pngData length] + 512];
        
        // Add form parameters
        for (NSString* key in [params allKeys])
        {
                NSString* paramContent = [NSString stringWithFormat:@"--%@\r\nContent-Disposition: form-data; name=\"%@\"\r\n\r\n%@\r\n",
                                                                  boundary,
                                                                  key,
                                                                  [params objectForKey:key]
                                                                 ];
                [postBody appendData:[paramContent dataUsingEncoding:NSUTF8StringEncoding]];
        }
        
        // Add file data parameter
        NSString* fileContentHeader = [NSString stringWithFormat:@"--%@\r\nContent-Disposition: form-data; name=\"file\"; filename=\"%@.png\"\r\nContent-Type:image/png\r\n\r\n",
                                                                   boundary, [imgName stringByAddingPercentEscapesUsingEncoding:NSASCIIStringEncoding]];
        [postBody appendData:[fileContentHeader dataUsingEncoding:NSUTF8StringEncoding]];
        [postBody appendData:pngData];
        [postBody appendData:[[NSString stringWithFormat:@"\r\n--%@--\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
        
        [uploadReq setHTTPBody:postBody];
        
        // Send the request and get the drop XML response synchronously (for now).
        NSURLResponse* uploadResp = nil;
        NSError* error = nil;
        NSData* xmlData = [NSURLConnection sendSynchronousRequest:uploadReq 
                                                                                        returningResponse:&uploadResp 
                                                                                                                error:&error];
        if (error != nil)
        {
                NSLog(@"HTTP Image File Upload Error: %@", error);
                [DropIO setLastError:error];
                return nil;
        }
        
        //NSString* xmlStr = [[NSString alloc] initWithData:xmlData encoding:NSASCIIStringEncoding];
        //NSLog(@"Drop.io API raw response data: %@", xmlStr);
        //[xmlStr release];
        
        // Parse the XML into DropIOAsset object
        NSArray* propArray = [DropIO parseResponse:xmlData
                                                                  fromNodeName:@"asset"
                                                                          toObject:@"NSMutableDictionary"
                                                                        parseError:&error];
        if (propArray == nil || [propArray count] == 0)
                return nil;
        
        DropIOAsset* asset = [DropIOAsset assetWithProperties:[propArray objectAtIndex:0]];
        if (asset != nil)
        {
                [self addAsset:asset];
        }
        return (DropIOImage*)asset;
}

- (void) recordVoicemail
{
        // Pass voicemail URL to app's openURL method.
        [[UIApplication sharedApplication] openURL:[self voicemailURL]];
}

- (void) conferenceCall
{
        // Pass conference URL to app's openURL method.
        [[UIApplication sharedApplication] openURL:[self conferenceURL]];
}

- (NSString*)bestTokenIncludingPassword:(BOOL)includePassword
{
        NSString* token = @"";
        if ((adminToken != nil) && (adminToken.length > 0))
                token = adminToken;
        else
        if ((guestToken != nil) && (guestToken.length > 0))
                token = guestToken;
        else
        if (includePassword && (password != nil) && (password.length > 0))
                token = password;
        
        return token;
}

// Determine access privileges for button enablement

- (BOOL) canAdd
{
        // User can add to drop if:
        // they have an admin token, or
        // they have a guest token AND guestsCanAdd is "true"
        return (((adminToken != nil) && (adminToken.length > 0))
                ||  ((guestToken != nil) && (guestToken.length > 0) 
                &&   (guestsCanAdd != nil) && [guestsCanAdd isEqualToString:@"true"]));
}

- (BOOL) canEdit
{
        // If you can add, you can edit.
        return [self canAdd];
}

- (BOOL) canDelete
{
        // User can delete from drop if:
        // they have an admin token, or
        // they have a guest token AND guestsCanDelete is "true"
        return (((adminToken != nil) && (adminToken.length > 0))
                ||  ((guestToken != nil) && (guestToken.length > 0) 
                &&   (guestsCanDelete != nil) && [guestsCanDelete isEqualToString:@"true"]));
}

- (BOOL) canComment
{
        // User can add comments to drop assets if:
        // they have an admin token, or
        // they have a guest token AND guestsCanComment is "true"
        return (((adminToken != nil) && (adminToken.length > 0))
                ||  ((guestToken != nil) && (guestToken.length > 0) 
                &&   (guestsCanComment != nil) && [guestsCanComment isEqualToString:@"true"]));
        
}

- (void) update
{
        [DropIO setLastError:nil];

        // Must already have a valid token to update drop properties; don't include password
        NSString* token = [self bestTokenIncludingPassword:NO];
        
        NSMutableDictionary* params = [NSMutableDictionary dictionaryWithCapacity:11];
        
        // Required parameters
        [params setObject:kDropIOParamValue_Format_XML          forKey:kDropIOParamKey_Format];
        [params setObject:kDropIOParamValue_Version_Latest      forKey:kDropIOParamKey_Version];
        [params setObject:[DropIO APIKey]                                       forKey:kDropIOParamKey_APIKey];
        [params setObject:token                                                         forKey:kDropIOParamKey_Token];
        
        // Optional parameters
        if (guestPassword        != nil)        [params setObject:guestPassword         forKey:kDropIOParamKey_GuestPassword];
        if (adminPassword        != nil)        [params setObject:adminPassword         forKey:kDropIOParamKey_AdminPassword];
        if (premiumCode          != nil)        [params setObject:premiumCode           forKey:kDropIOParamKey_PremiumCode];
        if (expirationLength != nil)    [params setObject:expirationLength      forKey:kDropIOParamKey_ExpirationLength];
        if (guestsCanAdd         != nil)        [params setObject:guestsCanAdd          forKey:kDropIOParamKey_GuestsCanAdd];
        if (guestsCanDelete  != nil)    [params setObject:guestsCanDelete       forKey:kDropIOParamKey_GuestsCanDelete];
        if (guestsCanComment != nil)    [params setObject:guestsCanComment      forKey:kDropIOParamKey_GuestsCanComment];
        
        [DropIO updateDropNamed:[self name] withParameters:params];
}

- (void) delete
{
        [DropIO setLastError:nil];
        
        // Must already have a valid token to delete drop properties; don't include password
        NSString* token = [self bestTokenIncludingPassword:NO];
        
        NSMutableDictionary* params = [NSMutableDictionary dictionaryWithCapacity:4];
        
        // Required parameters
        [params setObject:kDropIOParamValue_Format_XML          forKey:kDropIOParamKey_Format];
        [params setObject:kDropIOParamValue_Version_Latest      forKey:kDropIOParamKey_Version];
        [params setObject:[DropIO APIKey]                                       forKey:kDropIOParamKey_APIKey];
        [params setObject:token                                                         forKey:kDropIOParamKey_Token];
        
        [DropIO deleteDropNamed:[self name] withParameters:params];
        
        if ([DropIO lastError] != nil)
        {
                // For some reason the drop.io API returns a successful deletion in an error response.
                if ([[DropIO lastError] code] == kDropIOErrorCode_DropDeleted)
                {
                        [DropIO setLastError:nil];
                }
        }
}

// Key-Value Coding methods

- (void)setValue:(id)value 
 forUndefinedKey:(NSString *)key 
{
        // do nothing
        //NSLog(@"undefined key: %@ value: %@ for class: %@", key, value, [self class]);
}
@end

---