public static void BuildFolderTree(MailboxSession mailboxSession, SyncState syncState)
{
StoreObjectId defaultFolderId = mailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
SharingSubscriptionData[] array = null;
using (SharingSubscriptionManager sharingSubscriptionManager = new SharingSubscriptionManager(mailboxSession))
{
array = sharingSubscriptionManager.GetAll();
}
using (Folder folder = Folder.Bind(mailboxSession, defaultFolderId))
{
FolderTree folderTree;
using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.DeepTraversal, null, null, FolderTree.fetchProperties))
{
folderTree = new FolderTree();
object[][] rows;
do
{
rows = queryResult.GetRows(10000);
for (int i = 0; i < rows.Length; i++)
{
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(((VersionedId)rows[i][0]).ObjectId);
MailboxSyncItemId mailboxSyncItemId2 = MailboxSyncItemId.CreateForNewItem((StoreObjectId)rows[i][1]);
folderTree.AddFolder(mailboxSyncItemId);
object obj = rows[i][3];
int num = (obj is PropertyError) ? 0 : ((int)obj);
if ((num & 1073741824) != 0)
{
for (int j = 0; j < array.Length; j++)
{
if (array[j].LocalFolderId.Equals(mailboxSyncItemId.NativeId))
{
folderTree.SetPermissions(mailboxSyncItemId, SyncPermissions.Readonly);
folderTree.SetOwner(mailboxSyncItemId, array[j].SharerIdentity);
break;
}
}
}
if (!defaultFolderId.Equals(mailboxSyncItemId2.NativeId))
{
folderTree.AddFolder(mailboxSyncItemId2);
folderTree.LinkChildToParent(mailboxSyncItemId2, mailboxSyncItemId);
}
if ((bool)rows[i][2])
{
folderTree.SetHidden(mailboxSyncItemId, true);
}
}
}while (rows.Length != 0);
}
syncState[CustomStateDatumType.FullFolderTree] = folderTree;
syncState[CustomStateDatumType.RecoveryFullFolderTree] = syncState[CustomStateDatumType.FullFolderTree];
}
}
// Token: 0x06000884 RID: 2180 RVA: 0x000323A8 File Offset: 0x000305A8
public static bool FolderSyncRequired(SyncStateStorage syncStateStorage, HierarchySyncOperations folderHierarchyChanges, SyncState folderIdMappingSyncState = null)
{
bool flag = folderIdMappingSyncState == null;
try
{
if (folderIdMappingSyncState == null)
{
folderIdMappingSyncState = syncStateStorage.GetCustomSyncState(new FolderIdMappingSyncStateInfo(), new PropertyDefinition[0]);
if (folderIdMappingSyncState == null)
{
return(true);
}
}
FolderTree folderTree = (FolderTree)folderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
if (folderTree == null)
{
return(true);
}
for (int i = 0; i < folderHierarchyChanges.Count; i++)
{
HierarchySyncOperation hierarchySyncOperation = folderHierarchyChanges[i];
MailboxSyncItemId folderId = MailboxSyncItemId.CreateForNewItem(hierarchySyncOperation.ItemId);
MailboxSyncItemId folderId2 = MailboxSyncItemId.CreateForNewItem(hierarchySyncOperation.ParentId);
if (!folderTree.Contains(folderId2))
{
return(true);
}
if (!folderTree.Contains(folderId))
{
if (!folderTree.IsHidden(folderId2))
{
return(true);
}
}
else if (!folderTree.IsHidden(folderId) || (folderTree.IsHiddenDueToParent(folderId) && !folderTree.IsHidden(folderId2)))
{
return(true);
}
}
}
finally
{
if (flag && folderIdMappingSyncState != null)
{
folderIdMappingSyncState.Dispose();
}
}
return(false);
}
// Token: 0x060009BF RID: 2495 RVA: 0x000395CC File Offset: 0x000377CC
private static string GetOrAddSyncFolderId(SyncState folderIdMappingSyncState, StoreObjectId mailboxFolderId)
{
FolderIdMapping folderIdMapping = (FolderIdMapping)folderIdMappingSyncState[CustomStateDatumType.IdMapping];
FolderTree folderTree = (FolderTree)folderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(mailboxFolderId);
string text = folderIdMapping[mailboxSyncItemId];
if (text == null)
{
text = folderIdMapping.Add(mailboxSyncItemId);
folderTree.AddFolder(mailboxSyncItemId);
}
return(text);
}
protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc)
{
string namespaceURI = doc.DocumentElement.NamespaceURI;
DefaultFolderType defaultFolderType = base.MailboxSession.IsDefaultFolderType(folderRequest.ServerId);
AirSyncPermanentException ex;
if (defaultFolderType != DefaultFolderType.None)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfDefaultFolder");
ex = new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, base.ConstructErrorXml(StatusCode.Sync_InvalidSyncKey), null, false);
throw ex;
}
AggregateOperationResult aggregateOperationResult = base.MailboxSession.Delete(DeleteItemFlags.SoftDelete, new StoreObjectId[]
{
folderRequest.ServerId
});
if (aggregateOperationResult.OperationResult != OperationResult.Failed)
{
base.FolderHierarchySync.RecordClientOperation(folderRequest.ServerId, ChangeType.Delete, null);
folderRequest.RecoverySyncKey = folderRequest.SyncKey;
folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey);
base.SyncStateChanged = true;
base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey);
base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey);
FolderIdMapping folderIdMapping = (FolderIdMapping)base.FolderIdMappingSyncState[CustomStateDatumType.IdMapping];
FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
MailboxSyncItemId folderId = MailboxSyncItemId.CreateForNewItem(folderRequest.ServerId);
folderTree.RemoveFolderAndChildren(folderId, folderIdMapping);
folderIdMapping.CommitChanges();
base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ClientDeletes);
XmlNode xmlNode = doc.CreateElement("Status", namespaceURI);
xmlNode.InnerText = "1";
XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI);
xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture);
doc.DocumentElement.AppendChild(xmlNode);
doc.DocumentElement.AppendChild(xmlNode2);
return;
}
if (aggregateOperationResult.GroupOperationResults != null && aggregateOperationResult.GroupOperationResults.Length > 0 && aggregateOperationResult.GroupOperationResults[0] != null && aggregateOperationResult.GroupOperationResults[0].Exception is ObjectNotFoundException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfNonExistentFolder");
ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolError, base.ConstructErrorXml(StatusCode.Sync_ProtocolError), null, false);
throw ex;
}
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteFailed");
ex = new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, base.ConstructErrorXml(StatusCode.Sync_ClientServerConversion), null, false);
throw ex;
}
public bool SetHiddenDueToParent(bool newValue, FolderTree fullFolderTree, HashSet <ISyncItemId> visibilityChangedList)
{
if (this.HiddenDueToParent != newValue)
{
this.HiddenDueToParent = newValue;
if (!this.hidden)
{
foreach (ISyncItemId syncItemId in this.Children)
{
if (visibilityChangedList != null)
{
visibilityChangedList.Add(syncItemId);
}
fullFolderTree.SetHiddenDueToParent(syncItemId, newValue, visibilityChangedList);
}
}
return(true);
}
return(false);
}
// Token: 0x0600088B RID: 2187 RVA: 0x00032D38 File Offset: 0x00030F38
protected StoreObjectId GetXsoFolderId(string syncFolderId, out SyncPermissions permissions)
{
StoreObjectId result = null;
permissions = SyncPermissions.FullAccess;
if (syncFolderId == "0")
{
result = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
}
else
{
MailboxSyncItemId mailboxSyncItemId = ((FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping])[syncFolderId] as MailboxSyncItemId;
if (mailboxSyncItemId != null)
{
FolderTree folderTree = (FolderTree)this.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
result = (StoreObjectId)mailboxSyncItemId.NativeId;
permissions = folderTree.GetPermissions(mailboxSyncItemId);
}
}
return(result);
}
// Token: 0x06000932 RID: 2354 RVA: 0x00036550 File Offset: 0x00034750
public bool SetHidden(bool newValue, FolderTree fullFolderTree, HashSet<ISyncItemId> visibilityChangedList)
{
bool result = false;
if (this.ParentId == null && this.HiddenDueToParent)
{
this.HiddenDueToParent = false;
result = true;
}
if (this.hidden != newValue)
{
this.hidden = newValue;
foreach (ISyncItemId syncItemId in this.Children)
{
if (visibilityChangedList != null)
{
visibilityChangedList.Add(syncItemId);
}
fullFolderTree.SetHiddenDueToParent(syncItemId, newValue || this.HiddenDueToParent, visibilityChangedList);
}
result = true;
}
return result;
}
public override void HandleSyncStateVersioning(SyncState syncState)
{
if (syncState == null)
{
throw new ArgumentNullException("syncState");
}
if (syncState.BackendVersion == null)
{
return;
}
bool flag = true;
if (syncState.BackendVersion < 2 || syncState.BackendVersion > this.Version)
{
flag = false;
}
else if (syncState.BackendVersion.Value != this.Version)
{
switch (syncState.BackendVersion.Value)
{
case 2:
FolderTree.BuildFolderTree(syncState.StoreObject.Session as MailboxSession, syncState);
break;
case 3:
break;
default:
flag = false;
break;
}
}
if (!flag)
{
syncState.HandleCorruptSyncState();
}
}
// Token: 0x060008C8 RID: 2248 RVA: 0x00034B7C File Offset: 0x00032D7C
protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc)
{
if (FolderCommand.IsEmptyOrWhiteSpacesOnly(folderRequest.DisplayName))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "EmptyDisplayName");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), null, false);
throw ex;
}
using (Folder folder = Folder.Create(base.MailboxSession, folderRequest.ParentId, StoreObjectType.Folder))
{
string namespaceURI = doc.DocumentElement.NamespaceURI;
folder.DisplayName = folderRequest.DisplayName;
string classNameFromType = AirSyncUtility.GetClassNameFromType(folderRequest.Type);
if (classNameFromType == null)
{
AirSyncPermanentException ex;
if (!this.IsValidSpecialFolderType(base.Version, folderRequest.Type))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidFolderType");
ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), null, false);
throw ex;
}
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CreateOfSpecialFolder");
ex = new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, base.ConstructErrorXml(StatusCode.Sync_InvalidSyncKey), null, false);
throw ex;
}
else
{
folder.ClassName = classNameFromType;
try
{
folder.Save();
folder.Load();
}
catch (ObjectExistedException innerException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "FolderExistsOnCreate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), innerException, false);
throw ex;
}
catch (InvalidOperationException innerException2)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidOperationOnCreate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), innerException2, false);
throw ex;
}
catch (ObjectValidationException innerException3)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ObjectValidationOnCreate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), innerException3, false);
throw ex;
}
base.FolderHierarchySync.RecordClientOperation(folder.Id.ObjectId, ChangeType.Add, folder);
folderRequest.RecoverySyncKey = folderRequest.SyncKey;
folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey);
base.SyncStateChanged = true;
base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey);
base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey);
XmlNode xmlNode = doc.CreateElement("Status", namespaceURI);
xmlNode.InnerText = "1";
XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI);
xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture);
XmlNode xmlNode3 = doc.CreateElement("ServerId", namespaceURI);
FolderIdMapping folderIdMapping = (FolderIdMapping)base.FolderIdMappingSyncState[CustomStateDatumType.IdMapping];
ISyncItemId syncItemId = MailboxSyncItemId.CreateForNewItem(folder.Id.ObjectId);
xmlNode3.InnerText = folderIdMapping.Add(syncItemId);
folderIdMapping.CommitChanges();
doc.DocumentElement.AppendChild(xmlNode);
doc.DocumentElement.AppendChild(xmlNode2);
doc.DocumentElement.AppendChild(xmlNode3);
FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
folderTree.AddFolder(syncItemId);
if (!base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root).Equals(folderRequest.ParentId))
{
ISyncItemId parentId = MailboxSyncItemId.CreateForNewItem(folderRequest.ParentId);
folderTree.LinkChildToParent(parentId, syncItemId);
}
base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ClientAdds);
}
}
}
protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc)
{
DefaultFolderType defaultFolderType = base.MailboxSession.IsDefaultFolderType(folderRequest.ServerId);
if (defaultFolderType != DefaultFolderType.None)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateOfDefaultFolder");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), null, false);
throw ex;
}
if (FolderCommand.IsEmptyOrWhiteSpacesOnly(folderRequest.DisplayName))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateOfEmptyDisplayName");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), null, false);
throw ex;
}
string namespaceURI = doc.DocumentElement.NamespaceURI;
using (Folder folder = Folder.Bind(base.MailboxSession, folderRequest.ServerId, null))
{
try
{
this.ProcessFolderNameChange(folderRequest, folder);
if (folderRequest.ParentId.Equals(folderRequest.ServerId))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateUnderSelf");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), null, false);
throw ex;
}
if (!folderRequest.ParentId.Equals(folder.ParentId))
{
using (Folder.Bind(base.MailboxSession, folderRequest.ParentId, null))
{
}
AggregateOperationResult aggregateOperationResult = base.MailboxSession.Move(folderRequest.ParentId, new StoreObjectId[]
{
folderRequest.ServerId
});
if (aggregateOperationResult.OperationResult == OperationResult.Failed)
{
AirSyncPermanentException ex;
if (aggregateOperationResult.GroupOperationResults != null && aggregateOperationResult.GroupOperationResults[0] != null && aggregateOperationResult.GroupOperationResults[0].Exception is ObjectExistedException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateOfNonExistentFolder");
ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), null, false);
throw ex;
}
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateFailed");
ex = new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, base.ConstructErrorXml(StatusCode.Sync_ClientServerConversion), null, false);
throw ex;
}
}
FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
ISyncItemId syncItemId = MailboxSyncItemId.CreateForNewItem(folderRequest.ServerId);
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
ISyncItemId parentId = folderTree.GetParentId(syncItemId);
if (parentId != null)
{
folderTree.UnlinkChild(parentId, syncItemId);
}
if (!defaultFolderId.Equals(folderRequest.ParentId))
{
ISyncItemId parentId2 = MailboxSyncItemId.CreateForNewItem(folderRequest.ParentId);
folderTree.LinkChildToParent(parentId2, syncItemId);
}
}
catch (ObjectNotFoundException innerException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ObjectNotFoundOnUpdate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ServerError, base.ConstructErrorXml(StatusCode.Sync_ServerError), innerException, false);
throw ex;
}
catch (ObjectExistedException innerException2)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ObjectExistedOnUpdate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), innerException2, false);
throw ex;
}
base.FolderHierarchySync.RecordClientOperation(folder.Id.ObjectId, ChangeType.Change, folder);
folderRequest.RecoverySyncKey = folderRequest.SyncKey;
folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey);
base.SyncStateChanged = true;
base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey);
base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey);
base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ClientChanges);
}
XmlNode xmlNode = doc.CreateElement("Status", namespaceURI);
xmlNode.InnerText = "1";
XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI);
xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture);
doc.DocumentElement.AppendChild(xmlNode);
doc.DocumentElement.AppendChild(xmlNode2);
}
// Token: 0x06000886 RID: 2182 RVA: 0x00032504 File Offset: 0x00030704
internal override Command.ExecutionState ExecuteCommand()
{
try
{
FolderCommand.FolderRequest folderRequest = this.ParseRequest();
XmlDocument xmlDocument = new SafeXmlDocument();
XmlNode newChild = xmlDocument.CreateElement(base.XmlRequest.LocalName, base.XmlRequest.NamespaceURI);
xmlDocument.AppendChild(newChild);
try
{
base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.ClientSyncKey, folderRequest.SyncKey);
this.LoadSyncState(folderRequest.SyncKey);
this.ConvertSyncIdsToXsoIds(folderRequest);
this.folderHierarchySync = this.folderHierarchySyncState.GetFolderHierarchySync(new ChangeTrackingDelegate(FolderCommand.ComputeChangeTrackingHash));
if (folderRequest.SyncKey != 0)
{
if (!this.folderHierarchySyncState.Contains(CustomStateDatumType.SyncKey))
{
base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "I");
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "RecoveryNotAllowed");
throw new AirSyncPermanentException(StatusCode.Sync_OutOfDisk, this.ConstructErrorXml(StatusCode.Sync_OutOfDisk), null, false);
}
int data = this.folderHierarchySyncState.GetData <Int32Data, int>(CustomStateDatumType.SyncKey, -1);
int data2 = this.folderHierarchySyncState.GetData <Int32Data, int>(CustomStateDatumType.RecoverySyncKey, -1);
if (folderRequest.SyncKey != data && (!this.allowRecovery || folderRequest.SyncKey != data2))
{
base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "I");
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidSyncKey");
throw new AirSyncPermanentException(StatusCode.Sync_OutOfDisk, this.ConstructErrorXml(StatusCode.Sync_OutOfDisk), null, false);
}
FolderIdMapping folderIdMapping = (FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping];
if (folderRequest.SyncKey == data)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Committing folderIdMapping.");
base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "S");
folderIdMapping.CommitChanges();
this.folderHierarchySync.AcknowledgeServerOperations();
}
else
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Clearing changes on folderIdMapping.");
base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "R");
folderIdMapping.ClearChanges();
this.folderIdMappingSyncState[CustomStateDatumType.FullFolderTree] = this.folderIdMappingSyncState[CustomStateDatumType.RecoveryFullFolderTree];
}
}
else
{
base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "F");
base.SendServerUpgradeHeader = true;
}
this.ProcessCommand(folderRequest, xmlDocument);
if (this.folderHierarchySyncState != null)
{
int data3 = this.folderHierarchySyncState.GetData <Int32Data, int>(CustomStateDatumType.AirSyncProtocolVersion, -1);
if (base.Version > data3)
{
AirSyncDiagnostics.TraceDebug <int, int>(ExTraceGlobals.RequestsTracer, this, "Changing sync state protocol version from {0} to {1}.", data3, base.Version);
this.folderHierarchySyncState[CustomStateDatumType.AirSyncProtocolVersion] = new Int32Data(base.Version);
this.syncStateChanged = true;
}
}
if (this.syncStateChanged)
{
if (this.folderHierarchySyncState != null)
{
this.folderHierarchySyncState.CustomVersion = new int?(5);
this.folderHierarchySyncState.Commit();
}
if (this.folderIdMappingSyncState != null)
{
FolderIdMapping folderIdMapping2 = this.folderIdMappingSyncState[CustomStateDatumType.IdMapping] as FolderIdMapping;
FolderTree folderTree = this.folderIdMappingSyncState[CustomStateDatumType.FullFolderTree] as FolderTree;
if (folderIdMapping2.IsDirty || folderTree.IsDirty)
{
this.folderIdMappingSyncState.Commit();
}
}
}
}
finally
{
if (this.folderIdMappingSyncState != null)
{
this.folderIdMappingSyncState.Dispose();
}
if (this.folderHierarchySyncState != null)
{
this.folderHierarchySyncState.Dispose();
}
}
base.XmlResponse = xmlDocument;
}
catch (ObjectNotFoundException innerException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "FolderNotFound");
throw new AirSyncPermanentException(StatusCode.Sync_ProtocolError, this.ConstructErrorXml(StatusCode.Sync_ProtocolError), innerException, false);
}
catch (CorruptDataException ex)
{
AirSyncUtility.ExceptionToStringHelper arg = new AirSyncUtility.ExceptionToStringHelper(ex);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CorruptData");
AirSyncDiagnostics.TraceDebug <AirSyncUtility.ExceptionToStringHelper>(ExTraceGlobals.RequestsTracer, this, "Corrupted data found, replacing error with wrongsynckey error to force client to refresh.\r\n{0}", arg);
throw new AirSyncPermanentException(StatusCode.Sync_OutOfDisk, this.ConstructErrorXml(StatusCode.Sync_OutOfDisk), ex, false);
}
catch (QuotaExceededException)
{
throw;
}
catch (StoragePermanentException ex2)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, ex2.GetType().ToString());
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, this.ConstructErrorXml(StatusCode.Sync_ClientServerConversion), ex2, false);
}
catch (ArgumentException innerException2)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ArgumentException");
throw new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, this.ConstructErrorXml(StatusCode.Sync_NotificationGUID), innerException2, false);
}
catch (FormatException innerException3)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "FormatException");
throw new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, this.ConstructErrorXml(StatusCode.Sync_NotificationGUID), innerException3, false);
}
return(Command.ExecutionState.Complete);
}
// Token: 0x060008A6 RID: 2214 RVA: 0x00033214 File Offset: 0x00031414
protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc)
{
bool flag = folderRequest.SyncKey == 0;
string namespaceURI = doc.DocumentElement.NamespaceURI;
XmlNode xmlNode = doc.CreateElement("Status", namespaceURI);
doc.DocumentElement.AppendChild(xmlNode);
xmlNode.InnerText = "1";
base.DeviceSyncStateMetadata.RecordLatestFolderHierarchySnapshot(base.MailboxSession, base.Context);
HierarchySyncOperations hierarchySyncOperations = base.FolderHierarchySync.EnumerateServerOperations(base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root), false);
if (hierarchySyncOperations.Count > 0)
{
folderRequest.RecoverySyncKey = folderRequest.SyncKey;
folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey);
base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey);
if (folderRequest.RecoverySyncKey > 0)
{
base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey);
base.FolderIdMappingSyncState[CustomStateDatumType.RecoveryFullFolderTree] = base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
}
base.SyncStateChanged = true;
}
XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI);
doc.DocumentElement.AppendChild(xmlNode2);
xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture);
Dictionary <ISyncItemId, XmlNode> dictionary = new Dictionary <ISyncItemId, XmlNode>(flag ? (hierarchySyncOperations.Count + FolderSyncCommand.virtualFolders.Length) : hierarchySyncOperations.Count);
XmlNode xmlNode3 = doc.CreateElement("Changes", namespaceURI);
doc.DocumentElement.AppendChild(xmlNode3);
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
FolderIdMapping folderIdMapping = (FolderIdMapping)base.FolderIdMappingSyncState[CustomStateDatumType.IdMapping];
FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
HashSet <ISyncItemId> hashSet = new HashSet <ISyncItemId>();
HashSet <ISyncItemId> hashSet2 = new HashSet <ISyncItemId>();
bool flag2 = false;
AirSyncDiagnostics.TraceDebug <int>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). changes.Count={0}", hierarchySyncOperations.Count);
for (int i = 0; i < hierarchySyncOperations.Count; i++)
{
HierarchySyncOperation hierarchySyncOperation = hierarchySyncOperations[i];
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(hierarchySyncOperation.ItemId);
MailboxSyncItemId mailboxSyncItemId2 = MailboxSyncItemId.CreateForNewItem(hierarchySyncOperation.ParentId);
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). change# {0}. changeType{1}. Processing folder: {2} with parent {3}", new object[]
{
i,
Enum.GetName(typeof(ChangeType), hierarchySyncOperation.ChangeType),
mailboxSyncItemId,
mailboxSyncItemId2
});
string parentShortId = null;
bool flag3 = false;
switch (hierarchySyncOperation.ChangeType)
{
case ChangeType.Add:
{
if (folderTree.AddFolder(mailboxSyncItemId))
{
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Adding folder {0} with Parent {1} to Full Folder Tree.", mailboxSyncItemId, mailboxSyncItemId2);
}
folderTree.SetOwner(mailboxSyncItemId, hierarchySyncOperation.Owner);
folderTree.SetPermissions(mailboxSyncItemId, hierarchySyncOperation.Permissions);
if (!defaultFolderId.Equals(mailboxSyncItemId2.NativeId))
{
if (folderTree.AddFolder(mailboxSyncItemId2))
{
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Adding parent folder {0} to Full Folder Tree.", mailboxSyncItemId2);
hashSet2.Add(mailboxSyncItemId2);
}
folderTree.LinkChildToParent(mailboxSyncItemId2, mailboxSyncItemId, hashSet);
parentShortId = (folderIdMapping.Contains(mailboxSyncItemId2) ? folderIdMapping[mailboxSyncItemId2] : folderIdMapping.Add(mailboxSyncItemId2));
flag3 = folderTree.IsHidden(mailboxSyncItemId2);
}
bool sharedFolder = folderTree.IsSharedFolder(mailboxSyncItemId);
AirSyncUtility.GetAirSyncFolderType(base.MailboxSession, sharedFolder, hierarchySyncOperation.ItemId, hierarchySyncOperation.ClassName);
if (!this.IsFolderVisible(hierarchySyncOperation, flag3))
{
folderTree.SetHidden(mailboxSyncItemId, true, hashSet);
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Added folder {0} is set to hidden and will not be sent to client.", mailboxSyncItemId);
}
else
{
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Added folder {0} will be sent to client. Details next...", mailboxSyncItemId);
string text = folderIdMapping.Contains(mailboxSyncItemId) ? folderIdMapping[mailboxSyncItemId] : folderIdMapping.Add(mailboxSyncItemId);
dictionary[mailboxSyncItemId] = this.CreateChangeNode(doc, namespaceURI, hierarchySyncOperation.ChangeType, folderTree, mailboxSyncItemId, hierarchySyncOperation, text, parentShortId, ref flag2);
hashSet2.Add(mailboxSyncItemId);
}
break;
}
case ChangeType.Change:
if (!folderTree.Contains(mailboxSyncItemId))
{
AirSyncDiagnostics.TraceError(ExTraceGlobals.RequestsTracer, this, "Could not find folder {0} with item ID {1} in the full folder tree, skipping... FolderIdMappingSyncState backend version is {2} and current version is {3}.", new object[]
{
hierarchySyncOperation.DisplayName,
mailboxSyncItemId,
base.FolderIdMappingSyncState.BackendVersion,
base.FolderIdMappingSyncState.Version
});
}
else
{
if (!defaultFolderId.Equals(mailboxSyncItemId2.NativeId))
{
if (folderTree.AddFolder(mailboxSyncItemId2))
{
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} has new parent {1} to be sent to client.", mailboxSyncItemId, mailboxSyncItemId2);
hashSet2.Add(mailboxSyncItemId2);
}
flag3 = folderTree.IsHidden(mailboxSyncItemId2);
if (!flag3)
{
parentShortId = (folderIdMapping.Contains(mailboxSyncItemId2) ? folderIdMapping[mailboxSyncItemId2] : folderIdMapping.Add(mailboxSyncItemId2));
}
}
ISyncItemId parentId = folderTree.GetParentId(mailboxSyncItemId);
if (!mailboxSyncItemId2.Equals(parentId))
{
if (parentId != null)
{
folderTree.UnlinkChild(parentId, mailboxSyncItemId);
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, ISyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Removing changed folder {0} as child from old parent {1} in Full Folder Tree.", mailboxSyncItemId, parentId);
}
if (!defaultFolderId.Equals(mailboxSyncItemId2.NativeId))
{
folderTree.LinkChildToParent(mailboxSyncItemId2, mailboxSyncItemId, hashSet);
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Adding changed folder {0} as child to new parent {1} in Full Folder Tree.", mailboxSyncItemId, mailboxSyncItemId2);
}
else
{
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} now has no parent in Full Folder Tree.", mailboxSyncItemId);
}
}
folderTree.SetOwner(mailboxSyncItemId, hierarchySyncOperation.Owner);
folderTree.SetPermissions(mailboxSyncItemId, hierarchySyncOperation.Permissions);
bool sharedFolder = folderTree.IsSharedFolder(mailboxSyncItemId);
AirSyncUtility.GetAirSyncFolderType(base.MailboxSession, sharedFolder, hierarchySyncOperation.ItemId, hierarchySyncOperation.ClassName);
if (!this.IsFolderVisible(hierarchySyncOperation, flag3))
{
folderTree.SetHidden(mailboxSyncItemId, true, hashSet);
if (folderIdMapping.Contains(mailboxSyncItemId))
{
string text = folderIdMapping[mailboxSyncItemId];
folderIdMapping.Delete(new ISyncItemId[]
{
mailboxSyncItemId
});
dictionary[mailboxSyncItemId] = this.CreateDeleteNode(doc, namespaceURI, text);
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} is now hidden; deleting from client.", mailboxSyncItemId);
}
}
else
{
folderTree.SetHidden(mailboxSyncItemId, false, hashSet);
string text;
if (!folderIdMapping.Contains(mailboxSyncItemId))
{
text = folderIdMapping.Add(mailboxSyncItemId);
hierarchySyncOperation.ChangeType = ChangeType.Add;
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} is now visible; adding to client.", mailboxSyncItemId);
}
else
{
text = folderIdMapping[mailboxSyncItemId];
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} is being sent to client.", mailboxSyncItemId);
}
dictionary[mailboxSyncItemId] = this.CreateChangeNode(doc, namespaceURI, hierarchySyncOperation.ChangeType, folderTree, mailboxSyncItemId, hierarchySyncOperation, text, parentShortId, ref flag2);
}
}
break;
case ChangeType.Delete:
if (folderTree.Contains(mailboxSyncItemId))
{
if (folderIdMapping.Contains(mailboxSyncItemId))
{
string text = folderIdMapping[mailboxSyncItemId];
dictionary[mailboxSyncItemId] = this.CreateDeleteNode(doc, namespaceURI, text);
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, string>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Deleted folder {0} with Short Id {1} is being sent to client.", mailboxSyncItemId, text);
}
folderTree.RemoveFolderAndChildren(mailboxSyncItemId, folderIdMapping);
AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Deleted folder {0} and children are being removed from Full Folder Tree.", mailboxSyncItemId);
}
break;
}
}
if (flag)
{
this.AddVirtualFolders(doc, namespaceURI, dictionary);
}
using (HashSet <ISyncItemId> .Enumerator enumerator = hashSet.GetEnumerator())
{
while (enumerator.MoveNext())
{
ISyncItemId itemId = enumerator.Current;
if (folderTree.IsHidden(itemId))
{
dictionary.Remove(itemId);
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Removing hidden folder {0} from list of changes being sent to client.", new object[]
{
itemId.NativeId
});
if (folderIdMapping.Contains(itemId))
{
if (!hashSet2.Contains(itemId))
{
dictionary[itemId] = this.CreateDeleteNode(doc, namespaceURI, folderIdMapping[itemId]);
}
folderIdMapping.Delete(new ISyncItemId[]
{
itemId
});
}
}
else if (!dictionary.ContainsKey(itemId))
{
HierarchySyncOperation hierarchySyncOperation2 = (from change in hierarchySyncOperations
where change.ItemId == (StoreObjectId)itemId.NativeId
select change).First <HierarchySyncOperation>();
string parentShortId2 = folderIdMapping[folderTree.GetParentId(itemId)];
if (folderIdMapping.Contains(itemId))
{
flag2 = true;
AirSyncDiagnostics.TraceError <string, object>(ExTraceGlobals.RequestsTracer, this, "Hidden folder {0} with item ID {1} is in folderIdMapping table.", hierarchySyncOperation2.DisplayName, itemId.NativeId);
}
else
{
string shortId = folderIdMapping.Add(itemId);
dictionary[itemId] = this.CreateChangeNode(doc, namespaceURI, ChangeType.Add, folderTree, itemId, hierarchySyncOperation2, shortId, parentShortId2, ref flag2);
}
}
}
}
XmlNode xmlNode4 = doc.CreateElement("Count", namespaceURI);
xmlNode4.InnerText = dictionary.Count.ToString(CultureInfo.InvariantCulture);
xmlNode3.AppendChild(xmlNode4);
foreach (XmlNode newChild in dictionary.Values)
{
xmlNode3.AppendChild(newChild);
}
if (flag2)
{
Exception exception = new InvalidOperationException("FolderSyncCommand.ProcessCommand found errors. See traces above.");
if (GlobalSettings.SendWatsonReport)
{
AirSyncDiagnostics.SendWatson(exception, false);
}
}
}
// Token: 0x060008A9 RID: 2217 RVA: 0x00033BC0 File Offset: 0x00031DC0
private XmlNode CreateChangeNode(XmlDocument doc, string nameSpaceUri, ChangeType changeType, FolderTree fullFolderTree, ISyncItemId mailboxSyncId, HierarchySyncOperation op, string shortId, string parentShortId, ref bool sendWatson)
{
XmlNode xmlNode = null;
switch (changeType)
{
case ChangeType.Add:
xmlNode = doc.CreateElement("Add", nameSpaceUri);
base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ServerAdds);
break;
case ChangeType.Change:
xmlNode = doc.CreateElement("Update", nameSpaceUri);
base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ServerChanges);
break;
}
AirSyncDiagnostics.TraceDebug <string, string, string>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.CreateChangeNode(). <{0}> node for folder {1} with short ID {2} will be sent to client.", Enum.GetName(typeof(ChangeType), changeType), op.DisplayName, shortId);
XmlNode xmlNode2 = doc.CreateElement("ServerId", nameSpaceUri);
xmlNode2.InnerText = shortId;
xmlNode.AppendChild(xmlNode2);
XmlNode xmlNode3 = doc.CreateElement("ParentId", nameSpaceUri);
xmlNode3.InnerText = (string.IsNullOrEmpty(parentShortId) ? "0" : parentShortId);
xmlNode.AppendChild(xmlNode3);
XmlNode xmlNode4 = doc.CreateElement("DisplayName", nameSpaceUri);
if (op.DisplayName.Length < 255)
{
xmlNode4.InnerText = op.DisplayName;
}
else
{
using (Folder folder = op.GetFolder())
{
xmlNode4.InnerText = folder.DisplayName;
}
}
xmlNode.AppendChild(xmlNode4);
XmlNode xmlNode5 = doc.CreateElement("Type", nameSpaceUri);
xmlNode5.InnerText = AirSyncUtility.GetAirSyncFolderType(base.MailboxSession, fullFolderTree.IsSharedFolder(mailboxSyncId), op.ItemId, op.ClassName);
xmlNode.AppendChild(xmlNode5);
SyncPermissions permissions = fullFolderTree.GetPermissions(mailboxSyncId);
if (permissions != SyncPermissions.FullAccess)
{
if (base.Version < 140)
{
sendWatson = true;
AirSyncDiagnostics.TraceError <string, SyncPermissions>(ExTraceGlobals.RequestsTracer, this, "Error trying to change folder {0} with permissions {1}. Permissions must be FullAccess.", op.DisplayName, permissions);
}
else
{
XmlNode xmlNode6 = doc.CreateElement("Permissions", nameSpaceUri);
XmlNode xmlNode7 = xmlNode6;
int num = (int)permissions;
xmlNode7.InnerText = num.ToString(CultureInfo.InvariantCulture);
xmlNode.AppendChild(xmlNode6);
}
}
if (fullFolderTree.IsSharedFolder(mailboxSyncId))
{
string owner = fullFolderTree.GetOwner(mailboxSyncId);
if (base.Version < 140)
{
sendWatson = true;
AirSyncDiagnostics.TraceError <string, string>(ExTraceGlobals.RequestsTracer, this, "Folder {0} with owner {1} is marked as shared in a version lower than 14.", op.DisplayName, owner);
}
else
{
XmlNode xmlNode8 = doc.CreateElement("Owner", nameSpaceUri);
xmlNode8.InnerText = owner;
xmlNode.AppendChild(xmlNode8);
}
}
return(xmlNode);
}
public void ParseQueryNode(XmlElement queryNode)
{
this.searchCriteriaBuilder = new MailboxSearchCriteriaBuilder(this.context.Request.Culture);
if (!this.mailboxSession.Mailbox.IsContentIndexingEnabled)
{
AirSyncDiagnostics.LogPeriodicEvent(AirSyncEventLogConstants.Tuple_ContentIndexingNotEnabled, "ContentIndexingNotEnabled", new string[]
{
this.mailboxSession.MailboxOwner.MailboxInfo.Location.ServerFqdn
});
}
this.queryFilter = this.searchCriteriaBuilder.ParseTopLevelClassAndFolders(queryNode, this.mailboxSession.Mailbox.IsContentIndexingEnabled, this.versionFactory, this.context);
this.schemaCache = this.searchCriteriaBuilder.SchemaCache;
if (this.FolderIdMappingSyncState == null || !this.FolderIdMappingSyncState.Contains(CustomStateDatumType.FullFolderTree))
{
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.AlgorithmTracer, this, "FolderIdMappingSyncState error: {0}", (this.FolderIdMappingSyncState != null) ? "no FullFolderTree" : "FolderIdMappingSyncState is null");
throw new SearchNeedToFolderSyncException();
}
List <string> list = this.searchCriteriaBuilder.FolderScope;
FolderIdMapping folderIdMapping = (FolderIdMapping)this.FolderIdMappingSyncState[CustomStateDatumType.IdMapping];
FolderTree folderTree = (FolderTree)this.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
if (list.Count == 0)
{
this.folderScope = new StoreId[]
{
this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Root)
};
}
else
{
int num = 0;
this.folderScope = new StoreId[list.Count];
foreach (string text in list)
{
StoreObjectId storeObjectId = null;
if (text == "0")
{
storeObjectId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
}
else
{
SyncCollection.CollectionTypes collectionType = AirSyncUtility.GetCollectionType(text);
if (collectionType != SyncCollection.CollectionTypes.Mailbox && collectionType != SyncCollection.CollectionTypes.Unknown)
{
throw new AirSyncPermanentException(StatusCode.InvalidCombinationOfIDs, false)
{
ErrorStringForProtocolLogger = "BadIdComboInMbxSearch"
};
}
MailboxSyncItemId mailboxSyncItemId = folderIdMapping[text] as MailboxSyncItemId;
if (mailboxSyncItemId != null)
{
if (folderTree.IsSharedFolder(mailboxSyncItemId))
{
throw new AirSyncPermanentException(StatusCode.Sync_InvalidParameters, false)
{
ErrorStringForProtocolLogger = "AccessDeniedInMbxSearch"
};
}
storeObjectId = (StoreObjectId)mailboxSyncItemId.NativeId;
}
}
if (storeObjectId == null)
{
throw new SearchNeedToFolderSyncException();
}
try
{
using (Folder.Bind(this.mailboxSession, storeObjectId))
{
}
}
catch (ObjectNotFoundException)
{
throw new SearchNeedToFolderSyncException();
}
this.folderScope[num++] = storeObjectId;
}
}
foreach (object obj in folderTree)
{
ISyncItemId syncItemId = (ISyncItemId)obj;
MailboxSyncItemId mailboxSyncItemId2 = syncItemId as MailboxSyncItemId;
if (mailboxSyncItemId2 != null && (folderTree.IsHidden(syncItemId) || folderTree.IsSharedFolder(syncItemId)))
{
this.searchCriteriaBuilder.ExcludedFolders.Add((StoreObjectId)mailboxSyncItemId2.NativeId);
}
}
if (this.mailboxSchemaOptions.HasBodyPartPreferences)
{
if (this.searchCriteriaBuilder.Conversation == null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.AlgorithmTracer, this, "<BodyPartPreference> is only supported when search for ConversationId");
throw new AirSyncPermanentException(StatusCode.Sync_ObjectNotFound, false)
{
ErrorStringForProtocolLogger = "BodyPartNotSupported"
};
}
this.searchCriteriaBuilder.Conversation.LoadBodySummaries();
}
}
public void AddChild(ISyncItemId childId, FolderTree fullFolderTree, HashSet <ISyncItemId> visibilityChangedList)
{
this.Children.Add(childId);
fullFolderTree.SetHiddenDueToParent(childId, this.Hidden, visibilityChangedList);
}