Apply fix to #266

ios/RNFetchBlob/RNFetchBlob.m

                   callback:(RCTResponseSenderBlock)callback)
 {
 
-    [RNFetchBlobReqBuilder buildMultipartRequest:options taskId:taskId method:method url:url headers:headers form:form onComplete:^(__weak NSURLRequest *req, long bodyLength) {
+    [RNFetchBlobReqBuilder buildMultipartRequest:options
+                                          taskId:taskId
+                                          method:method
+                                             url:url
+                                         headers:headers
+                                            form:form
+                                      onComplete:^(__weak NSURLRequest *req, long bodyLength)
+    {
+        // something went wrong when building the request body
+        if(req == nil)
+        {
+            callback(@[@"RNFetchBlob.fetchBlobForm failed to create request body"]);
+        }
         // send HTTP request
-        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+        else
+        {
+            RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
+            [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+        }
     }];
 
 }
                   headers:(NSDictionary *)headers
                   body:(NSString *)body callback:(RCTResponseSenderBlock)callback)
 {
-    [RNFetchBlobReqBuilder buildOctetRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
+    [RNFetchBlobReqBuilder buildOctetRequest:options
+                                      taskId:taskId
+                                      method:method
+                                         url:url
+                                     headers:headers
+                                        body:body
+                                  onComplete:^(NSURLRequest *req, long bodyLength)
+    {
+        // something went wrong when building the request body
+        if(req == nil)
+        {
+            callback(@[@"RNFetchBlob.fetchBlob failed to create request body"]);
+        }
         // send HTTP request
-        __block RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+        else
+        {
+            __block RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
+            [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+        }
     }];
 }
 
 }
 
 #pragma mark - fs.readFile
-RCT_EXPORT_METHOD(readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXPORT_METHOD(readFile:(NSString *)path
+                  encoding:(NSString *)encoding
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
 
-    [RNFetchBlobFS readFile:path encoding:encoding resolver:resolve rejecter:reject onComplete:nil];
+    [RNFetchBlobFS readFile:path encoding:encoding onComplete:^(id content, NSString * err) {
+        if(err != nil)
+        {
+            reject(@"RNFetchBlob failed to read file", err, nil);
+            return;
+        }
+        if(encoding == @"ascii")
+        {
+            resolve((NSMutableArray *)content);
+        }
+        else
+        {
+            resolve((NSString *)content);
+        }
+    }];
 }
 
 #pragma mark - fs.readStream
 }
 
 # pragma mark - getCookies
-
 RCT_EXPORT_METHOD(getCookies:(NSString *)url resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     resolve([RNFetchBlobNetwork getCookies:url]);
 }
 
-# pragma mark - removeCookie
-
-RCT_EXPORT_METHOD(removeCookies:(NSString *)domain resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    NSError * err = nil;
-    [RNFetchBlobNetwork removeCookies:domain error:&err];
-    if(err)
-        reject(@"RNFetchBlob failed to remove cookie", @"RNFetchBlob failed to remove cookie", nil);
-    else
-        resolve(@[[NSNull null]]);
-}
-
 # pragma mark - check expired network events
 
 RCT_EXPORT_METHOD(emitExpiredEvent:(RCTResponseSenderBlock)callback)
 }
 
 
-
-
 @end

ios/RNFetchBlobFS.h

 + (void) exists:(NSString *) path callback:(RCTResponseSenderBlock)callback;
 + (void) writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 + (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
-+ (void) readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject onComplete:(void (^)(NSData * content))onComplete;
++ (void) readFile:(NSString *)path encoding:(NSString *)encoding onComplete:(void (^)(NSData * content, NSString * errMsg))onComplete;
 + (void) readAssetFile:(NSData *)assetUrl completionBlock:(void(^)(NSData * content))completionBlock failBlock:(void(^)(NSError * err))failBlock;
 + (void) slice:(NSString *)path
          dest:(NSString *)dest

ios/RNFetchBlobFS.m

 
 # pragma mark - read file
 
-+ (void) readFile:(NSString *)path encoding:(NSString *)encoding
-         resolver:(RCTPromiseResolveBlock)resolve
-         rejecter:(RCTPromiseRejectBlock)reject
-       onComplete:(void (^)(NSData * content))onComplete
++ (void) readFile:(NSString *)path
+         encoding:(NSString *)encoding
+       onComplete:(void (^)(id content, NSString * errMsg))onComplete
 {
-    @try
-    {
-        [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
-            __block NSData * fileContent;
-            NSError * err;
-            __block Byte * buffer;
-            if(asset != nil)
+    [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        __block NSData * fileContent;
+        NSError * err;
+        __block Byte * buffer;
+        if(asset != nil)
+        {
+            buffer = malloc(asset.size);
+            [asset getBytes:buffer fromOffset:0 length:asset.size error:&err];
+            if(err != nil)
             {
-                buffer = malloc(asset.size);
-                [asset getBytes:buffer fromOffset:0 length:asset.size error:&err];
-                if(err != nil)
-                {
-                    reject(@"RNFetchBlobFS readFile error", @"failed to read asset", [err localizedDescription]);
-                    return;
-                }
-                fileContent = [NSData dataWithBytes:buffer length:asset.size];
+                onComplete(nil, [err description]);
                 free(buffer);
+                return;
             }
-            else
-            {
-                if(![[NSFileManager defaultManager] fileExistsAtPath:path]) {
-
-                    reject(@"RNFetchBlobFS readFile error", @"file not exists", nil);
-                    return;
-                }
-                fileContent = [NSData dataWithContentsOfFile:path];
-
+            fileContent = [NSData dataWithBytes:buffer length:asset.size];
+            free(buffer);
+        }
+        else
+        {
+            if(![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+                onComplete(nil, @"file not exists");
+                return;
             }
-            if(onComplete != nil)
-                onComplete(fileContent);
-
-            if([[encoding lowercaseString] isEqualToString:@"utf8"]) {
-                if(resolve != nil) {
-                    NSString * utf8 = [[NSString alloc] initWithData:fileContent encoding:NSUTF8StringEncoding];
-                    if(utf8 == nil)
-                        resolve([[NSString alloc] initWithData:fileContent encoding:NSISOLatin1StringEncoding]);
-                    else
-                        resolve(utf8);
-                }
+            fileContent = [NSData dataWithContentsOfFile:path];
+            
+        }
+        
+        if(encoding != nil)
+        {
+            if([[encoding lowercaseString] isEqualToString:@"utf8"])
+            {
+                NSString * utf8 = [[NSString alloc] initWithData:fileContent encoding:NSUTF8StringEncoding];
+                if(utf8 == nil)
+                    onComplete([[NSString alloc] initWithData:fileContent encoding:NSISOLatin1StringEncoding], nil);
+                else
+                    onComplete(utf8, nil);
             }
             else if ([[encoding lowercaseString] isEqualToString:@"base64"]) {
-                if(resolve != nil)
-                    resolve([fileContent base64EncodedStringWithOptions:0]);
+                onComplete([fileContent base64EncodedStringWithOptions:0], nil);
             }
             else if ([[encoding lowercaseString] isEqualToString:@"ascii"]) {
                 NSMutableArray * resultArray = [NSMutableArray array];
                 for(int i=0;i<[fileContent length];i++) {
                     [resultArray addObject:[NSNumber numberWithChar:bytes[i]]];
                 }
-                if(resolve != nil)
-                    resolve(resultArray);
+                onComplete(resultArray, nil);
             }
-        }];
-    }
-    @catch(NSException * e)
-    {
-        if(reject != nil)
-            reject(@"RNFetchBlobFS readFile error", @"error", [e description]);
-    }
+        }
+        else
+        {
+            onComplete(fileContent, nil);
+        }
+        
+    }];
 }
 
+
 # pragma mark - mkdir
 
 + (BOOL) mkdir:(NSString *) path {
              @"size" : size,
              @"filename" : filename,
              @"path" : path,
-             @"lastModified" : [NSString stringWithFormat:@"%@", [NSNumber numberWithLong:(time_t) [lastModified timeIntervalSince1970]*1000]],
+             @"lastModified" : [NSNumber numberWithLong:(time_t) [lastModified timeIntervalSince1970]*1000],
              @"type" : isDir ? @"directory" : @"file"
             };
 

ios/RNFetchBlobNetwork.h

 
 typedef void(^CompletionHander)(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error);
 typedef void(^DataTaskCompletionHander) (NSData * _Nullable resp, NSURLResponse * _Nullable response, NSError * _Nullable error);
-typedef NS_ENUM(NSUInteger, ResponseFormat) {
-    UTF8,
-    BASE64,
-    AUTO
-};
 
 @interface RNFetchBlobNetwork : NSObject  <NSURLSessionDelegate, NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
 
 @property (strong, nonatomic) CompletionHander fileTaskCompletionHandler;
 @property (strong, nonatomic) DataTaskCompletionHander dataTaskCompletionHandler;
 @property (nullable, nonatomic) NSError * error;
-@property (nullable, nonatomic) NSMutableArray * redirects;
-
-@property (nonatomic) BOOL respFile;
-@property (nonatomic) BOOL isNewPart;
-@property (nonatomic) BOOL isIncrement;
-@property (nullable, nonatomic) NSMutableData * partBuffer;
-@property (nullable, nonatomic) NSString * destPath;
-@property (nullable, nonatomic) NSOutputStream * writeStream;
-@property (nonatomic) long bodyLength;
-@property (nullable, nonatomic) NSMutableDictionary * respInfo;
-@property (nonatomic) NSInteger respStatus;
-@property (nonatomic) ResponseFormat responseFormat;
-@property ( nonatomic) BOOL followRedirect;
 
 
 + (NSMutableDictionary  * _Nullable ) normalizeHeaders:(NSDictionary * _Nullable)headers;
 - (nullable id) init;
 - (void) sendRequest;
 - (void) sendRequest:(NSDictionary  * _Nullable )options contentLength:(long)contentLength bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback;
-+ (void) removeCookies:(NSString *) domain error:(NSError **)error;
 + (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config;
 + (void) enableUploadProgress:(NSString *) taskId config:(RNFetchBlobProgress *)config;
-+ (NSDictionary *) getCookies:(NSString *) url;
++ (NSArray *) getCookies:(NSString *) url;
 
 
 

ios/RNFetchBlobNetwork.m

 
 NSMapTable * taskTable;
 NSMapTable * expirationTable;
+NSMapTable * cookiesTable;
 NSMutableDictionary * progressTable;
 NSMutableDictionary * uploadProgressTable;
 
     {
         uploadProgressTable = [[NSMutableDictionary alloc] init];
     }
+    if(cookiesTable == nil)
+    {
+        cookiesTable = [[NSMapTable alloc] init];
+    }
 }
 
 
+typedef NS_ENUM(NSUInteger, ResponseFormat) {
+    UTF8,
+    BASE64,
+    AUTO
+};
+
+
+@interface RNFetchBlobNetwork ()
+{
+    BOOL * respFile;
+    BOOL isNewPart;
+    BOOL * isIncrement;
+    NSMutableData * partBuffer;
+    NSString * destPath;
+    NSOutputStream * writeStream;
+    long bodyLength;
+    NSMutableDictionary * respInfo;
+    NSInteger respStatus;
+    NSMutableArray * redirects;
+    ResponseFormat responseFormat;
+    BOOL * followRedirect;
+}
+
+@end
 
 @implementation RNFetchBlobNetwork
 
 @synthesize callback;
 @synthesize bridge;
 @synthesize options;
-@synthesize redirects;
 @synthesize fileTaskCompletionHandler;
 @synthesize dataTaskCompletionHandler;
 @synthesize error;
 
-@synthesize respFile;
-@synthesize isNewPart;
-@synthesize isIncrement;
-@synthesize partBuffer;
-@synthesize destPath;
-@synthesize writeStream;
-@synthesize bodyLength;
-@synthesize respInfo;
-@synthesize respStatus;
-@synthesize responseFormat;
-@synthesize followRedirect;
-
 
 // constructor
 - (id)init {
     return self;
 }
 
++ (NSArray *) getCookies:(NSString *) url
+{
+    NSString * hostname = [[NSURL URLWithString:url] host];
+    NSMutableArray * cookies = [NSMutableArray new];
+    NSArray * list = [cookiesTable objectForKey:hostname];
+    for(NSHTTPCookie * cookie in list)
+    {
+        NSMutableString * cookieStr = [[NSMutableString alloc] init];
+        [cookieStr appendString:cookie.name];
+        [cookieStr appendString:@"="];
+        [cookieStr appendString:cookie.value];
+
+        if(cookie.expiresDate == nil) {
+            [cookieStr appendString:@"; max-age=0"];
+        }
+        else {
+            [cookieStr appendString:@"; expires="];
+            NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
+            [dateFormatter setDateFormat:@"EEE, dd MM yyyy HH:mm:ss ZZZ"];
+            NSString *strDate = [dateFormatter stringFromDate:cookie.expiresDate];
+            [cookieStr appendString:strDate];
+        }
+
+
+        [cookieStr appendString:@"; domain="];
+        [cookieStr appendString:hostname];
+        [cookieStr appendString:@"; path="];
+        [cookieStr appendString:cookie.path];
+
+
+        if (cookie.isSecure) {
+            [cookieStr appendString:@"; secure"];
+        }
+
+        if (cookie.isHTTPOnly) {
+            [cookieStr appendString:@"; httponly"];
+        }
+        [cookies addObject:cookieStr];
+    }
+    return cookies;
+}
+
 + (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config
 {
     if(progressTable == nil)
         // # 153 get cookies
         if(response.URL != nil)
         {
-            NSHTTPCookieStorage * cookieStore = [NSHTTPCookieStorage sharedHTTPCookieStorage];
             NSArray<NSHTTPCookie *> * cookies = [NSHTTPCookie cookiesWithResponseHeaderFields: headers forURL:response.URL];
             if(cookies != nil && [cookies count] > 0) {
-                [cookieStore setCookies:cookies forURL:response.URL mainDocumentURL:nil];
+                [cookiesTable setObject:cookies forKey:response.URL.host];
             }
         }
 
     }
 }
 
-# pragma mark - cookies handling API
-
-+ (NSDictionary *) getCookies:(NSString *) domain
-{
-    NSMutableDictionary * result = [NSMutableDictionary new];
-    NSHTTPCookieStorage * cookieStore = [NSHTTPCookieStorage sharedHTTPCookieStorage];
-    for(NSHTTPCookie * cookie in [cookieStore cookies])
-    {
-        NSString * cDomain = [cookie domain];
-        if([result objectForKey:cDomain] == nil)
-        {
-            [result setObject:[NSMutableArray new] forKey:cDomain];
-        }
-        if([cDomain isEqualToString:domain] || [domain length] == 0)
-        {
-            NSMutableString * cookieStr = [[NSMutableString alloc] init];
-            cookieStr = [[self class] getCookieString:cookie];
-            NSMutableArray * ary = [result objectForKey:cDomain];
-            [ary addObject:cookieStr];
-            [result setObject:ary forKey:cDomain];
-        }
-    }
-    return result;
-}
-
-// remove cookies for given domain, if domain is empty remove all cookies in shared cookie storage.
-+ (void) removeCookies:(NSString *) domain error:(NSError **)error
-{
-    @try
-    {
-        NSHTTPCookieStorage * cookies = [NSHTTPCookieStorage sharedHTTPCookieStorage];
-        for(NSHTTPCookie * cookie in [cookies cookies])
-        {
-            BOOL shouldRemove = domain == nil || [domain length] < 1 || [[cookie domain] isEqualToString:domain];
-            if(shouldRemove)
-            {
-                [cookies deleteCookie:cookie];
-            }
-        }
-    }
-    @catch(NSError * err)
-    {
-        *error = err;
-    }
-}
-
-// convert NSHTTPCookie to string
-+ (NSString *) getCookieString:(NSHTTPCookie *) cookie
-{
-    NSMutableString * cookieStr = [[NSMutableString alloc] init];
-    [cookieStr appendString:cookie.name];
-    [cookieStr appendString:@"="];
-    [cookieStr appendString:cookie.value];
-    
-    if(cookie.expiresDate == nil) {
-        [cookieStr appendString:@"; max-age=0"];
-    }
-    else {
-        [cookieStr appendString:@"; expires="];
-        NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
-        [dateFormatter setDateFormat:@"EEE, dd MM yyyy HH:mm:ss ZZZ"];
-        NSString *strDate = [dateFormatter stringFromDate:cookie.expiresDate];
-        [cookieStr appendString:strDate];
-    }
-    
-    
-    [cookieStr appendString:@"; domain="];
-    [cookieStr appendString: [cookie domain]];
-    [cookieStr appendString:@"; path="];
-    [cookieStr appendString:cookie.path];
-    
-    
-    if (cookie.isSecure) {
-        [cookieStr appendString:@"; secure"];
-    }
-    
-    if (cookie.isHTTPOnly) {
-        [cookieStr appendString:@"; httponly"];
-    }
-    return cookieStr;
-
-}
-
 + (void) cancelRequest:(NSString *)taskId
 {
     NSURLSessionDataTask * task = [taskTable objectForKey:taskId];

ios/RNFetchBlobReqBuilder.m

     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
         __block NSMutableData * postData = [[NSMutableData alloc] init];
         // combine multipart/form-data body
-        [[self class] buildFormBody:form boundary:boundary onComplete:^(NSData *formData) {
-            if(formData != nil) {
-                [postData appendData:formData];
-                // close form data
-                [postData appendData: [[NSString stringWithFormat:@"--%@--\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
-                [request setHTTPBody:postData];
+        [[self class] buildFormBody:form boundary:boundary onComplete:^(NSData *formData, BOOL hasError) {
+            if(hasError)
+            {
+                onComplete(nil, nil);
+            }
+            else
+            {
+                if(formData != nil)
+                {
+                    [postData appendData:formData];
+                    // close form data
+                    [postData appendData: [[NSString stringWithFormat:@"--%@--\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
+                    [request setHTTPBody:postData];
+                }
+                // set content-length
+                [mheaders setValue:[NSString stringWithFormat:@"%lu",[postData length]] forKey:@"Content-Length"];
+                [mheaders setValue:@"100-continue" forKey:@"Expect"];
+                // appaned boundary to content-type
+                [mheaders setValue:[NSString stringWithFormat:@"multipart/form-data; charset=utf-8; boundary=%@", boundary] forKey:@"content-type"];
+                [request setHTTPMethod: method];
+                [request setAllHTTPHeaderFields:mheaders];
+                onComplete(request, [formData length]);
             }
-            // set content-length
-            [mheaders setValue:[NSString stringWithFormat:@"%lu",[postData length]] forKey:@"Content-Length"];
-            [mheaders setValue:@"100-continue" forKey:@"Expect"];
-            // appaned boundary to content-type
-            [mheaders setValue:[NSString stringWithFormat:@"multipart/form-data; charset=utf-8; boundary=%@", boundary] forKey:@"content-type"];
-            [request setHTTPMethod: method];
-            [request setAllHTTPHeaderFields:mheaders];
-            onComplete(request, [formData length]);
         }];
 
     });
                     orgPath = [RNFetchBlobFS getPathOfAsset:orgPath];
                     if([orgPath hasPrefix:AL_PREFIX])
                     {
-                        [RNFetchBlobFS readFile:orgPath encoding:@"utf8" resolver:nil rejecter:nil onComplete:^(NSData *content) {
-                            [request setHTTPBody:content];
-                            [request setHTTPMethod: method];
-                            [request setAllHTTPHeaderFields:mheaders];
-                            onComplete(request, [content length]);
+                        
+                        [RNFetchBlobFS readFile:orgPath encoding:nil onComplete:^(NSData *content, NSString * err) {
+                            if(err != nil)
+                            {
+                                onComplete(nil, nil);
+                            }
+                            else
+                            {
+                                [request setHTTPBody:content];
+                                [request setHTTPMethod: method];
+                                [request setAllHTTPHeaderFields:mheaders];
+                                onComplete(request, [content length]);
+                            }
                         }];
+                        
                         return;
                     }
                     size = [[[NSFileManager defaultManager] attributesOfItemAtPath:orgPath error:nil] fileSize];
     });
 }
 
-+(void) buildFormBody:(NSArray *)form boundary:(NSString *)boundary onComplete:(void(^)(NSData * formData))onComplete
++(void) buildFormBody:(NSArray *)form boundary:(NSString *)boundary onComplete:(void(^)(NSData * formData, BOOL hasError))onComplete
 {
     __block NSMutableData * formData = [[NSMutableData alloc] init];
     if(form == nil)
-        onComplete(nil);
+        onComplete(nil, NO);
     else
     {
         __block int i = 0;
                     {
                         NSString * orgPath = [content substringFromIndex:[FILE_PREFIX length]];
                         orgPath = [RNFetchBlobFS getPathOfAsset:orgPath];
-                        [RNFetchBlobFS readFile:orgPath encoding:@"utf8" resolver:nil rejecter:nil onComplete:^(NSData *content) {
+
+                        [RNFetchBlobFS readFile:orgPath encoding:nil onComplete:^(NSData *content, NSString * err) {
+                            if(err != nil)
+                            {
+                                onComplete(formData, YES);
+                                return;
+                            }
                             NSString * filename = [field valueForKey:@"filename"];
                             [formData appendData:[[NSString stringWithFormat:@"--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
                             [formData appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"%@\"; filename=\"%@\"\r\n", name, filename] dataUsingEncoding:NSUTF8StringEncoding]];
                             }
                             else
                             {
-                                onComplete(formData);
+                                onComplete(formData, NO);
                                 getFieldData = nil;
                             }
                         }];
             }
             else
             {
-                onComplete(formData);
+                onComplete(formData, NO);
                 getFieldData = nil;
             }