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);
}
}