Promise.map没有完成，因为随后的Promise.join首先完成?承诺全部吗? [英] Promise.map not finishing because subsequent Promise.join finishes first? Promise.all?

问题描述

我仍然信守诺言.

以下是涉及的数据库集合的模型:

Here are the models of the db collections involved:

var itemSchema = new Schema({
  label : String,
  tag : { "type": Schema.ObjectId, "ref": "tag" }
});

var tagSchema = new Schema({
  label : String,
});

这是Promises(地图，地图，地图，联接)的系列:

And here's the series of Promises (map, map, map, join):

现在，Promise.join保存并在"items"图完成运行之前完成，因此"senders"图在保存时不包括"itemsArray" javascriptObject.如何解决此问题?

var reqItems = req.body.items;
var itemsArray = [];
var items = Promise.map(reqItems,function(element){
    var existingItem = Models.Item.findOneAsync({ "label": element });
        existingItem.then(function (value) {
        if ( (existingItem.fulfillmentValue != null) ) { // if this item exists
            var itemObject = [
                                { "item" : existingItem.fulfillmentValue._id },
                                { "label" : existingItem.fulfillmentValue.label }
                                { "tag" : existingItem.fulfillmentValue.tag }
                            ];
            itemsArray.push(itemObject);
        } else { // first instance of this item .. create newItem
            var existingTag = Models.Tag.findOneAsync({ "label": element });
                existingTag.then(function (value) {
                if ( (existingTag.fulfillmentValue != null) ) { // if this tag exists
                    var newItem = new Models.Item(
                        {
                          label : element,
                          tag : existingTag.fulfillmentValue._id,
                        }
                    );
                    newItem.save(function (err) { // save the newItem with existing tag
                        console.log(err);
                        var newSavedItem = Models.Item.findOneAsync({ "label": element });
                        newSavedItem.then(function (value) { // ensure existence of newItem
                            var itemObject = [
                                                { "item" : newSavedItem.fulfillmentValue._id },
                                                { "label" : newSavedItem.fulfillmentValue.label },
                                                { "tag" : newSavedItem.fulfillmentValue.tag }
                                            ];
                            itemsArray.push(itemObject); // push item to array
                        });
                    });
                } else { // else this tag does not exist
                        var newTag = new Models.Tag(
                            {
                              label : element
                            }
                        );
                        newTag.save(function (err) {
                            console.log(err);
                            var newSavedTag = Models.Tag.findOneAsync({ "label": element });
                            newSavedTag.then(function (value) { // ensure existence of newTag
                                if ( (newSavedTag.fulfillmentValue != null) ) {
                                    var newItem = new Models.Item(
                                        {
                                          label : element,
                                          tag : newSavedTag.fulfillmentValue._id,
                                        }
                                    );
                                    newItem.save(function (err) {
                                        console.log(err);
                                        var newSavedItem = Models.Item.findOneAsync({ "label": element });
                                        newSavedItem.then(function (value) { // ensure existence of newItem
                                            var itemObject = [
                                                                { "item" : newSavedItem.fulfillmentValue._id },
                                                                { "label" : newSavedItem.fulfillmentValue.label },
                                                                { "tag" : newSavedItem.fulfillmentValue.tag }
                                                            ];
                                            itemsArray.push(itemObject); // push item to array
                                        }); // newSavedItem.then
                                    }); // newItem.save
                                } // if newSavedTag.isFulfilled
                            }); // newSavedTag.then
                        }); // newTag.save
                } // else tag does not exist
                }); // existingTag.then
          } // first instance of this item .. create newItem
        }); // existingItem.then
    itemObject = null; // reset for map loop
}); // Promise.map itemsArray


var receivers = Promise.map(receiverArray,function(element){
    return Promise.props({
        username : element
    });
});
var senders = Promise.map(senderArray,function(element){
    return Promise.props({
        username : element,
        items : itemsArray
    });
});
Promise.join(receivers, senders, function(receivers, senders){
    store.receivers = receivers;
    store.senders = senders;
    var saveFunc = Promise.promisify(store.save, store);
    return saveFunc();
}).then(function(saved) {
    console.log(saved);
    res.json(saved);
})...error handling...});

推荐答案

是的，可以大大简化，尽管您的问题可能只是忘记将任何内容退还给第一个映射器(以及无用的实现价值代码的巨大浪费). /p>

Yes that can be massively simplified, although your problem was probably just forgetting to return anything to the first mapper (and the massive wasteland of useless fulfillmentValue code).

var reqItems = req.body.items;
var items = Promise.map(reqItems, function(element) {
    return Models.Item.findOneAsync({ "label": element }).then(function(item) {
        if (item != null) {
            return item;
        } else {
            return Models.Tag.findOneAsync({ "label": element }).then(function(tag) {
                if (tag == null) {
                    var newTag = new Models.Tag({label: element});
                    return newTag.saveAsync().then(function() {
                        return Models.Tag.findOneAsync({ "label": element });
                    })
                }
                return tag;
            }).then(function(tag) {
                var newItem = new Models.Item({
                    label: element,
                    tag: tag._id
                });
                return newItem.saveAsync().then(function() {
                    return Models.Item.findOneAsync({ "label": element });
                });
            })
        }
    });
});

var receivers = Promise.map(receiverArray, function(element){
    return Promise.props({
        username : element
    });
});
var senders = Promise.map(senderArray, function(element){
    return Promise.props({
        username : element,
        items : itemsArray
    });
});

Promise.join(receivers, senders, items, function(receivers, senders, items) {
   store.receivers = receivers;
   store.senders = senders;
   store.items = items;
   return store.saveAsync().return(store);
}).then(function(store) {
   console.log("saved store", store);
   res.json(store);
}).catch(Promise.OperationalError, function(e) {
   console.log("error", e);
   res.send(500, "error");
});

这篇关于Promise.map没有完成，因为随后的Promise.join首先完成?承诺全部吗?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！