获取Javascript中电子邮件地址的每个附件

Question

我想从电子邮件中获取所有附件。 问题是，对于附件，我必须执行列表请求以从页面​​中获取电子邮件，然后对于每个电子邮件，另一个请求以获取完整信息，然后对每个附件进行另一个请求。

这就是我现在要做的，因为有太多请求，我遇到了一些并发请求错误（我使用setTimout进行测试）

async function listMessagesWithAttachments(
  auth,
  pageToken = "08116115363713650026"
) {
  const gmail = google.gmail({ version: "v1", auth });
  console.log(123);
  await gmail.users.messages.list(
    {
      userId: "me",
      maxResults: 50,
      pageToken,
    },
    async (err, { data }) => {
      const { nextPageToken } = data;
      console.log("test", nextPageToken);
      if (err)
        return console.log(
          "Error in listMessageswithAttachments, messages list: " + err
        );
      let { messages } = data;
      let fullMessages = [];
      messages.forEach(async (message, id) => {
        setTimeout(() => {
          gmail.users.messages.get(
            {
              userId: "me",
              id: message.id,
              format: "full",
            },
            (err, { data } = { data: "" }) => {
              if (err) console.log("Error ", err);
              fullMessages = [...fullMessages, data];
              if (fullMessages.length === messages.length) {
                let attachmentIds = [];
                let attachments = [];

                fullMessages.forEach(
                  (message = { payload: { parts: [] } }, messageIndex) => {
                    if (!message.payload) {
                      message.payload = { parts: [] };
                    }
                    let parts =
                      (message && message.payload && message.payload.parts) ||
                      [];
                    parts &&
                      parts.forEach((part, partId) => {
                        if (
                          part.body.size &&
                          part.body.size > 0 &&
                          part.body.attachmentId
                        ) {
                          let object = {
                            index: `${partId}`,
                            messageId: message.id,
                            attachmentId: part.body.attachmentId,
                          };
                          attachmentIds = [...attachmentIds, object];
                        }
                      });
                    if (fullMessages.length - 1 === messageIndex) {
                      attachmentIds.forEach(attachment => {
                        gmail.users.messages.attachments.get(
                          {
                            userId: "me",
                            messageId: attachment.messageId,
                            id: attachment.attachmentId,
                          },
                          (err, { data }) => {
                            if (err) {
                              console.log("Error getting attachement: " + err);
                              return 0;
                            }
                            attachments = [...attachments, data];
                            if (attachments.length === attachmentIds.length) {
                              if (nextPageToken) {
                                console.log(nextPageToken);
                                listMessagesWithAttachments(
                                  auth,
                                  nextPageToken
                                );
                              }
                            }
                            console.log(attachments);
                          }
                        );
                      });
                    }
                  }
                );
              }
            }
          );
        }, id * 20);
      });
      listMessagesWithAttachments(auth, nextPageToken);
    }
  );
}

有一个更好的方法吗？ 例如，一种获取list请求中完整消息的方法，然后我可以仅对附件提出请求。 但是主要的问题是找到一种减少请求并发的方法。

谢谢。

Answer 1

避免嵌套循环

相反，您可以创建单独的函数，这些函数返回您的请求响应，并将其作为参数传递给下一个函数。

例如

var list=gmail.users.messages.list(...)

要么：

gmail.users.messages.get()
{
...
if (part.body.size && part.body.size > 0 &&part.body.attachmentId){
...
IdArray.push(messageId)
...)
return array;
...
}

getAttachmentId(IdArray){
...
}

这将不必使代码更短或更有效，但是它将减少并发请求超时。