猫鼬：findOneAndUpdate 找到比 _id 更复杂的表达式

Question

我想找到一个文档，它匹配一些计算出的 ID，然后查看时间戳是否小于 15 分钟。如果是这样并且找到了文档，我想用 req.body 更新文档。否则，如果它超过 15 分钟，或者没有找到文档，我想用 req.body.

创建一个新文档

现在我的问题是，我应该使用静态 findOneAndUpdate 方法还是它对我的目的来说太不灵活了？我正在使用聚合框架，它可以做那些类型的事情吗，比如更新字段和/或设置字段（如果它们还不存在）？这是我的聚合管道，用于查找不到 15 分钟的文档 ID 和时间戳：

exports.calcID = function(req,res) {
        console.log("Call aggregation stage..:")        

        Flex.aggregate([        
            {
                $addFields: {
                    subID:  {
                        "$eq": [{"$trunc": {"$divide": ["$_id", 1000000]}}, +req.params.demo_id]                    
                    },
                    rightTime: {
                        "$gte": ["$createdAt", new Date(+new Date()- 60*1000*15)]
                    }
                }
            },      
            {
                "$match": { 
                    subID:true,
                    rightTime:true

                }
            },
            {
                "$sort": {"Timestamp":-1}
            },
            {
                "$limit": 1
            },
            {
                "$project": {subID:0, rightTime:0}
            }
        ]).exec(function(err, flPot) {
            console.log(flPot);
            console.log("Anzahl gefundener Dokumente: ", flPot.length)      
            if (flPot.length == 0) {
                res.end("Keine Dokumente juenger 15 Minuten gefunden!")
                var flex = new FlexPotenzial(req.body);     
                flex.save(function(err) {
                if (err) {
                    console.log(err);
                    res.status(400);
                    res.send(err);
                }
                else {              
                    console.log("Instanz FlexPotenzial in Datenbank erzeugt!");
                    res.status(200);
                    res.json({ message: 'FlexPotenzial-Instance created in datbase!\n', flex });
                }
                })
            }
            else if (flPot.lengh!==0) {
                    flPot.Timestamp = req.body.Timestamp;
                    flPot.aktThErzeugungsleistungWaerme = req.body.aktThErzeugungsleistungWaerme;
                    flPot.aktThNachfrageleistungWaerme = req.body.aktThNachfrageleistungWaerme;
                    flPot.aktThErzeugungsleistungGas = req.body.aktThErzeugungsleistungGas;
                    flPot.aktThNachfrageleistungGas = req.body.aktThNachfrageleistungGas;
                    flPot.aktLeistungsuntergrenze = req.body.aktLeistungsuntergrenze;
                    flPot.aktLeistungsobergrenze = req.body.aktLeistungsobergrenze;
                    flPot.BrennRohstoffbezug = req.body.BrennRohstoffbezug;
                    flPot.Produktstrom = req.body.Produktstrom;
                    flPot.Dummy1 = req.body.Dummy1;
                    flPot.Dummy2 = req.body.Dummy2;
                    flPot.Dummy3 = req.body.Dummy3;
                    flPot.Dummy4 = req.body.Dummy4;

                    flPot.save(function(err) {
                        if (err) {
                            console.log(err);
                            res.status(400);
                            res.send(err);
                        }
                        else {              
                            console.log("FlexPotenzial aggregierte Daten in Datenbank aktualisiert!");
                            res.status(200);
                            res.json({ message: 'FlexPotenzial-Instance aggregated data updated!\n', flex });
                        }
                    }
                )
            }
        });
    }

我不知道这里最好的方法是什么，如何在找到文档后进行检查，如何更新字段，如果没有找到文档，如何在聚合或单独的文档中创建新文档然后函数...

Answer 1

我假设您将存储的 ID 分开以获得一系列 ID。为什么不在查询中这样做：

const minID = req.params.demo_id * 1000000;
const maxID = (req.params.demo_id + 1) * 1000000;
const fifteenMinutesAgo = new Date(Date.now() - 15*3600*1000)
Flex.findOneAndUpdate({
  _id: { $gte: minID, $lt: maxID },
  createdAt: { $gte: fifteenMinutesAgo }
}, { $set: req.body })

当然，你应该清理你的输入，而不仅仅是把 req.body 扔进去。

如果 ID 计算比您在此代码段中输入的更复杂，请考虑将其存储在您的文档中。

猫鼬：findOneAndUpdate 找到比 _id 更复杂的表达式

mongoose: findOneAndUpdate find more complicated expression than _id

insert-update

mongoose

mongodb

node.js

aggregation-framework