protected override MailboxChangesManifest EnumerateSourceHierarchyChanges(MailboxCopierBase mbxCtx, bool catchup, SyncContext syncContext)
{
if (catchup)
{
if (!mbxCtx.IsRoot)
{
return(null);
}
return(base.EnumerateSourceHierarchyChanges(mbxCtx, catchup, syncContext));
}
else
{
if (mbxCtx.IsRoot)
{
return(base.EnumerateSourceHierarchyChanges(mbxCtx, catchup, syncContext));
}
FolderMap destinationFolderMap = base.GetRootMailboxContext().GetDestinationFolderMap(GetFolderMapFlags.None);
EntryIdMap <FolderRecWrapper> primaryMailboxFolderRecWrappers = new EntryIdMap <FolderRecWrapper>();
destinationFolderMap.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper primaryFolderRecWrapper, FolderMap.EnumFolderContext enumFolderContext)
{
if (mbxCtx.IsContentAvailableInTargetMailbox(primaryFolderRecWrapper))
{
byte[] key = (byte[])primaryFolderRecWrapper.FolderRec[PropTag.LTID];
primaryMailboxFolderRecWrappers[key] = primaryFolderRecWrapper;
}
});
EntryIdMap <FolderRecWrapper> secondaryMailboxFolderRecWrappers = new EntryIdMap <FolderRecWrapper>();
syncContext.TargetFolderMap.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper secondaryFolderRecWrapper, FolderMap.EnumFolderContext enumFolderContext)
{
if (mbxCtx.IsContentAvailableInTargetMailbox(secondaryFolderRecWrapper))
{
byte[] key = (byte[])secondaryFolderRecWrapper.FolderRec[PropTag.LTID];
secondaryMailboxFolderRecWrappers[key] = secondaryFolderRecWrapper;
}
});
MailboxChangesManifest mailboxChangesManifest = new MailboxChangesManifest();
mailboxChangesManifest.ChangedFolders = new List <byte[]>();
mailboxChangesManifest.DeletedFolders = new List <byte[]>();
foreach (KeyValuePair <byte[], FolderRecWrapper> keyValuePair in primaryMailboxFolderRecWrappers)
{
FolderRecWrapper folderRecWrapper;
if (!secondaryMailboxFolderRecWrappers.TryGetValue(keyValuePair.Key, out folderRecWrapper) || folderRecWrapper.FolderRec.LastModifyTimestamp != keyValuePair.Value.FolderRec.LastModifyTimestamp)
{
mailboxChangesManifest.ChangedFolders.Add(mbxCtx.SourceMailbox.GetSessionSpecificEntryId(keyValuePair.Key));
}
}
foreach (KeyValuePair <byte[], FolderRecWrapper> keyValuePair2 in secondaryMailboxFolderRecWrappers)
{
FolderRecWrapper folderRecWrapper2;
if (!primaryMailboxFolderRecWrappers.TryGetValue(keyValuePair2.Key, out folderRecWrapper2))
{
mailboxChangesManifest.DeletedFolders.Add(mbxCtx.SourceMailbox.GetSessionSpecificEntryId(keyValuePair2.Key));
}
}
return(mailboxChangesManifest);
}
}
public void InitializeNextPage(MailboxChangesManifest mailboxChangesManifest, int maxChanges)
{
this.changes = mailboxChangesManifest;
this.changes.ChangedFolders = new List <byte[]>((!this.isPagedEnumeration) ? 4 : maxChanges);
this.changes.DeletedFolders = new List <byte[]>();
this.maxChanges = maxChanges;
this.countEnumeratedChanges = 0;
bool flag = this.isPagedEnumeration;
}
MailboxChangesManifest IHierarchyChangesFetcher.EnumerateHierarchyChanges(SyncHierarchyManifestState hierState, EnumerateHierarchyChangesFlags flags, int maxChanges)
{
MailboxChangesManifest mailboxChangesManifest = this.EnumerateChanges(hierState, flags, maxChanges);
MrsTracer.Provider.Debug("Discovered {0} changed, {1} deleted", new object[]
{
mailboxChangesManifest.ChangedFolders.Count,
mailboxChangesManifest.DeletedFolders.Count
});
return(mailboxChangesManifest);
}
protected override MailboxChangesManifest RunManualHierarchySync(bool catchup, SyncHierarchyManifestState hierState)
{
MrsTracer.Provider.Function("EasSourceMailbox.RunManualHierarchySync", new object[0]);
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
EasHierarchySyncState easHierarchySyncState = EasHierarchySyncState.Deserialize(hierState.ProviderSyncState);
hierState.ProviderSyncState = null;
EasHierarchySyncState easHierarchySyncState2 = base.RefreshFolderCache();
EntryIdMap <EasHierarchySyncState.EasFolderData> entryIdMap = new EntryIdMap <EasHierarchySyncState.EasFolderData>();
foreach (EasHierarchySyncState.EasFolderData easFolderData in easHierarchySyncState.FolderData)
{
entryIdMap[EasMailbox.GetEntryId(easFolderData.ServerId)] = easFolderData;
}
EntryIdMap <EasHierarchySyncState.EasFolderData> entryIdMap2 = new EntryIdMap <EasHierarchySyncState.EasFolderData>();
foreach (EasHierarchySyncState.EasFolderData easFolderData2 in easHierarchySyncState2.FolderData)
{
entryIdMap2[EasMailbox.GetEntryId(easFolderData2.ServerId)] = easFolderData2;
}
MailboxChangesManifest mailboxChangesManifest = new MailboxChangesManifest();
mailboxChangesManifest.DeletedFolders = new List <byte[]>();
foreach (byte[] array in entryIdMap.Keys)
{
if (!entryIdMap2.ContainsKey(array))
{
mailboxChangesManifest.DeletedFolders.Add(array);
}
}
mailboxChangesManifest.ChangedFolders = new List <byte[]>();
foreach (KeyValuePair <byte[], EasHierarchySyncState.EasFolderData> keyValuePair in entryIdMap2)
{
byte[] key = keyValuePair.Key;
EasHierarchySyncState.EasFolderData value = keyValuePair.Value;
EasHierarchySyncState.EasFolderData easFolderData3;
if (entryIdMap.TryGetValue(key, out easFolderData3))
{
if (easFolderData3.ParentId != value.ParentId || easFolderData3.DisplayName != value.DisplayName)
{
mailboxChangesManifest.ChangedFolders.Add(key);
}
}
else
{
mailboxChangesManifest.ChangedFolders.Add(key);
}
}
return(mailboxChangesManifest);
}
MailboxChangesManifest ISourceMailbox.EnumerateHierarchyChanges(EnumerateHierarchyChangesFlags flags, int maxChanges)
{
MailboxChangesManifest result = null;
base.CreateContext("ISourceMailbox.EnumerateHierarchyChanges", new DataContext[]
{
new SimpleValueDataContext("flags", flags),
new SimpleValueDataContext("maxChanges", maxChanges)
}).Execute(delegate
{
result = ((ISourceMailbox)this.WrappedObject).EnumerateHierarchyChanges(flags, maxChanges);
}, true);
return(result);
}
protected override MailboxChangesManifest DoManifestSync(EnumerateHierarchyChangesFlags flags, int maxChanges, SyncHierarchyManifestState hierState, MapiStore mapiStore)
{
MrsTracer.Provider.Function("EasSourceMailbox.DoManifestSync", new object[0]);
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
flags.HasFlag(EnumerateHierarchyChangesFlags.Catchup);
EasHierarchySyncState easHierarchySyncState = EasHierarchySyncState.Deserialize(hierState.ProviderSyncState);
string syncKey = easHierarchySyncState.SyncKey;
string syncKey2;
IReadOnlyCollection <Add> readOnlyCollection;
MailboxChangesManifest folderChangesOnServer = this.GetFolderChangesOnServer(syncKey, out syncKey2, out readOnlyCollection);
bool flag = false;
easHierarchySyncState.SyncKey = syncKey2;
if (folderChangesOnServer.DeletedFolders != null)
{
List <Add> list = new List <Add>(folderChangesOnServer.DeletedFolders.Count);
foreach (Add add in easHierarchySyncState.Folders)
{
foreach (byte[] entryId in folderChangesOnServer.DeletedFolders)
{
if (StringComparer.Ordinal.Equals(add.ServerId, EasMailbox.GetStringId(entryId)))
{
list.Add(add);
break;
}
}
}
foreach (Add item in list)
{
easHierarchySyncState.Folders.Remove(item);
flag = true;
}
}
if (readOnlyCollection != null)
{
foreach (Add item2 in readOnlyCollection)
{
easHierarchySyncState.Folders.Add(item2);
flag = true;
}
}
hierState.ProviderSyncState = easHierarchySyncState.Serialize(false);
if (flag)
{
base.RefreshFolderCache(easHierarchySyncState);
}
return(folderChangesOnServer);
}
private MailboxChangesManifest EnumerateChanges(SyncHierarchyManifestState hierState, EnumerateHierarchyChangesFlags flags, int maxChanges)
{
MailboxChangesManifest mailboxChangesManifest = new MailboxChangesManifest();
this.ConfigureMapiManifest(hierState, mailboxChangesManifest, flags, maxChanges);
ManifestStatus manifestStatus;
do
{
manifestStatus = this.mapiManifest.Synchronize();
}while (manifestStatus != ManifestStatus.Done && manifestStatus != ManifestStatus.Yielded);
byte[] idsetGiven;
byte[] cnsetSeen;
this.mapiManifest.GetState(out idsetGiven, out cnsetSeen);
hierState.IdsetGiven = idsetGiven;
hierState.CnsetSeen = cnsetSeen;
return(mailboxChangesManifest);
}
private MailboxChangesManifest GetFolderChangesOnServer(string syncKey, out string newSyncKey, out IReadOnlyCollection <Add> newFolders)
{
newFolders = null;
FolderSyncResponse folderSyncResponse = base.EasConnectionWrapper.FolderSync(syncKey);
newSyncKey = folderSyncResponse.SyncKey;
MailboxChangesManifest mailboxChangesManifest = new MailboxChangesManifest();
mailboxChangesManifest.ChangedFolders = new List <byte[]>(0);
mailboxChangesManifest.DeletedFolders = new List <byte[]>(0);
if (folderSyncResponse.Changes != null)
{
List <Add> additions = folderSyncResponse.Changes.Additions;
if (additions != null && additions.Count > 0)
{
mailboxChangesManifest.ChangedFolders.Capacity += additions.Count;
foreach (Add add in additions)
{
mailboxChangesManifest.ChangedFolders.Add(EasMailbox.GetEntryId(add.ServerId));
}
newFolders = additions;
}
List <Update> updates = folderSyncResponse.Changes.Updates;
if (updates != null && updates.Count > 0)
{
mailboxChangesManifest.ChangedFolders.Capacity += updates.Count;
foreach (Update update in updates)
{
mailboxChangesManifest.ChangedFolders.Add(EasMailbox.GetEntryId(update.ServerId));
}
}
List <Delete> deletions = folderSyncResponse.Changes.Deletions;
if (deletions != null && deletions.Count > 0)
{
mailboxChangesManifest.DeletedFolders.Capacity = deletions.Count;
foreach (Delete delete in deletions)
{
mailboxChangesManifest.DeletedFolders.Add(EasMailbox.GetEntryId(delete.ServerId));
}
}
}
return(mailboxChangesManifest);
}
private void ConfigureMapiManifest(SyncHierarchyManifestState syncState, MailboxChangesManifest changes, EnumerateHierarchyChangesFlags flags, int maxChanges)
{
if (this.isPagedEnumeration && !flags.HasFlag(EnumerateHierarchyChangesFlags.FirstPage))
{
this.callback.InitializeNextPage(changes, maxChanges);
return;
}
this.callback = new ManifestHierarchyCallback(this.isPagedEnumeration);
this.callback.InitializeNextPage(changes, maxChanges);
SyncConfigFlags syncConfigFlags = SyncConfigFlags.ManifestHierReturnDeletedEntryIds;
if (((this.mailbox.ServerVersion >= Server.E14MinVersion && this.mailbox.ServerVersion < Server.E15MinVersion) || (long)this.mailbox.ServerVersion >= ManifestHierarchyChangesFetcher.E15MinVersionSupportsOnlySpecifiedPropsForHierarchy) && !this.mailbox.IsPureMAPI)
{
syncConfigFlags |= SyncConfigFlags.OnlySpecifiedProps;
}
using (this.mailbox.RHTracker.Start())
{
this.mapiManifest = this.mapiFolder.CreateExportHierarchyManifestEx(syncConfigFlags, syncState.IdsetGiven, syncState.CnsetSeen, this.callback, new PropTag[]
{
PropTag.EntryId
}, null);
}
}
public MailboxChanges(MailboxChangesManifest hierarchyChanges)
{
this.hierarchyChanges = hierarchyChanges;
this.folderChanges = new EntryIdMap <FolderChangesManifest>();
}
