[Test]//, Ignore( "Investigating problems on OMNIAMEA-UNIT")]
public void Test()
{
FolderDescriptor folderDescriptor = FolderEnum.SearchFolder("Format");
Assert.IsNotNull(folderDescriptor);
IEFolder folder =
OutlookSession.OpenFolder(folderDescriptor.FolderIDs.EntryId, folderDescriptor.FolderIDs.StoreId);
Assert.IsNotNull(folder);
using ( folder )
{
IEMessages messages = folder.GetMessages();
Assert.IsNotNull(messages);
using ( messages )
{
Assert.AreEqual(1, messages.GetCount());
IEMessage mail = messages.OpenMessage(0);
Assert.IsNotNull(mail);
using ( mail )
{
MessageBody msgBody = mail.GetRawBodyAsRTF();
Assert.AreEqual(MailBodyFormat.PlainTextInRTF, msgBody.Format);
}
}
}
}
private void ExecuteImpl()
{
bool wasChanges = false;
IEMessage message = OpenMessage(ref wasChanges);
if (message == null)
{
return;
}
using ( message )
{
SetPriority(message, ref wasChanges);
SetSubject(message, ref wasChanges);
SetDescription(message, ref wasChanges);
SetDueDate(message, ref wasChanges);
SetStartDate(message, ref wasChanges);
SetRemindDate(message, ref wasChanges);
SetRemindActive(message, ref wasChanges);
SetStatus(message, ref wasChanges);
if (Settings.SyncTaskCategory)
{
SetCategories(message, ref wasChanges);
}
SetOMTaskID(message, ref wasChanges);
if (wasChanges)
{
OutlookSession.SaveChanges(_created, "Export task resource id = " + _task.Id, message, message.GetBinProp(MAPIConst.PR_ENTRYID));
}
}
}
private static int GetAttachNum(IEMessage message, int index)
{
IETable table = message.GetAttachments();
if (table == null)
{
return(0);
}
using ( table )
{
int count = table.GetRowCount();
for (int i = 0; i < count; i++)
{
IERowSet row = table.GetNextRow();
if (row != null)
{
using ( row )
{
if (index == i)
{
return(row.FindLongProp(MAPIConst.PR_ATTACH_NUM));
}
}
}
if (index < i)
{
break;
}
}
}
return(0);
}
public IEAttach OpenAttach()
{
try
{
IEMessage message = OpenMessage();
if (message == null)
{
return(null);
}
using ( message )
{
if (_num == -1)
{
_num = GetAttachNum(message, _attachmentIndex);
ResourceProxy resAttach = new ResourceProxy(_resAttach);
resAttach.SetPropAsync(PROP.PR_ATTACH_NUM, _num);
resAttach.SetPropAsync(PROP.AttachMethod, _attachMethod);
}
return(message.OpenAttach(_num));
}
}
catch
{
return(null);
}
}
private void QuoteReply(IResource mail)
{
try
{
if (_mailItem.BodyFormat == OlBodyFormat.olFormatPlain)
{
}
}
catch (NullReferenceException)
{
return;
}
if (_mailItem.BodyFormat == OlBodyFormat.olFormatPlain)
{
IEMessage message = OutlookSession.OpenMessage(_entryId, _storeId);
if (message != null)
{
string body = message.GetStringProp(MAPIConst.PR_BODY);
if (body != null)
{
_newMail.Body = new ReplyQuoter(mail).QuoteReply(body);
}
}
}
}
//---------------------------------------------------------------------
// Iterate over all contacts in the AB represented by parentId, find all
// contact resources with corresponding IEMessages not existing in the AB,
// and remove them from AB - remove EntryID property AND unlink with AB
// resource.
//---------------------------------------------------------------------
private void RemoveContactFromSync(string parentId, string storeId)
{
IResource AB = Core.ResourceStore.FindUniqueResource("AddressBook", PROP.EntryID, parentId);
if (AB != null)
{
IResourceList contacts = AB.GetLinksOfType("Contact", "InAddressBook");
foreach (IResource contact in contacts.ValidResources)
{
if (contact.HasProp(PROP.EntryID))
{
IEMessage contactMsg = OutlookSession.OpenMessage(contact.GetStringProp(PROP.EntryID), storeId);
if (contactMsg != null)
{
// Item exists in the Outlook folder, the object is not
// needed anymore.
contactMsg.Dispose();
}
else
{
Contact.RemoveFromSync(contact, true);
}
}
}
}
}
private void SetPriority(IEMessage message, ref bool wasChanges)
{
int priorityOld = Task.GetPriority(message);
int priority = _task.GetIntProp(PROP.Priority);
if (_created || priority != priorityOld)
{
if (priority == 1)
{
message.SetLongProp(MAPIConst.PR_PRIORITY, 1);
message.SetLongProp(MAPIConst.PR_IMPORTANCE, 2);
}
else if (priority == 2)
{
message.SetLongProp(MAPIConst.PR_PRIORITY, -1);
message.SetLongProp(MAPIConst.PR_IMPORTANCE, 0);
}
else
{
message.SetLongProp(MAPIConst.PR_PRIORITY, 0);
message.SetLongProp(MAPIConst.PR_IMPORTANCE, 1);
}
wasChanges = true;
}
}
public MailDescriptor(FolderDescriptor folderDescriptor, string entryID,
IEMessage message, MDState state)
{
_state = state;
Init(folderDescriptor, entryID, message, null);
_longBody = message.GetPlainBody(_longBodyMaxSize);
}
protected override void ExecuteAction(IResource resource, PairIDs pairIDs)
{
Tracer._Trace("Execute action: UnDeleteIMAPMessageAction");
Trace.WriteLine(">>> UnDeleteIMAPMessageAction.ExecuteAction");
if (pairIDs == null)
{
return;
}
IResource folder = resource.GetLinkProp(PROP.MAPIFolder);
if (!Folder.IsIMAPFolder(folder))
{
return;
}
IEMessage message = OutlookSession.OpenMessage(pairIDs.EntryId, pairIDs.StoreId);
if (message == null)
{
return;
}
using ( message )
{
int tag = message.GetIDsFromNames(ref GUID.set1, lID.msgDeletedInIMAP, PropType.PT_LONG);
message.DeleteProp(tag);
OutlookSession.SaveChanges("Undelete message resource id = " + resource.Id, message, pairIDs.EntryId);
}
Trace.WriteLine("<<< UnDeleteIMAPMessageAction.ExecuteAction");
}
private void LoadMessageID()
{
IEFolder folderFirst =
OutlookSession.OpenFolder(_folderFirst.FolderIDs.EntryId, _folderFirst.FolderIDs.StoreId);
Assert.IsNotNull(folderFirst);
using ( folderFirst )
{
IEMessages messages = folderFirst.GetMessages();
Assert.IsNotNull(messages);
using ( messages )
{
if (messages.GetCount() == 0)
{
Assert.Fail("Source folder should have at least one message");
}
if (messages.GetCount() != 1)
{
Assert.Fail("Source folder should have one message");
}
IEMessage message = messages.OpenMessage(0);
Assert.IsNotNull(message);
using ( message )
{
_messageID = OutlookSession.GetMessageID(message);
_recordKey = message.GetBinProp(MAPIConst.PR_RECORD_KEY);
}
}
}
Assert.IsNotNull(_messageID);
}
protected override void ExecuteActionImpl(IEMessage message, string fileName)
{
FileStream file = null;
TextWriter writer = null;
try
{
file = File.Create(fileName);
if (file != null)
{
string body = message.GetPlainBody();
byte[] bytes = Encoding.Unicode.GetBytes(body);
writer = new StreamWriter(file);
writer.Write(Encoding.ASCII.GetString(bytes));
writer.Flush();
}
}
finally
{
if (file != null)
{
file.Close();
}
}
}
private string[] SaveMessages(IResourceList selectedResources)
{
ArrayList array = new ArrayList(selectedResources.Count);
foreach (IResource resource in selectedResources.ValidResources)
{
PairIDs msgId = PairIDs.Get(resource);
IEMessage message = OutlookSession.OpenMessage(msgId.EntryId, msgId.StoreId);
if (message != null)
{
using ( message )
{
string path = Core.FileResourceManager.GetUniqueTempDirectory();
path = Path.Combine(path, resource.GetPropText(Core.Props.Name) + ".msg");
message.SaveToMSG(path);
array.Add(path);
}
}
}
string[] files = new string[array.Count];
for (int i = 0; i < array.Count; ++i)
{
files[i] = array[i] as string;
}
return(files);
}
private void DoMoveBetweenStorages(IResource resMail, IEMessage message, PairIDs messageIDs, PairIDs selectedFolderIDs)
{
using ( message )
{
IEFolder folder =
OutlookSession.OpenFolder(selectedFolderIDs.EntryId, selectedFolderIDs.StoreId);
if (folder == null)
{
return;
}
using ( folder )
{
IEMessage newMessage = folder.CreateMessage("IPM.note");
using ( newMessage )
{
message.CopyTo(newMessage);
string entryID = newMessage.GetBinProp(MAPIConst.PR_ENTRYID);
OutlookSession.SaveChanges(true, "Save mail for moving between storages resource id = " + resMail.Id, newMessage, entryID);
if (_copy)
{
return;
}
if (!string.IsNullOrEmpty(entryID) && !resMail.HasProp(-PROP.Attachment))
{
new ResourceProxy(resMail).SetProp(PROP.EntryID, entryID);
}
OutlookSession.DeleteMessage(messageIDs.StoreId, messageIDs.EntryId, false);
}
}
}
}
protected override void ExecuteAction(IResource resource, PairIDs pairIDs)
{
Tracer._Trace("Execute action: SaveToMSGAction");
Trace.WriteLine(">>> SaveToMSGAction.ExecuteAction");
if (pairIDs != null)
{
IEMessage message = OutlookSession.OpenMessage(pairIDs.EntryId, pairIDs.StoreId);
if (message == null)
{
return;
}
using ( message )
{
string fileName = null;
if (!_single)
{
string subject = message.GetStringProp(MAPIConst.PR_SUBJECT);
CorrectFileName(ref subject);
if (subject == null || subject.Length == 0)
{
subject = message.GetBinProp(MAPIConst.PR_ENTRYID);
}
fileName = Path.Combine(_path, subject + ".msg");
}
else
{
fileName = _path;
}
ExecuteActionImpl(message, fileName);
}
}
Trace.WriteLine("<<< SaveToMSGAction.ExecuteAction");
}
private void SetCategories(IEMessage message, ref bool wasChanges)
{
if (ExportCategories.ProcessCategories(message, _task))
{
wasChanges = true;
}
}
private static string GenerateBodyForReportDelivered(IEMessage message)
{
string displayTo = message.GetStringProp(MAPIConst.PR_ORIGINAL_DISPLAY_TO);
string bodyText = "Your message: \n\n" + "\tTo:\t\t\t" + displayTo + "\n";
string subject = message.GetStringProp(MAPIConst.PR_ORIGINAL_SUBJECT);
bodyText += "\tSubject: \t" + subject + "\n";
DateTime submitTime = message.GetDateTimeProp(MAPIConst.PR_ORIGINAL_SUBMIT_TIME);
if (submitTime != DateTime.MinValue)
{
bodyText += "\tSent: \t\t" + submitTime.ToString() + "\n\n";
}
bodyText += "was delivered to the following recipient(s):\n\n";
string name = message.GetStringProp(MAPIConst.PR_DISPLAY_TO);
bodyText += "\t" + name;
DateTime deliveryTime = message.GetDateTimeProp(MAPIConst.PR_MESSAGE_DELIVERY_TIME);
if (deliveryTime != DateTime.MinValue)
{
bodyText += " on " + deliveryTime.ToString() + "\n";
}
return(bodyText);
}
void EnumerateMailWithBody(IEFolder mapiFolder)
{
IEMessages messages = mapiFolder.GetMessages();
if (messages == null)
{
return;
}
using ( messages )
{
int count = messages.GetCount();
if (count > 100)
{
count = 100;
}
for (int i = 0; i < count; ++i)
{
IEMessage message = messages.OpenMessage(i);
if (message == null)
{
continue;
}
using ( message )
{
string plainBody = message.GetPlainBody();
plainBody = plainBody;
}
}
}
}
private static void AddMail(string messageClass, string entryID,
FolderDescriptor folderDescriptor, IEFolder mapiFolder, string longBody)
{
Guard.NullArgument(messageClass, "messageClass");
if (MessageType.InterpretAsMail(messageClass))
{
IEMessage message = null;
try
{
message = OutlookSession.OpenMessage(mapiFolder, entryID);
}
catch (COMException exception)
{
if (exception.ErrorCode == MapiError.MAPI_E_SUBMITTED)
{
Core.NetworkAP.QueueJobAt(DateTime.Now.AddSeconds(10),
new DelegateTryAgainToAddMail(TryAgainToAddMail), folderDescriptor, entryID, longBody);
}
}
if (message == null)
{
return;
}
using ( message )
{
Core.ResourceAP.QueueJob(new MailDescriptor(folderDescriptor, entryID, message, longBody));
}
}
}
private void EnumerateTasks(FolderDescriptor folder, IEFolder mapiFolder)
{
OnFolderFetched(folder.Name);
IEMessages messages = mapiFolder.GetMessages();
if (messages != null)
{
using ( messages )
{
int count = messages.GetCount();
for (int i = 0; i < count; i++)
{
IEMessage message = messages.OpenMessage(i);
if (message != null)
{
using ( message )
{
string entryID = OutlookSession.GetMessageID(message);
TaskDescriptor.Do(folder, message, entryID);
}
}
}
}
}
}
private void SetFullName(IEMessage message)
{
string tempString = message.GetStringProp(MAPIConst.PR_GIVEN_NAME);
_contactNames.FirstName = tempString;
string fullName = null;
if (tempString != null)
{
fullName = tempString;
}
tempString = message.GetStringProp(MAPIConst.PR_SURNAME);
_contactNames.LastName = tempString;
if (tempString != null)
{
if (fullName != null)
{
fullName += " ";
}
fullName += tempString;
}
if (fullName == null)
{
int tag = message.GetIDsFromNames(ref GUID.set3, lID.contactDisplayName, PropType.PT_STRING8);
fullName = message.GetStringProp(tag);
}
if (fullName != null)
{
fullName = fullName.Trim();
}
_contactNames.FullName = fullName;
}
protected virtual void ExecuteActionImpl(IResourceList selectedResources)
{
Tracer._Trace("Execute action: SyncMail");
PairIDs selectedFolderIDs = PairIDs.Get(_selectedFolder);
if (!OutlookSession.FolderExists(selectedFolderIDs))
{
return;
}
foreach (IResource resMail in selectedResources.ValidResources)
{
PairIDs messageIDs = PairIDs.Get(resMail);
if (messageIDs == null)
{
continue;
}
IEMessage message =
OutlookSession.OpenMessage(messageIDs.EntryId, messageIDs.StoreId);
if (message == null)
{
continue;
}
if (selectedFolderIDs.StoreId.Equals(messageIDs.StoreId))
{
DoMoveImpl(message, messageIDs, selectedFolderIDs);
}
else
{
DoMoveBetweenStorages(resMail, message, messageIDs, selectedFolderIDs);
}
}
}
private void OnImportanceMailChangedImpl(IResource emailResource)
{
if (emailResource != null && emailResource.Type == STR.Email)
{
if (Mail.MailInIMAP(emailResource))
{
return;
}
int importance = emailResource.GetIntProp(PROP.Importance);
PairIDs messageIDs = PairIDs.Get(emailResource);
if (messageIDs == null)
{
return;
}
IEMessage message = OutlookSession.OpenMessage(messageIDs.EntryId, messageIDs.StoreId);
if (message != null)
{
using ( message )
{
message.SetLongProp(MAPIConst.PR_IMPORTANCE, importance + 1);
OutlookSession.SaveChanges("Export importance flag for resource id = " + emailResource.Id, message, messageIDs.EntryId);
}
}
}
}
public NewMailDescriptor(FolderDescriptor folderDescriptor, string entryID, IEMessage message) :
base(folderDescriptor, entryID, message)
{
if (Settings.TraceOutlookListeners)
{
_tracer.Trace("NewMailDescriptor was created");
}
}
private void ProcessContactFolder(PairIDs folderIDs, string abName)
{
IEFolder folder = null;
try
{
folder = OutlookSession.OpenFolder(folderIDs.EntryId, folderIDs.StoreId);
}
catch (System.Threading.ThreadAbortException)
{
}
catch (Exception exception)
{
if (exception is COMException &&
((COMException)exception).ErrorCode != (unchecked ((int)0x80040111))) //ClassFactory cannot supply requested class
{
return;
}
Core.ReportException(exception, ExceptionReportFlags.AttachLog);
return;
}
if (folder == null)
{
return;
}
using ( folder )
{
OutlookAddressBook AB = new OutlookAddressBook(abName, folderIDs, true);
AB.RunAB();
IEMessages messages = folder.GetMessages();
if (messages == null)
{
return;
}
using ( messages )
{
int mesCount = messages.GetCount();
for (int i = 0; i < mesCount; i++)
{
if (ShuttingDown)
{
break;
}
OutlookSession.ProcessJobs();
IEMessage message = messages.OpenMessage(i);
if (message == null)
{
continue;
}
using ( message )
{
string mesEntryID = OutlookSession.GetMessageID(message);
Core.ResourceAP.QueueJob(new ContactDescriptor(message, mesEntryID, mesEntryID, AB));
}
}
}
}
}
protected override void Execute()
{
if (OutlookSession.OutlookProcessor.ShuttingDown)
{
return;
}
IEFolder folder = OutlookSession.OpenFolder(_ntf.ParentID, _storeID);
if (folder != null)
{
using ( folder )
{
FolderDescriptor folderDescriptor = FolderDescriptor.Get(folder);
if (folderDescriptor == null)
{
return;
}
IResource resFolder = Folder.Find(folderDescriptor.FolderIDs.EntryId);
if (resFolder == null)
{
return;
}
bool ignoredFolder = Folder.IsIgnored(resFolder);
IEMessage message = OutlookSession.OpenMessage(_ntf.EntryID, _storeID);
if (message == null)
{
return;
}
using ( message )
{
string entryId = OutlookSession.GetMessageID(message);
IResource mail = Core.ResourceStore.FindUniqueResource("Email", PROP.EntryID, _ntf.EntryID);
if (mail == null && _ntf.OldEntryID != null)
{
mail = Core.ResourceStore.FindUniqueResource("Email", PROP.EntryID, _ntf.OldEntryID);
}
if (ignoredFolder && mail != null)
{
Trace.WriteLine("Moved mail ID=" + mail.Id + " to ignored folder");
Mail.ForceDelete(mail);
return;
}
if (mail == null)
{
ProcessMailAddNtf.DoJob(_ntf, _storeID);
return;
}
mail.SetProp(PROP.EntryID, entryId);
Folder.LinkMail(resFolder, mail);
}
}
}
}
private void LoadProp(ref string member, IEMessage message, int propTag)
{
string prop = message.GetStringProp(propTag);
if (prop != null)
{
member = prop;
}
}
private void LoadStreamProp(ref string member, IEMessage message)
{
string prop = message.GetPlainBody();
if (prop != null)
{
member = prop;
}
}
private void SetOMTaskID(IEMessage message, ref bool wasChanges)
{
if (Task.GetOMTaskID(message) != _OMTaskId)
{
int tag = message.GetIDsFromNames(ref GUID.set4, "OMTaskID", PropType.PT_STRING8);
message.SetStringProp(tag, _OMTaskId);
wasChanges = true;
}
}
private void OnUnreadItemChangedImpl(IResource emailResource)
{
Guard.NullArgument(emailResource, "emailResource");
if (emailResource.Type != STR.Email)
{
return;
}
PairIDs messageIDs = PairIDs.Get(emailResource);
if (messageIDs == null)
{
return;
}
IResource folder = Mail.GetParentFolder(emailResource);
if (folder != null && Folder.IsIMAPFolder(folder))
{
PairIDs folderIDs = PairIDs.Get(folder);
if (folderIDs != null)
{
IEFolder mapiFolder = OutlookSession.OpenFolder(folderIDs.EntryId, folderIDs.StoreId);
if (mapiFolder != null)
{
using ( mapiFolder )
{
try
{
mapiFolder.SetReadFlags(messageIDs.EntryId, emailResource.HasProp(Core.Props.IsUnread));
return;
}
catch (COMException exception)
{
if (exception.ErrorCode == (unchecked ((int)0x80040604)))
{
StandartJobs.MessageBox("Unspecified error. Can't change unread flag for email.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
Core.ReportException(exception, ExceptionReportFlags.AttachLog);
}
}
}
}
}
IEMessage message = OutlookSession.OpenMessage(messageIDs.EntryId, messageIDs.StoreId);
if (message != null)
{
using ( message )
{
bool unread = emailResource.HasProp(Core.Props.IsUnread);
message.SetUnRead(unread);
OutlookSession.SaveChanges("Export Read/Unread flag" + emailResource.Id, message, messageIDs.EntryId);
}
}
}
public static void Do(JobPriority jobPriority, FolderDescriptor folder, IEMessage message, string entryID)
{
if (folder == null || folder.FolderIDs == null)
{
Tracer._Trace("Cannot locate folder");
return;
}
Core.ResourceAP.QueueJob(jobPriority, new TaskDescriptor(folder, message, entryID));
}
internal IBroadcastMessage CreateSETMessage(string message)
{
IBroadcastMessage result;
try
{
string text = message.Substring(0, 2);
switch (text)
{
case "TP":
result = new TPMessage(message);
return result;
case "L+":
result = new LSAccumulate(message);
return result;
case "PO":
result = new POMessage(message);
return result;
case "B+":
result = new BCTextMessage(message);
return result;
case "IS":
result = new ISMessage(message);
return result;
case "IE":
result = new IEMessage(message);
return result;
case "LO":
this.loMessage.Unpack(message);
result = this.loMessage;
return result;
case "MT":
result = new MarketInfo(message);
return result;
case "PD":
this.pdMessage.Unpack(message);
result = this.pdMessage;
return result;
case "SC":
this.scMessage.Unpack(message);
result = this.scMessage;
return result;
case "SS":
result = new SSMessage(message);
return result;
case "AA":
this.aaMessage.Unpack(message);
result = this.aaMessage;
return result;
case "NH":
this.nhMessage.Unpack(message);
result = this.nhMessage;
return result;
case "BA":
result = new BAMessage(message);
return result;
case "0I":
result = new OrderInfoClient(message);
return result;
case "0B":
this.broadcastMessageClient.Unpack(message);
result = this.broadcastMessageClient;
return result;
case "0G":
this.dgwOrderReply.Unpack(message);
result = this.dgwOrderReply;
return result;
}
result = null;
}
catch (Exception ex)
{
throw ex;
}
return result;
}
