Using PromiseKit to force sequential download

Question

I am using PromiseKit and would like to force sequential download of JSONs. The count of JSONs might change.

I have read this about chaining. If I had a fixed number of say 3 downloads, this would be fine.

But what if I had a changing count of download that I would like to download sequentially?

This is my code for 2 URLs. I wonder how I could do this with dateUrlArray[i] iteration over the array?

 - (void)downloadJSONWithPromiseKitDateArray:(NSMutableArray *)dateUrlArray {
    [self.operationManager GET:dateUrlArray[0]
                    parameters:nil]
    .then(^(id responseObject, AFHTTPRequestOperation *operation) {
        NSDictionary *resultDictionary = (NSDictionary *) responseObject;
        Menu *menu = [JsonMapper mapMenuFromDictionary:resultDictionary];
        if (menu) {
            [[DataAccess instance] addMenuToRealm:menu];
        }
        return [self.operationManager GET:dateUrlArray[1]
                               parameters:nil];
    }).then(^(id responseObject, AFHTTPRequestOperation *operation) {
        NSDictionary *resultDictionary = (NSDictionary *) responseObject;

        Menu *menu = [JsonMapper mapMenuFromDictionary:resultDictionary];
        if (menu) {
            [[DataAccess instance] addMenuToRealm:menu];
        }
    })
    .catch(^(NSError *error) {
        dispatch_async(dispatch_get_main_queue(), ^{
            [self handleCatchwithError:error];
        });
    }).finally(^{
        dispatch_async(dispatch_get_main_queue(), ^{
            DDLogInfo(@".....finally");
        });
    });
}

score 6 · Accepted Answer · edited Jun 07 '15 at 21:30

The concept you're looking for is thenable chaining. You want to chain multiple promises in a for loop.

My Objective-C is really rusty - but it should look something like:

// create an array for the results
__block NSMutableArray *results = [NSMutableArray arrayWithCapacity:[urls count]];
// create an initial promise
PMKPromise *p = [PMKPromise promiseWithValue: nil]; // create empty promise
for (id url in urls) {
    // chain
    p = p.then(^{
        // chain the request and storate
        return [self.operationManager GET:url
                parameters:nil].then(^(id responseObject, AFHTTPRequestOperation *operation) {
              [results addObject:responseObject]; // reference to result
              return nil; 
        });
    });
}
p.then(^{
    // all results available here
});

Many many thanks for that 'rusty' ObjC ;-) Great answer, and IMHO an omission on the Promisekit Site. I did a small edit (p should be of type PMKPromise). — brainray, Jun 07 '15 at 20:43

score 6 · Answer 2 · answered Sep 27 '16 at 15:47

For those of us looking for a Swift 2.3 solution:

import PromiseKit

extension Promise {
    static func resolveSequentially(promiseFns: [()->Promise<T>]) -> Promise<T>? {
        return promiseFns.reduce(nil) { (fn1: Promise<T>?, fn2: (()->Promise<T>)?) -> Promise<T>? in
            return fn1?.then({ (_) -> Promise<T> in
                return fn2!()
            }) ?? fn2!()
        }
    }
}

Note that this function returns nil if the promises array is empty.

Example of use

Below is an example of how to upload an array of attachments in sequence:

func uploadAttachments(attachments: [Attachment]) -> Promise<Void> {
    let promiseFns = attachments.map({ (attachment: Attachment) -> (()->Promise<Void>) in
        return {
            return self.uploadAttachment(attachment)
        }
    })
    return Promise.resolveSequentially(promiseFns)?.then({}) ?? Promise()
}

func uploadAttachment(attachment: Attachment) -> Promise<Void> {
    // Do the actual uploading
    return Promise()
}

Thanks a lot for the input! BTW: meanwhile I solve this kind of tasks with NSOperation wgich doesn't require a third party library — brainray, Sep 27 '16 at 21:00

score 4 · Answer 3 · answered Nov 24 '16 at 20:35

Thanks for Vegard's answer and I rewrite for Swift 3:

extension Promise {
    static func resolveSequentially(promiseFns: [()->Promise<T>]) -> Promise<T>? {
        return promiseFns.reduce(nil) { (fn1: Promise<T>?, fn2: (()->Promise<T>)?) -> Promise<T>? in
            return fn1?.then{ (_) -> Promise<T> in
                return fn2!()
            } ?? fn2!()
        }
    }
}



/* Example */
func uploadAttachments(_ attachments: [Attachment]) -> Promise<Void> {
    let promiseFns = attachments.map({ (attachment: Attachment) -> (()->Promise<Void>) in
        return {
            return self. uploadAttachment(attachment)
        }
    })

    return Promise.resolveSequentially(promiseFns: promiseFns)?.then{Void -> Void in} ?? Promise { Void -> Void in }
}

Using PromiseKit to force sequential download

3 Answers3

Linked