EntryIdMap <byte[]> IFxProxyPool.GetFolderData() { EntryIdMap <byte[]> entryIdMap = new EntryIdMap <byte[]>(); foreach (KeyValuePair <byte[], byte[]> keyValuePair in base.WrappedObject.GetFolderData()) { if (keyValuePair.Key.Length == 46) { entryIdMap.Add(this.sourceMailbox.GetSessionSpecificEntryId(keyValuePair.Key), keyValuePair.Value); } } return(entryIdMap); }
protected void RefreshFolderCache(EasHierarchySyncState state) { IReadOnlyCollection <Add> folders = state.Folders; EntryIdMap <Add> entryIdMap = new EntryIdMap <Add>(folders.Count); this.defaultCalendarId = null; foreach (Add add in folders) { EasFolderType easFolderType = add.GetEasFolderType(); if (easFolderType == EasFolderType.Calendar) { this.defaultCalendarId = EasMailbox.GetEntryId(add.ServerId); } EasFolderType easFolderType2 = easFolderType; if (easFolderType2 == EasFolderType.UserGeneric) { goto IL_8B; } bool flag; switch (easFolderType2) { case EasFolderType.Contacts: case EasFolderType.UserContacts: flag = !ConfigBase <MRSConfigSchema> .GetConfig <bool>("DisableContactSync"); goto IL_9D; case EasFolderType.UserMail: case EasFolderType.UserCalendar: goto IL_8B; } flag = EasMailbox.folderTypeMap.ContainsKey(easFolderType); IL_9D: if (flag) { entryIdMap.Add(EasMailbox.GetEntryId(add.ServerId), add); continue; } MrsTracer.Provider.Debug("EasMailbox.RefreshFolderCache: ignore {0} folder '{1}' since it is not supported yet", new object[] { easFolderType, add.DisplayName }); continue; IL_8B: flag = true; goto IL_9D; } this.EasFolderCache = entryIdMap; }
EntryIdMap <byte[]> IFxProxyPool.GetFolderData() { EntryIdMap <byte[]> folderData = base.WrappedObject.GetFolderData(); EntryIdMap <byte[]> entryIdMap = new EntryIdMap <byte[]>(); foreach (KeyValuePair <byte[], byte[]> keyValuePair in folderData) { byte[] array = keyValuePair.Key; if (CommonUtils.IsSameEntryId(array, this.mapper.folderMapping.TargetFolder.EntryId)) { array = this.mapper.folderMapping.EntryId; } entryIdMap.Add(array, keyValuePair.Value); } return(entryIdMap); }
public ReplayActionsQueue GetAndTranslateActions(string replaySyncState, int maxNumberOfActions, MergeSyncContext syncContext, out string retrieveSyncState, out bool moreActions) { MrsTracer.Service.Function("MailboxMerger.GetAndTranslateActions", new object[0]); List <ReplayAction> actions = base.DestMailbox.GetActions(replaySyncState, maxNumberOfActions); moreActions = (actions.Count == maxNumberOfActions); retrieveSyncState = ((actions.Count == 0) ? replaySyncState : actions[actions.Count - 1].Watermark); ReplayActionsQueue replayActionsQueue = new ReplayActionsQueue(actions.Count); foreach (ReplayAction action in actions) { replayActionsQueue.Enqueue(action); } EntryIdMap <List <byte[]> > entryIdMap = new EntryIdMap <List <byte[]> >(); foreach (ReplayAction replayAction in actions) { if (!replayAction.Ignored) { foreach (KeyValuePair <byte[], byte[]> keyValuePair in replayAction.GetMessageEntryIdsToTranslate()) { byte[] key = keyValuePair.Key; byte[] value = keyValuePair.Value; List <byte[]> list; if (!entryIdMap.TryGetValue(key, out list)) { list = new List <byte[]>(); entryIdMap.Add(key, list); } list.Add(value); } } } syncContext.PrefetchSourceMessageIdsFromTargetMessageIds(entryIdMap); foreach (ReplayAction replayAction2 in actions) { if (!replayAction2.Ignored) { replayAction2.TranslateEntryIds(syncContext); } } return(replayActionsQueue); }
private void RegisterUniqueTargetSecondaryKeys(MessageRec message, List <byte[]> secondaryKeys, EntryIdMap <MessageRec> messageMap, HashSet <byte[]> duplicateKeys) { foreach (byte[] array in secondaryKeys) { if (array != null && !duplicateKeys.Contains(array)) { if (!messageMap.ContainsKey(array)) { messageMap.Add(array, message); } else { MrsTracer.Service.Debug("Duplicate SecondaryKey found for target message {0}", new object[] { TraceUtils.DumpEntryId(message.EntryId) }); messageMap.Remove(array); duplicateKeys.Add(array); } } } }
public void ComputeFolderMapping(FolderHierarchy targetHierarchy, bool createMissingFolderRecs) { if (!this.folderFilterApplied) { this.SetFolderFilter(null, false, null, string.Empty, false, Guid.Empty); } EntryIdMap <FolderMapping> targetBySourceEntryID = new EntryIdMap <FolderMapping>(); targetHierarchy.EnumerateSubtree(EnumHierarchyFlags.AllFolders, targetHierarchy.RootFolder, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; byte[] array = folderMapping.FolderRec[targetHierarchy.SourceEntryIDPtag] as byte[]; if (array != null && !targetBySourceEntryID.ContainsKey(array)) { targetBySourceEntryID.Add(array, folderMapping); } }); base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; FolderMapping wellKnownFolder; if (folderMapping.WKFType != WellKnownFolderType.None) { wellKnownFolder = targetHierarchy.GetWellKnownFolder(folderMapping.WKFType); if (wellKnownFolder != null) { folderMapping.TargetFolder = wellKnownFolder; wellKnownFolder.SourceFolder = folderMapping; this.MapPublicFolderDumpster(folderMapping, wellKnownFolder); return; } } if (targetBySourceEntryID.TryGetValue(folderMapping.EntryId, out wellKnownFolder)) { folderMapping.TargetFolder = wellKnownFolder; wellKnownFolder.SourceFolder = folderMapping; this.MapPublicFolderDumpster(folderMapping, wellKnownFolder); } }); base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; if (folderMapping.TargetFolder != null) { this.MapSubtreeByName(folderMapping, createMissingFolderRecs); ctx.Result = EnumHierarchyResult.SkipSubtree; } }); FolderMapping ipmSubtree = this.GetWellKnownFolder(WellKnownFolderType.IpmSubtree); if (ipmSubtree != null) { base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; if (folderMapping.IsIncluded && folderMapping.TargetFolder == null) { this.MapFolderByName(folderMapping, ipmSubtree.TargetFolder, createMissingFolderRecs); if (folderMapping.TargetFolder != null) { this.MapSubtreeByName(folderMapping, createMissingFolderRecs); } ctx.Result = EnumHierarchyResult.SkipSubtree; } }); } }
List <MessageRec> IFolder.LookupMessages(PropTag ptagToLookup, List <byte[]> keysToLookup, PropTag[] additionalPtagsToLoad) { EntryIdMap <MessageRec> result = new EntryIdMap <MessageRec>(); ContentsTableFlags[] array = new ContentsTableFlags[] { ContentsTableFlags.None, ContentsTableFlags.Associated }; List <PropTag> pta = new List <PropTag>(5); int idxEntryId = pta.Count; pta.Add(PropTag.EntryId); int idxMessageSize = pta.Count; pta.Add(PropTag.MessageSize); int idxCreationTime = pta.Count; pta.Add(PropTag.CreationTime); int idxExtraPtags = pta.Count; if (additionalPtagsToLoad != null) { pta.AddRange(additionalPtagsToLoad); } for (int i = 0; i < array.Length; i++) { if (result.Count >= keysToLookup.Count) { break; } ContentsTableFlags flags = ContentsTableFlags.DeferredErrors | array[i]; bool doingFAI = (flags & ContentsTableFlags.Associated) != ContentsTableFlags.None; ExecutionContext.Create(new DataContext[] { new OperationDataContext("MapiFolder.GetContentsTable", OperationType.None), new SimpleValueDataContext("Flags", flags) }).Execute(delegate { MapiTable msgTable; using (this.Mailbox.RHTracker.Start()) { msgTable = this.Folder.GetContentsTable(flags); } using (msgTable) { if (ptagToLookup != PropTag.EntryId) { using (this.Mailbox.RHTracker.Start()) { msgTable.SortTable(new SortOrder(ptagToLookup, SortFlags.Ascend), SortTableFlags.None); } } msgTable.SetColumns(pta); using (List <byte[]> .Enumerator enumerator = keysToLookup.GetEnumerator()) { while (enumerator.MoveNext()) { byte[] key = enumerator.Current; if (!result.ContainsKey(key)) { ExecutionContext.Create(new DataContext[] { new EntryIDsDataContext(key) }).Execute(delegate { try { using (this.Mailbox.RHTracker.Start()) { if (!msgTable.FindRow(Restriction.EQ(ptagToLookup, key), BookMark.Beginning, FindRowFlag.None)) { return; } } } catch (MapiExceptionNotFound) { return; } PropValue[][] array2; using (this.Mailbox.RHTracker.Start()) { array2 = msgTable.QueryRows(1); } if (array2.Length == 1) { PropValue[] array3 = array2[0]; if (array3.Length != pta.Count) { return; } PropValueData[] array4 = null; if (additionalPtagsToLoad != null && additionalPtagsToLoad.Length > 0) { array4 = new PropValueData[additionalPtagsToLoad.Length]; for (int j = idxExtraPtags; j < array3.Length; j++) { array4[j - idxExtraPtags] = DataConverter <PropValueConverter, PropValue, PropValueData> .GetData(array3[j]); } } MessageRec value = new MessageRec(array3[idxEntryId].GetBytes(), this.FolderId, MapiUtils.GetDateTimeOrDefault(array3[idxCreationTime]), array3[idxMessageSize].GetInt(1000), doingFAI ? MsgRecFlags.Associated : MsgRecFlags.None, array4); result.Add(key, value); return; } }); } } } } }); } MrsTracer.Provider.Debug("MapiFolder.LookupMessages returns {0} items.", new object[] { result.Count }); return(new List <MessageRec>(result.Values)); }
public static void LookupBadMessagesInMailbox(ISourceMailbox mailbox, List <MessageRec> messages, out EntryIdMap <MessageRec> lookedUpMsgs, out EntryIdMap <FolderRec> folderRecs) { EntryIdMap <EntryIdMap <MessageRec> > entryIdMap = new EntryIdMap <EntryIdMap <MessageRec> >(); folderRecs = new EntryIdMap <FolderRec>(); lookedUpMsgs = new EntryIdMap <MessageRec>(); foreach (MessageRec messageRec in messages) { EntryIdMap <MessageRec> entryIdMap2; if (!entryIdMap.TryGetValue(messageRec.FolderId, out entryIdMap2)) { entryIdMap2 = new EntryIdMap <MessageRec>(); entryIdMap.Add(messageRec.FolderId, entryIdMap2); } entryIdMap2[messageRec.EntryId] = null; } MrsTracer.Common.Debug("Looking up {0} messages in {1} folders.", new object[] { messages.Count, entryIdMap.Count }); foreach (KeyValuePair <byte[], EntryIdMap <MessageRec> > keyValuePair in entryIdMap) { using (ISourceFolder folder = mailbox.GetFolder(keyValuePair.Key)) { if (folder == null) { MrsTracer.Common.Warning("Folder {0} disappeared.", new object[] { TraceUtils.DumpEntryId(keyValuePair.Key) }); } else { FolderRec folderRec = folder.GetFolderRec(null, GetFolderRecFlags.None); folderRecs[folderRec.EntryId] = folderRec; EntryIdMap <MessageRec> value = keyValuePair.Value; MrsTracer.Common.Debug("Looking up {0} messages in folder '{1}'.", new object[] { value.Count, folderRec.FolderName }); int num = 0; if (mailbox.IsCapabilitySupported(MRSProxyCapabilities.SimpleExport)) { List <byte[]> keysToLookup = new List <byte[]>(value.Keys); List <MessageRec> list = folder.LookupMessages(PropTag.EntryId, keysToLookup, BadMessageRec.BadItemPtags); if (list == null) { goto IL_230; } using (List <MessageRec> .Enumerator enumerator3 = list.GetEnumerator()) { while (enumerator3.MoveNext()) { MessageRec messageRec2 = enumerator3.Current; lookedUpMsgs[messageRec2.EntryId] = messageRec2; num++; } goto IL_230; } } List <MessageRec> list2 = folder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages, BadMessageRec.BadItemPtags); foreach (MessageRec messageRec3 in list2) { if (value.ContainsKey(messageRec3.EntryId)) { lookedUpMsgs[messageRec3.EntryId] = messageRec3; num++; } } IL_230: MrsTracer.Common.Debug("Found {0} messages.", new object[] { num }); } } } MrsTracer.Common.Debug("Looked up {0} messages.", new object[] { lookedUpMsgs.Count }); }