public static void LoadItemsAttachmentsListLv(Item oItem, ref ListView oListView)
{
oListView.Clear();
oListView.View = View.Details;
oListView.GridLines = true;
oListView.FullRowSelect = true;
oListView.Columns.Add("Id", 70, HorizontalAlignment.Left);
oListView.Columns.Add("ContentId", 70, HorizontalAlignment.Left);
oListView.Columns.Add("ContentLocation", 70, HorizontalAlignment.Left);
oListView.Columns.Add("ContentType", 70, HorizontalAlignment.Left);
oListView.Columns.Add("Name", 140, HorizontalAlignment.Left);
oListView.Columns.Add("IsInline", 50, HorizontalAlignment.Left); // Exchange 2010 and later.
//oListView.Columns.Add("LastModifiedTime", 70, HorizontalAlignment.Left); // Exchange 2010 and later.
//oListView.Columns.Add("Size", 70, HorizontalAlignment.Right); // Exchange 2010 and later.
ListViewItem oListItem = null;
int iAttachmentCount = 0;
foreach (Attachment oAttachment in oItem.Attachments)
{
oItem.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID
oAttachment.Load();
if (oAttachment is ItemAttachment)
{
ItemAttachment oItemAttachment = oAttachment as ItemAttachment;
// Load attachment into memory so we can get to the item properties (such as subject).
oItem.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID
oItemAttachment.Load();
oListItem = new ListViewItem(oAttachment.Id, 0);
oListItem.SubItems.Add(oItemAttachment.ContentId);
oListItem.SubItems.Add(oItemAttachment.ContentLocation);
oListItem.SubItems.Add(oItemAttachment.ContentType);
oListItem.SubItems.Add(oItemAttachment.Name);
oListItem.SubItems.Add(oItemAttachment.IsInline.ToString());
oListItem.Tag = iAttachmentCount;
oListView.Items.AddRange(new ListViewItem[] { oListItem });
oListItem = null;
}
if (oAttachment is FileAttachment)
{
}
}
iAttachmentCount++;
}
public EWSIncomingItemAttachment(ItemAttachment attachment)
{
_attachment = attachment;
Logger.DebugFormat("Loading attachment");
var additionalProperties = new PropertySet {
ItemSchema.MimeContent
};
_attachment.Load(additionalProperties);
Logger.DebugFormat("Attachment name is {0}", _attachment.Name);
}
/// <summary>
/// Demonstrates three ways to get file attachments and how to get an item attachment.
/// </summary>
/// <param name="service">An ExchangeService object with credentials and the EWS URL.</param>
private static void GetAttachments(ExchangeService service)
{
// Return a single item.
ItemView view = new ItemView(1);
string querystring = "HasAttachments:true Subject:'Message with Attachments' Kind:email";
// Find the first email message in the Inbox that has attachments. This results in a FindItem operation call to EWS.
FindItemsResults <Item> results = service.FindItems(WellKnownFolderName.Inbox, querystring, view);
if (results.TotalCount > 0)
{
EmailMessage email = results.Items[0] as EmailMessage;
// Request all the attachments on the email message. This results in a GetItem operation call to EWS.
email.Load(new PropertySet(EmailMessageSchema.Attachments));
foreach (Attachment attachment in email.Attachments)
{
if (attachment is FileAttachment)
{
FileAttachment fileAttachment = attachment as FileAttachment;
// Load the file attachment into memory. This gives you access to the attachment content, which
// is a byte array that you can use to attach this file to another item. This results in a GetAttachment operation
// call to EWS.
fileAttachment.Load();
Console.WriteLine("Load a file attachment with a name = " + fileAttachment.Name);
// Load attachment contents into a file. This results in a GetAttachment operation call to EWS.
fileAttachment.Load("C:\\temp\\" + fileAttachment.Name);
// Put attachment contents into a stream.
using (FileStream theStream = new FileStream("C:\\temp\\Stream_" + fileAttachment.Name, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
//This results in a GetAttachment operation call to EWS.
fileAttachment.Load(theStream);
}
}
else // Attachment is an item attachment.
{
ItemAttachment itemAttachment = attachment as ItemAttachment;
// Load the item attachment properties. This results in a GetAttachment operation call to EWS.
itemAttachment.Load();
Console.WriteLine("Loaded an item attachment with Subject = " + itemAttachment.Item.Subject);
}
}
}
}
//gavdcodeend 16
//gavdcodebegin 17
static void GetAttachments(ExchangeService ExService)
{
SearchFilter myFilter = new SearchFilter.SearchFilterCollection(
LogicalOperator.And,
new SearchFilter.IsEqualTo(
EmailMessageSchema.Subject,
"Email with Attachments"));
ItemView myView = new ItemView(1);
FindItemsResults <Item> findResults = ExService.FindItems(
WellKnownFolderName.Inbox, myFilter, myView);
ItemId myEmailId = null;
foreach (Item oneItem in findResults)
{
myEmailId = oneItem.Id;
}
PropertySet myPropSet = new PropertySet(BasePropertySet.IdOnly,
ItemSchema.Attachments);
EmailMessage emailWithAttachments =
EmailMessage.Bind(ExService, myEmailId, myPropSet);
foreach (Attachment oneAttachment in emailWithAttachments.Attachments)
{
if (oneAttachment is FileAttachment) // Attachment is a File
{
FileAttachment myAttachment = oneAttachment as FileAttachment;
FileStream attStream = new FileStream(@"C:\Temporary\Attch_" +
myAttachment.Name, FileMode.OpenOrCreate, FileAccess.ReadWrite);
myAttachment.Load(attStream);
attStream.Close();
attStream.Dispose();
}
else // Attachment is an Item
{
ItemAttachment itemAttachment = oneAttachment as ItemAttachment;
itemAttachment.Load();
Console.WriteLine("Subject: " + itemAttachment.Item.Subject);
}
}
}
public EmailAttachDTO(object attach, bool loadContent = true)
{
byte[] content = null;
if (attach.GetType() == typeof(FileAttachment))
{
FileAttachment fAttach = (FileAttachment)attach;
if (loadContent)
{
if (fAttach.Content is null)
{
fAttach.Load();
}
content = fAttach.Content;
}
cargar_datos(fAttach.Id, fAttach.Name, fAttach.ContentType, fAttach.Size, content, fAttach.IsInline);
}
else if (attach.GetType() == typeof(ItemAttachment))
{
ItemAttachment iAttach = (ItemAttachment)attach;
if (loadContent)
{
iAttach.Load(ItemSchema.MimeContent);
if (iAttach.Item is object && iAttach.Item.GetType() == typeof(EmailMessage))
{
EmailMessage mAttach = (EmailMessage)iAttach.Item;
if (loadContent)
{
content = mAttach.MimeContent.Content;
}
cargar_datos(iAttach.Id, iAttach.Name + ".eml", iAttach.ContentType, iAttach.Size, content, iAttach.IsInline);
}
else
{
cargar_datos(iAttach.Id, iAttach.Name, iAttach.ContentType, iAttach.Size, null, iAttach.IsInline);
}
}
else
{
cargar_datos(iAttach.Id, iAttach.Name, iAttach.ContentType, iAttach.Size, null, iAttach.IsInline);
}
}
}
public static void downloadWithUniqueName(this Microsoft.Exchange.WebServices.Data.Attachment att, ref string path, int mtaNum)
{
try
{
Directory.CreateDirectory(path);
path += ("\\" + EvaultWin.Common.evWinHash.MD5Hasing.GetMD5HashFromText(mtaNum.ToString() + EvaultWin.Common.evWinRandom.winRandomNumber.GetRandomName(DateTime.Now.ToString())) + Path.GetExtension(att.Name));
if (att is FileAttachment)
{
FileAttachment fa = att as FileAttachment;
fa.Load(path);
}
else
{
ItemAttachment itemAtt = att as ItemAttachment;
itemAtt.Load(new PropertySet(EmailMessageSchema.MimeContent));
MessageBox.Show("is item Att with path : " + path);
//path += ".eml";
byte[] mc = itemAtt.Item.MimeContent.Content;
using (FileStream fs = File.Open(path, FileMode.Create, FileAccess.Write))
{
fs.Write(mc, 0, mc.Length);
}
}
}
catch (Exception err)
{
path = string.Empty;
WinEventLog.WriteEventLog("MTA failed to download attachment for scanning, error = " + err.Message, EventLogEntryType.FailureAudit);
EvaultWin.DLP.evWinExceptionHandlingCMC.ExceptionHandling.DetailEventLog(true, false,
EvaultWin.DLP.evWinExceptionHandlingCMC.EventExceptionType.UnexpectedResult, EvaultWin.DLP.evWinExceptionHandlingCMC.EventSeverityLevel.Error,
err.Message, err.Source.ToString() + " : " + err.TargetSite.ToString(), err.ToString().Replace("\r", "").ToString());
//MessageBox.Show("Failed to download attachment, err : " + err.Message);
}
}
private void ProcesarAdjuntos(Item item)
{
if (item.HasAttachments)//solo si tenemos adjuntos
//obtenemos cada uno de los adjuntos contenidos en la collection Attachments
{
foreach (Attachment adjunto in item.Attachments)
{
if (adjunto is FileAttachment)// si es un archivo adjunto
{
FileAttachment archivoAdjunto = adjunto as FileAttachment;
// Load the attachment into a file.
// This call results in a GetAttachment call to EWS.
archivoAdjunto.Load("C:\\temp\\" + archivoAdjunto.Name);
Console.WriteLine("nombre del archivo adjunto: " + archivoAdjunto.Name);
}
else // si es un item adjunto
{
ItemAttachment itemAdjunto = adjunto as ItemAttachment;
//cargamos el adjunto en memoria.
//esta llamada resulta en una llamada GetAttachment a EWS
itemAdjunto.Load();
Console.WriteLine("nombre del item adjunto: " + itemAdjunto.Name);
}
FolderId folderID = getFolderID("procesados");
if (folderID != null) //si encontramos la carpeta la
{
item.Move(folderID); //movemos el item.
Console.WriteLine("Item Movido.");
}
}
}
}
private void MnuSaveAttach_Click(object sender, EventArgs e)
{
// Don't do anything if a content row is not selected
if (this.ContentsGrid.SelectedRows.Count == 0)
{
return;
}
Attachment attach = this.ContentsGrid.SelectedRows[0].Cells[ColNameAttachmentObj].Value as Attachment;
// If we can't get the attachment object bail out
if (attach == null)
{
return;
}
// Get the file name we'll save to and bail out if we don't succeed
// Create a file path to save the item properties to
string fileName = null;
//fileName = string.Format(
//System.Globalization.CultureInfo.CurrentCulture,
// "{0}\\{1}.xml",
// destinationFolderPath,
// FileHelper.SanitizeFileName(item.Subject));
fileName = this.GetTargetFileName(fileName);
if (fileName == string.Empty)
{
return;
}
this.Cursor = Cursors.WaitCursor;
System.Diagnostics.Debug.WriteLine("ItemClass of Mesage: " + currentParentItem.ItemClass);
// If the attachment is a FileAttachment then simply save the content
FileAttachment fileAttach = attach as FileAttachment;
if (fileAttach != null)
{
if (fileAttach.Content == null)
{
ErrorDialog.ShowWarning("Cannot save FileAttachment because FileAttachment.Content is NULL.");
return;
}
try
{
this.Cursor = Cursors.WaitCursor;
System.IO.File.WriteAllBytes(fileName, fileAttach.Content);
}
finally
{
this.Cursor = Cursors.Default;
}
}
else
{
ItemAttachment itemAttachment = attach as ItemAttachment;
if (itemAttachment != null)
{
if (itemAttachment.Item == null)
{
ErrorDialog.ShowWarning("Cannot save ItemAttachment because ItemAttachment.Item is NULL.");
return;
}
try
{
this.Cursor = Cursors.WaitCursor;
//if (currentParentItem.ItemClass == "")
//{
//}
// Note that not everything has a MIME type. An NDR does not have one, so MIME conversion will fail.
// Save an attached email by using the EWS Managed API
// https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-get-attachments-by-using-ews-in-exchange
string sMIME = string.Empty;
//System.Diagnostics.Debug.WriteLine("ItemClass of Mesage: " + currentParentItem.ItemClass);
try
{
itemAttachment.Load(ItemSchema.MimeContent);
//UTF8Encoding oUTF8Encoding = new UTF8Encoding(); // For debugging
//sMIME = oUTF8Encoding.GetString(itemAttachment.Item.MimeContent.Content); // For debugging
System.IO.File.WriteAllBytes(fileName, itemAttachment.Item.MimeContent.Content);
}
catch (Exception ex)
{
}
//string sFolderPath = System.IO.Path.GetPathRoot(fileName);
//string sFilePath = System.IO.Path.GetFileName(fileName);
//EWSEditor.Common.DumpHelper.DumpXMLbyFileName(
// itemAttachment.Item,
// sFolderPath,
// sFilePath);
}
finally
{
this.Cursor = Cursors.Default;
}
this.Cursor = Cursors.WaitCursor;
// An Item Attachment may have attachemnets also - so, save them off also. Things like NDR messages contain the origional message.
try
{
this.Cursor = Cursors.WaitCursor;
// Save an attached email by using the EWS Managed API
// https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-get-attachments-by-using-ews-in-exchange
// Code to save message attachment sub-items. This will work for journaled messages.
int iSub1AttachCount = 0;
if (itemAttachment.Item.Attachments.Count > 0)
{
foreach (Attachment Sub1Attachment in itemAttachment.Item.Attachments)
{
ItemAttachment Sub1ItemAttachment = Sub1Attachment as ItemAttachment;
if (Sub1ItemAttachment != null)
{
iSub1AttachCount++;
try
{
Sub1ItemAttachment.Load(ItemSchema.MimeContent); // if MIME can be pulled then save it. not all types have a MIME equivilent.
System.IO.File.WriteAllBytes(fileName + " - " + iSub1AttachCount.ToString(), Sub1ItemAttachment.Item.MimeContent.Content);
}
finally
{
}
}
}
//int iSub2AttachCount = 0;
//foreach (ItemAttachment o in itemAttachment.Item.Attachments)
//{
// ItemAttachment itemSubAttachment = o as ItemAttachment;
// if (itemAttachment != null)
// {
// iSub2AttachCount++;
// try
// {
// //o.Load(ItemSchema.MimeContent); // if MIME can be pulled then save it. not all types have a MIME equivilent.
// //System.IO.File.WriteAllBytes(fileName + " - ItemAttachment " + iSubAttachCount.ToString(), itemAttachment.Item.MimeContent.Content);
// //int iSub2AttachCount = 0;
// //foreach (ItemAttachment o2 in o.Item.Attachments)
// //{
// // ItemAttachment itemSub2Attachment = o2 as ItemAttachment;
// // if (itemAttachment != null)
// // {
// // iSub2AttachCount++;
// // try
// // {
// // itemAttachment.Load(ItemSchema.MimeContent); // if MIME can be pulled then save it. not all types have a MIME equivilent.
// // System.IO.File.WriteAllBytes(fileName + " - ItemAttachment " + iSub2AttachCount.ToString(), itemAttachment.Item.MimeContent.Content);
// // }
// // finally
// // {
// // }
// // }
// //}
// }
// finally
// {
// }
// }
//}
}
this.Cursor = Cursors.Default;
string sFolderPath = System.IO.Path.GetPathRoot(fileName);
string sFilePath = System.IO.Path.GetFileName(fileName);
//EWSEditor.Common.DumpHelper.DumpXMLbyFileName(
// itemAttachment.Item,
// sFolderPath,
// sFilePath);
}
finally
{
this.Cursor = Cursors.Default;
}
}
}
}
} // End Sub SendMailWithAttachment
public static void FindUnreadEmail(ExchangeService service)
{
try
{
Folder inbox = Folder.Bind(service, WellKnownFolderName.Inbox);
}
catch (System.Exception e)
{
System.Console.WriteLine(e);
}
// The search filter to get unread email.
SearchFilter sf = new SearchFilter.SearchFilterCollection(LogicalOperator.And
, new SearchFilter.IsEqualTo(EmailMessageSchema.IsRead, false));
ItemView view = new ItemView(1);
// https://stackoverflow.com/questions/20662855/fetching-all-mails-in-inbox-from-exchange-web-services-managed-api-and-storing-t
FindItemsResults <Item> findResults = null;
do
{
// Fire the query for the unread items.
// This method call results in a FindItem call to EWS.
findResults = service.FindItems(WellKnownFolderName.Inbox, sf, view);
System.Console.WriteLine(findResults.TotalCount);
foreach (Item item in findResults)
{
if (item is EmailMessage)
{
EmailMessage em = item as EmailMessage;
System.Console.WriteLine("Subject: \"{0}\"", em.Subject);
// https://msdn.microsoft.com/en-us/library/office/dn726695(v=exchg.150).aspx
if (em.HasAttachments)
{
EmailMessage message = EmailMessage.Bind(service, item.Id
, new PropertySet(BasePropertySet.IdOnly, ItemSchema.Attachments));
foreach (Attachment attachment in message.Attachments)
{
System.Console.WriteLine(attachment.Name);
if (attachment is FileAttachment)
{
FileAttachment fa = attachment as FileAttachment;
fa.Load();
// System.Console.WriteLine(fa.Content);
// System.IO.File.WriteAllBytes(@"d:\" + attachment.Name, fa.Content);
// System.Console.WriteLine(fa.ContentType);
// System.Console.WriteLine(fa.Content.Length);
} // End if (attachment is FileAttachment)
else if (attachment is ItemAttachment)
{
ItemAttachment itemAttachment = attachment as ItemAttachment;
itemAttachment.Load(ItemSchema.MimeContent);
string fileName = @"C:\Temp\" + itemAttachment.Item.Subject + @".eml";
// Write the bytes of the attachment into a file.
// System.IO.File.WriteAllBytes(fileName, itemAttachment.Item.MimeContent.Content);
System.Console.WriteLine("Email attachment name: " + itemAttachment.Item.Subject + ".eml");
} // End else if (attachment is ItemAttachment)
} // Next attachment
} // End if (em.HasAttachments)
} // End if (item is EmailMessage)
else if (item is MeetingRequest)
{
MeetingRequest mr = item as MeetingRequest;
System.Console.WriteLine("Subject: \"{0}\"", mr.Subject);
}
else
{
// we can handle other item types
}
} // Next item
//any more batches?
if (findResults.NextPageOffset.HasValue)
{
view.Offset = findResults.NextPageOffset.Value;
} // End if (findResults.NextPageOffset.HasValue)
} while (findResults.MoreAvailable);
} // End Sub FindUnreadEmail
public string DownloadAttachments(EmailMessage message, string AttachmentSavePath, string[] EmailAttachment, string RetainOriginalAttName, string emailAttachmentLocation, int emailID = 0)
{
try
{
string emailAttachments = "";
int fileID = 0;
foreach (Attachment attachment in message.Attachments)
{
if (attachment.IsInline == false)
{
string emailAttachmentSaveLocation = "";
if ((EmailAttachment.Any(attachment.Name.Contains) == false) && EmailAttachment[0] != "")
{
continue;
}
string extension = "";
string filename = "";
if (attachment is ItemAttachment)
{
ItemAttachment fileAttachment = attachment as ItemAttachment;
extension = ".eml";
filename = fileAttachment.Name.ToString();
Regex rgx = new Regex("[^a-zA-Z0-9 ]");
filename = rgx.Replace(filename, "");
filename = filename + extension;
}
else
{
FileAttachment fileAttachment = attachment as FileAttachment;
filename = fileAttachment.Name.ToString();
extension = Path.GetExtension(filename);
}
if (RetainOriginalAttName == "true")
{
if (emailID == 0)
{
emailAttachmentLocation = AttachmentSavePath + filename;
}
else
{
emailAttachmentLocation = AttachmentSavePath + emailID + @"\" + filename;
}
if (emailAttachments == "")
{
emailAttachments = filename;
}
else
{
emailAttachments = emailAttachments + "|" + filename;
}
}
else
{
fileID++;
if (emailID == 0)
{
emailAttachmentLocation = AttachmentSavePath + fileID + extension;
}
else
{
emailAttachmentLocation = AttachmentSavePath + emailID + @"\" + fileID + extension;
}
if (emailAttachments == "")
{
emailAttachments = fileID + extension;
}
else
{
emailAttachments = emailAttachments + "|" + fileID + extension;
}
}
emailAttachmentSaveLocation = emailAttachmentLocation;
if (attachment is ItemAttachment)
{
ItemAttachment fileAttachment = attachment as ItemAttachment;
fileAttachment.Load(EmailMessageSchema.MimeContent);
// MimeContent.Content will give you the byte[] for the ItemAttachment
// Now all you have to do is write the byte[] to a file
File.WriteAllBytes(emailAttachmentLocation, fileAttachment.Item.MimeContent.Content);
}
else
{
FileAttachment fileAttachment = attachment as FileAttachment;
fileAttachment.Load(emailAttachmentLocation);
}
}
}
return(emailAttachments);
}
catch (Exception e)
{
throw;
}
}
static void Main(string[] args)
{
var service = new ExchangeService();
service.Credentials = new NetworkCredential("*****@*****.**", "Kittyapu*5");
try
{
service.Url = new Uri("https://outlook.office365.com/EWS/Exchange.asmx");
}
catch (AutodiscoverRemoteException ex)
{
Console.WriteLine(ex.Message);
}
FolderId inboxId = new FolderId(WellKnownFolderName.Inbox, "*****@*****.**");
var findResults = service.FindItems(inboxId, new ItemView(150));
try
{
foreach (var message in findResults.Items)
{
var msg = EmailMessage.Bind(service, message.Id, new PropertySet(BasePropertySet.IdOnly, ItemSchema.Attachments));
foreach (Microsoft.Exchange.WebServices.Data.Attachment attachment in msg.Attachments)
{
if (attachment is FileAttachment)
{
FileAttachment fileAttachment = attachment as FileAttachment;
// Load the file attachment into memory and print out its file name.
fileAttachment.Load();
var filename = fileAttachment.Name;
bool b;
b = filename.Contains(".xlsx");
if (b == true)
{
bool a;
bool k;
a = filename.Contains("Fields");
k = filename.Contains("MaterialID");
if (a == true || k == true)
{
var theStream = new FileStream("C:\\data\\kittu1\\" + fileAttachment.Name, FileMode.OpenOrCreate, FileAccess.ReadWrite);
fileAttachment.Load(theStream);
theStream.Close();
theStream.Dispose();
}
}
}
else // Attachment is an item attachment.
{
// Load attachment into memory and write out the subject.
ItemAttachment itemAttachment = attachment as ItemAttachment;
itemAttachment.Load();
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Error Occured" + e.Message);
}
Console.WriteLine("Success");
Console.ReadLine();
}
public void getEmailsAndSave(string uri, string username, string password, List <string> exchangeMailList, string savePath)
{
//Uri V = new Uri("https://outlook.office365.com/EWS/Exchange.asmx");
ExchangeService exchange = new ExchangeService(ExchangeVersion.Exchange2007_SP1);
Uri V = new Uri(uri);
exchange.Url = V;
exchange.Credentials = new WebCredentials(username, password);
bool hit = false;
int i = 0;
if (exchange != null)
{
Console.WriteLine("Connected to mailbox\n");
FindItemsResults <Item> result = exchange.FindItems(WellKnownFolderName.Inbox, new ItemView(100));
Console.WriteLine("Looping through emails");
foreach (Item item in result)
{
EmailMessage message = EmailMessage.Bind(exchange, item.Id);
try
{
if (exchangeMailList.Contains(message.Sender.Address.ToString()) && message.IsRead == false)
{
Console.WriteLine("hit!");
i++;
Directory.CreateDirectory(savePath + "\\" + i);
File.WriteAllText(savePath + "\\" + i + @"\Subject.txt", message.Subject.ToString());
File.WriteAllText(savePath + "\\" + i + @"\Body.txt", message.Body.Text.ToString());
File.WriteAllText(savePath + "\\" + i + @"\Id.txt", message.Id.ToString());
foreach (Attachment attachment in message.Attachments)
{
if (attachment is FileAttachment)
{
FileAttachment fileAttachment = attachment as FileAttachment;
// Load the attachment into a file.
// This call results in a GetAttachment call to EWS.
fileAttachment.Load(savePath + "\\" + i + "\\" + fileAttachment.Name);
Console.WriteLine("File attachment name: " + fileAttachment.Name);
}
else // Attachment is an item attachment.
{
ItemAttachment itemAttachment = attachment as ItemAttachment;
// Load attachment into memory and write out the subject.
// This does not save the file like it does with a file attachment.
// This call results in a GetAttachment call to EWS.
itemAttachment.Load();
Console.WriteLine("Item attachment name: " + itemAttachment.Name);
}
}
mailHit = true;
}
}
catch (System.NullReferenceException)
{
Console.WriteLine("This message does not containt a subject");
}
}
}
}
public static void GetMails()
{
try
{
//TimeSpan ts = new TimeSpan(0, -1, 0, 0);
TimeSpan ts = new TimeSpan(0, 0, -5, 0);
DateTime date = DateTime.Now.Add(ts);
//ExchangeService exchange = new ExchangeService(ExchangeVersion.Exchange2010);
ExchangeService exchange = new ExchangeService(ExchangeVersion.Exchange2013_SP1);
//exchange.Credentials = new WebCredentials("Domain\\Username", @"Password");
exchange.Credentials = new WebCredentials("Domain\\myusername", @"mypassword");
//Uri - https://mail.comanyname.com/EWS/Exchange.asmx
exchange.Url = new Uri("https://mail.uhc.com/EWS/Exchange.asmx");
exchange.TraceEnabled = true;
exchange.TraceFlags = TraceFlags.All;
exchange.AutodiscoverUrl("*****@*****.**", RedirectionCallback);
SearchFilter.IsGreaterThanOrEqualTo filter = new SearchFilter.IsGreaterThanOrEqualTo(ItemSchema.DateTimeReceived, date);
Service1.Log("calling service");
FindItemsResults <Item> findResults = exchange.FindItems(WellKnownFolderName.Inbox, filter, new ItemView(50));
bool RedirectionCallback(string url)
{
return(url.ToLower().StartsWith("https://"));
}
foreach (Item item in findResults.Items)
{
GetAttachmentsFromEmail(exchange, item.Id, item.Subject);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadLine();
Service1.Log(ex.Message);
}
void GetAttachmentsFromEmail(ExchangeService service, ItemId itemId, String subject)
{
// Bind to an existing message item and retrieve the attachments collection.
// This method results in an GetItem call to EWS.
EmailMessage message = EmailMessage.Bind(service, itemId, new PropertySet(ItemSchema.Attachments));
// Iterate through the attachments collection and load each attachment.
Service1.Log("Downloading attachments");
foreach (Attachment attachment in message.Attachments)
{
if (attachment is FileAttachment)
{
FileAttachment fileAttachment = attachment as FileAttachment;
// fileAttachment.Load("Put mails attachments" + fileAttachment.Name);
fileAttachment.Load("C:\\MailAttachments\\" + fileAttachment.Name);
//System.IO.FileInfo fi = new System.IO.FileInfo("C:\\Mails\\" + fileAttachment.Name);
//if (fi.Exists)
//{
// // Move file with a new name. Hence renamed.
// fi.MoveTo(@"C:\\Mails\\" + subject);
// Console.WriteLine("File Renamed.");
//}
Console.WriteLine("File attachment name: " + fileAttachment.Name);
}
else // Attachment is an item attachment.
{
ItemAttachment itemAttachment = attachment as ItemAttachment;
// Load attachment into memory and write out the subject.
// This does not save the file like it does with a file attachment.
// This call results in a GetAttachment call to EWS.
itemAttachment.Load();
Console.WriteLine("Item attachment name: " + itemAttachment.Name);
Service1.Log("Item attachment name: " + itemAttachment.Name);
}
}
}
}
