public virtual void CopyFrom(FolderRecWrapper sourceRec) { this.FolderRec.CopyFrom(sourceRec.FolderRec); this.Rules = sourceRec.Rules; this.FolderNTSD = sourceRec.FolderNTSD; this.FolderFreeBusyNTSD = sourceRec.FolderFreeBusyNTSD; this.FolderACL = sourceRec.FolderACL; this.FolderFreeBusyACL = sourceRec.FolderFreeBusyACL; this.SearchFolderRestriction = sourceRec.SearchFolderRestriction; this.SearchFolderScopeIDs = sourceRec.SearchFolderScopeIDs; this.SearchFolderState = sourceRec.SearchFolderState; this.LoadedData = sourceRec.LoadedData; this.MappedData = sourceRec.MappedData; }
public void CopyFolderData(FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder) { MrsTracer.Service.Debug("Loading mappable folder properties", new object[0]); FolderRecDataFlags dataToCopy = FolderRecDataFlags.SearchCriteria; if (!base.MRSJob.CachedRequestJob.IsPublicFolderMailboxRestore) { bool flag; this.CopyFolderProperties(fm, srcFolder, destFolder, dataToCopy, out flag); } if (fm.FolderType != FolderType.Search) { this.MergeFolderContents(fm, srcFolder, destFolder); } }
public void CopyFolderPropertiesAndContents(FolderMapping folder, FolderContentsCrawler sourceFolderCrawler, IDestinationFolder destFolder, bool copyProperties, TimeSpan maxOperationDuration) { MrsTracer.Service.Function("CopyFolderPropertiesAndContents('{0}')", new object[] { folder.FullFolderName }); if (copyProperties) { MrsTracer.Service.Debug("Loading mappable folder properties", new object[0]); FolderRecDataFlags dataToCopy = FolderRecDataFlags.SearchCriteria; if (!base.MRSJob.CachedRequestJob.IsPublicFolderMailboxRestore) { bool flag; this.CopyFolderProperties(folder, sourceFolderCrawler.WrappedObject, destFolder, dataToCopy, out flag); } } if (folder.FolderType != FolderType.Search) { this.MergeFolderContentsPaged(folder, sourceFolderCrawler, destFolder, maxOperationDuration); } }
public override void EnsureDataLoaded(IFolder folder, FolderRecDataFlags dataToLoad, MailboxCopierBase mbxCtx) { if (mbxCtx.IsPublicFolderMigration) { switch (this.WKFType) { case WellKnownFolderType.Root: case WellKnownFolderType.NonIpmSubtree: case WellKnownFolderType.IpmSubtree: case WellKnownFolderType.EFormsRegistry: dataToLoad &= ~(FolderRecDataFlags.SecurityDescriptors | FolderRecDataFlags.FolderAcls | FolderRecDataFlags.ExtendedAclInformation); break; default: if (this.IsLegacyPublicFolder) { dataToLoad &= ~(FolderRecDataFlags.SecurityDescriptors | FolderRecDataFlags.FolderAcls | FolderRecDataFlags.ExtendedAclInformation); } break; } } base.EnsureDataLoaded(folder, dataToLoad, mbxCtx); }
public override void CopyFolderProperties(FolderRecWrapper sourceFolderRecWrapper, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped) { Guid empty = Guid.Empty; bool isRoot = base.IsRoot; bool flag = false; wasPropertyCopyingSkipped = false; FolderMapping folderMapping = sourceFolderRecWrapper as FolderMapping; while (folderMapping.WKFType != WellKnownFolderType.Root) { if (folderMapping.IsLegacyPublicFolder) { return; } folderMapping = (folderMapping.Parent as FolderMapping); } if (destFolder == null) { if (!isRoot || ((FolderMapping)sourceFolderRecWrapper).IsSystemPublicFolder) { MrsTracer.Service.Debug("Skipping final property copying for \"{0}\" folder since it's contents don't reside in this mailbox", new object[] { sourceFolderRecWrapper.FullFolderName }); return; } throw new FolderCopyFailedPermanentException(sourceFolderRecWrapper.FullFolderName); } else { PropValueData[] props = destFolder.GetProps(new PropTag[] { PropTag.ReplicaList, PropTag.IpmWasteBasketEntryId }); IDataConverter <PropValue, PropValueData> dataConverter = new PropValueConverter(); PropValue nativeRepresentation = dataConverter.GetNativeRepresentation(props[0]); byte[] array = nativeRepresentation.Value as byte[]; if (!nativeRepresentation.IsNull() && !nativeRepresentation.IsError() && array != null) { StorePropertyDefinition replicaList = CoreFolderSchema.ReplicaList; string[] stringArrayFromBytes = ReplicaListProperty.GetStringArrayFromBytes(array); if (stringArrayFromBytes.Length > 0 && GuidHelper.TryParseGuid(stringArrayFromBytes[0], out empty)) { flag = (empty == base.TargetMailboxGuid); } } FolderStateSnapshot folderStateSnapshot = base.ICSSyncState[sourceFolderRecWrapper.EntryId]; FolderState state = folderStateSnapshot.State; if (sourceFolder.GetFolderRec(this.GetAdditionalFolderPtags(), GetFolderRecFlags.None).IsGhosted) { folderStateSnapshot.State |= FolderState.IsGhosted; } else { folderStateSnapshot.State &= ~FolderState.IsGhosted; } if (state != folderStateSnapshot.State) { base.SaveICSSyncState(false); } if (!isRoot && !flag) { return; } List <PropValueData> list = new List <PropValueData>(2); bool flag2 = false; if (flag) { PropValue nativeRepresentation2 = dataConverter.GetNativeRepresentation(sourceFolder.GetProps(new PropTag[] { PropTag.PfProxy })[0]); if (!nativeRepresentation2.IsNull() && !nativeRepresentation2.IsError()) { byte[] array2 = nativeRepresentation2.Value as byte[]; if (array2 != null && array2.Length == 16 && new Guid(array2) != Guid.Empty) { Guid a = Guid.Empty; bool flag3 = base.Flags.HasFlag(MailboxCopierFlags.CrossOrg); if (flag3) { a = destFolder.LinkMailPublicFolder(LinkMailPublicFolderFlags.EntryId, sourceFolderRecWrapper.EntryId); } else { a = destFolder.LinkMailPublicFolder(LinkMailPublicFolderFlags.ObjectGuid, array2); } if (a != Guid.Empty) { list.Add(new PropValueData(PropTag.PfProxy, a.ToByteArray())); list.Add(new PropValueData(PropTag.PfProxyRequired, true)); flag2 = true; } else { base.Report.Append(new ReportEntry(MrsStrings.ReportFailedToLinkADPublicFolder(sourceFolderRecWrapper.FullFolderName, BitConverter.ToString(array2), BitConverter.ToString(sourceFolderRecWrapper.EntryId)), ReportEntryType.Warning)); } } } } if (!flag2) { list.Add(new PropValueData(PropTag.PfProxy, Guid.Empty.ToByteArray())); list.Add(new PropValueData(PropTag.PfProxyRequired, false)); } List <PropValueData> list2 = new List <PropValueData>(9); if (isRoot) { if (!flag) { dataToCopy &= (FolderRecDataFlags.SecurityDescriptors | FolderRecDataFlags.FolderAcls | FolderRecDataFlags.ExtendedAclInformation); } list2.AddRange(list); } else { byte[] sessionSpecificEntryId = this.hierarchyMailbox.GetSessionSpecificEntryId(sourceFolderRecWrapper.EntryId); using (IDestinationFolder folder = this.hierarchyMailbox.GetFolder(sessionSpecificEntryId)) { if (folder == null) { MrsTracer.Service.Error("Something deleted destination hierarchy folder from under us", new object[0]); throw new UnexpectedErrorPermanentException(-2147221238); } if (list.Count > 0) { folder.SetProps(list.ToArray()); } } } base.CopyFolderProperties(sourceFolderRecWrapper, sourceFolder, destFolder, dataToCopy, out wasPropertyCopyingSkipped); PropTag[] pta = new PropTag[] { PropTag.DisablePeruserRead, PropTag.OverallAgeLimit, PropTag.RetentionAgeLimit, PropTag.PfQuotaStyle, PropTag.PfOverHardQuotaLimit, PropTag.PfStorageQuota, PropTag.PfMsgSizeLimit }; foreach (PropValueData propValueData in sourceFolder.GetProps(pta)) { PropValue nativeRepresentation3 = dataConverter.GetNativeRepresentation(propValueData); if (!nativeRepresentation3.IsNull() && !nativeRepresentation3.IsError()) { if (propValueData.PropTag == 1721303043 && (int)propValueData.Value > 0) { propValueData.Value = (int)EnhancedTimeSpan.FromDays((double)((int)propValueData.Value)).TotalSeconds; } list2.Add(propValueData); } } if (list2.Count > 0) { destFolder.SetProps(list2.ToArray()); } return; } }
public override void CopyFolderProperties(FolderRecWrapper folderRec, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped) { base.CopyFolderProperties(folderRec, sourceFolder, destFolder, dataToCopy, out wasPropertyCopyingSkipped); MrsTracer.Service.Debug("Stamping additional properties on the target folder", new object[0]); List <PropValueData> list = new List <PropValueData>(3); list.Add(new PropValueData(this.DestHierarchy.SourceEntryIDPtag, folderRec.EntryId)); list.Add(new PropValueData(this.DestHierarchy.SourceLastModifiedTimestampPtag, folderRec.FolderRec.LastModifyTimestamp)); WellKnownFolderType wellKnownFolderType = WellKnownFolderType.None; if (this.SourceHierarchy != null) { wellKnownFolderType = this.SourceHierarchy.GetWellKnownFolderType(folderRec.EntryId); } if (wellKnownFolderType != WellKnownFolderType.None) { list.Add(new PropValueData(this.DestHierarchy.SourceWKFTypePtag, (int)wellKnownFolderType)); } destFolder.SetProps(list.ToArray()); }
protected override void CatchupFolderHierarchy() { if (!this.PrimaryHierarchyMbxWrapper.Mailbox.IsConnected()) { this.PrimaryHierarchyMbxWrapper.Mailbox.Connect(MailboxConnectFlags.None); } FolderRecDataFlags folderRecDataFlags = FolderRecDataFlags.SearchCriteria; if (!base.CachedRequestJob.SkipFolderPromotedProperties) { folderRecDataFlags |= FolderRecDataFlags.PromotedProperties; } if (!base.CachedRequestJob.SkipFolderViews) { folderRecDataFlags |= FolderRecDataFlags.Views; } if (!base.CachedRequestJob.SkipFolderRestrictions) { folderRecDataFlags |= FolderRecDataFlags.Restrictions; } List <WellKnownFolder> list = this.folderMover.SourceMailbox.DiscoverWellKnownFolders(0); List <WellKnownFolder> destinationWellKnownFolders = this.folderMover.DestMailbox.DiscoverWellKnownFolders(0); foreach (byte[] array in this.foldersToMove) { using (IFolder folder = ((ISourceMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array)) { using (IDestinationFolder folder2 = this.folderMover.DestMailbox.GetFolder(this.folderMover.DestMailbox.GetSessionSpecificEntryId(array))) { if (folder2 == null) { if (folder == null) { MrsTracer.Service.Debug("Folder {0} unavailable at both source and destination mailbox during catchup", new object[] { HexConverter.ByteArrayToHexString(array) }); } else { List <FolderRecWrapper> list2 = new List <FolderRecWrapper>(); byte[] entryId = array; for (;;) { using (ISourceFolder folder3 = this.folderMover.SourceMailbox.GetFolder(entryId)) { if (folder3 != null) { FolderRecWrapper folderRecWrapper = new FolderRecWrapper(folder3.GetFolderRec(null, GetFolderRecFlags.None)); if (folderRecWrapper.ParentId != null) { list2.Insert(0, folderRecWrapper); bool flag = false; foreach (WellKnownFolder wellKnownFolder in list) { if (CommonUtils.IsSameEntryId(wellKnownFolder.EntryId, folderRecWrapper.ParentId)) { flag = true; break; } } if (!flag) { entryId = folderRecWrapper.ParentId; continue; } } } } break; } foreach (FolderRecWrapper folderRecWrapper2 in list2) { byte[] entryId2 = folderRecWrapper2.FolderRec.EntryId; byte[] parentId = folderRecWrapper2.FolderRec.ParentId; byte[] sessionSpecificEntryId = this.folderMover.DestMailbox.GetSessionSpecificEntryId(entryId2); bool flag2 = false; byte[] destinationFolderIdFromSourceFolderId = AuxFolderMoveJob.GetDestinationFolderIdFromSourceFolderId(list, destinationWellKnownFolders, this.folderMover.DestMailbox, parentId, out flag2); using (IDestinationFolder folder4 = this.folderMover.DestMailbox.GetFolder(sessionSpecificEntryId)) { if (folder4 == null) { using (ISourceFolder folder5 = this.folderMover.SourceMailbox.GetFolder(entryId2)) { if (folder5 == null) { MrsTracer.Service.Warning("Source folder '{0}' {1} disappeared, skipping", new object[] { folderRecWrapper2.FolderName, folderRecWrapper2.EntryId }); break; } folderRecWrapper2.EnsureDataLoaded(folder5, folderRecDataFlags, this.folderMover); this.folderMover.TranslateFolderData(folderRecWrapper2); CreateFolderFlags createFolderFlags = CreateFolderFlags.None; folderRecWrapper2.FolderRec.EntryId = sessionSpecificEntryId; folderRecWrapper2.FolderRec.ParentId = destinationFolderIdFromSourceFolderId; byte[] array2; this.folderMover.CreateFolder(null, folderRecWrapper2, createFolderFlags, out array2); folderRecWrapper2.FolderRec.EntryId = entryId2; folderRecWrapper2.FolderRec.ParentId = parentId; } } } } } } } } } base.SyncStage = SyncStage.CreatingInitialSyncCheckpoint; base.OverallProgress = 15; base.TimeTracker.CurrentState = RequestState.CreatingInitialSyncCheckpoint; base.SaveState(SaveStateFlags.Regular, delegate(TransactionalRequestJob moveRequest) { moveRequest.RestartFromScratch = false; }); base.ScheduleWorkItem(new Action(base.CatchupFolders), WorkloadType.Unknown); }
public void TranslateMappableData(MailboxCopierBase mbxCopier) { if (this.FieldIsLoaded(FolderRecDataFlags.PromotedProperties) && !this.FieldIsMapped(FolderRecDataFlags.PromotedProperties)) { PropTag[] promotedProperties = this.FolderRec.GetPromotedProperties(); mbxCopier.NamedPropTranslator.TranslatePropTags(promotedProperties); this.FolderRec.SetPromotedProperties(promotedProperties); this.MappedData |= FolderRecDataFlags.PromotedProperties; } if (this.FieldIsLoaded(FolderRecDataFlags.Views) && !this.FieldIsMapped(FolderRecDataFlags.Views) && this.FolderRec.Views != null) { foreach (SortOrderData so in this.FolderRec.Views) { mbxCopier.NamedPropTranslator.TranslateSortOrder(so); } this.MappedData |= FolderRecDataFlags.Views; } if (this.FieldIsLoaded(FolderRecDataFlags.Restrictions) && !this.FieldIsMapped(FolderRecDataFlags.Restrictions) && this.FolderRec.Restrictions != null) { foreach (RestrictionData restrictionData in this.FolderRec.Restrictions) { mbxCopier.NamedPropTranslator.TranslateRestriction(restrictionData); if (mbxCopier.FolderIdTranslator != null) { mbxCopier.FolderIdTranslator.TranslateRestriction(restrictionData); } } this.MappedData |= FolderRecDataFlags.Restrictions; } if (this.FieldIsLoaded(FolderRecDataFlags.SearchCriteria) && !this.FieldIsMapped(FolderRecDataFlags.SearchCriteria)) { if (this.FolderType == FolderType.Search) { mbxCopier.NamedPropTranslator.TranslateRestriction(this.SearchFolderRestriction); if (mbxCopier.FolderIdTranslator != null) { mbxCopier.FolderIdTranslator.TranslateRestriction(this.SearchFolderRestriction); this.SearchFolderScopeIDs = mbxCopier.FolderIdTranslator.TranslateFolderIds(this.SearchFolderScopeIDs); } } this.MappedData |= FolderRecDataFlags.SearchCriteria; } if (mbxCopier.PrincipalTranslator != null && this.FieldIsLoaded(FolderRecDataFlags.SecurityDescriptors) && !this.FieldIsMapped(FolderRecDataFlags.SecurityDescriptors)) { mbxCopier.PrincipalTranslator.TranslateSecurityDescriptor(this.FolderNTSD, TranslateSecurityDescriptorFlags.None); mbxCopier.PrincipalTranslator.TranslateSecurityDescriptor(this.FolderFreeBusyNTSD, TranslateSecurityDescriptorFlags.None); this.MappedData |= FolderRecDataFlags.SecurityDescriptors; } if (this.Rules != null && this.FieldIsLoaded(FolderRecDataFlags.Rules) && !this.FieldIsMapped(FolderRecDataFlags.Rules)) { mbxCopier.NamedPropTranslator.TranslateRules(this.Rules); if (!mbxCopier.SourceMailbox.IsCapabilitySupported(MRSProxyCapabilities.InMailboxExternalRules) && mbxCopier.DestMailbox.IsCapabilitySupported(MRSProxyCapabilities.InMailboxExternalRules)) { this.PatchRulesForDownlevelSources(this.Rules, mbxCopier.GetSourceFolderMap(GetFolderMapFlags.None)); } if (mbxCopier.SourceMailbox.IsCapabilitySupported(MRSProxyCapabilities.InMailboxExternalRules) && !mbxCopier.DestMailbox.IsCapabilitySupported(MRSProxyCapabilities.InMailboxExternalRules)) { this.PatchRulesForDownlevelDestinations(this.Rules); } if (mbxCopier.FolderIdTranslator != null) { mbxCopier.FolderIdTranslator.TranslateRules(this.Rules); } if (mbxCopier.PrincipalTranslator != null) { mbxCopier.PrincipalTranslator.TranslateRules(this.Rules); } this.MappedData |= FolderRecDataFlags.Rules; } if (mbxCopier.PrincipalTranslator != null && ((this.FieldIsLoaded(FolderRecDataFlags.FolderAcls) && !this.FieldIsMapped(FolderRecDataFlags.FolderAcls)) || (this.FieldIsLoaded(FolderRecDataFlags.ExtendedAclInformation) && !this.FieldIsMapped(FolderRecDataFlags.ExtendedAclInformation)))) { mbxCopier.PrincipalTranslator.TranslateFolderACL(this.FolderACL); mbxCopier.PrincipalTranslator.TranslateFolderACL(this.FolderFreeBusyACL); this.MappedData |= (this.FieldIsLoaded(FolderRecDataFlags.ExtendedAclInformation) ? FolderRecDataFlags.ExtendedAclInformation : FolderRecDataFlags.FolderAcls); } }
public virtual void EnsureDataLoaded(IFolder folder, FolderRecDataFlags dataToLoad, MailboxCopierBase mbxCtx) { FolderRecDataFlags folderRecDataFlags = dataToLoad & FolderRecDataFlags.ExtendedData; if (folderRecDataFlags != FolderRecDataFlags.None && !this.FieldIsLoaded(folderRecDataFlags)) { GetFolderRecFlags getFolderRecFlags = GetFolderRecFlags.None; if (this.FolderType == FolderType.Generic) { if ((dataToLoad & FolderRecDataFlags.PromotedProperties) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.PromotedProperties)) { getFolderRecFlags |= GetFolderRecFlags.PromotedProperties; } if ((dataToLoad & FolderRecDataFlags.Restrictions) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.Restrictions)) { getFolderRecFlags |= GetFolderRecFlags.Restrictions; } } if ((this.FolderType == FolderType.Generic || this.FolderType == FolderType.Search) && (dataToLoad & FolderRecDataFlags.Views) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.Views)) { getFolderRecFlags |= GetFolderRecFlags.Views; } if (getFolderRecFlags != GetFolderRecFlags.None) { FolderRec folderRec = folder.GetFolderRec(null, getFolderRecFlags); this.FolderRec.SetPromotedProperties(folderRec.GetPromotedProperties()); this.FolderRec.Views = folderRec.Views; this.FolderRec.ICSViews = folderRec.ICSViews; this.FolderRec.Restrictions = folderRec.Restrictions; } this.LoadedData |= folderRecDataFlags; } if ((dataToLoad & FolderRecDataFlags.SearchCriteria) != FolderRecDataFlags.None && !this.IsSpoolerQueue && !this.FieldIsLoaded(FolderRecDataFlags.SearchCriteria)) { this.ReadSearchCriteria(folder, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.SearchCriteria; } if ((dataToLoad & FolderRecDataFlags.Rules) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.Rules)) { this.ReadRules(folder, FolderRecWrapper.extraTags, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.Rules; MrsTracer.Service.Debug("Rules loaded: {0}", new object[] { new RulesDataContext(this.Rules) }); } if ((dataToLoad & FolderRecDataFlags.SecurityDescriptors) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.SecurityDescriptors)) { this.FolderNTSD = this.ReadSD(folder, SecurityProp.NTSD, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.FolderFreeBusyNTSD = this.ReadSD(folder, SecurityProp.FreeBusyNTSD, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.SecurityDescriptors; MrsTracer.Service.Debug("FolderSDs loaded: NTSD {0}, FreeBusyNTSD {1}", new object[] { CommonUtils.GetSDDLString(this.FolderNTSD), CommonUtils.GetSDDLString(this.FolderFreeBusyNTSD) }); } if (dataToLoad.HasFlag(FolderRecDataFlags.FolderAcls) && !this.FieldIsLoaded(FolderRecDataFlags.FolderAcls)) { this.FolderACL = this.ReadACL(folder, SecurityProp.NTSD, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.FolderFreeBusyACL = this.ReadACL(folder, SecurityProp.FreeBusyNTSD, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.FolderAcls; MrsTracer.Service.Debug("FolderAcls are loaded: ACL {0}, FreeBusyACL {1}", new object[] { new PropValuesDataContext(this.FolderACL).ToString(), new PropValuesDataContext(this.FolderFreeBusyACL).ToString() }); } if (dataToLoad.HasFlag(FolderRecDataFlags.ExtendedAclInformation) && !this.FieldIsLoaded(FolderRecDataFlags.ExtendedAclInformation)) { this.FolderACL = this.ReadExtendedAcl(folder, AclFlags.FolderAcl, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.FolderFreeBusyACL = this.ReadExtendedAcl(folder, AclFlags.FreeBusyAcl, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.ExtendedAclInformation; MrsTracer.Service.Debug("FolderExtendedAcls are loaded: Acl {0}, FreeBusyAcl {1}", new object[] { new PropValuesDataContext(this.FolderACL).ToString(), new PropValuesDataContext(this.FolderFreeBusyACL).ToString() }); } }
public bool FieldIsMapped(FolderRecDataFlags field) { return((this.MappedData & field) != FolderRecDataFlags.None); }
public override void CopyFolderProperties(FolderRecWrapper sourceFolderRecWrapper, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped) { wasPropertyCopyingSkipped = false; if (this.sessionSpecificEntryIds.ContainsKey(sourceFolderRecWrapper.EntryId) && destFolder != null) { if (base.SupportsPerUserReadUnreadDataTransfer) { using (IFxProxy fxProxy = destFolder.GetFxProxy(FastTransferFlags.PassThrough)) { using (IFxProxy fxProxy2 = base.CreateFxProxyTransmissionPipeline(fxProxy)) { sourceFolder.CopyTo(fxProxy2, CopyPropertiesFlags.CopyFolderPerUserData, Array <PropTag> .Empty); } } } base.CopyFolderProperties(sourceFolderRecWrapper, sourceFolder, destFolder, FolderRecDataFlags.Rules, out wasPropertyCopyingSkipped); } }