javascript - 解析 afterSave 函数被跳过

Question

所以我有一个使用 parse.com 作为后端的消息应用程序。当我从应用程序发送消息时，它会将其保存在 Parse.com 上的一个名为“NewMessages”的类中。然后在我的云代码中，我有一个专用于此类的 afterSave 函数，以便当新对象保存到“NewMessages”时，它会选择一个随机用户将其附加到消息并将其保存在名为“Inbox”的新类中。然后它从“NewMessages”中删除原始消息。

所以“NewMessages”类应该始终为空，对吗？但当我很快发送一堆消息时，有些消息就会被跳过。我该如何解决这个问题？

有没有比使用 afterSave 更好的方法来构建它？

function varReset(leanBody, leanSenderName, leanSenderId, randUsers){
   leanBody = "";
   leanSenderName = "";
   leanSenderId = "";
   randUsers = [];
   console.log("The variables were set");
}


Parse.Cloud.afterSave("Lean", function(leanBody, leanSenderName, leanSenderId, randUsers, request) {
  varReset(leanBody, leanSenderName, leanSenderId, randUsers);

  var query = new Parse.Query("NewMessages");
  query.first({
    success: function(results){
      leanBody = (results.get("MessageBody"));
      leanSenderName = (results.get("senderName"));
      leanSenderId = (results.get("senderId"));
      getUsers(leanBody, leanSenderName, leanSenderId);
      results.destroy({
        success: function(results){
          console.log("deleted");
        }, error: function(results, error){
        }
      });
    }, error: function(error){
    }

  });
});

  function getUsers(leanBody, leanSenderName, leanSenderId, response){

    var query = new Parse.Query(Parse.User);
    query.find({
        success: function(results){
            var users = [];
            console.log(leanBody);
            console.log(leanSenderName);

            //extract out user names from results
            for(var i = 0; i < results.length; ++i){
                users.push(results[i].id);
            }
            for(var i = 0; i < 3; ++i){
                var rand = users[Math.floor(Math.random() * users.length)];
                var index = users.indexOf(rand);
                users.splice(index, 1);
                randUsers.push(rand);
                }
            console.log("The random users are " + randUsers);
            sendMessage(leanBody, leanSenderName, leanSenderId, randUsers);
        }, error: function(error){
            response.error("Error");
        }
    });
  }

  function sendMessage(leanBody, leanSenderName, leanSenderId, randUsers){
    var Inbox = Parse.Object.extend("Inbox");

    for(var i = 0; i < 3; ++i){

      var inbox = new Inbox();
      inbox.set("messageBody", leanBody);
      inbox.set("senderName",  leanSenderName);
      inbox.set("senderId", leanSenderId);
      inbox.set("recipientId", randUsers[i]);
      console.log("leanBody = " + leanBody);
      console.log("leanSenderName = " + leanSenderName);
      console.log("leanSenderId = " + leanSenderId);
      console.log("recipient = " + randUsers[i]);

      inbox.save(null, {
        success: function(inbox) {
          // Execute any logic that should take place after the object is saved.
          alert('New object created with objectId: ' + inbox.id);
        },
        error: function(inbox, error) {
          // Execute any logic that should take place if the save fails.
          // error is a Parse.Error with an error code and message.
          alert('Failed to create new object, with error code: ' + error.message);
        }
      });
    }
  }

Answer 1

1. 您检查过日志吗？您可能遇到了资源限制( https://parse.com/docs/cloud_code_guide#functions-resource )。如果即时性并不重要，那么可能值得考虑设置一个后台作业，每隔几分钟运行一次并处理未送达的消息。也可以将这两种方法结合起来:让 afterSave 函数尝试立即发送到收件箱，而后台作业则定期拾取剩余的任何 NewMessage。这不是最漂亮的解决方案，但至少你有更多的可靠性。 (您必须考虑竞争条件，尽管两者可能会尝试传递同一个 NewMessage。)

2. 关于更好的结构的问题，如果两个类相同(或足够接近)，是否可以只拥有一个 Messages 类？最初，“收件人”字段将为空，但会在 beforeSave 函数上分配一个随机收件人。这可能会更快、更简洁。

编辑:添加最初是评论的第三个观察结果:

我发现您在 afterSave 中使用 Query.first() 来查找要处理的 NewMessage。有可能，在调用 Save 和运行查询之间，可能会出现新的 NewMessage。为什么不获取保存的 NewMessage 的 ID 并在查询中使用它，而不是 first()？

query.get(request.object.id,...);

这可确保 afterSave 中的代码处理为其调用的 NewMessage，而不是最近保存的 NewMessage。