在Node中实现蓝鸟嵌套循环承诺

Question

我在NodeJS里用蓝知更鸟。我想做一个嵌套循环。就像这样：

  var Promise = require('bluebird');

  funcs.getLatestVideos = function(job, done) {
              return Promise.try(function() {
                      return ProcessRules.getLatestVideos();
                  })
                  .then(function(object) {
                      return ({
                          'series': ProcessRules.getSeriesRules(),
                          'videos': object.videos
                      });
                  })
                  .then(function(inputs) {
                      return Promise.map(inputs.videos, function(video) {
                          return Promise.map(inputs.series, function(series) {
                              return Promise.map(series.rules, function(rule) {
                                  return ProcessRules.processRules(video, rule);
                              });
                          });
                      })
                  })
                  .then(function(result) {
                      W.debug("done");
                      console.log(JSON.stringify(result));
                      done();
                  })
                  .catch(function(err) {
                      done(err);
                      W.error("Error occurred ", err.message, err.stack);
                  });
   }

ProcessRules

     var Promise = require('bluebird');
     var rp = require('request-promise');
     var W = require('winston');
     var RuleEngine = require('node-rules');
     var _ = require('lodash');

          funcs.getSeriesRules = function() {
              return new Promise(function(resolve, reject) {
                  var options = {
                      method: "GET",
                      uri: API_URL,
                      // body: status,
                      json: true // Automatically stringifies the body to JSON
                  };

                  rp(options)
                      .then(function(result) {
                          resolve(result)
                      })
                      .catch(function(err) {
                          reject(err)
                      });
              });
          };

            funcs.processRules = function(fact, rule) {
                return new Promise(function(resolve, reject) {
                    var rules = [];
                    var value = new RegExp(rule.value, 'i');

                    switch (rule.type) {
                        case 'title':
                            rules = [{
                                "condition": function(R) {
                                    //  console.log(this.title.match(value));
                                    R.when(this.title.match(value) > -1);
                                },
                                "consequence": function(R) {
                                    this.result = false;
                                    this.video = R;
                                    R.stop();
                                }
                            }];
                            break;
                        case 'desc':
                            rules = [{
                                "condition": function(R) {
                                    //console.log(this.desc.match(value));
                                    R.when(this.desc.match(value) > -1);
                                },
                                "consequence": function(R) {
                                    this.result = false;
                                    this.video = R;
                                    R.stop();
                                }
                            }];
                            break;
                        case 'tag':
                            rules = [{
                                "condition": function(R) {
                                    //  console.log(this.tag.match(value));
                                    R.when(!_.some(this.tags, { 'text': rule.value}))
                                },
                                "consequence": function(R) {
                                    this.result = false;
                                    this.video = R;
                                    R.stop();
                                }
                            }];
                            break;
                        default:
                            break
                    };

                    //initialize the rule engine
                    const R = new RuleEngine(rules);

                    //Now pass the fact on to the rule engine for results
                    R.execute(fact, function(result) {
                        //console.log(result);
                        if (result.result) {
                            resolve(result._id)
                        }else{
                          resolve({})
                        }
                    });
                });

            };

它返回我的输出

  [[[{},{},"58e9d6816961c30367b5154c"],[{}],[],[],[]],[[{},{},"58e9d6816961c30367b5154d"],[{}],[],[],[]]]

但我期望有以下产出：

 [58e9d6816961c30367b5154c,58e9d6816961c30367b5154d]

我看到了一些类似的问题，但并没有从他们那里得到确切的想法。

在getLatestVideos函数中无法得到完成结果，请帮助我解决这个问题。

请帮助我实现嵌套的每一个循环与蓝鸟承诺。

Answer 1

经过多个问题和答案的长时间搜索，我得到了Flattening a Promise map的答案。

我不知道它到底是怎么走的，但它是为我工作的。

            .then(function(inputs) {
                return Promise.map(inputs.videos, function(video) {
                    return Promise.map(inputs.series, function(series) {
                        return Promise.map(series.rules, function(rule) {
                            return ProcessRules.processRules(video, rule);
                        }).reduce(function(prev, cur) {
                            return cur ? prev.concat(cur) : [];
                        }, [])
                    }).reduce(function(prev, cur) {
                        return prev.concat(cur);
                    }, [])
                }).reduce(function(prev, cur) {
                    return prev.concat(cur);
                }, [])
            })

它还给我[58e9d6816961c30367b5154c,58e9d6816961c30367b5154d]。

谢谢大家。