public virtual void OnNewMail(MAPINtf ntf)
{
if (_mapiListener != null)
{
_mapiListener.OnNewMail(ntf);
}
}
public virtual void OnFolderDelete(MAPINtf ntf)
{
if (_mapiListener != null)
{
_mapiListener.OnFolderDelete(ntf);
}
}
public FolderModifiedDescriptor(MAPINtf ntf, string storeID, bool isMovedFolder)
{
Guard.NullArgument(ntf, "ntf");
_isMovedFolder = isMovedFolder;
IEFolder folder = OutlookSession.OpenFolder(ntf.EntryID, storeID);
if (folder != null)
{
using ( folder )
{
_folder = FolderDescriptor.Get(folder);
if (ntf.ParentID != null && ntf.ParentID.Length > 0)
{
IEFolder parentFolder =
OutlookSession.OpenFolder(ntf.ParentID, storeID);
if (parentFolder != null)
{
using ( parentFolder )
{
_parentFolder = FolderDescriptor.Get(parentFolder);
}
}
}
}
}
}
public void OnMailAdd(MAPINtf ntf)
{
if (CheckArgument("OnMailAdd", ntf) && Settings.ProcessMessageAdd)
{
_jobStrategy.QueueJob(new DelegateMAPINtf(OnMailAddImpl), ntf);
}
}
public void OnNewMail(MAPINtf ntf)
{
if (CheckArgument("OnNewMail", ntf) && Settings.ProcessMessageNew)
{
_jobStrategy.QueueJob(new DelegateMAPINtf(OnNewMailImpl), ntf);
}
}
private void OnMailDeleteImpl(MAPINtf ntf)
{
if (!CheckStorageIgnored(_storeID))
{
Core.ResourceAP.QueueJob(JobPriority.AboveNormal, new MailDeletedDescriptor(ntf, _storeID));
}
}
public void OnFolderModify(MAPINtf ntf)
{
if (CheckArgument("OnFolderModify", ntf) && Settings.ProcessFolderModify)
{
_jobStrategy.QueueJob(new DelegateMAPINtf(OnFolderModifyImpl), ntf);
}
}
public void OnFolderDelete(MAPINtf ntf)
{
if (CheckArgument("OnFolderDelete", ntf))
{
_jobStrategy.QueueJob(new DelegateMAPINtf(OnFolderDeleteImpl), ntf);
}
}
public virtual void OnMailAdd(MAPINtf ntf)
{
if (_mapiListener != null)
{
_mapiListener.OnMailAdd(ntf);
}
}
public virtual void OnFolderModify(MAPINtf ntf)
{
if (_mapiListener != null)
{
_mapiListener.OnFolderModify(ntf);
}
}
private void OnFolderDeleteImpl(MAPINtf ntf)
{
if (CheckStorageIgnored(_storeID))
{
return;
}
Core.ResourceAP.QueueJob(JobPriority.AboveNormal, new FolderDeletedDescriptor(ntf, _storeID));
}
private void OnFolderAddImpl(MAPINtf ntf)
{
if (CheckStorageIgnored(_storeID))
{
return;
}
FolderAddDescriptor.Do(JobPriority.AboveNormal, ntf, _storeID);
}
private void OnMailAddImpl(MAPINtf ntf)
{
if (CheckStorageIgnored(_storeID))
{
return;
}
ProcessMailAddNtf.DoJob(ntf, _storeID);
}
public static void Do(JobPriority jobPriority, MAPINtf ntf, string storeID)
{
FolderAddDescriptor descriptor = new FolderAddDescriptor(ntf, storeID);
if (descriptor.GetParentFolder() != null)
{
Core.ResourceAP.QueueJob(jobPriority, descriptor);
}
}
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 void OnMailDelete(MAPINtf ntf)
{
if (CheckArgument("OnMailDelete", ntf))
{
Trace("Attempt to ignore OnMailDelete");
}
//if ( CheckArgument( "OnMailDelete", ntf ) )
{
_jobStrategy.QueueJob(new DelegateMAPINtf(OnMailDeleteImpl), ntf);
}
}
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);
}
}
private bool CheckArgument(string category, MAPINtf ntf)
{
Guard.NullArgument(ntf, "ntf");
if (_bTrace)
{
Trace(category, ntf);
}
if (ntf.EntryID != null && ntf.EntryID.Length > 0)
{
bool ret = OutlookSession.IsMailExported(ntf.EntryID);
if (ret)
{
Trace(category + ": event is ignored");
}
return(!ret);
}
return(true);
}
public static void DoJobImpl(MAPINtf ntf, IEMessage message, FolderDescriptor folderDescriptor)
{
string entryId = OutlookSession.GetMessageID(message);
string messageClass = MessageType.GetMessageClass(message);
if (MessageType.InterpretAsMail(messageClass))
{
new MailDescriptor(folderDescriptor, entryId, message).QueueJob(JobPriority.AboveNormal);
}
else if (MessageType.InterpretAsContact(messageClass))
{
ContactDescriptorWrapper.Do(JobPriority.AboveNormal, folderDescriptor, entryId, entryId);
}
else if (MessageType.InterpretAsTask(messageClass))
{
Tracer._Trace("Task was added");
TaskDescriptor.Do(JobPriority.AboveNormal, folderDescriptor, message, entryId);
}
else
{
Tracer._Trace("Unknown item of class " + messageClass + " was added");
}
}
private void OnFolderModifyImpl(MAPINtf ntf)
{
Core.ResourceAP.QueueJob(new FolderModifiedDescriptor(ntf, _storeID, false));
}
public virtual void OnFolderAdd(MAPINtf ntf)
{
}
public virtual void OnFolderModify(MAPINtf ntf)
{
}
public FolderDeletedDescriptor(MAPINtf ntf, string storeID)
{
Guard.NullArgument(ntf, "ntf");
Guard.EmptyStringArgument(storeID, "storeID");
_ntf = ntf;
_storeID = storeID;
// The notification contains only the short-term entry ID, and since the
// folder has already been deleted, it is no longer possible to get the
// long-term entry ID. Thus, we need to scan the children of the parent of
// the deleted folder and check if all of them still exist.
IResource resFolder = Folder.Find(ntf.EntryID);
if (resFolder == null)
{
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)
{
parentMAPIFolder = Folder.Find(ntf.ParentID);
}
if (parentMAPIFolder != null)
{
IResourceList childFolders = parentMAPIFolder.GetLinksTo("MAPIFolder", "Parent");
foreach (IResource childFolderRes in childFolders)
{
IEFolder childFolder = OutlookSession.OpenFolder(childFolderRes.GetStringProp("EntryID"),
storeID);
if (childFolder != null)
{
childFolder.Dispose();
}
else
{
_entryId = childFolderRes.GetStringProp("EntryID");
}
}
if (_entryId == null)
{
HashSet set = new HashSet(childFolders.Count);
foreach (IResource childFolderRes in childFolders)
{
set.Add(childFolderRes.GetStringProp("EntryID"));
}
IEFolders folders = OutlookSession.GetFolders(parentFolder);
if (folders != null)
{
using ( folders )
{
for (int i = 0; i < folders.GetCount(); ++i)
{
IEFolder folder = OutlookSession.OpenFolder(folders, i);
if (folder != null)
{
using ( folder )
{
string entryId = folder.GetBinProp(MAPIConst.PR_ENTRYID);
if (entryId != null)
{
set.Remove(entryId);
}
}
}
}
}
}
foreach (HashSet.Entry entry in set)
{
_entryId = (string)entry.Key;
break;
}
if (_entryId == null && Retry)
{
OutlookSession.OutlookProcessor.QueueJobAt(DateTime.Now.AddMinutes(2), "Delete folder",
new MethodInvoker(CreateFolderDeletedDescriptor));
}
}
}
}
}
}
else
{
_entryId = ntf.EntryID;
}
}
public virtual void OnNewMail(MAPINtf ntf)
{
}
public virtual void OnMailAdd(MAPINtf ntf)
{
}
public virtual void OnFolderDelete(MAPINtf ntf)
{
}
private FolderAddDescriptor(MAPINtf ntf, string storeID) : base(ntf, storeID, false)
{
}
private void Trace(string category, MAPINtf ntf)
{
Trace(category, "storeID", _storeID);
Trace(category, "parentID", ntf.ParentID);
Trace(category, "entryID", ntf.EntryID);
}
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);
}
}
}
public virtual void OnMailDelete(MAPINtf ntf)
{
}
