Question

我正在开发一个电子商务网络应用程序。我遇到了如下问题。

我想要运行一个cron工作。当品牌向系统添加新产品时，销售该品牌的每个商店将自动显示该品牌新添加的产品。 Cron Job每天早上12点开始运行，单独通过所有商店，并添加新添加的产品。

现在商店将拥有一系列产品。从这一系列产品中，我需要获取所有独特品牌，以便将其与新增产品的品牌进行比较。如果shop.products []中存在新添加产品的品牌，则该product._id将被推送到该数组中。

这是我的代码。

CRON JOB CODE：

module.exports.newProductAddedCronJob = function(req,res){
    // console.log("New Products Added Cron Job");
    ProductReplacement.find({
        status: "Pending",
        "type": "new"
    })
    .populate("primaryProduct")
    .exec(function(err,newProducts){
        if(err) return res.status(500).send({err});
        if(newProducts.length < 1) return res.status(404).send({err : "No New Products Added."});
        async.forEachSeries(newProducts,function(item){
            console.log("New Product : ", item.primaryProduct.brand._id);
            Shop.find({
                "products.brand._id" : {
                    $in: [item.primaryProduct.brand._id]
                }
            })
            .populate("products")
            .exec(function(err,shopsWithBrand){
                console.log("SHOPS WITH Brand "+item.primaryProduct.brand._id + " Total = "+shopsWithBrand.length);
                console.log("SHOPS WITH BRAND : ",shopsWithBrand);
                for(var j = 0 ; j < shopsWithBrand.length; j++){
                    console.log("Shop = "+shopsWithBrand[i].name);
                }
            });
        },function(err,data){
            console.log("Final Callback!")
            if(err) return res.status(500).send({err})
            res.send({newProducts});
        })
    })
}

ProductReplacement 用于多种用途。在该特定模式中，type =“new”表示品牌新添加的产品，status =“Pending”表示尚未处理。

var Product = new mongoose.Schema({

    brand: {
            _id: mongoose.Schema.Types.ObjectId,
            name: {
                type: String,
                required: true
            },
            nameSlug: {
                type: String,
                required: true
            },
            images: [Image]
        }

});

品牌架构：

var Brand = new mongoose.Schema({

    name: {
            type: String,
            minlength: 2,
            maxlength: 30,
            required: true
        },
        images: [{
            src: String,
            alt: String,
            type: {
                type: String,
                enum: imageTypes,
                validate: validators.isIn({message: 'The image type should be one of the following: (' + imageTypes + ')'}, imageTypes)
            }
        }]

});

Shop Schema：

var Shop = new mongoose.Schema({

    products: [{
            _id: {
                type: mongoose.Schema.Types.ObjectId,
                ref: 'Product'
            },
            stock: {
                type: Number,
                required: true
            },
            price: {
                type: Number
            }]

});

ProductReplacement Schema：

var ProductReplacement = new mongoose.Schema({
    primaryProduct : {
        type: mongoose.Schema.ObjectId,
        ref: 'Product'
    },
    duplicateProduct: {
        type: mongoose.Schema.ObjectId,
        ref: 'Product'
    },
    "type": {
        type: String,
        required: true,
        default: "merge"
    },
    created_at    : { 
        type: Date, 
        required: true, 
        default: Date.now
    },
    status: {
        type: String,
        required: true,
        default: "Pending"
    }
});

所以我需要的是Shop.products.brand.id，将其与新添加产品的品牌ID进行比较。如果它们匹配，我会把它推到那个特定商店的产品阵列中。

但我无法让商店使用该查询。

逐个遍历每个商店的所有产品的最后一个选择肯定是开放的。但我想知道是否有某种方法可以使用查询来做同样的事情。

在Mongoose中Populate（）的Populate（）用于查询以匹配数组

0 个答案: