Получение более 100 идентификаторов сообщений из Gmail API

Question

В моей учетной записи Gmail 3000 писем. Я хочу создать сводный список всех отправителей, чтобы я мог более эффективно очистить свой почтовый ящик. Мне не нужно загружать текст сообщения или вложения.

Я использовал этот пример, чтобы начать работу (https://developers.google.com/gmail/api/quickstart/dotnet), хотя теперь я не могу понять, как вернуть более 100 идентификаторов сообщений при выполнении этого кода:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

using Google.Apis.Auth.OAuth2;
using Google.Apis.Gmail.v1;
using Google.Apis.Gmail.v1.Data;
using Google.Apis.Requests;
using Google.Apis.Services;
using Google.Apis.Util;
using Google.Apis.Util.Store;

namespace GmailQuickstart
{
    class Program
    {
        static string[] Scopes = { GmailService.Scope.GmailReadonly };
        static string ApplicationName = "Gmail API .NET Quickstart";

        static void Main(string[] args)
        {
            UserCredential credential;

            using (var stream = new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
            {
                string credPath = "token.json";
                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets,
                    Scopes,
                    "user",
                    CancellationToken.None,
                    new FileDataStore(credPath, true)).Result;
                Console.WriteLine("Credential file saved to: " + credPath);
            }

            // Create Gmail API service.
            var service = new GmailService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName = ApplicationName,
            });


            ////get all of the message ids for the messages in the inbox
            var messageRequest = service.Users.Messages.List("me");
            messageRequest.LabelIds = "INBOX";

            var messageList = new List<Message>();

            ListMessagesResponse messageResponse1 = new ListMessagesResponse();
            var k = 0;

            do
            {
                messageResponse1 = messageRequest.Execute();
                messageList.AddRange(messageResponse1.Messages);

                var output = $"Request {k} - Message Count: {messageList.Count()} Page Token: {messageRequest.PageToken} - Next Page Token: {messageResponse1.NextPageToken}";
                Console.WriteLine(output);
                System.IO.File.AppendAllText(@"C:\000\log.txt", output);

                messageRequest.PageToken = messageResponse1.NextPageToken;
                k++;

                //this switch allowed me to walk through getting multiple pages of emails without having to get them all
                //if (k == 5)
                //{
                //    break;
                //}

            } while (!String.IsNullOrEmpty(messageRequest.PageToken));

            //once i created the list of all the message ids i serialized the list to JSON and wrote it to a file
            //so I could test the next portions without having to make the calls against the above each time
            var serializedMessageIdList = Newtonsoft.Json.JsonConvert.SerializeObject(messageList);
            System.IO.File.WriteAllText(@"C:\000\MessageIds.json", serializedMessageIdList);


            //read in the serialized list and rehydrate it to test the next portion
            var mIdList = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Message>>(System.IO.File.ReadAllText(@"C:\000\MessageIds.json"));

            //this method takes those message ids and gets the message object from the api for each of them
            //1000 is the maximum number of requests google allows in a batch request
            var messages = BatchDownloadEmails(service, mIdList.Select(m => m.Id), 1000);


            //again i'm serializing the message list and writing them to a file
            var serializedMessageList = Newtonsoft.Json.JsonConvert.SerializeObject(messages);
            System.IO.File.WriteAllText(@"C:\000\Messages.json", serializedMessageList);

            //and then reading them in and rehydrating the list to test the next portion
            var mList = Newtonsoft.Json.JsonConvert.DeserializeObject<IList<Message>>(System.IO.File.ReadAllText(@"C:\000\Messages.json"));

            //then i loop through each message and pull the values out of the payload header i'm looking for
            var emailList = new List<EmailItem>();

            foreach (var message in mList)
            {
                if (message != null)
                {
                    var from = message.Payload.Headers.SingleOrDefault(h => h.Name == "From")?.Value;
                    var date = message.Payload.Headers.SingleOrDefault(h => h.Name == "Date")?.Value;
                    var subject = message.Payload.Headers.SingleOrDefault(h => h.Name == "Subject")?.Value;

                    emailList.Add(new EmailItem() { From = from, Subject = subject, Date = date });
                }
            }

            //i serialized this list as well
            var serializedEmailItemList = Newtonsoft.Json.JsonConvert.SerializeObject(emailList);
            System.IO.File.WriteAllText(@"C:\000\EmailItems.json", serializedEmailItemList);

            //rehydrate for testing
            var eiList = Newtonsoft.Json.JsonConvert.DeserializeObject<List<EmailItem>>(System.IO.File.ReadAllText(@"C:\000\EmailItems.json"));

            //here is where i do the actual aggregation to determine which senders i have the most email from
            var senderSummary = eiList.GroupBy(g => g.From).Select(g => new { Sender = g.Key, Count = g.Count() }).OrderByDescending(g => g.Count);

            //serialize and output the results
            var serializedSummaryList = Newtonsoft.Json.JsonConvert.SerializeObject(senderSummary);
            System.IO.File.WriteAllText(@"C:\000\SenderSummary.json", serializedSummaryList);
        }

        public static IList<Message> BatchDownloadEmails(GmailService service, IEnumerable<string> messageIds, int chunkSize)
        {
            // Create a batch request.
            var messages = new List<Message>();

            //because the google batch request will only allow 1000 requests per batch the list needs to be split
            //based on chunk size
            var lists = messageIds.ChunkBy(chunkSize);

            //double batchRequests = (2500 + 999) / 1000;

            //for each list create a request with teh message id and add it to the batch request queue
            for (int i = 0; i < lists.Count(); i++)
            {
                var list = lists.ElementAt(i);

                Console.WriteLine($"list: {i}...");
                var request = new BatchRequest(service);

                foreach (var messageId in list)
                {
                    //Console.WriteLine($"message id: {messageId}...");
                    var messageBodyRequest = service.Users.Messages.Get("me", messageId);
                    //messageBodyRequest.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Metadata;

                    request.Queue<Message>(messageBodyRequest,
                        (content, error, index, message) =>
                        {
                            messages.Add(content);
                        });
                }

                Console.WriteLine("");
                Console.WriteLine("ExecuteAsync");
                //execute all the requests in the queue
                request.ExecuteAsync().Wait();

                System.Threading.Thread.Sleep(5000);
            }

            return messages;
        }
    }

    public class EmailItem
    {
        public string From { get; set; }
        public string Subject { get; set; }
        public string Date { get; set; }
    }

    public static class IEnumerableExtensions
    {
        public static IEnumerable<IEnumerable<T>> ChunkBy<T>(this IEnumerable<T> source, int chunkSize)
        {
            return source
                .Select((x, i) => new { Index = i, Value = x })
                .GroupBy(x => x.Index / chunkSize)
                .Select(x => x.Select(v => v.Value));
        }
    }
}

Исследование, которое я провел, говорит, что мне нужно использовать пакетный запрос, и на основании информации, которую я нашел, я не могу адаптировать ее к тому, что я пытаюсь выполнить. Насколько я понимаю, я бы использовал пакетный запрос, чтобы получить все идентификаторы сообщений, а затем 3000 отдельных вызовов, чтобы получить фактические данные, тему и дату, полученные от каждого сообщения электронной почты в моем почтовом ящике ??

Answer 1

Вы также можете использовать PageStreamer для получения остатка результатов.

var pageStreamer = new PageStreamer<Google.Apis.Gmail.v1.Data.Message, UsersResource.MessagesResource.ListRequest, ListMessagesResponse, string>(
            (request, token) => request.PageToken = token,
            response => response.NextPageToken,
            response => response.Messages);
var req = service.Users.Messages.List("me");
req.MaxResults = 1000;
foreach (var result in pageStreamer.Fetch(req))
    {
            Console.WriteLine(result.Id);
    }

Этот код будет продолжать выполняться до тех пор, пока к запросу будут добавлены дополнительные результаты. Пакетная обработка действительно не поможет вам в этом, поскольку нет никакого способа узнать, каким будет маркер следующей страницы.

Answer 2

Вы можете использовать пейджинг, чтобы получить полный список.

Передайте маркер страницы с предыдущей страницы, чтобы получить следующий вызов на Users.Messages.List (не переходите к первому вызову, чтобы начать работу). Определить конец, когда результат не содержит сообщений.

Это позволяет вам получать все сообщения в почтовом ящике.

NB. Я предлагаю вам сделать код асинхронным: если нужно прочитать несколько сообщений, их получение может занять значительное время.