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);
}
}
}
}
//---------------------------------------------------------------------
// 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 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 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));
}
}
}
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");
}
internal static IEMAPIProp OpenMessage(IEFolder folder, IResource contact,
bool create, bool forceCreate, bool trace,
out bool newCreated, out bool createdAsMailUser)
{
createdAsMailUser = false;
newCreated = false;
using ( folder )
{
IEMAPIProp message = null;
if (!create)
{
string mesEntryId = contact.GetPropText(PROP.EntryID);
if (mesEntryId.Length > 0)
{
message = OutlookSession.OpenMessage(folder, mesEntryId);
if (message == null)
{
Contact.RemoveFromSync(contact, true);
}
}
if (!forceCreate)
{
return(message);
}
}
if (message == null)
{
string folderId = folder.GetBinProp(MAPIConst.PR_ENTRYID);
_tracer.Trace(folderId);
IEAddrBook ab = OutlookSession.GetAddrBook();
if (ab != null)
{
for (int i = 0; i < ab.GetCount(); ++i)
{
string abEntryId = ab.FindBinProp(i, MAPIConst.PR_ENTRYID_ASSOCIATED_WITH_AB);
if (abEntryId == folderId)
{
IEABContainer abContainer = ab.OpenAB(i);
if (abContainer != null)
{
using ( abContainer )
{
message = abContainer.CreateMailUser( );
if (message != null)
{
createdAsMailUser = true;
return(message);
}
}
}
break;
}
}
}
message = folder.CreateMessage("IPM.Contact");
newCreated = true;
}
return(message);
}
}
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 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);
}
}
}
}
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 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 MailDeletedDescriptor(MAPINtf ntf, string storeId)
{
Guard.NullArgument(ntf, "ntf");
Guard.NullArgument(storeId, "storeID");
IEMessage deletedItem = OutlookSession.OpenMessage(ntf.EntryID, storeId);
if (deletedItem != null)
{
using ( deletedItem )
{
Trace.WriteLine("Successfully opened deleted item resource");
string entryId = OutlookSession.GetMessageID(deletedItem);
if (String.IsNullOrEmpty(entryId))
{
throw new ArgumentNullException("entryId", "MailDeletedDescriptor -- NULL entryId string of the existing IEMessage");
}
FindResourcesByEntryId(entryId);
}
}
else
{
FindResourcesByEntryId(ntf.EntryID);
if (_resourceToDelete != null)
{
return;
}
// we've got a short-term entry ID in the notification; we need to scan the parent
// folder to find the resources which need to be deleted
IEFolder parentFolder = OutlookSession.OpenFolder(ntf.ParentID, storeId);
if (parentFolder != null)
{
using ( parentFolder )
{
string parentId = OutlookSession.GetFolderID(parentFolder);
IResource parentMAPIFolder = Folder.Find(parentId);
if (parentMAPIFolder != null)
{
if (Folder.IsFolderOfType(parentMAPIFolder, FolderType.Contact))
{
RemoveContactFromSync(parentId, storeId);
return;
}
// Deletion from the folder which we ignore anyway
// must not lead to a great performance loss.
if (!parentMAPIFolder.HasProp(PROP.IgnoredFolder))
{
FindResourceToDelete(parentFolder, parentMAPIFolder, storeId);
}
}
}
}
}
}
public MailBodyDescriptor(IResource mail)
{
try
{
IEMessage message = null;
if (mail.Type == STR.Email)
{
PairIDs IDs = PairIDs.Get(mail);
if (IDs != null)
{
message = OutlookSession.OpenMessage(IDs.EntryId, IDs.StoreId);
}
else
{
message = new OutlookAttachment(mail).OpenEmbeddedMessage();
}
}
else if (mail.Type == STR.EmailFile)
{
message = OutlookSession.OpenEmailFile(mail);
}
if (message != null)
{
using ( message )
{
_subject = message.GetStringProp(MAPIConst.PR_SUBJECT);
MessageBody body = message.GetRawBodyAsRTF();
if (body.Format == MailBodyFormat.PlainTextInRTF || body.Format == MailBodyFormat.RTF)
{
_body = _rtfParser.Parse(body.text);
}
else
{
_body = body.text;
}
_isHTML = (body.Format == EMAPILib.MailBodyFormat.HTML);
}
}
}
catch (Exception exception)
{
Tracer._TraceException(exception);
}
if (_subject == null)
{
_subject = string.Empty;
}
if (_body == null)
{
_body = string.Empty;
}
}
private IEMessage OpenMessage(ref bool wasChanges)
{
if (_createNew && _OMTaskId == null)
{
return(null);
}
wasChanges = false;
IEMessage message = null;
if (!_createNew)
{
PairIDs IDs = PairIDs.Get(_task);
if (IDs == null)
{
if (_task.HasProp(PROP.EntryID))
{
IEFolder taskFolder = OutlookSession.OpenDefaultTaskFolder();
if (taskFolder == null)
{
return(null);
}
using ( taskFolder )
{
IDs = new PairIDs(_task.GetStringProp(PROP.EntryID), taskFolder.GetBinProp(MAPIConst.PR_STORE_ENTRYID));
}
}
if (IDs == null)
{
return(null);
}
}
message = OutlookSession.OpenMessage(IDs.EntryId, IDs.StoreId);
}
if (message == null)
{
IEFolder taskFolder = OutlookSession.OpenDefaultTaskFolder();
if (taskFolder == null)
{
return(null);
}
wasChanges = true;
using ( taskFolder )
{
message = taskFolder.CreateMessage("IPM.Task");
_created = true;
}
}
return(message);
}
private MessageBody ReadBody()
{
if (_mail.HasProp(PROP.EmbeddedMessage))
{
OutlookAttachment attach = new OutlookAttachment(_mail);
EMAPILib.IEMessage message = attach.OpenEmbeddedMessage();
if (message != null)
{
using ( message )
{
return(message.GetRawBodyAsRTF());
}
}
return(null);
}
if (_mail.Type == STR.EmailFile)
{
IEMessage message = OutlookSession.OpenEmailFile(_mail);
if (message != null)
{
using ( message )
{
_subject = message.GetStringProp(MAPIConst.PR_SUBJECT);
return(message.GetRawBodyAsRTF());
}
}
return(null);
}
PairIDs IDs = PairIDs.Get(_mail);
if (IDs != null)
{
EMAPILib.IEMessage message = OutlookSession.OpenMessage(IDs.EntryId, IDs.StoreId);
if (message != null)
{
using ( message )
{
return(OutlookSession.GetMessageBody(message));
}
}
else
{
string bodyText = "Could not open message. It may have been moved or deleted in Outlook. Or message store for this mail cannot be open.";
return(new MessageBody(bodyText, MailBodyFormat.PlainText, 0));
}
}
return(null);
}
private void UpdateMail(IERowSet row, IResource email, string messageClass, string entryId,
FolderDescriptor folder, IEFolder mapiFolder)
{
Guard.NullArgument(messageClass, "messageClass");
bool checkForDateTimeNeeded = false;
bool bWereChanges = false;
bool interpretAsMail = MessageType.InterpretAsMail(messageClass);
if (interpretAsMail)
{
bWereChanges = WereChanges(row, email, out checkForDateTimeNeeded);
}
if (bWereChanges)
{
IEMessage message = OutlookSession.OpenMessage(folder.FolderIDs.EntryId, mapiFolder, entryId);
if (message == null)
{
return;
}
using ( message )
{
if (checkForDateTimeNeeded)
{
DateTime lastModifiedDate = message.GetDateTimeProp(MAPIConst.PR_LAST_MODIFICATION_TIME);
lastModifiedDate = lastModifiedDate.ToUniversalTime();
if (lastModifiedDate.Equals(email.GetProp(PROP.LastModifiedTime)))
{
bWereChanges = false;
}
}
if (bWereChanges)
{
Core.ResourceAP.QueueJob(new MailDescriptor(folder, entryId, message, MailDescriptor.UpdateState, row.GetStringProp(7)));
}
else
{
Core.ResourceAP.QueueJob(new SyncOnlyMailDescriptor(folder, entryId, message));
}
}
}
else
{
MailSyncToFolder.LinkOrDelete(folder, email);
}
}
public static void DoJob(MAPINtf ntf, string storeID)
{
if (ntf == null)
{
return;
}
try
{
IEFolder folder = OutlookSession.OpenFolder(ntf.ParentID, storeID);
if (folder == null)
{
return;
}
FolderDescriptor folderDescriptor = FolderDescriptor.Get(folder);
if (folderDescriptor == null)
{
return;
}
using ( folder )
{
if (folderDescriptor.ContainerClass == FolderType.IMAP)
{
if (!ProcessIMAPMessage(folder, ntf.EntryID))
{
return;
}
}
IEMessage message = OutlookSession.OpenMessage(ntf.EntryID, storeID);
if (message == null)
{
return;
}
using ( message )
{
DoJobImpl(ntf, message, folderDescriptor);
}
}
}
catch (System.Threading.ThreadAbortException exception)
{
Tracer._TraceException(exception);
}
catch (Exception exception)
{
Core.ReportException(exception, ExceptionReportFlags.AttachLog);
}
}
public IEMessage OpenMessage()
{
IResource mail = Core.ResourceStore.LoadResource(_sourceMailID);
if (mail == null)
{
return(null);
}
PairIDs messageIDs = PairIDs.Get(mail);
if (messageIDs == null)
{
return(null);
}
return(OutlookSession.OpenMessage(messageIDs.EntryId, messageIDs.StoreId));
}
protected override void Execute()
{
IEMessage message = OutlookSession.OpenMessage(_entryId, _storeId);
if (message == null)
{
return;
}
using ( message )
{
if (ProcessCategories(message, _mail))
{
OutlookSession.SaveChanges("Export categoryies for resource id = " + _mail.Id, message, _entryId);
}
}
}
protected override void Execute()
{
IEMessage message = OutlookSession.OpenMessage(_messageIDs.EntryId, _messageIDs.StoreId);
if (message == null)
{
return;
}
using ( message )
{
int flagStatus = 0;
int flagColor = 0;
GetCurrentFlag(message, out flagStatus, out flagColor);
ExportFlag(message, flagStatus, flagColor);
}
}
private static void ExportAnnotationImpl(IResource emailResource)
{
Guard.NullArgument(emailResource, "emailResource");
if (emailResource.Type != STR.Email)
{
throw new ArgumentException("Expected 'Email' resource but was " + emailResource.Type);
}
if (Mail.MailInIMAP(emailResource))
{
return;
}
PairIDs messageIDs = PairIDs.Get(emailResource);
if (messageIDs == null)
{
return;
}
IEMessage message = OutlookSession.OpenMessage(messageIDs.EntryId, messageIDs.StoreId);
if (message == null)
{
return;
}
using ( message )
{
string annotation = emailResource.GetPropText(Core.Props.Annotation);
int tag = message.GetIDsFromNames(ref GUID.set1, lID.msgFlagAnnotation, PropType.PT_STRING8);
string oldAnnotation = message.GetStringProp(tag);
if (oldAnnotation == null)
{
oldAnnotation = string.Empty;
}
if (!oldAnnotation.Equals(annotation))
{
if (annotation.Length == 0)
{
message.DeleteProp(tag);
}
else
{
message.SetStringProp(tag, annotation);
}
OutlookSession.SaveChanges("ExportAnnotation for resource id = " + emailResource.Id, message, messageIDs.EntryId);
}
}
}
protected override void Execute()
{
if (IsDataCorrect(_folder))
{
PairIDs folderIDs = _folder.FolderIDs;
IEMessage message = OutlookSession.OpenMessage(_entryID, folderIDs.StoreId);
if (message == null)
{
return;
}
using ( message )
{
OutlookAddressBook AB = new OutlookAddressBook(_folder.Name, _folder.FolderIDs, true);
ContactDescriptor contactDescriptor =
new ContactDescriptor(message, _entryID, _searchEntryID, AB);
Core.ResourceAP.QueueJob(contactDescriptor);
}
}
}
private void OnMailModifyImpl(MAPIFullNtf ntf)
{
if (CheckStorageIgnored(_storeID))
{
return;
}
try
{
IEFolder folder = OutlookSession.OpenFolder(ntf.ParentID, _storeID);
if (folder == null)
{
return;
}
using ( folder )
{
FolderDescriptor folderDescriptor = FolderDescriptor.Get(folder);
if (folderDescriptor.ContainerClass == FolderType.IMAP)
{
if (!ProcessMailAddNtf.ProcessIMAPMessage(folder, ntf.EntryID))
{
return;
}
}
IEMessage message = OutlookSession.OpenMessage(ntf.EntryID, _storeID);
if (message == null)
{
return;
}
using ( message )
{
ProcessMailModifyImpl(ntf, message, folderDescriptor);
}
}
}
catch (System.Threading.ThreadAbortException ex)
{
Tracer._TraceException(ex);
}
catch (Exception exception)
{
Core.ReportBackgroundException(exception);
}
}
private static void TryAgainToAddMail(FolderDescriptor folderDescriptor, string entryID, string longBody)
{
IEMessage message = null;
try
{
message = OutlookSession.OpenMessage(entryID, folderDescriptor.FolderIDs.StoreId);
}
catch (COMException exception)
{
if (exception.ErrorCode == MapiError.MAPI_E_SUBMITTED)
{
Core.NetworkAP.QueueJobAt(DateTime.Now.AddMinutes(1),
new DelegateTryAgainToAddMail(TryAgainToAddMail), folderDescriptor, entryID, longBody);
}
}
using ( message )
{
Core.ResourceAP.QueueJob(new MailDescriptor(folderDescriptor, entryID, message, longBody));
}
}
public static bool DeleteMessage(string storeId, string entryId, bool DeletedItems)
{
if (!DeletedItems)
{
OutlookSession.DeleteMessageImpl(storeId, entryId, false);
return(true);
}
PairIDs folderIds = OutlookSession.GetDeletedItemsFolderIDs(storeId);
if (folderIds == null)
{
OutlookSession.DeleteMessageImpl(storeId, entryId, false);
return(true);
}
string folderID = null;
IEMessage message = OutlookSession.OpenMessage(entryId, storeId);
if (message == null)
{
return(false);
}
using ( message )
{
folderID = message.GetBinProp(MAPIConst.PR_PARENT_ENTRYID);
}
if (folderID != null)
{
if (folderID != folderIds.EntryId)
{
if (MoveMessage(storeId, entryId, folderID, folderIds))
{
return(true);
}
}
}
OutlookSession.DeleteMessageImpl(storeId, entryId, false);
return(true);
}
private void FindResourceToDelete(IEFolder parentFolder, IResource parentMAPIFolder, string storeId)
{
// NOTE: In Cached Exchange mode (at least), messages can be opened successfully
// immediately after they are permanently deleted, but opening them through
// the short-term entry ID that we got in the notification still does not work.
// Thus, if the message was permanently deleted in Outlook, the code below will
// not find the deleted message, and we will have to rely on background enumeration
// to delete it.
// When the message is permanently deleted in OmniaMea, we immediately delete
// the resource as well.
IResourceList children = parentMAPIFolder.GetLinksOfType(null, PROP.MAPIFolder);
foreach (IResource child in children.ValidResources)
{
if (child.HasProp(PROP.EntryID))
{
IEMessage deletedItem = OutlookSession.OpenMessage(child.GetStringProp(PROP.EntryID), storeId);
if (deletedItem != null)
{
// Item exists in the folder, the object is not needed anymore
deletedItem.Dispose();
}
else
{
Trace.WriteLine("Failed to open resource with ID=" + child.Id + ", queueing for delete");
_resourceToDelete = child;
break;
}
}
}
if (_resourceToDelete == null)
{
HashSet set = new HashSet(children.Count);
Tracer._Trace("Cannot find deleted mail.");
Tracer._Trace("Try another algorithm.");
foreach (IResource child in children.ValidResources)
{
if (!child.HasProp(PROP.EntryID))
{
continue;
}
set.Add(child.GetStringProp(PROP.EntryID));
}
IEMessages messages = parentFolder.GetMessages();
if (messages != null)
{
using ( messages )
{
for (int i = 0; i < messages.GetCount(); i++)
{
IEMessage message = messages.OpenMessage(i);
if (message != null)
{
using ( message )
{
string entryid = message.GetBinProp(MAPIConst.PR_ENTRYID);
if (entryid != null)
{
set.Remove(entryid);
}
}
}
}
}
}
if (set.Count > 0)
{
foreach (HashSet.Entry entry in set)
{
FindResourcesByEntryId((string)entry.Key);
if (_resourceToDelete != null)
{
Tracer._Trace("Resource found for deleting.");
break;
}
}
}
}
}
public void RemoveDeletedMailsFromIndex()
{
try
{
int count = 0;
MailInIndexEnum mailEnum = _mailsInOldIndex.GetEnumerator();
int total = mailEnum.Count;
// _tracer.Trace( "Start RemoveDeletedMailsFromIndex" );
// _tracer.Trace( "RemoveDeletedMailsFromIndex : mail to remove " + total.ToString() );
int curTickCount = Environment.TickCount;
for (int i = 0; i < total; i++)
{
OutlookSession.ProcessJobs();
if (OutlookSession.OutlookProcessor.ShuttingDown)
{
break;
}
if (_idle && Settings.IdleModeManager.CheckInterruptIdle())
{
break;
}
int percentage = (total == 0)
? 100
: ++count * 100 / total;
if (percentage > 100)
{
percentage = 100;
}
if (Environment.TickCount - curTickCount > 500)
{
string statusText = "Synchronizing mails(" + count + "/" + total + ")...";
Settings.UpdateProgress(percentage, statusText, string.Empty);
curTickCount = Environment.TickCount;
}
IResource resMail = mailEnum.GetResource(i);
if (resMail == null || !Guard.IsResourceLive(resMail))
{
// _tracer.Trace( "RemoveDeletedMailsFromIndex : resMail == null" );
continue;
}
PairIDs messageIDs = PairIDs.Get(resMail);
if (messageIDs == null)
{
if (!resMail.HasProp(PROP.EmbeddedMessage))
{
new ResourceProxy(resMail).DeleteAsync();
}
continue;
}
string storeID = messageIDs.StoreId;
string folderID = null;
IEMessage mapiMessage =
OutlookSession.OpenMessage(messageIDs.EntryId, storeID);
if (mapiMessage != null)
{
using ( mapiMessage )
{
folderID = mapiMessage.GetBinProp(MAPIConst.PR_PARENT_ENTRYID);
}
}
FolderDescriptor folder = null;
if (folderID != null)
{
folder = FolderDescriptor.Get(folderID, storeID);
}
MailSyncToFolder.LinkOrDelete(folder, resMail);
OutlookSession.ProcessJobs();
}
}
finally
{
_mailsInOldIndex.Clear();
}
OutlookSession.ProcessJobs();
}
private void OnNewMailImpl(MAPINtf ntf)
{
Trace("[New] *Email* - OnNewMailImpl");
if (CheckStorageIgnored(_storeID))
{
Trace("OnNewMailImpl: storage is ignored");
return;
}
FolderDescriptor folderDescriptor = FolderDescriptor.Get(ntf.ParentID, _storeID);
if (folderDescriptor == null)
{
Trace("OnNewMailImpl: folderDescriptor == null");
return;
}
if (folderDescriptor.ContainerClass == FolderType.IMAP)
{
IEFolder folder = OutlookSession.OpenFolder(ntf.ParentID, _storeID);
if (folder == null)
{
return;
}
using ( folder )
{
if (!ProcessMailAddNtf.ProcessIMAPMessage(folder, ntf.EntryID))
{
return;
}
}
}
IEMessage message = OutlookSession.OpenMessage(ntf.EntryID, _storeID);
if (message == null)
{
Trace("OnNewMailImpl: cannot open mapi message");
return;
}
using ( message )
{
try
{
string entryId = OutlookSession.GetMessageID(message);
if (OutlookSession.IsMailExported(entryId))
{
Trace("OnNewMailImpl: mail is exported at the moment");
return;
}
new NewMailDescriptor(folderDescriptor, entryId, message).QueueJob(JobPriority.AboveNormal);
}
catch (System.Threading.ThreadAbortException ex)
{
Tracer._TraceException(ex);
}
catch (Exception exception)
{
Core.ReportBackgroundException(exception);
}
}
}
private void OnMailMoveImpl(MAPIFullNtf ntf)
{
if (CheckStorageIgnored(_storeID))
{
return;
}
FolderDescriptor folderDescriptor = FolderDescriptor.Get(ntf.ParentID, _storeID);
if (folderDescriptor == null)
{
return;
}
try
{
IEMessage message = OutlookSession.OpenMessage(ntf.EntryID, _storeID);
if (message == null)
{
return;
}
using ( message )
{
string realID = message.GetBinProp(MAPIConst.PR_ENTRYID);
if (realID == null)
{
realID = ntf.EntryID;
}
else
{
if (OutlookSession.IsMailExported(realID))
{
return;
}
}
string messageClass = MessageType.GetMessageClass(message);
if (MessageType.InterpretAsMail(messageClass))
{
Core.ResourceAP.QueueJob(JobPriority.AboveNormal, new MailMovedDescriptor(ntf, _storeID));
}
else
if (MessageType.InterpretAsContact(messageClass))
{
if (folderDescriptor.ContainerClass != FolderType.Contact)
{
_tracer.Trace("Contact was moved to deleted items");
IResource contact = Core.ResourceStore.FindUniqueResource(STR.Contact, PROP.EntryID, realID);
string entryID = realID;
if (contact == null && ntf.OldEntryID != null)
{
_tracer.Trace("contact not found");
contact = Core.ResourceStore.FindUniqueResource(STR.Contact, PROP.EntryID, ntf.OldEntryID);
entryID = ntf.EntryID;
}
if (contact != null)
{
_tracer.Trace("contact found");
_tracer.Trace("RemoveFromSync");
Contact.RemoveFromSync(contact, entryID);
}
else
{
_tracer.Trace("ClearInvalidEntryIDFromContacts");
_jobStrategy.QueueJob(new MethodInvoker(REGISTRY.ClearInvalidEntryIDFromContacts));
}
}
else
{
string searchEntryID = realID;
if (realID != ntf.OldEntryID)
{
searchEntryID = ntf.OldEntryID;
}
_tracer.Trace("ContactDescriptorWrapper process moving");
ContactDescriptorWrapper.Do(_jobStrategy.JobPriority, folderDescriptor, realID, searchEntryID);
}
//OutlookSession.OutlookProcessor.QueueJob( new ContactDescriptorWrapper( folderDescriptor, ntf.EntryID ) );
}
else if (MessageType.InterpretAsTask(messageClass))
{
_tracer.Trace("Task was moved");
if (Core.ResourceStore.FindUniqueResource(STR.Task, PROP.EntryID, realID) != null)
{
TaskDescriptor.Do(JobPriority.AboveNormal, folderDescriptor, message, realID);
}
else
{
RefreshTaskFolder(folderDescriptor);
FolderDescriptor oldFolderDescriptor = FolderDescriptor.Get(ntf.OldParentID, _storeID);
if (oldFolderDescriptor != null)
{
RefreshTaskFolder(oldFolderDescriptor);
}
}
}
else
{
_tracer.Trace("Unknown item of class " + messageClass + " was moved");
}
}
}
catch (System.Threading.ThreadAbortException ex)
{
Tracer._TraceException(ex);
}
catch (Exception exception)
{
Core.ReportBackgroundException(exception);
}
}