private Message GetMessage(string messageId)
{
UsersResource.MessagesResource.GetRequest request = _gmailService.Users.Messages.Get("me", messageId);
Message message = request.Execute();
return(message);
}
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());
}
// Retrieve the message payload.
private MessagePart GetEmailDetails(Message message)
{
UsersResource.MessagesResource.GetRequest singleMessage = service.Users.Messages.Get("me", message.Id);
MessagePart messagePayload = singleMessage.Execute().Payload;
return(messagePayload);
}
private Message RetrieveMessageById(string messageId)
{
UsersResource.MessagesResource.GetRequest msg = this.service.Users.Messages.Get("me", messageId);
msg.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
Message retrievedMsg = msg.Execute();
return(retrievedMsg);
}
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);
}
private void FetchTask()
{
var tasks = new List <Task>();
while (Exit == false || TodoCount != 0)
{
Message element = null;
lock (TodoLock)
{
element = Todo.Count > 0 ? Todo[0] : null;
if (element != null)
{
Todo.Remove(element);
}
}
if (element != null)
{
var cachedElement = _gmailCache.Get(element.Id);
if (cachedElement != null)
{
lock (DoneLock)
Done.Add(cachedElement);
}
else
{
var request = new UsersResource.MessagesResource.GetRequest(clientService, "me", element.Id);
var fetchTask = Task.Run(() =>
{
var responseMessage = request.Execute();
var mess = new MessageFromItem()
{
Id = responseMessage.Id,
From = responseMessage.Payload.Headers.Single(x => x.Name.Equals("From", StringComparison.OrdinalIgnoreCase)).Value,
};
lock (DoneLock)
{
Done.Add(mess);
}
_gmailCache.AddItem(mess);
});
tasks.Add(fetchTask);
}
}
else
{
System.Threading.Thread.Sleep(100);
}
}
Task.WhenAll(tasks).Wait();
}
/// <summary>
/// Gets a specific MailMessage by ID.
/// </summary>
/// <param name="ID">The ID of the requested message.</param>
/// <returns>A MailMessage of the requested message.</returns>
public MailMessage getEmail(string ID)
{
GmailService service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = getGmailCred()
});
UsersResource.MessagesResource.GetRequest getReq = new UsersResource.MessagesResource.GetRequest(service, "me", ID);
Message result = getReq.Execute();
return(convertToMailMessage(result));
}
public void ConstructMailLine(UsersResource.MessagesResource.GetRequest req)
{
// Construct the ListViewItem object
string text = "(no subject)";
foreach (var header in MailService.GetMessageHeaders(req))
{
if (header.Name.Equals("Subject") && header.Value.Length > 0)
{
text = header.Value;
break;
}
}
ListViewItem item = new ListViewItem(text);
item.Tag = req.Id;
Inbox.Items.Add(item);
}
public static string GetMessageBodyHtml(UsersResource.MessagesResource.GetRequest req)
{
// Refactored "clever" solution
var response = req.Execute();
string encodedBody = null;
if (response.Payload.Parts[1].Body.Data == null)
{
encodedBody = response.Payload.Body.Data;
}
else
{
encodedBody = response.Payload.Parts[1].Body.Data;
}
string result = Base64Translator.Base64UrlDecode(encodedBody);
return(result);
}
public string?ExtractEmailSnippetContent(GmailRequest request)
{
UsersResource.MessagesResource.ListRequest listRequest = _gmailService.Users.Messages.List("me");
listRequest.Q = request.Query;
var response = listRequest.Execute();
if (response.Messages == null)
{
return(null);
}
var messages = new List <Message>();
foreach (var message in response.Messages)
{
UsersResource.MessagesResource.GetRequest msgRequest = _gmailService.Users.Messages.Get("me", message.Id);
messages.Add(msgRequest.Execute());
}
var authMessage = messages
.Where(m => m.InternalDate >= request.NewerThan?.ToUnixTimeMilliseconds())
.OrderByDescending(m => m.InternalDate)
.FirstOrDefault();
if (authMessage == null)
{
return(null);
}
if (request.SnippetRegex == null)
{
return(null);
}
var matches = request.SnippetRegex.Matches(authMessage.Snippet);
if (matches.Any() && matches[0].Groups.Count > 1)
{
return(matches[0].Groups[1].Value);
}
return(null);
}
public static string GetEmailWindowHeader(UsersResource.MessagesResource.GetRequest req)
{
string subject = "(no subject)";
string sender = null;
foreach (var header in GetMessageHeaders(req))
{
if (header.Name.Equals("Subject") && header.Value.Length > 0)
{
subject = header.Value;
}
if (header.Name.Equals("From"))
{
sender = header.Value;
}
}
string result = sender + " " + subject;
return(result);
}
private UsersResource.MessagesResource.GetRequest GetSelectedItemReqById()
{
UsersResource.MessagesResource.GetRequest reqResult = null;
try
{
ListViewItem listViewItem = Inbox.SelectedItems[0] as ListViewItem;
string id = listViewItem.Tag.ToString();
foreach (var req in messageRequests)
{
if (req.Id.Equals(id))
{
reqResult = req;
break;
}
}
}
catch (NullReferenceException e)
{
Console.WriteLine(e.Message);
}
return(reqResult);
}
/// <summary>
/// Attempts to fully load the mail. IsFullyLoaded will return true after this if it succeeded.
/// </summary>
/// <returns>Whether the operation succeeded in loading everything</returns>
public bool LoadFull()
{
try
{
UsersResource.MessagesResource.GetRequest request = Account.service.Users.Messages.Get("me", _id);
request.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
Message message = request.Execute();
MessagePart part = message.Payload;
_snippet = message.Snippet;
try
{
_text = Encoding.UTF8.GetString(Convert.FromBase64String(part.Parts[0].Body.Data));
}
catch
{
}
foreach (MessagePartHeader h in part.Headers)
{
if (h.Name == "Return-Path")
{
_from = h.Value.Substring(1, h.Value.Length - 2);
}
else if (h.Name == "Subject")
{
_subject = h.Value;
}
}
_complete = true;
return(true);
}
catch //(Exception e)
{
}
return(false);
}
public IList <Message> GetBandejaPorAsunto(string Asunto)
{
UserCredential Credential;
using (var stream = new FileStream("client_secret_instalado.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;
}
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = Credential,
ApplicationName = ApplicationName
});
UsersResource.MessagesResource.ListRequest request = service.Users.Messages.List("me");
request.Q = Asunto; // subject:(Solicitud automática de nuevo asunto con el despacho) is:unread"
IList <Message> _result = request.Execute().Messages;
List <Message> _resultado = new List <Message>();
if (_result != null && _result.Count > 0)
{
foreach (Message msj in _result)
{
UsersResource.MessagesResource.GetRequest peticion = service.Users.Messages.Get("me", msj.Id);
peticion.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
var elementos = peticion.Execute();
_resultado.Add(elementos);
}
return(_resultado);
}
return(null);
}
private async Task <List <CurrentMessage> > GetMessagesPartsAsync(List <Message> messages, GmailService service)
{
List <CurrentMessage> messagesInfo = new List <CurrentMessage>();
if (messages != null)
{
foreach (var msg in messages)
{
UsersResource.MessagesResource.GetRequest emailInfoRequest = service.Users.Messages.Get("me", msg.Id);
var emailInfoResponse = await emailInfoRequest.ExecuteAsync();
if (emailInfoResponse != null)
{
CurrentMessage currentMsg = new CurrentMessage();
foreach (var mParts in emailInfoResponse.Payload.Headers)
{
currentMsg.Id = msg.Id;
if (mParts.Name == "Date")
{
currentMsg.Date = mParts.Value;
}
else if (mParts.Name == "From")
{
currentMsg.From = mParts.Value;
}
else if (mParts.Name == "Subject")
{
currentMsg.Subject = mParts.Value;
}
}
messagesInfo.Add(currentMsg);
}
}
}
return(messagesInfo);
}
/// <summary>
/// Gets all of the emails from a selected account. This is a
/// proof of concept and probably shouldn't be used by the
/// application.
/// </summary>
/// <returns>An IList of every message.</returns>
public IList <MailMessage> getEmails()
{
IList <MailMessage> result = new List <MailMessage>();
GmailService service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = getGmailCred()
});
IList <Message> messages = service.Users.Messages.List(ProudSourceEmail).Execute().Messages;
foreach (Message message in messages)
{
result.Add(getEmail(message.Id)); UsersResource.MessagesResource.GetRequest getReq = new UsersResource.MessagesResource.GetRequest(service, "me", message.Id);
getReq.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
Message fullMessage = getReq.Execute();
MailMessage decodedMessage = convertToMailMessage(fullMessage);
result.Add(decodedMessage);
}
return(result);
}
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();
}
public List <GMessage> getMessages(string query)
{
ListMessages(query);
List <GMessage> result = new List <GMessage>();
for (int i = 0; i < Messages.Count; i++)
{
UsersResource.MessagesResource.GetRequest request = gs.Users.Messages.Get(this.userName, Messages[i].Id);
request.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Metadata;
Message m = request.Execute();
GMessage mess = new GMessage();
mess.Snipet = WebUtility.HtmlDecode(m.Snippet);
mess.Link = "https://mail.google.com/mail/#inbox/" + m.Id;
mess.Id = m.Id;
DateTime start = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
mess.EmailDate = start.AddMilliseconds(m.InternalDate.GetValueOrDefault()).ToLocalTime();
bool receivedFound = false;
//loop on header extracting data
for (int j = 0; j < m.Payload.Headers.Count; j++)
{
if (m.Payload.Headers[j].Name.ToLower() == "from")
{
int size = m.Payload.Headers[j].Value.IndexOf("<");
if (size <= 0)
{
size = m.Payload.Headers[j].Value.IndexOf("@");
}
if (size < 0)
{
size = m.Payload.Headers[j].Value.Length;
}
mess.Sender = m.Payload.Headers[j].Value.Substring(0, size).Replace("\"", "").Replace("<", "").Trim();
}
else if (m.Payload.Headers[j].Name.ToLower() == "subject")
{
mess.Subject = m.Payload.Headers[j].Value;
}
else if (!receivedFound && m.Payload.Headers[j].Name.ToLower() == "received")
{
receivedFound = true;
try
{
string[] splitedReceived = m.Payload.Headers[j].Value.Split(';');
CultureInfo provider = CultureInfo.InvariantCulture;
//Tue, 12 Sep 2017 04:03:21 - 0700(PDT)
DateTime receivedDate = new DateTime();
bool parseOk = DateTime.TryParseExact(splitedReceived[splitedReceived.Length - 1].Substring(0, splitedReceived[splitedReceived.Length - 1].IndexOf("(")).Trim(), "ddd, dd MMM yyyy HH:mm:ss K", provider, DateTimeStyles.AdjustToUniversal, out receivedDate);
if (parseOk)
{
mess.EmailDate = receivedDate.ToLocalTime();
}
} catch { }
}
}
result.Add(mess);
}
return(result);
}
internal static void ReadMails(GmailService service, string userId)
{
try
{
string defaultSubjectValue = "Trello";
UsersResource.MessagesResource.ListRequest inboxlistRequest = service.Users.Messages.List(userId);
inboxlistRequest.LabelIds = "INBOX";
inboxlistRequest.Q = "is:unread";
inboxlistRequest.IncludeSpamTrash = false;
ListMessagesResponse emailListResponse = inboxlistRequest.Execute();
if (emailListResponse != null && emailListResponse.Messages != null)
{
List <Message> newMessageList = new List <Message>();
if (MessagesList == null)
{
MessagesList = new List <Message>();
}
foreach (Message email in emailListResponse.Messages)
{
UsersResource.MessagesResource.GetRequest emailInfoRequest = service.Users.Messages.Get(userId, email.Id);
Message emailInfoResponse = emailInfoRequest.Execute();
if (emailInfoResponse != null)
{
string subjectValue = emailInfoResponse.Payload.Headers.Where(header => header.Name == "Subject")
.Select(subj => subj.Value).ToArray().First();
if (subjectValue.Contains(defaultSubjectValue))
{
newMessageList.Add(emailInfoResponse);
if (MessagesList.Find(x => x.Id == emailInfoResponse.Id) == null)
{
string cardBody = emailInfoResponse.Snippet;
TrelloInformation information = TrelloUtilities.CreateDefaultTrelloInformation(subjectValue, cardBody);
string cardId = TrelloUtilities.MakeAndPostTrelloCard(information);
if (cardId != null)
{
GmailMessageObject gmailMessage = CreateGmailObject(emailInfoResponse, cardId);
if (gmailMessage != null)
{
GmailXTrelloMessagesList.Add(gmailMessage);
}
Console.WriteLine("Card criado com sucesso! ");
}
else
{
Console.WriteLine("Não foi possível criar o Card.");
}
}
}
}
}
List <Message> returnedList = MessageListVerifier(newMessageList);
if (returnedList != null)
{
MoveEmailToReadCard(returnedList);
}
}
}
catch (Exception error)
{
Tools.LogWriter.WriteLog(error.Message);
}
}
public static void email(String userId)
{
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;
}
// Create Gmail API service.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Define parameters of request.
UsersResource.MessagesResource.ListRequest messagesListRequest =
service.Users.Messages.List("*****@*****.**");
// List labels.
IList <Message> messageIDs = messagesListRequest.Execute().Messages;
Database db = new Database("database");
List <string> knownID = db.getEmailIds();
foreach (Message messageID in messageIDs)
{
if (!knownID.Contains(messageID.Id))
{
String decodedString = "";
UsersResource.MessagesResource.GetRequest preMessage =
service.Users.Messages.Get(userID, messageID.Id);
preMessage.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
Message message = preMessage.Execute();
string base64proper = message.Payload.Parts[0].Body.Data;
base64proper = base64proper.Replace('-', '+');
base64proper = base64proper.Replace('_', '/');
byte[] data = Convert.FromBase64String(base64proper);
string rawData = Encoding.UTF8.GetString(data);
string posSender = "";
foreach (MessagePartHeader header in message.Payload.Headers)
{
if (header.Name == "From")
{
posSender = header.Value;
break;
}
}
List <string> companies = db.getCompanyNames();
string sender = "Unknown";
foreach (string company_name in companies)
{
Regex regex = new Regex(company_name.ToLower());
if (regex.IsMatch(posSender.ToLower()) || regex.IsMatch(rawData.ToLower()))
{
sender = company_name;
}
}
long?internalDate = message.InternalDate; //Put in database
db.newEmail(messageID.Id, sender, internalDate, categoriseEmail(rawData));
Console.WriteLine("");
}
}
}
public static IList <MessagePartHeader> GetMessageHeaders(UsersResource.MessagesResource.GetRequest req)
{
return(req.Execute().Payload.Headers);
}
public IList <MailMessage> getUnreadEmails()
{
// The list of messages that we're going to return
IList <MailMessage> result = new List <MailMessage>();
// First we need to find the ID of the UNREAD label, which we'll use
// to select all of the unread messages.
GmailService service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = getGmailCred()
});
IList <Label> labels = service.Users.Labels.List(ProudSourceEmail).Execute().Labels;
string unreadID = "";
foreach (Label l in labels)
{
if (l.Name == "UNREAD")
{
unreadID = l.Id;
}
}
// This should be impossible, because UNREAD is a system label
// rather than a user label
if (unreadID == "")
{
throw new Exception();
}
// And now we see what messages we have.
UsersResource.MessagesResource.ListRequest listRequest = service.Users.Messages.List(ProudSourceEmail);
// We specify that we only want unread messages
listRequest.LabelIds = unreadID;
IList <Message> messages = listRequest.Execute().Messages;
// Now we get the full messages, and add them to a list
foreach (Message message in messages)
{
// We have to get each email -- we've only listed them up until this point
result.Add(getEmail(message.Id)); UsersResource.MessagesResource.GetRequest getReq = new UsersResource.MessagesResource.GetRequest(service, "me", message.Id);
getReq.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
Message fullMessage = getReq.Execute();
MailMessage decodedMessage = convertToMailMessage(fullMessage);
// Now we mark the message as read
ModifyMessageRequest modMessageReq = new ModifyMessageRequest();
// Because of the request parameters, we neeed to make a list.
IList <string> labelIDs = new List <string>(); labelIDs.Add(unreadID);
// We tell the request what labels we want to remove
modMessageReq.RemoveLabelIds = labelIDs;
// And execute
//service.Users.Messages.Modify(modMessageReq, ProudSourceEmail, fullMessage.Id).Execute();
result.Add(decodedMessage);
}
return(result);
}
public static string GetMessageBodyPlain(UsersResource.MessagesResource.GetRequest req)
{
// The "clever" solution
return(Base64Translator.Base64UrlDecode(req.Execute().Payload.Parts[0].Body.Data));
}
public static string GetMessageSnippet(UsersResource.MessagesResource.GetRequest req)
{
return(req.Execute().Snippet.Replace("'", "\'"));
}
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-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.MessagesResource.ListRequest request = service.Users.Messages.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.");
* }
*/
// List messages
IList <Message> messages = ListMessages(service, "me");
Console.WriteLine("Messages: ");
if (messages != null && messages.Count > 0)
{
foreach (Message message in messages)
{
UsersResource.MessagesResource.GetRequest asd = service.Users.Messages.Get("me", message.Id);
string messageSnippet = asd.Execute().Snippet;
var messagePayload = asd.Execute().Payload;
string sender = messagePayload.Headers[6].Value;
var parts = messagePayload.Parts;
Console.WriteLine("From: " + sender);
if (!string.IsNullOrWhiteSpace(parts[0].Body.Data))
{
string InputStr = parts[0].Body.Data.Replace("-", "+").Replace("_", "/");
string decodedString = Encoding.UTF8.GetString(Convert.FromBase64String(InputStr));
Console.WriteLine("Body: " + decodedString);
}
else
{
Console.WriteLine("Well that didn't work out, did it?");
}
}
}
else
{
Console.WriteLine("No messages found");
}
Console.Read();
}
public static async Task <List <string[]> > GetEmailsAndScrapeThem(string search,
Action <string[]> onAdd)
{
var rows = new List <string[]>();
UsersResource.MessagesResource.ListRequest request =
GmailService.Users.Messages.List("me");
request.MaxResults = int.MaxValue;
request.Q = search;
IList <Message> messages = (await request.ExecuteAsync()).Messages;
if (messages == null || messages.Count <= 0)
{
return(rows);
}
try
{
foreach (Message message in messages)
{
if (Stop)
{
break;
}
UsersResource.MessagesResource.GetRequest req =
GmailService.Users.Messages.Get("me", message.Id);
Message mes = await req.ExecuteAsync();
string a;
if (!string.IsNullOrEmpty(mes.Payload.Parts[0].Body.Data))
{
a = mes.Payload.Parts[0].Body.Data;
}
else if (mes.Payload.Parts[0].Parts[0].Parts != null)
{
a = mes.Payload.Parts[0].Parts[0].Parts[1].Body.Data;
}
else
{
a = mes.Payload.Parts[0].Parts[1].Body.Data;
}
if (a == null)
{
continue;
}
string body = Utf8.GetString(WebEncoders.Base64UrlDecode(a));
var results = new string[FieldsList.Count];
for (var i = 0; i < FieldsList.Count; i++)
{
FieldToFind f = FieldsList[i];
Match rcMatch = Regex.Match(body, f.Regex, RegExOptions);
if (f.Required && !rcMatch.Success)
{
results[i] = "NOT FOUND";
}
else
{
results[i] = rcMatch.Groups[f.GroupNumber].Value;
}
}
onAdd(results);
rows.Add(results);
}
}
catch
{
// ignored
}
return(rows);
}
public MainWindow()
{
InitializeComponent();
UserCredential credential;
using (var stream =
new FileStream(@"C:\Users\Kaivaan\source\repos\WpfApp1\WpfApp1\client_id.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = System.IO.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.
var labels = request.Execute().Labels;
Console.WriteLine("Labels:");
if (labels != null && labels.Count > 0)
{
foreach (var labelItem in labels)
{
if (labelItem.Name == "Work")
{
Console.WriteLine("{0}", labelItem.Name);
}
}
}
else
{
Console.WriteLine("No labels found.");
}
//Console.Read();
///--- retrive first email body
Message messageFeed = service.Users.Messages.List("me").Execute().Messages.First();//get first latest message
UsersResource.MessagesResource.GetRequest getReq = new UsersResource.MessagesResource.GetRequest(service, "me", messageFeed.Id);
getReq.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Full;
Message message = getReq.Execute();
var BodyOftheFirstMessage = GetMimeString(message.Payload);
// Console.WriteLine(BodyOftheFirstMessage);
//--------headers of first email
foreach (var i in message.Payload.Headers)
{
if (i.Name == "From")
{
var x = i.Value;
Console.WriteLine("From : " + i.Value);
}
if (i.Name == "To")
{
var x = i.Value;
Console.WriteLine("To : " + i.Value);
}
else if (i.Name == "Subject")
{
var x = i.Value;
Console.WriteLine("Subject : " + i.Value);
}
}
}
