public static List<Thread> ListThread(GmailService service, String userId, String labelIds, String query)
{
List<Thread> result = new List <Thread>();
UsersResource.ThreadsResource.ListRequest request = service.Users.Threads.List(userId);
request.LabelIds = labelIds;
request.Q = query;
do
{
try
{
ListThreadsResponse response = request.Execute();
result.AddRange(response.Threads);
request.PageToken = response.NextPageToken;
}
catch (Exception e)
{
Console.WriteLine("An error occured: " + e.Message);
}
} while (!String.IsNullOrEmpty(request.PageToken));
return result;
}
public static void TrashMessage(GmailService service, String userId, String messageId)
{
try
{
service.Users.Messages.Trash(userId, messageId).Execute();
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
}
public static GmailService GetGmailService(UserCredential cr = null)
{
UserCredential credential = cr ?? GetGmailCredentials();
// Create Gmail API service.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
return service;
}
public static Google.Apis.Gmail.v1.Data.Message GetMessage(GmailService service, String userId, String messageId)
{
try
{
var req = service.Users.Messages.Get(userId, messageId);
req.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
return req.Execute();
}
catch (Exception e)
{
MessageBox.Show("An error occurred: " + e.Message);
}
return null;
}
public async Task<List<string>> GetListSender(GmailService service, String userId, String query, String labelId)
{
var msgBox = new List<Message>();
Task<List<Message>> task = this.ListOfMessages(service, userId, query, labelId);
var listM = await task;
var m = new Message();
if (listM.Count > 0)
{
var id = "";
foreach (var msgObj in listM)
{
//Console.WriteLine(msgObj);
id = msgObj.Id;
Task<Message> t = this.GetMessage(service,userId, id);
m = await t;
msgBox.Add(m);
// msgBox.Add(service.Users.Messages.Get(userId, id).Execute());
}
}
var fromList = new List<string>();
foreach (var msg in msgBox)
{
fromList.Add(msg.Payload.Headers.FirstOrDefault(messHeader => messHeader.Name == "From").Value);
}
MsgPopUp.Visibility = System.Windows.Visibility.Collapsed;
return fromList.Distinct().ToList();
}
public async Task ListLabels()
{
UserCredential credential;
using (var stream = new FileStream("client_secrets_desktop.json", FileMode.Open, FileAccess.Read))
{
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(GoogleClientSecrets.Load(stream).Secrets,
new[] { GmailService.Scope.GmailReadonly },
"user", CancellationToken.None);
}
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Gmail Test",
});
try
{
ListLabelsResponse response = service.Users.Labels.List("me").Execute();
foreach (Label label in response.Labels.OrderBy(p=>p.Name))
{
Console.WriteLine(label.Id + " - " + label.Name);
}
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
}
public async Task ListLabels()
{
UserCredential credential;
using (var stream = new FileStream("client_secrets_desktop.json", FileMode.Open, FileAccess.Read))
{
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(GoogleClientSecrets.Load(stream).Secrets,
new[] { GmailService.Scope.GmailReadonly },
"user", CancellationToken.None);
}
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Gmail Test",
});
try
{
ListLabelsResponse response = service.Users.Labels.List("me").Execute();
foreach (Label label in response.Labels.OrderBy(p => p.Name))
{
Console.WriteLine(label.Id + " - " + label.Name);
}
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
}
public IActionResult Setup()
{
UserCredential credential = GetCredentials();
_logger.LogInformation($"Got credentials {credential?.Token?.AccessToken}");
// Create Gmail API service.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Define parameters of request.
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("*****@*****.**");
_logger.LogInformation($"Got request {request?.MethodName}");
// List labels.
IList <Label> labels = request.Execute().Labels;
_logger.LogInformation("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (var labelItem in labels)
{
_logger.LogInformation("{0}", labelItem.Name);
}
}
else
{
_logger.LogInformation("No labels found.");
}
return(Ok());
}
/// <summary>
/// Send Email
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public static async System.Threading.Tasks.Task SendMailAsync(string[] args)
{
try
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("SendMailSettings.json")
.Build();
Dictionary <string, string> MailSettings;
MailSettings = configuration.GetSection("MailSettings").GetChildren().ToDictionary(x => x.Key, x => x.Value);
MailSettings.Add("to", args[0]);
MailSettings.Add("link", args[1]);
GoogleClientSecrets gSecrets = GetSecretsFromEnvironment();
string credPath = "token.json";
UserCredential gcredential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
gSecrets.Secrets,
Scopes,
MailSettings["account"],
CancellationToken.None,
new FileDataStore(credPath, true));
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = gcredential,
ApplicationName = ApplicationName,
});
SendConfirmationEmail(service, MailSettings);
Console.WriteLine($"Succesfully sent registration email to {args[0]}");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task SendMailAsync(string accessToken, string subject, string to, string body, string from)
{
var service = new GmailService(new BaseClientService.Initializer
{
HttpClientInitializer = GoogleCredential.FromAccessToken(accessToken),
});
//send email
var msg = new AE.Net.Mail.MailMessage
{
Subject = subject,
Body = body,
From = new MailAddress(from),
};
string Mails = to;
var recipients = Mails.Split(' ');
foreach (var recipient in recipients)
{
msg.To.Add(new MailAddress(recipient));
msg.ReplyTo.Add(msg.From);
var msgStr = new StringWriter();
msg.Save(msgStr);
await service.Users.Messages.Send(new Message()
{
Raw = Base64UrlEncode(msgStr.ToString())
}, "me").ExecuteAsync();
}
}
private static GmailService InitilizeGmailService()
{
UserCredential credential;
string[] scopes = { GmailService.Scope.GmailSend };
var applicationName = TextResources.gmailApplicationName;
using (var stream = new FileStream(TextResources.credentialsFile, FileMode.Open, FileAccess.Read))
{
var credPath = TextResources.tokenSendFile;
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
scopes,
TextResources.gmailUsername,
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
}
var gmailService = new GmailService(
new BaseClientService.Initializer {
HttpClientInitializer = credential, ApplicationName = applicationName
});
return(gmailService);
}
public static GmailService GetServiceClient(GoogleClient config, string token)
{
// Create Gmail API service.
var flow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = config.ClientId,
ClientSecret = config.ClientSecret,
},
Scopes = config.Scopes,
DataStore = new FileDataStore("Store"),
});
var tokenRes = new TokenResponse
{
AccessToken = token,
ExpiresInSeconds = 3600,
IssuedUtc = DateTime.UtcNow,
};
var credential = new UserCredential(flow, Environment.UserName, tokenRes);
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = config.ApplicationName,
});
return(service);
}
/// <summary>
/// Get and store attachment from Message with given ID.
/// </summary>
/// <param name="service">Gmail API service instance.</param>
/// <param name="userId">User's email address. The special value "me"
/// can be used to indicate the authenticated user.</param>
/// <param name="messageId">ID of Message containing attachment.</param>
public static string GetAttachments(GmailService service, String userId, Message message)
{
try
{
IList <MessagePart> parts = message.Payload.Parts;
foreach (MessagePart part in parts)
{
if (!String.IsNullOrEmpty(part.Filename))
{
String attId = part.Body.AttachmentId;
MessagePartBody attachPart = service.Users.Messages.Attachments.Get(userId, message.Id, attId).Execute();
// Converting from RFC 4648 base64 to base64url encoding
// see http://en.wikipedia.org/wiki/Base64#Implementations_and_history
String attachData = attachPart.Data.Replace('-', '+');
attachData = attachData.Replace('_', '/');
byte[] data = Convert.FromBase64String(attachData);
return(System.Text.Encoding.Default.GetString(data));
}
}
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
return(null);
}
return(null);
}
public static Google.Apis.Gmail.v1.Data.Message GetMessage(GmailService service, String userId, String messageId)
{
UsersResource.MessagesResource.GetRequest getReq = new UsersResource.MessagesResource.GetRequest(service, "me", messageId);
getReq.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Raw;
return(getReq.Execute());
}
public async Task Authorize(string mailServer, int port , bool ssl, string login,string password)
{
if (ssl)
{
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
new ClientSecrets {
ClientId = "28442394418-7uqnmq187jlq53edfhhueebtb040grtk.apps.googleusercontent.com",
ClientSecret = "rgBZD9PjWvUAsU7IUjUcHnFy"
},
new[] { GmailService.Scope.GmailReadonly },
"user", CancellationToken.None, new FileDataStore("Books.ListMyLibrary"));
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Gmail Scraper",
});
client.ConnectSsl(mailServer);
client.Login(login, password);
//Client.ConnectSsl(mailServer, port);
//Client.Login(login, password);
}
else
{
client.ConnectSsl(mailServer);
client.Login(login, password);
}
}
public static GmailService GetGMailService(string[] scopes, string applicationName)
{
UserCredential credential;
using (var stream =
new FileStream(@"Data\credentials2.json", FileMode.Open, FileAccess.Read))
{
// The file token.json stores the user's access and refresh tokens, and is created
// automatically when the authorization flow completes for the first time.
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,
});
return(service);
}
public void ReadLabels()
{
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
IList <Google.Apis.Gmail.v1.Data.Label> labels = request.Execute().Labels;
System.Diagnostics.Debug.WriteLine("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (var labelItem in labels)
{
System.Diagnostics.Debug.WriteLine(labelItem.Name);
}
}
else
{
System.Diagnostics.Debug.WriteLine("No labels found.");
}
}
public static List <Draft> GetDrafts(GmailService service)
{
UsersResource.DraftsResource.ListRequest request = service.Users.Drafts.List("me");
var drafts = request.Execute();
return(drafts.Drafts.ToList());
}
public static List <string> GetLabels(GmailService service)
{
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
IList <Label> labels = request.Execute().Labels;
return(labels.Select(l => l.Name).ToList());
}
public static Draft GetDraft(GmailService service, string draftId)
{
UsersResource.DraftsResource.GetRequest request = service.Users.Drafts.Get("me", draftId);
var draft = request.Execute();
return(draft);
}
public static Message SendEmail(GmailService service)
{
var mailMessage = new MailMessage
{
From = new MailAddress("*****@*****.**"),
Subject = "Testing message",
Body = "This is <b>Body</b> of the message. This message was sent from .NET as <em>testing</em>.",
IsBodyHtml = true
};
mailMessage.To.Add(new MailAddress("*****@*****.**"));
mailMessage.Attachments.Add(new Attachment("sample.txt"));
var mimeMsg = MimeMessage.CreateFromMailMessage(mailMessage);
var encodedMsg = mimeMsg.ToString();
var rawMsg = Base64UrlEncode(encodedMsg);
var gmailMessage = new Message()
{
Raw = rawMsg
};
var request = service.Users.Messages.Send(gmailMessage, "me");
var result = request.Execute();
return(result);
}
/// <summary>
///
/// </summary>
public EmailService()
{
string[] Scopes = { GmailService.Scope.GmailReadonly, GmailService.Scope.GmailLabels };
string ApplicationName = "Gmail API Quickstart";
UserCredential credential;
using (var stream =
new FileStream(@"C:\Users\swapn\Desktop\Thesis\ThesisProject\ThesisProject\App_Data\client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials");
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.
this.gmailService = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
}
private static void SendConfirmationEmail(GmailService gmail, Dictionary <string, string> dict)
{
MailMessage mailmsg = new MailMessage();
{
mailmsg.Subject = dict["subject"];
mailmsg.Body = string.Format(dict["HTML"], dict["link"]);
mailmsg.From = new MailAddress(dict["from"]);
mailmsg.To.Add(new MailAddress(dict["to"]));
mailmsg.IsBodyHtml = true;
}
////add attachment if specified
if (dict.ContainsKey("attachement"))
{
if (File.Exists(dict["attachment"]))
{
Attachment data = new Attachment(dict["attachment"]);
mailmsg.Attachments.Add(data);
}
else
{
Console.WriteLine("Error: Invalid Attachemnt");
}
}
//Make mail message a Mime message
MimeKit.MimeMessage mimemessage = MimeKit.MimeMessage.CreateFromMailMessage(mailmsg);
Google.Apis.Gmail.v1.Data.Message finalmessage = new Google.Apis.Gmail.v1.Data.Message();
finalmessage.Raw = Base64UrlEncode(mimemessage.ToString());
var result = gmail.Users.Messages.Send(finalmessage, "me").Execute();
}
public void CreateGmailService()
{
string ApplicationName = "EmailParser.EBFI";
FileParser.Delete(GoogleWebAuthorizationBroker.Folder);
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
new ClientSecrets
{
ClientId = "924776002477-2lmjf195p2ajjbshcsubeg2sr9lmordv.apps.googleusercontent.com",
ClientSecret = "6o1rF8fLCdzYbzmOojU6UoYn"
},
new[] { GmailService.Scope.GmailModify },
"user",
CancellationToken.None
).Result;
string[] scopes = new string[]
{
GmailService.Scope.GmailReadonly,
GmailService.Scope.MailGoogleCom,
GmailService.Scope.GmailMetadata
};
gmailService = new GmailService(new BaseClientService.Initializer
{
ApplicationName = "GmailParserViewProgram",
HttpClientInitializer = credential
});
}
public void CreateEmail(GoogleCredential cred, string userEmailAddress, EmailTemplate emailTemplate, List <School> schools)
{
// Create the Gmail API service
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = cred,
ApplicationName = "Coach Email Web Client"
});
foreach (var school in schools.Where(x => x.IsEnabled == true))
{
var scrubbedEmailSubject = ScrubSubjectLineTags(emailTemplate.EmailSubjectLine, school);
var scrubbedEmailBodyText = ScrubEmailBodyTags(emailTemplate.EmailBody, school);
CreateGmailDraft(service, userEmailAddress, scrubbedEmailBodyText, scrubbedEmailSubject, school.CoachEmail);
}
//var tagValues = new Dictionary<string, string>()
//{
// { "coach-name", "RYAN LIFFERTH" },
// { "school-name", "BYU" }
//};
//var scrubbedEmailText = ReplaceEmailTags(emailText, tagValues);
//CreateGmailDraft(service, userEmailAddress, scrubbedEmailText);
}
/// <summary>
///
/// </summary>
/// <param name="page"></param>
/// <returns></returns>
public override List <Entities.Message> ReadMessages(int page = 1)
{
//var url = "https://www.googleapis.com/discovery/v1/apis/gmail/v1/rest";
//var response = ReadApi(url);
//Logger.Info(response);
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = GetCredential(),
ApplicationName = ApplicationName,
});
// Define parameters of request.
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
// List labels.
IList <Label> labels = request.Execute().Labels;
Logger.Info("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (var labelItem in labels)
{
Logger.Info($"{labelItem.Name}");
}
}
else
{
Logger.Info("No labels found.");
}
return(new List <Entities.Message>());
}
public static async Task <int> PullMessagesAsync(GmailService service, string projectId, string subscriptionId, bool acknowledge)
{
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName);
// SubscriberClient runs your message handle function on multiple
// threads to maximize throughput.
int messageCount = 0;
Task startTask = subscriber.StartAsync((PubsubMessage message, CancellationToken cancel) =>
{
string text = System.Text.Encoding.UTF8.GetString(message.Data.ToArray());
text = text.Substring(text.IndexOf("{"));
MessageResponse messageResponse = Newtonsoft.Json.JsonConvert.DeserializeObject <MessageResponse>(text);
GetListMessage(service, messageResponse.HistoryId);
Console.WriteLine($"Message {message.MessageId}: {text}");
Interlocked.Increment(ref messageCount);
return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack));
});
await Task.Delay(500000);
await subscriber.StopAsync(CancellationToken.None);
// Lets make sure that the start task finished successfully after the call to stop.
await startTask;
return(messageCount);
}
// Connect to Gmail API.
public void Connect()
{
UserCredential credential;
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/gmail-dotnet-quickstart.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.
service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Define parameters of request.
UsersResource.MessagesResource.ListRequest request = service.Users.Messages.List("me");
}
public static GmailService GetService()
{
UserCredential credential;
string[] Scopes = { GmailService.Scope.MailGoogleCom };
string ApplicationName = "ZparseEmail";
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/zparse_email.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,
});
return(service);
}
/// <summary>
/// Get and store attachment from Message with given ID.
/// </summary>
/// <param name="service">Gmail API service instance.</param>
/// <param name="userId">User's email address. The special value "me"
/// can be used to indicate the authenticated user.</param>
/// <param name="messageId">ID of Message containing attachment.</param>
/// <param name="outputDir">Directory used to store attachments.</param>
public static void GetAttachments(GmailService service, String userId, String messageId, String outputDir)
{
try
{
Message message = service.Users.Messages.Get(userId, messageId).Execute();
IList<MessagePart> parts = message.Payload.Parts;
foreach (MessagePart part in parts)
{
if (!String.IsNullOrEmpty(part.Filename))
{
String attId = part.Body.AttachmentId;
MessagePartBody attachPart = service.Users.Messages.Attachments.Get(userId, messageId, attId).Execute();
// Converting from RFC 4648 base64-encoding
// see http://en.wikipedia.org/wiki/Base64#Implementations_and_history
String attachData = attachPart.Data.Replace('-', '+');
attachData = attachData.Replace('_', '/');
byte[] data = Convert.FromBase64String(attachData);
File.WriteAllBytes(Path.Combine(outputDir, part.Filename), data);
}
}
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
}
public static bool Open(string PathOfUserData)
{
// Convert this string to Stream to read at Gmail API
MemoryStream StreamJson = new MemoryStream(Encoding.ASCII.GetBytes(ConfigGmail.JsonContent_Gmail));
try
{
// Set value for UserCredential (Credential: Chứng chỉ)
UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(StreamJson).Secrets,
Scopes,
"user",
CancellationToken.None,
new FileDataStore(PathOfUserData, true)).Result;
// Create Gmail API service. (servis: Dịch vụ)
service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName
});
return(true);
}
catch (Exception)
{
return(false);
}
}
public void SendIt(string From, string To, string Subject, string Body)
{
System.Diagnostics.Debug.WriteLine("TRYING TO SEND IT. FROM IS --" + From + "-- AND TO IS --" + To + "--");
var msg = new AE.Net.Mail.MailMessage
{
Subject = Subject,
Body = Body,
From = new MailAddress(From)
};
msg.To.Add(new MailAddress(To));
msg.ReplyTo.Add(msg.From);
var msgStr = new StringWriter();
msg.Save(msgStr);
var gmail = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
var result = gmail.Users.Messages.Send(new Message
{
Raw = Base64UrlEncode(msgStr.ToString())
}, "me").Execute();
Console.WriteLine("Message ID {0} sent.", result.Id);
}
public GmailService GetService(string userName, string password)
{
UserCredential credential;
string[] Scopes = { GmailService.Scope.GmailReadonly };
string ApplicationName = "Gmail API .NET Quickstart";
using (var stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/gmail-dotnet-quickstart.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(GoogleClientSecrets.Load(stream).Secrets, Scopes,
"user", CancellationToken.None, new FileDataStore(credPath, true)).Result;
}
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
return(service);
}
public async void ReadAllMails(string label)
{
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = _credentials,
ApplicationName = ApplicationName,
});
// Define parameters of request.
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("fnb");
// List labels.
IList <Label> labels = request.Execute().Labels;
Console.WriteLine("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (var labelItem in labels)
{
Console.WriteLine("{0}", labelItem.Name);
}
}
else
{
Console.WriteLine("No labels found.");
}
Console.Read();
}
private async void btnSendCompose_Click(object sender, RoutedEventArgs e)
{
try
{
UserCredential credential = await serviceGmail.getCredential();
if (credential != null)
{
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Gmail API",
});
string plainText = string.Format("To: {0}\r\n" +
"Subject: {1}\r\n" +
"Content-Type: text/html; charset=us-ascii\r\n\r\n" +
"<h1>{2}</h1>", txtEmailSend.Text, txtSubject.Text, txtContentSend.Text);
var newMsg = new Google.Apis.Gmail.v1.Data.Message();
newMsg.Raw = Base64UrlEncode(plainText.ToString());
service.Users.Messages.Send(newMsg, "me").Execute();
ShowHideCompose.Visibility = Visibility.Collapsed;
}
}
catch (Exception) { }
}
public async Task <Boolean> checkCredential()
{
var app = new AppFlowMetadata();
var result = await new AuthorizationCodeMvcApp(this, app).
AuthorizeAsync(cancellationToken);
//var accessToken = result.Credential.Token.AccessToken;
//string a = accessToken.Value;
if (result.Credential != null)
{
//result.Credential.Token.AccessToken = null;
service = new GmailService(new BaseClientService.Initializer
{
HttpClientInitializer = result.Credential,
ApplicationName = "ASP.NET MVC Sample"
});
return(true);
}
else
{
return(false);
}
}
public async Task <GmailService> SetGmailService()
{
try
{
UserCredential credential;
using (var stream = new FileStream("C:\\Users\\Nair.ACER\\Documents\\Visual Studio 2015\\Projects\\GmailClientDemo\\GmailClientDemo.Web\\JSON\\client_secret_1043375833636-npt5ih8uo00sh5p19t2s5eettmpdm4ph.apps.googleusercontent.com.json", FileMode.Open, FileAccess.Read))
{
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
// This OAuth 2.0 access scope allows for read-only access to the authenticated
// user's account, but not other types of account access.
new[] { GmailService.Scope.GmailReadonly,
GmailService.Scope.MailGoogleCom,
GmailService.Scope.GmailModify,
GmailService.Scope.GmailSend },
"yash bee",
CancellationToken.None,
new FileDataStore(this.GetType().ToString())
);
}
GmailService gService = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = this.GetType().ToString()
});
return(gService);
}
catch (Exception ex)
{
return(gmailService);
}
}
public async void SynchronizeMails(ListMessagesResponse emailListResponse, List <Mail> MailsInDB)
{
try
{
GmailService gmailService = await GetGmailService();
foreach (Message msg in emailListResponse.Messages)
{
var emailInfoRequest = gmailService.Users.Messages.Get("*****@*****.**", msg.Id);
//make another request for that email id...
var emailInfoResponse = await emailInfoRequest.ExecuteAsync();
if (emailInfoResponse != null)
{
if (MailExistsinDB(emailInfoResponse, MailsInDB) == false)
{
await InsertMailIntoDB(emailInfoResponse);
}
}
}
}
catch (Exception ex)
{
}
}
public async Task InsertMailIntoDB(Message msg)
{
try
{
GmailService gmailService = await GetGmailService();
var emailInfoRequest = gmailService.Users.Messages.Get("*****@*****.**", msg.Id);
var emailInfoResponse = await emailInfoRequest.ExecuteAsync();
Mail newMail = new Mail()
{
MailID = emailInfoResponse.Id,
HistoryId = emailInfoResponse.HistoryId,
Etag = emailInfoResponse.ETag,
InternalDate = emailInfoResponse.InternalDate,
Raw = emailInfoResponse.Raw,
SizeEstimate = emailInfoResponse.SizeEstimate,
Snippet = emailInfoResponse.Snippet,
ThreadId = emailInfoResponse.ThreadId,
SendBy = GetSenderInfo(emailInfoResponse),
Subject = GetSubject(emailInfoResponse),
SenderEmailAddress = GetSenderEmailAddress(emailInfoResponse),
Data = GetMailData(emailInfoResponse),
Date = GetMailDate(emailInfoResponse)
};
Insert(newMail);
}
catch (Exception ex)
{
}
}
public async Task<JsonResult> GmailAsync(CancellationToken cancellationToken)
{
ViewBag.Message = "Your drive page.";
var result = await new AuthorizationCodeMvcApp(this, new AppAuthFlowMetaData()).
AuthorizeAsync(cancellationToken);
// if (result.Credential == null)
// return new RedirectResult(result.RedirectUri);
var gmailService = new GmailService(new BaseClientService.Initializer
{
HttpClientInitializer = result.Credential,
ApplicationName = "Lecture Support Server"
});
var messageFeed = gmailService.Users.Messages.List("me").Execute().Messages;
foreach (var email in messageFeed)
{
var r = new UsersResource.MessagesResource.GetRequest(gmailService, "me",email.Id);
r.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
var messg = r.Execute();
MetaDatalist.Add(messg);
}
// var mailBody = msg.Payload.Parts.Where(x => x.MimeType == "text/plain");
//.ToString()).ToString();
//var req = new UsersResource.MessagesResource.GetRequest(gmailService, "me", msg);
/*var decodedMessage = FromBase64ForUrlString(msg.ToString());
var ConvertedMessage = System.Text.Encoding.Default.GetString(decodedMessage);
var convertMessageForHtml = ConvertedMessage;
*/
var items = new FileModel();
//items.Id = msg.Id;
foreach (var lbl in MetaDatalist)
{
if (!(lbl.Payload.Headers.Where(x => x.Name == "Subject").First().Value == null))
{
mailSubjectList.Add(lbl.Payload.Headers.Where(x => x.Name == "Subject").First().Value);
}
}
// items.downloadUrl = msg.InternalDate.Value.ToString();
return Json(mailSubjectList,JsonRequestBehavior.AllowGet);
}
public static Message GetMessage(GmailService service, String userId, String messageId)
{
try
{
return service.Users.Messages.Get(userId, messageId).Execute();
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
return null;
}
public static Thread GetThread(GmailService service, String userId, String threadId)
{
try
{
return service.Users.Threads.Get(userId, threadId).Execute();
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
return null;
}
private async void Login_Click(object sender, RoutedEventArgs e)
{
IConfigurableHttpClientInitializer credential;
// var matchingString = "verification OR Confirmation OR confirm OR verify OR Activate";
var matchingString = "verification OR Confirmation OR Activate";
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = System.IO.Path.Combine(credPath, ".credentials");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
Scopes,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
}
// Create Gmail API service.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
MsgPopUp.Visibility = System.Windows.Visibility.Visible;
Task<List<string>> task = this.GetListSender(service, "me", matchingString, "INBOX");
var list = await task;
var gridList = new ObservableCollection<DataObject>();
foreach (var msgSender in list) {
gridList.Add(new DataObject() { SenderEmail = msgSender });
}
this.dataDridHolder.ItemsSource = gridList;
}
public void GMail()
{
UserCredential credential;
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/gmail-dotnet-quickstart.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,
});
// Define parameters of request.
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
// List labels.
IList<Label> labels = request.Execute().Labels;
Console.WriteLine("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (var labelItem in labels)
{
Console.WriteLine("{0}", labelItem.Name);
}
}
else
{
Console.WriteLine("No labels found.");
}
Console.Read();
}
static void Main(string[] args)
{
UserCredential credential;
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials-gmail");
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,
});
// Define parameters of request.
UsersResource.ThreadsResource.ListRequest request = service.Users.Threads.List("me");
// List threads.
IList<Google.Apis.Gmail.v1.Data.Thread> threads = request.Execute().Threads;
Console.WriteLine("Emails:");
if (threads != null && threads.Count > 0)
{
foreach (var threadItem in threads)
{
Console.WriteLine("{0}", threadItem.Snippet);
}
}
else
{
Console.WriteLine("No emails found.");
}
Console.Read();
}
public Google()
{
UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
new ClientSecrets
{
ClientId = Music.APIKeyProvider.Google_ClientId,
ClientSecret = Music.APIKeyProvider.Google_Secret
},
new string[] { GmailService.Scope.MailGoogleCom },
"user",
CancellationToken.None,
new FileDataStore("./", true)).Result;
this.client = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "bourdon",
});
}
/// <summary>
/// List all Messages of the user's mailbox matching the query.
/// </summary>
/// <param name="service">Gmail API service instance.</param>
/// <param name="userId">User's email address. The special value "me"
/// can be used to indicate the authenticated user.</param>
/// <param name="query">String used to filter Messages returned.</param>
public static List<Message> GetAllBiopsyMessages(GmailService service, String userId, Label label, String query)
{
List<Message> result = new List<Message>();
UsersResource.MessagesResource.ListRequest request = service.Users.Messages.List(userId);
request.LabelIds = label.Id;
/// request.Q = query;
do
{
try
{
ListMessagesResponse response = request.Execute();
result.AddRange(response.Messages);
request.PageToken = response.NextPageToken;
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
} while (!String.IsNullOrEmpty(request.PageToken));
return result;
}
public Task<Message> GetMessage(GmailService service, String userId, String messageId)
{
return Task<Message>.Run(() => { return this.getM(service, userId, messageId); });
}
/// <summary>
/// List the labels in the user's mailbox.
/// </summary>
/// <param name="service">Gmail API service instance.</param>
/// <param name="userId">User's email address. The special value "me"
/// can be used to indicate the authenticated user.</param>
public static void ListLabels(GmailService service, String userId)
{
try
{
ListLabelsResponse response = service.Users.Labels.List(userId).Execute();
foreach (Label label in response.Labels)
{
Console.WriteLine(label.Id + " - " + label.Name);
}
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
}
public Task<List<Message>> ListOfMessages(GmailService service, String userId, String query, String labelId)
{
return Task<List<Message>>.Run(() => { return this.ListMessages(service, userId, query, labelId); });
}
private async void Login_Click(object sender, RoutedEventArgs e)
{
UserCredential credential;
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = System.IO.Path.Combine(credPath, ".credentials");
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,
});
// Define parameters of request.
//UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
// List labels.
//IList<Google.Apis.Gmail.v1.Data.Label> labels = request.Execute().Labels;
//Console.WriteLine("Labels:");
//if (labels != null && labels.Count > 0)
//{
// foreach (var labelItem in labels)
// {
// Console.WriteLine("Id:" + labelItem.Id + " Name:" + labelItem.Name);
// }
//}
//else
//{
// Console.WriteLine("No labels found.");
//}
MsgPopUp.Visibility = System.Windows.Visibility.Visible;
Task<List<string>> task = this.GetListSender(service, "me", "verify", "INBOX");
var list = await task;
var gridList = new ObservableCollection<DataObject>();
foreach (var msgSender in list) {
gridList.Add(new DataObject() { SenderEmail = msgSender });
}
// Console.Read();
this.dataDridHolder.ItemsSource = gridList;
}
public static void GetLabels()
{
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = GetCredentials(),
ApplicationName = ApplicationName,
});
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
IList<Label> labels = request.Execute().Labels;
Console.WriteLine("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (var labelItem in labels)
{
Console.WriteLine("{0}", labelItem.Name);
}
}
else
{
Console.WriteLine("No labels found.");
}
Console.Read();
}
public static List<Message> ListMessages(GmailService service, String userId, String query)
{
List<Message> result = new List<Message>();
UsersResource.MessagesResource.ListRequest request = service.Users.Messages.List(userId);
request.Q = query;
do
{
try
{
ListMessagesResponse response = request.Execute();
result.AddRange(response.Messages);
request.PageToken = response.NextPageToken;
}
catch { }
} while (!String.IsNullOrEmpty(request.PageToken));
return result;
}
public static void LoadLineups(NPGGFFLDataContext context, DateTime triggerDate)
{
Console.WriteLine("Getting service...");
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = GetCredentials(),
ApplicationName = ApplicationName,
});
var seasonWeek = context.SeasonWeeks.Where(sw => sw.StartDtm <= triggerDate && sw.EndDtm >= triggerDate).First();
ModifyMessageRequest mods = new ModifyMessageRequest();
mods.AddLabelIds = (new string[] { }).ToList();
mods.RemoveLabelIds = (new string[] { "INBOX" }).ToList();
ListLabelsResponse response = service.Users.Labels.List(UserId).Execute();
foreach (Label label in response.Labels)
{
if (label.Name.ToUpper().Equals(string.Format("WEEK {0}", seasonWeek.WeekNum)))
{
mods.AddLabelIds.Add(label.Id);
break;
}
}
Console.WriteLine("Getting messages...");
var msgs = ListMessages(service, UserId, "label:inbox");
foreach (var msg in msgs)
{
Console.WriteLine("Getting message email and body...");
var message = service.Users.Messages.Get(UserId, msg.Id).Execute();
var partsBody = (message.Payload.Parts == null ? message.Payload.Body.Data : message.Payload.Parts.Where(p => p.MimeType.Equals("text/plain")).First().Body.Data);
var plainTextBody = Encoding.UTF8.GetString(Convert.FromBase64String(partsBody));
var fromAddress = string.Empty;
var body = string.Empty;
//check for forward
if (plainTextBody.Contains("Forwarded"))
{
var fromLine = plainTextBody.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None).Where(l => l.Contains("From:")).FirstOrDefault();
MailAddress email = new MailAddress(fromLine.Substring(fromLine.IndexOf("From:")+6));
fromAddress = email.Address.ToUpper();
bool afterEmailForwardSignature = false;
foreach (var line in plainTextBody.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None))
{
if (line.Contains("To:"))
{
afterEmailForwardSignature = true;
}
if (afterEmailForwardSignature)
{
body += line + "\r\n";
}
}
}
else
{
MailAddress email = new MailAddress(message.Payload.Headers.Where(h => h.Name.Equals("From")).FirstOrDefault().Value);
fromAddress = email.Address.ToUpper();
body = plainTextBody;
}
//Console.WriteLine("Loading Lineup..");
//if (SaveLineup(context, fromAddress, body, seasonWeek.SeasonWeekId))
//{
// //Console.WriteLine("Trash Message...");
// //service.Users.Messages.Trash(UserId, message.Id).Execute();
//}
service.Users.Messages.Modify(mods, UserId, message.Id).Execute();
}
Console.WriteLine("Done...");
}
async static Task<GmailService> Authenticate()
{
UserCredential credential;
using (var stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
stream,
new[] { GmailService.Scope.GmailReadonly },
"user",
CancellationToken.None,
new FileDataStore("Gmail.Attachments"));
}
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "get-gmail-attachments"
});
return service;
}
/// <summary>
///
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
private static Label getInboxLabel(GmailService service, String userId)
{
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List(userId);
IList<Label> labels = request.Execute().Labels;
Console.WriteLine("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (Label labelItem in labels)
{
if (String.Compare(labelItem.Id, "Inbox", StringComparison.InvariantCultureIgnoreCase)==0)
{
return labelItem;
}
}
}
else
{
Debug.Assert(false, "Inbox wasn't found");
}
return null;
}
static void Main(string[] args)
{
UserCredential credential;
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = GetLocalCredentialsPath();
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,
});
Label inbox = getInboxLabel(service, "me");
List<Message> biopsyMessages = GetAllBiopsyMessages(service, "me", inbox, "");
foreach (Message m in biopsyMessages)
{
Message fullMessage = GetMessage(service, "me", m.Id);
String subject = null;
String from = null;
foreach (MessagePartHeader header in fullMessage.Payload.Headers)
{
if (header.Name.Equals("Subject", StringComparison.InvariantCultureIgnoreCase))
{
subject = header.Value;
} else if (header.Name.Equals("From", StringComparison.InvariantCultureIgnoreCase))
{
from = header.Value;
}
}
Debug.Assert(subject != null && from != null, "Either subject or from are null. What happened!!");
String biopsyId = ExtractBiopsyIdFromTitle(subject);
if (biopsyId != null)
{
Console.WriteLine("Processing {0}", biopsyId);
String biopsyType = ExtractBiopsyTypeFromTitle(subject);
String attachmentsPath = GetAttachmentsFolderFor(biopsyId, biopsyType);
Directory.CreateDirectory(attachmentsPath);
GetAttachments(service, "me", fullMessage.Id, attachmentsPath);
}
}
Console.ReadLine();
}
public Message getM(GmailService service, String userId, String messageId)
{
var msg = service.Users.Messages.Get(userId, messageId).Execute();
return msg;
}
static string ApplicationName = "Gmail API Quickstart";//???????????? AppName是什么鬼？
static void Main(string[] args)
{
UserCredential credential;//用户令牌？
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);//获取本机的“文档”文件夹路径
credPath = Path.Combine(credPath, ".credentials");//设置保存证书的路径
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
Scopes,
"user",
System.Threading.CancellationToken.None,
new FileDataStore(credPath, true)).Result;//登陆获取授权oAuth2.0
Console.WriteLine("Credential file saved to: " + credPath);
}
// Create Gmail API service.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Define parameters of request.
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
#endregion
// List labels.
Console.WriteLine("标签：");
ListLabels(service, "me");
//IList<Label> labels = request.Execute().Labels;
//Console.WriteLine("Labels:");
//if (labels != null && labels.Count > 0)
//{
// foreach (var labelItem in labels)
// {
// Console.WriteLine("{0}", labelItem.Name);
// }
//}
//else
//{
// Console.WriteLine("No labels found.");
//}
Console.WriteLine("================================================\n按下回车查看每个对话的每个消息的snippet");
Console.Read();
//显示thread ID
List<Google.Apis.Gmail.v1.Data.Thread> threads = ListThreads(service, "me");
if(threads != null && threads.Count>0)
{
foreach(var threadItem in threads)
{
Console.WriteLine("对话ID：{0}",threadItem.Id);
Thread thread = GetThread(service,"me",threadItem.Id);
foreach (var message in thread.Messages)
{
Console.WriteLine("内容提要：" + message.Snippet);
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("****************");
}
}
else
{
Console.WriteLine("没有发现thread");
}
Console.WriteLine("================================================按下回车查看每个对话的每个消息的id");
Console.Read();
//message
List<Message> messages = ListMessages(service, "me","");
if (messages != null && messages.Count > 0)
{
foreach (var messageItem in messages)
{
Console.WriteLine("{0}", messageItem.Id);
}
}
else
{
Console.WriteLine("没有发现message");
}
Console.Read();
}
private static void Main(string[] args)
{
UserCredential credential;
//Save Token Response Path
string credPath = Environment.CurrentDirectory + @"\";
credPath = Path.Combine(credPath, ".credentials/gmail-dotnet-quickstart");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
new ClientSecrets { ClientId = CID, ClientSecret = CSECRET },
Scopes,
"user", // I don't know
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,
});
// Define parameters of request.
var requestLabel = service.Users.Labels.List("me");
var requestLabelList = new List<string>();
var requestLabelNameList = new List<string>() { "unread", "CATEGORY_UPDATES" };
// List labels.
var labels = requestLabel.Execute().Labels;
Console.WriteLine("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (var labelItem in labels)
{
Console.WriteLine("{0}", labelItem.Name);
//Getting wanted Label
if (requestLabelNameList.Contains(labelItem.Name)) requestLabelList.Add(labelItem.Id);
}
}
//GetMessage
//Me means myself
var request = service.Users.Messages.List("me");
request.LabelIds = requestLabelList;
//Get maximum message
request.MaxResults = 4;
//plain text query
//request.Q = "is:unread category:updates is:important";
ListMessagesResponse respM = request.Execute();
if (respM.Messages != null)
{
foreach (var m in respM.Messages)
{
var id = m.Id;
var getReq = new UsersResource.MessagesResource.GetRequest(service, "me", id);
//Get Message from id
var data = getReq.Execute();
//Output Message's Label
foreach (var l in data.LabelIds)
Console.Write(l + " ");
Console.WriteLine();
var heads = data.Payload.Headers;
/*
//output full header info
var hCount = 1;
foreach(var head in heads)
{
Console.WriteLine("Head {0} {1} {2}", hCount, head.Name, head.Value);
hCount++;
}
*/
var subject = heads.FirstOrDefault(x => x.Name == "Subject")?.Value ?? "NotSubject";
Console.WriteLine(subject);
var body = GetMimeString(data.Payload);
var fix = Strings.Replace(body, subject, "", 1);
Console.WriteLine(fix);
Console.WriteLine("++++++++++++++++++++++++++++++++++++");
}
}
Console.Read();
}
