public static Google.Apis.Gmail.v1.Data.Message CreateEmail(string emailBody)
{
var mailMessage = new System.Net.Mail.MailMessage();
mailMessage.From = new System.Net.Mail.MailAddress("*****@*****.**");
mailMessage.To.Add("*****@*****.**");
mailMessage.ReplyToList.Add("*****@*****.**");
mailMessage.Subject = "Parsed Homes";
mailMessage.Body = emailBody;
mailMessage.IsBodyHtml = false;
//foreach (System.Net.Mail.Attachment attachment in email.Attachments)
//{
// mailMessage.Attachments.Add(attachment);
//}
var mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mailMessage);
var gmailMessage = new Google.Apis.Gmail.v1.Data.Message
{
Raw = Encode(mimeMessage.ToString())
};
return(gmailMessage);
}
public static bool SendMail()
{
try
{
// Operaciones
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;
}
// Creamos un servicio de GMAIL.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Definimos parametros de la solicitud.
UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
//UsersResource.LabelsResource.ListRequest request =
string plainText = "To: [email protected]\r\n" +
"Subject: subject Test\r\n" +
"Content-Type: text/html; charset=us-ascii\r\n\r\n" +
"<h1>Body Test </h1>";
var newMsg = new Google.Apis.Gmail.v1.Data.Message();
newMsg.Raw = EmailHelper.Base64UrlEncode(plainText.ToString());
service.Users.Messages.Send(newMsg, "me").Execute();
// ??
//IList<Label> labels = request.Execute().Labels;
//if (labels != null && labels.Count > 0)
//{
// foreach (var labelItem in labels)
// File.AppendAllText("salidaLabels.txt", labelItem.Name);
//}
//else
//{
// throw new ApplicationException("No labels found.");
//}
return(true);
}
catch (Exception ex)
{
// LOGGER
return(false);
}
}
public static string DecodeEmailBody(Google.Apis.Gmail.v1.Data.Message m)
{
string codedBody = m.Raw.Replace("-", "+");
codedBody = codedBody.Replace("_", "/");
return(Encoding.UTF8.GetString(Convert.FromBase64String(codedBody)));
}
public bool Send(string[] recipeints, string subject, string htmlBody)
{
try
{
StringBuilder sb = new StringBuilder();
string recips = "To: ";
foreach (var r in recipeints)
{
recips += r + ",";
}
recips = recips.TrimEnd(',');
sb.AppendLine(recips);
sb.AppendLine("Subject: " + subject);
sb.AppendLine("Content-Type: text/html; charset=us-ascii");
sb.AppendLine(); //add second terminator
sb.AppendLine(htmlBody); //html
//string plainText1 = "To: [email protected]\r\n" +
// "Subject: test 2\r\n" +
// "Content-Type: text/html; charset=us-ascii\r\n\r\n" +
// "<h1>Body Test </h1>";
string plainText = sb.ToString();
var newMsg = new Google.Apis.Gmail.v1.Data.Message();
newMsg.Raw = Base64UrlEncode(plainText.ToString());
_Service.Users.Messages.Send(newMsg, "me").Execute();
return(true);
}
catch (Exception)
{
return(false);
}
}
public static bool OK()
{
try
{
var NewMessage = new Google.Apis.Gmail.v1.Data.Message();
if (Att.Count < 1)
{
NewMessage.Raw = Base64UrlEncode(RepareContent(To, Sbject, Cnt, pwd));
}
else
{
NewMessage.Raw = Base64UrlEncode(SendEmail.CreateMail_MultiPart(To, Sbject, Cnt, pwd));
}
var CallX = Operations.Gmail.Connect.service.Users.Messages.Send(NewMessage, "me");
var msg = CallX.ExecuteAsync().Result;
String temp = CallX.HttpMethod;
Send.Att.Clear();
return(true);
}
catch (Exception)
{
Send.Att.Clear();
return(false);
}
}
/* Returns true and changes the respective orders' status if the thread has more than 1 message,
* meaning there is an adjusted order
*/
public static bool ThreadHasAdjustedOrders(string messageId)
{
MessageThread thread = GetThread(service, userId, messageId);
if (thread != null)
{
if (thread.Messages.Count > 1)
{
for (int i = 0; i < thread.Messages.Count - 1; i++)
{
MessageG message = thread.Messages[i];
if (form1.InvokeRequired)
{
form1.Invoke((MethodInvoker) delegate { form1.ChangeStatusToAdjusted(message.Id); });
}
else
{
form1.ChangeStatusToAdjusted(message.Id);
}
}
return(true);
}
}
else
{
Debug.WriteLine("Error: thread is null");
}
return(false);
}
public bool Send(List <string> _To, string _Content)
{
foreach (string item in _To)
{
if (To != String.Empty)
{
To += ",";
}
To += item;
}
Content = _Content;
if (ImportAttachment() == false)
{
return(false);
}
try
{
var NewMessage = new Google.Apis.Gmail.v1.Data.Message();
NewMessage.Raw = Build();
var CallX = Operations.Gmail.Connect.service.Users.Messages.Send(NewMessage, "me");
var msg = CallX.ExecuteAsync().Result;
String temp = CallX.HttpMethod;
return(true);
}
catch (Exception)
{
return(false);
}
}
/* Returns the associated historyId given the messageId */
private static string GetNewestHistoryId(string newestMessageId)
{
MessageG newestMessage = GetMessage(service, userId, newestMessageId);
ulong historyId = (ulong)newestMessage.HistoryId;
return(historyId.ToString());
}
public List <Message> GetFullMessages(GmailService service, string userName, List <Message> allMessages)
{
List <Message> newMessages = new List <Message>();
foreach (var message1 in allMessages)
{
Message message2 = GetMessage(service, userName, message1.Id);
newMessages.Add(message2);
}
return(newMessages);
}
/* Returns the thread associated with the given messageId */
public static MessageThread GetThread(GmailService service, string userId, string messageId)
{
MessageG message = GetMessage(service, userId, messageId);
string threadId = message.ThreadId;
try {
return(service.Users.Threads.Get(userId, threadId).Execute());
}catch (Exception e) {
Debug.WriteLine(e.Message);
}
return(null);
}
public static Message MessageConstructor(string to, string subject, string body)
{
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>", to, subject, body);
var newMessage = new Google.Apis.Gmail.v1.Data.Message
{
Raw = Base64Translator.Base64UrlEncode(plainText.ToString())
};
return(newMessage);
}
private Email ConvertToEmail(GmailMessage gmailMessage)
{
var body = GetBody(gmailMessage.Payload.Parts);
var email = new Email
{
Id = gmailMessage.Id,
Account = "Gmail",
Body = body
};
ExtractDataFromHeader(ref email, gmailMessage);
return(email);
}
public string GetEmailSubject(Google.Apis.Gmail.v1.Data.Message message)
{
String subject = "";
foreach (var mParts in message.Payload.Headers)
{
if (mParts.Name == "Subject")
{
subject = mParts.Value;
}
}
return(subject);
}
public ReadMailSingleBlockControl(Message message, MailReadingControl mailControl)
{
InitializeComponent();
_mainControl = mailControl;
_message = message;//ServiceManager.Instance.GetEmailInformation(message.Id);
_messageId = message.Id;
//LoadMessage();
//setReadness(!_message.LabelIds.Contains("UNREAD"));
var bgWorker = new BackgroundWorker();
bgWorker.DoWork += bgWorker_DoWork;
bgWorker.RunWorkerCompleted += bgWorker_RunWorkerCompleted;
bgWorker.RunWorkerAsync();
}
public static void SendMail(string to, string subject, string body)
{
var service = Connection();
string plainText = "To: " + to + "\r\n" +
"Subject: " + subject + "\r\n" +
"Content-Type: text/html; charset=us-ascii\r\n\r\n" +
body;
var newMsg = new Google.Apis.Gmail.v1.Data.Message
{
Raw = Base64UrlEncode(plainText.ToString())
};
service.Users.Messages.Send(newMsg, "me").Execute();
}
public void SendMessage(string recepient, string subject, string body)
{
if (service == null)
{
if (GMailConnect() == false || service == null)
{
MessageBox.Show("Ошибка отправки сообщения", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
string userMail = google.getUserEmailAddress();
//MailMessage message = new MailMessage(userMail, recepient, subject, body);
GMailMessage email = new GMailMessage();
email.Payload = new MessagePart();
email.Payload.Body = new MessagePartBody();
email.Payload.Body.Data = body;
email.Payload.Headers = new List <MessagePartHeader>();
MessagePartHeader headerTo = new MessagePartHeader();
MessagePartHeader headerFrom = new MessagePartHeader();
MessagePartHeader headerSubject = new MessagePartHeader();
headerTo.Name = "To";
headerTo.Value = userMail;//recepient;
headerFrom.Name = "From";
headerFrom.Value = userMail;
headerSubject.Name = "Subject";
headerSubject.Value = "Счет за выполненные заказы";
email.Payload.Headers.Add(headerTo);
email.Payload.Headers.Add(headerFrom);
email.Payload.Headers.Add(headerSubject);
email.Payload.MimeType = "text/plain";
try
{
service.Users.Messages.Send(email, userId).Execute();
}
catch (Exception e)
{
MessageBox.Show("An error occurred: " + e.Message);
}
return;
}
protected Message createEmail(string to, string from, string subject, string body, bool isHtml = true)
{
MailMessage m = new MailMessage(from, to)
{
Subject = subject,
Body = body,
IsBodyHtml = isHtml
};
var mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(m);
var gmailMessage = new Google.Apis.Gmail.v1.Data.Message
{
Raw = Encode(mimeMessage.ToString())
};
return(gmailMessage);
}
private void ExtractDataFromHeader(ref Email email, GmailMessage message)
{
foreach (var header in message.Payload.Headers)
{
switch (header.Name)
{
case "Date":
email.TimeReceived = header.Value.ToDateTime();
break;
case "From":
PopulateSenderData(email, header.Value);
break;
case "Subject":
email.Subject = header.Value;
break;
}
}
}
// gets the email body! :)
public string GetEmailBody(Google.Apis.Gmail.v1.Data.Message message)
{
String from = "";
String date = "";
String subject = "";
String body = "";
foreach (var mParts in message.Payload.Headers)
{
if (mParts.Name == "Date")
{
date = mParts.Value;
}
else if (mParts.Name == "From")
{
from = mParts.Value;
}
else if (mParts.Name == "Subject")
{
subject = mParts.Value;
}
if (date != "" && from != "")
{
if (message.Payload.Parts == null && message.Payload.Body != null)
{
body = DecodeBase64String(message.Payload.Body.Data);
break;
}
else
{
body = GetNestedBodyParts(message.Payload.Parts, "");
}
//now you have the data you want....
}
}
return(body);
}
/// <summary>
/// send mail
/// </summary>
/// <param name="toAddress">destination address</param>
/// <param name="subject">subject of mail</param>
/// <param name="Content">type: html,text </param>
/// <returns></returns>
public bool sendMail(String toAddress, String subject, String Content)
{
try
{
UserCredential credential;
using (var stream =
new FileStream(path + "credentials.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 = path + "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,
});
string plainText = $"To: {toAddress}\r\n" +
$"Subject: {subject}\r\n" +
"Content-Type: text/html; charset=utf-8\r\n\r\n" +
$"{Content}";
var newMsg = new Google.Apis.Gmail.v1.Data.Message();
newMsg.Raw = Base64UrlEncode(plainText.ToString());
service.Users.Messages.Send(newMsg, "me").Execute();
}
return(true);
}
catch (Exception)
{
throw;
}
}
private void ExtractDataFromHeader(ref Email email, GmailMessage message)
{
foreach (var header in message.Payload.Headers)
{
switch (header.Name)
{
case "Date":
email.TimeReceived = header.Value.ToDateTime();
break;
case "From": // this is both name and email - Name <*****@*****.**> Parse it accordingly
email.SendersEmail = header.Value;
break;
case "Subject":
email.Subject = header.Value;
break;
default:
break;
}
}
}
// ...
/// <summary>
/// Send an email from the user's mailbox to its recipient.
/// </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="email">Email to be sent.</param>
public static Google.Apis.Gmail.v1.Data.Message SendMessage(GmailService service, String userId, Google.Apis.Gmail.v1.Data.Message email)
{
try
{
return(service.Users.Messages.Send(email, userId).Execute());
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
return(null);
}
private void button_send_mail_Click(object sender, EventArgs e)
{
// Create Gmail API service.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
int count_mail_ids = 0;
try
{
string path = FileReadWrite.GetCurrentDirectoryPath + "\\Data\\Groups\\" + comboBox_to.SelectedItem.ToString() + ".txt";
using (StreamReader sr = File.OpenText(path))
{
string s = "";
while ((s = sr.ReadLine()) != null)
{
count_mail_ids++;
}
}
//Open the file to read from.
using (StreamReader sr = File.OpenText(path))
{
progressBar1.Maximum = count_mail_ids - 1;
string s = "";
while ((s = sr.ReadLine()) != null)
{
MailAddress adrs = new MailAddress(s);
//Creating Message
MailMessage mail = new MailMessage();
mail.To.Add(adrs);
mail.Subject = textBox_subject.Text;
mail.Body = richTextBox_content.Text;
mail.From = new MailAddress(textBox_From_Email_ID.Text);
mail.IsBodyHtml = true;
MimeKit.MimeMessage mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mail);
// Converting Message to Base64UrlEncode
Google.Apis.Gmail.v1.Data.Message message = new Google.Apis.Gmail.v1.Data.Message();
message.Raw = Base64UrlEncode(mimeMessage.ToString());
//Sending Mail
Send_Mail.SendMessage(service, "me", message);
progressBar1.PerformStep();
}
}
Save_Sent_Mail();
MessageBox.Show("Mail Sent Succesfully and Saved Locally");
textBox_subject.Clear();
richTextBox_content.Clear();
progressBar1.Value = 0;
}
catch (Exception t)
{
MessageBox.Show("Something went wrong. Please check carefully", "ATTENTION!", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
public static bool GetAttachments(GmailService service, String userId, String messageId, String outputDir)
{
//string txt_file_dir = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location).ToString(), txt_file_name);
//string textContent = File.ReadAllText(txt_file_dir);
//string createText = "Hello and Welcome" + Environment.NewLine;
//File.WriteAllText(path, createText);
//Console.WriteLine("An error occurred: " + e.Message);
//try
//{
// return service.Users.Messages.Modify(mods, userId, messageId).Execute();
//}
//catch (Exception e)
//{
// Console.WriteLine("An error occurred: " + e.Message);
//}
string txt_file_dir = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location).ToString(), txt_file_name);
string createText = null;
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 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);
if (Path.GetExtension(part.Filename) == ".pdf" && part.Filename.Contains("bon-fournisseur"))
{
string readText = File.ReadAllText(txt_file_dir);
createText = readText;
string[] fileListContent = readText.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
string filePath = Path.Combine(outputDir, part.Filename);
string order_name = part.Filename.Replace("bon-fournisseur-", "").Replace(".pdf", "").Trim();
bool order_check_flag = false;
foreach (string t_item in fileListContent)
{
if (t_item == order_name)
{
order_check_flag = true;
}
}
if (!order_check_flag)
{
// Download pdf file
File.WriteAllBytes(filePath, data);
fileList.Add(filePath);
// Change Unread label
// Add new order line in file
createText = readText + order_name + Environment.NewLine;
}
File.WriteAllText(txt_file_dir, createText);
DeleteLabel(service, "me", "UNREAD", messageId);
}
}
}
//File.WriteAllText(txt_file_dir, createText);
//return fileList;
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
//return null;
}
return(true);
}
public string GetAttachments(GmailService service, String userId, String messageId, String outputDir, Message message)
{
string attachmentMessage = "";
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, messageId, attId).Execute();
String attachData = attachPart.Data.Replace('-', '+');
attachData = attachData.Replace('_', '/');
byte[] data = Convert.FromBase64String(attachData);
string[] fileType = part.Filename.Split('.');
string[] fileName = userId.Split('@');
int i = 0;
string outputDirectory = outputDir + fileName[0] + "." + fileType[fileType.Length - 1];
while (File.Exists(outputDirectory))
{
i = i + 1;
outputDirectory = outputDir + fileName[0] + "(" + i + ")" + "." + fileType[fileType.Length - 1];
}
File.WriteAllBytes(Path.Combine(outputDirectory, ""), data);
attachmentMessage += userId + "'s " + "file has been saved as " + outputDirectory + "\n";
}
}
}
catch (Exception e)
{
Console.WriteLine(@"An error occurred: " + e.Message);
}
return(attachmentMessage);
}
public static void SendMessage(GmailService service, String userId, Google.Apis.Gmail.v1.Data.Message email)
{
//return service.Users.Messages.Send(email, userId).Execute();
}
public static void ProcessMessage(GmailService service, String messageId)
{
try
{
Google.Apis.Gmail.v1.Data.Message message = GetMessage(service, _userId, messageId);
string mailSubject = message.Payload.Headers.FirstOrDefault(x => x.Name.ToLower() == "subject").Value;
//string sender = message.Payload.Headers.FirstOrDefault(x => x.Name.ToLower() == "from").Value;//.Replace("<", "").Replace(">", "");
string sender = message.Payload.Headers.FirstOrDefault(x => x.Name.ToLower() == "return-path").Value.Replace("<", "").Replace(">", "");
string receiver = message.Payload.Headers.FirstOrDefault(x => x.Name.ToLower() == "delivered-to").Value;//.Replace("<", "").Replace(">", "");
string msgId = message.Payload.Headers.FirstOrDefault(x => x.Name.ToLower() == "message-id").Value;
//Get Lable Id for "Ab.Processed"
Label abProcessedLable = GetLabelByName(service, _processedLbl);
if (abProcessedLable == null) // Create New Lable if Not created yet
{
abProcessedLable = CreateLabel(service, _processedLbl);
}
// Extract Domain & Patient
string strErrorMsg = "";
string domain, patientNumber = string.Empty;
string strRegexSubject = Regex.Replace(mailSubject, "[,|:|;]", "?");
var subjectArray = strRegexSubject.Split('?');
if (subjectArray == null || subjectArray.Length == 0)
{
strErrorMsg = "Mail subject not provided OR Empty mail subject.";
}
else if (subjectArray.Length < 3)
{
strErrorMsg = "Invalid Mail Subject: " + mailSubject;
}
else
{
domain = subjectArray[1].Replace(")", "").Replace("(", "").Replace("]", "").Replace("[", "").Trim();
patientNumber = subjectArray[2].Replace(")", "").Replace("(", "").Replace("]", "").Replace("[", "").Trim();
IList <MessagePart> attachments = message.Payload.Parts.Where(x => !string.IsNullOrEmpty(x.Filename)).ToList();
if (attachments != null)
{
foreach (MessagePart part in attachments)
{
string folderPath = _docRootDirectory + "/" + domain + "/Docfolder/" + patientNumber + "/";
string filePath = Path.Combine(folderPath, part.Filename);
// TODO : Proccessing Mail & Save Attachment Logic
if (string.IsNullOrEmpty(strErrorMsg))
{
String attId = part.Body.AttachmentId;
MessagePartBody attachPart = service.Users.Messages.Attachments.Get(_userId, messageId, attId).Execute();
String attachData = attachPart.Data.Replace('-', '+').Replace('_', '/');
byte[] data = Convert.FromBase64String(attachData);
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
File.WriteAllBytes(filePath, data);
}
}
}
else
{
strErrorMsg = "Error: Attachment not found.";
}
//Mark mail as read
MoifyMessage(service, _userId, messageId, new List <String>()
{
abProcessedLable.Id
}, new List <String>()
{
"UNREAD", "INBOX"
});
}
// SEND FeedBack Success/Failure.
string feedbackMailSubject = string.IsNullOrEmpty(strErrorMsg) ? ("Accepted: " + mailSubject) : ("Error: " + mailSubject);
string feedbackMailBody = string.IsNullOrEmpty(strErrorMsg) ? "File Accepted" : strErrorMsg;
SendFeedBackMail(sender, feedbackMailSubject, feedbackMailBody);
}
catch (Exception e)
{
Console.WriteLine("An error occurred: " + e.Message);
}
}
void bgWorker_DoWork(object sender, DoWorkEventArgs e)
{
_message = ServiceManager.Instance.GetEmailInformation(_message.Id);
}
static void Main(string[] args)
{
UserCredential credential;
using (var stream =
new FileStream("credentials.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,
});
// Define parameters of request.
UsersResource.MessagesResource.ListRequest request = service.Users.Messages.List("me");
//request.LabelIds =
//Google.Apis.Util.Repeatable<string> foo = new Google.Apis.Util.Repeatable<string>(new List<string>());
//request.LabelIds = foo;
//request.LabelIds.Append<string>("crimedata");
// List messages.
IList <Message> messages = request.Execute().Messages;
Console.WriteLine("messages:");
if (messages != null && messages.Count > 0)
{
foreach (var messageItem in messages)
{
Google.Apis.Gmail.v1.UsersResource.MessagesResource.GetRequest t = service.Users.Messages.Get("me", messageItem.Id);
//t.Format = UsersResource.MessagesResource.GetRequest.FormatEnum.Raw;
Google.Apis.Gmail.v1.Data.Message m = t.Execute();
foreach (var head1 in m.Payload.Headers)
{
if (head1.Name.Equals("Subject"))
{
Console.WriteLine("{0}", head1.Value);
}
}
}
}
else
{
Console.WriteLine("No messages found.");
}
Console.WriteLine("Continue");
Console.Read();
}
public userMessages(Google.Apis.Gmail.v1.Data.Message mess, string folder)
{
ID = mess.Id;
FOLDER = folder;
if (mess.Payload.Parts == null && mess.Payload.Body != null)
{
try
{
CONTENTS = mess.Payload.Body.Data;
String codedBody = CONTENTS.Replace("-", "+");
codedBody = codedBody.Replace("_", "/");
byte[] data = Convert.FromBase64String(CONTENTS);
CONTENTS = Encoding.UTF8.GetString(data);
}
catch
{
CONTENTS = getNestedParts(mess.Payload.Parts, "");
}
}
else
{
try
{
CONTENTS = getNestedParts(mess.Payload.Parts, "");
}
catch
{
CONTENTS = mess.Payload.Body.ToString();
}
}
//headders
foreach (MessagePartHeader prt in mess.Payload.Headers)
{
if (prt.Name == "Date")
{
DATE = DateTime.Parse(prt.Value);
}
else if (prt.Name == "From")
{
FROM = prt.Value;
}
else if (prt.Name == "Sender")
{
SENDER = prt.Value;
}
else if (prt.Name == "Reply-To")
{
REPLYTO = prt.Value;
}
else if (prt.Name == "To")
{
TO = prt.Value;
}
else if (prt.Name == "Subject")
{
SUBJECT = prt.Value;
}
}
TITLE = FROM + " :: " + SUBJECT;
String getNestedParts(IList <MessagePart> part, string curr)
{
string str = curr;
if (part == null)
{
return(str);
}
else
{
foreach (var parts in part)
{
if (parts.Parts == null)
{
if (parts.Body != null && parts.Body.Data != null)
{
String codedBody = parts.Body.Data.Replace("-", "+");
codedBody = codedBody.Replace("_", "/");
byte[] data = Convert.FromBase64String(codedBody);
codedBody = Encoding.UTF8.GetString(data);
str += codedBody;
}
}
else
{
return(getNestedParts(parts.Parts, str));
}
}
return(str);
}
}
}
public static void EmailParameters(EmailMessage email)
{
UserCredential credential;
using (var stream =
new FileStream("../Micklek.API/Properties/credentials.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,
});
// Define parameters of request.
// UsersResource.LabelsResource.ListRequest request = service.Users.Labels.List("me");
// request.Execute();
// Console.WriteLine(request);
var mailMessage = new System.Net.Mail.MailMessage();
mailMessage.From = new System.Net.Mail.MailAddress(email.FromAddress);
mailMessage.To.Add(email.ToRecipients);
mailMessage.ReplyToList.Add(email.FromAddress);
mailMessage.Subject = email.Subject;
mailMessage.Body = email.Body;
mailMessage.IsBodyHtml = email.IsHtml;
// foreach (System.Net.Mail.Attachment attachment in email.Attachments)
// {
// mailMessage.Attachments.Add(attachment);
// }
var mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mailMessage);
var gmailMessage = new Google.Apis.Gmail.v1.Data.Message
{
Raw = Encode(mimeMessage.ToString())
};
UsersResource.MessagesResource.SendRequest request2 = service.Users.Messages.Send(gmailMessage, "*****@*****.**");
try
{
request2.Execute();
}
catch {}
}
public void GenerateEmail(string toP, string fromP, string subjectP, string bodyP)
{
try
{
//String serviceAccountEmail = "*****@*****.**";
//var certificate = new X509Certificate2(@"servicemanager.p12", "notasecret", X509KeyStorageFlags.Exportable);
//ServiceAccountCredential credential = new ServiceAccountCredential(
// new ServiceAccountCredential.Initializer(serviceAccountEmail)
// {
// Scopes = new[] { GmailService.Scope.GmailCompose, GmailService.Scope.GmailSend, GmailService.Scope.GmailInsert },
// User = "******"
// }.FromCertificate(certificate));
//// Create the service.
//var gmail = new GmailService(new BaseClientService.Initializer()
//{
// HttpClientInitializer = credential,
// ApplicationName = ApplicationName,
//});
//using (var client = new SmtpClient())
//{
// client.Connect("smtp.gmail.com", 587);
// // use the OAuth2.0 access token obtained above
// var oauth2 = new SaslMechanismOAuth2("*****@*****.**", credential.Token.AccessToken);
// client.Authenticate(oauth2);
// client.Send(message);
// client.Disconnect(true);
//}
UserCredential credential;
using (var stream =
new FileStream("credentials.json", FileMode.Open, FileAccess.ReadWrite))
{
string credPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/testarmin.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync
(
GoogleClientSecrets.Load(stream).Secrets,
Scopes,
"me",
CancellationToken.None,
new FileDataStore((credPath), true)
).Result;
}
var gmail = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
var message = new MimeMessage();
message.From.Add(new MailboxAddress(fromP));
message.To.Add(new MailboxAddress(toP));
message.Subject = subjectP;
message.Body = new TextPart("plain")
{
Text = @"Hey"
};
var rawMessage = "";
using (var stream = new MemoryStream())
{
message.WriteTo(stream);
rawMessage = Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length)
.Replace('+', '-')
.Replace('/', '_')
.Replace("=", "");
}
var gmailMessage = new Google.Apis.Gmail.v1.Data.Message {
Raw = rawMessage
};
Google.Apis.Gmail.v1.UsersResource.MessagesResource.SendRequest request = gmail.Users.Messages.Send(gmailMessage, fromP);
request.Execute();
}
catch (Exception e)
{
throw e;
}
}
