// Token: 0x06000C4A RID: 3146 RVA: 0x00040EDC File Offset: 0x0003F0DC
private StoreObjectId GetStoreObjectId(string collectionId, string serverId)
{
StoreObjectId result = null;
FolderSyncState folderSyncState;
if (this.syncStates.ContainsKey(collectionId))
{
folderSyncState = this.syncStates[collectionId];
}
else
{
folderSyncState = this.syncStateStorage.GetFolderSyncState(collectionId);
if (folderSyncState != null)
{
this.syncStates.Add(collectionId, folderSyncState);
}
}
if (folderSyncState != null)
{
ItemIdMapping itemIdMapping = (ItemIdMapping)folderSyncState[CustomStateDatumType.IdMapping];
if (itemIdMapping != null)
{
MailboxSyncItemId mailboxSyncItemId = itemIdMapping[serverId] as MailboxSyncItemId;
if (mailboxSyncItemId != null)
{
result = (StoreObjectId)mailboxSyncItemId.NativeId;
}
}
}
return(result);
}
// Token: 0x06001809 RID: 6153 RVA: 0x0008D7B8 File Offset: 0x0008B9B8
private void UpdateMapping(Dictionary <string, StoreObjectId> mapping)
{
FolderIdMapping folderIdMapping = (FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping];
Dictionary <StoreObjectId, FolderStateEntry> data = ((GenericDictionaryData <StoreObjectIdData, StoreObjectId, FolderStateEntry>) this.syncState[SyncStateProp.ClientState]).Data;
foreach (string text in mapping.Keys)
{
StoreObjectId storeObjectId = mapping[text];
folderIdMapping.Add(MailboxSyncItemId.CreateForNewItem(storeObjectId), text);
if (data.ContainsKey(storeObjectId))
{
FolderStateEntry folderStateEntry = data[storeObjectId];
if (folderStateEntry.ChangeKey.Length == 1 && folderStateEntry.ChangeKey[0] == 1)
{
folderStateEntry.ChangeTrackingHash = "blah".GetHashCode();
}
else
{
folderStateEntry.ChangeTrackingHash = FolderCommand.ComputeChangeTrackingHash(this.mailboxSession, mapping[text], null);
}
}
}
folderIdMapping.CommitChanges();
StoreObjectId defaultFolderId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Inbox);
mapping.Add("EmailSyncFile", defaultFolderId);
defaultFolderId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Contacts);
mapping.Add("ContactsSyncFile", defaultFolderId);
defaultFolderId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Calendar);
mapping.Add("CalendarSyncFile", defaultFolderId);
defaultFolderId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Tasks);
mapping.Add("TasksSyncFile", defaultFolderId);
}
// Token: 0x06000D09 RID: 3337 RVA: 0x00047074 File Offset: 0x00045274
private string GetDstSyncItemId(StoreObjectId dstFolderId, StoreObjectId mailboxItemId)
{
string text = this.FolderIdMapping[MailboxSyncItemId.CreateForNewItem(dstFolderId)];
SyncState syncState;
if (this.loadedSyncStates.ContainsKey(text))
{
syncState = this.loadedSyncStates[text];
}
else
{
syncState = base.SyncStateStorage.GetFolderSyncState(text);
if (syncState == null)
{
MailboxSyncProviderFactory syncProviderFactory = new MailboxSyncProviderFactory(base.MailboxSession, dstFolderId);
syncState = base.SyncStateStorage.CreateFolderSyncState(syncProviderFactory, text);
}
if (syncState[CustomStateDatumType.IdMapping] == null)
{
syncState[CustomStateDatumType.IdMapping] = new ItemIdMapping(text);
}
this.loadedSyncStates.Add(text, syncState);
}
ItemIdMapping itemIdMapping = (ItemIdMapping)syncState[CustomStateDatumType.IdMapping];
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(mailboxItemId);
string text2 = itemIdMapping[mailboxSyncItemId];
if (text2 == null)
{
text2 = itemIdMapping.Add(mailboxSyncItemId);
}
return(text2);
}
private StoreObjectId GetStoreObjectId(string folderId)
{
SyncCollection.CollectionTypes collectionType = AirSyncUtility.GetCollectionType(folderId);
if (collectionType != SyncCollection.CollectionTypes.Mailbox && collectionType != SyncCollection.CollectionTypes.Unknown)
{
throw new AirSyncPermanentException(StatusCode.InvalidCombinationOfIDs, false)
{
ErrorStringForProtocolLogger = "BadIdComboInConversationMove"
};
}
if (this.folderIdMapping == null)
{
using (CustomSyncState customSyncState = this.syncStateStorage.GetCustomSyncState(new FolderIdMappingSyncStateInfo(), new PropertyDefinition[0]))
{
if (customSyncState == null)
{
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, false)
{
ErrorStringForProtocolLogger = "NoSyncStateInConversationMove"
};
}
if (customSyncState[CustomStateDatumType.IdMapping] == null)
{
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, false)
{
ErrorStringForProtocolLogger = "NoIdMappingInConversationMove"
};
}
this.folderIdMapping = (FolderIdMapping)customSyncState[CustomStateDatumType.IdMapping];
this.fullFolderTree = (FolderTree)customSyncState[CustomStateDatumType.FullFolderTree];
}
}
ISyncItemId syncItemId = this.folderIdMapping[folderId];
if (syncItemId == null)
{
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, false)
{
ErrorStringForProtocolLogger = "NoFldrIdInMappingInConversationMove"
};
}
MailboxSyncItemId mailboxSyncItemId = syncItemId as MailboxSyncItemId;
if (mailboxSyncItemId == null)
{
throw new AirSyncPermanentException(StatusCode.InvalidIDs, false)
{
ErrorStringForProtocolLogger = "BadIdInConversationMove"
};
}
if (this.fullFolderTree.IsSharedFolder(mailboxSyncItemId) || this.fullFolderTree.GetPermissions(mailboxSyncItemId) != SyncPermissions.FullAccess)
{
throw new AirSyncPermanentException(StatusCode.Sync_Retry, false)
{
ErrorStringForProtocolLogger = "DeniedInConversationMove"
};
}
return((StoreObjectId)mailboxSyncItemId.NativeId);
}
// Token: 0x06000D02 RID: 3330 RVA: 0x0004676C File Offset: 0x0004496C
private void ParseXmlRequest()
{
if (base.XmlRequest.Name != "MoveItems")
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidParentTag");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.InvalidXML, null, false);
}
using (XmlNodeList elementsByTagName = base.XmlRequest.GetElementsByTagName("Move", "Move:"))
{
if (elementsByTagName.Count < 1 || elementsByTagName.Count >= GlobalSettings.MaxNoOfItemsMove)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, (elementsByTagName.Count < 1) ? "NoMoveTags" : "MITooManyOperations");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.InvalidXML, null, false);
}
foreach (object obj in elementsByTagName)
{
XmlNode xmlNode = (XmlNode)obj;
string text = null;
string text2 = null;
string text3 = null;
try
{
text = xmlNode["SrcMsgId", "Move:"].InnerText;
text2 = xmlNode["SrcFldId", "Move:"].InnerText;
text3 = xmlNode["DstFldId", "Move:"].InnerText;
}
catch (NullReferenceException innerException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MessageOrFolderIdNotSpecified");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.InvalidXML, innerException, false);
}
if ((AirSyncUtility.GetCollectionType(text2) != SyncCollection.CollectionTypes.Mailbox && AirSyncUtility.GetCollectionType(text2) != SyncCollection.CollectionTypes.Unknown) || (AirSyncUtility.GetCollectionType(text3) != SyncCollection.CollectionTypes.Mailbox && AirSyncUtility.GetCollectionType(text3) != SyncCollection.CollectionTypes.Unknown))
{
this.AppendItemXmlNode(text, 105.ToString(CultureInfo.InvariantCulture), text3);
}
else
{
StoreObjectId xsoItemId = this.GetXsoItemId(text2, text);
MailboxSyncItemId mailboxSyncItemId = this.FolderIdMapping[text2] as MailboxSyncItemId;
MailboxSyncItemId mailboxSyncItemId2 = this.FolderIdMapping[text3] as MailboxSyncItemId;
StoreObjectId srcFldId = (mailboxSyncItemId == null) ? null : ((StoreObjectId)mailboxSyncItemId.NativeId);
StoreObjectId dstFldId = (mailboxSyncItemId2 == null) ? null : ((StoreObjectId)mailboxSyncItemId2.NativeId);
if (mailboxSyncItemId != null && (!this.FullFolderTree.Contains(mailboxSyncItemId) || this.FullFolderTree.GetPermissions(mailboxSyncItemId) != SyncPermissions.FullAccess || this.FullFolderTree.IsSharedFolder(mailboxSyncItemId)))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MoveFromNonFullAccessFolder");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.Success, null, false);
}
if (mailboxSyncItemId2 != null && (!this.FullFolderTree.Contains(mailboxSyncItemId2) || this.FullFolderTree.GetPermissions(mailboxSyncItemId2) != SyncPermissions.FullAccess || this.FullFolderTree.IsSharedFolder(mailboxSyncItemId2)))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MoveToNonFullAccessFolder");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.Sync_ProtocolVersionMismatch, null, false);
}
this.ValidateItem(text, xsoItemId, srcFldId, dstFldId);
}
}
}
}
public override ISyncItemId CreateISyncItemIdForNewItem(StoreObjectId itemId)
{
base.CheckDisposed("CreateISyncItemIdForNewItem");
if (itemId == null)
{
throw new ArgumentNullException("itemId");
}
return(MailboxSyncItemId.CreateForNewItem(itemId));
}
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: 0x06001850 RID: 6224 RVA: 0x0008EB8C File Offset: 0x0008CD8C
private void UpdateMapping(Dictionary <StoreObjectId, string> mappingFromStorageIds, Dictionary <string, string> mappingToSP2Id)
{
ItemIdMapping itemIdMapping = (ItemIdMapping)this.syncState[CustomStateDatumType.IdMapping];
foreach (StoreObjectId storeObjectId in mappingFromStorageIds.Keys)
{
string key = mappingFromStorageIds[storeObjectId];
string syncId = mappingToSP2Id[key];
itemIdMapping.Add(MailboxSyncItemId.CreateForNewItem(storeObjectId), syncId);
}
}
private static StoreObjectId GetItemId(ItemIdMapping idmapping, string folder, string item)
{
string syncId = folder + ":" + item;
MailboxSyncItemId mailboxSyncItemId = idmapping[syncId] as MailboxSyncItemId;
if (mailboxSyncItemId != null)
{
return((StoreObjectId)mailboxSyncItemId.NativeId);
}
return(null);
}
// 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);
}
// 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);
}
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;
}
// Token: 0x06000763 RID: 1891 RVA: 0x000291AC File Offset: 0x000273AC
private StoreObjectId GetStoreObjectId(string folderId)
{
if (this.folderIdMapping == null)
{
using (CustomSyncState customSyncState = this.syncStateStorage.GetCustomSyncState(new FolderIdMappingSyncStateInfo(), new PropertyDefinition[0]))
{
if (customSyncState == null)
{
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, false)
{
ErrorStringForProtocolLogger = "NoSyncStateInEmptyFolder"
};
}
if (customSyncState[CustomStateDatumType.IdMapping] == null)
{
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, false)
{
ErrorStringForProtocolLogger = "NoIdMappingInEmptyFolder"
};
}
this.folderIdMapping = (FolderIdMapping)customSyncState[CustomStateDatumType.IdMapping];
}
}
SyncCollection.CollectionTypes collectionType = AirSyncUtility.GetCollectionType(folderId);
if (collectionType != SyncCollection.CollectionTypes.Mailbox && collectionType != SyncCollection.CollectionTypes.Unknown)
{
throw new AirSyncPermanentException(StatusCode.Sync_Retry, false)
{
ErrorStringForProtocolLogger = "SpecialFolderInEmptyFolder"
};
}
MailboxSyncItemId mailboxSyncItemId = this.folderIdMapping[folderId] as MailboxSyncItemId;
if (mailboxSyncItemId == null)
{
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, false)
{
ErrorStringForProtocolLogger = "NoIdMappingInEmptyFolder2"
};
}
return((StoreObjectId)mailboxSyncItemId.NativeId);
}
// 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);
}
private bool RemoveFolderAndChildren(ISyncItemId folderId, FolderIdMapping folderIdMapping, int foldersSeen, int numberOfFoldersInTree)
{
FolderTree.FolderInfo folderInfo = this.GetFolderInfo(folderId);
foldersSeen++;
if (foldersSeen > numberOfFoldersInTree)
{
AirSyncDiagnostics.TraceError <int>(ExTraceGlobals.AlgorithmTracer, this, "Error: Loop detected in folder tree. NumberOfFoldersInTree: {0}", numberOfFoldersInTree);
this.TraceTree();
return(false);
}
int num = 0;
while (folderInfo.Children.Count > num)
{
ISyncItemId syncItemId = folderInfo.Children[num];
if (this.folderTree.ContainsKey(syncItemId))
{
if (!this.RemoveFolderAndChildren(syncItemId, folderIdMapping, foldersSeen, numberOfFoldersInTree))
{
return(false);
}
}
else
{
num++;
MailboxSyncItemId mailboxSyncItemId = syncItemId as MailboxSyncItemId;
AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.AlgorithmTracer, this, "FolderTree.RemoveFolderAndChildren could not find child folder: {0} to remove.", (mailboxSyncItemId == null) ? "<folder is not a MailboxSyncItemId>" : mailboxSyncItemId.ToString());
}
}
if (folderIdMapping.Contains(folderId))
{
folderIdMapping.Delete(new ISyncItemId[]
{
folderId
});
}
this.RemoveFolder(folderId);
return(true);
}
// Token: 0x06000498 RID: 1176 RVA: 0x0001C590 File Offset: 0x0001A790
private void ParseRequest(MailboxSession mailboxSession)
{
this.collectionRequest = default(CollectionCommand.CollectionRequestStruct);
string collectionId = this.CollectionId;
if (collectionId != null)
{
MailboxSyncItemId mailboxSyncItemId = ((FolderIdMapping)this.syncState[CustomStateDatumType.IdMapping])[collectionId] as MailboxSyncItemId;
if (mailboxSyncItemId == null)
{
throw new AirSyncPermanentException(StatusCode.Sync_ProtocolError, CollectionCommand.ConstructErrorXml(StatusCode.Sync_ProtocolError), null, false)
{
ErrorStringForProtocolLogger = "FolderNotFound2"
};
}
this.collectionRequest.CollectionId = (StoreObjectId)mailboxSyncItemId.NativeId;
AirSyncDiagnostics.TraceDebug <string, StoreObjectId>(ExTraceGlobals.RequestsTracer, this, "Received request with syncCollectionId {0}, which maps to collection Id {1}.", collectionId, this.collectionRequest.CollectionId);
}
string parentId = this.ParentId;
if (parentId == "0")
{
this.collectionRequest.ParentId = mailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
}
else if (parentId != null)
{
MailboxSyncItemId mailboxSyncItemId2 = ((FolderIdMapping)this.syncState[CustomStateDatumType.IdMapping])[parentId] as MailboxSyncItemId;
if (mailboxSyncItemId2 == null)
{
throw new AirSyncPermanentException(StatusCode.Sync_ServerError, CollectionCommand.ConstructErrorXml(StatusCode.Sync_ServerError), null, false)
{
ErrorStringForProtocolLogger = "NoIdMappingForParentId"
};
}
this.collectionRequest.ParentId = (StoreObjectId)mailboxSyncItemId2.NativeId;
AirSyncDiagnostics.TraceDebug <string, StoreObjectId>(ExTraceGlobals.RequestsTracer, this, "Received request with syncParentId {0}, which maps to parent Id {1}.", parentId, this.collectionRequest.ParentId);
}
this.collectionRequest.CollectionName = this.CollectionName;
}
// Token: 0x0600184E RID: 6222 RVA: 0x0008E9FC File Offset: 0x0008CBFC
private void UpdateFilter(Dictionary <StoreObjectId, string> mapping, DateTimeCustomSyncFilter dateTimeFilter, Dictionary <string, CommonNode> items)
{
foreach (StoreObjectId storeObjectId in mapping.Keys)
{
string key = mapping[storeObjectId];
CommonNode commonNode = items[key];
ISyncItemId syncItemId = MailboxSyncItemId.CreateForNewItem(storeObjectId);
if (commonNode.IsCalendar)
{
dateTimeFilter.UpdateFilterStateWithAddOrChange(syncItemId, true, true, commonNode.EndTime);
}
ChangeTrackingNode[] array;
if (commonNode.IsEmail)
{
array = new ChangeTrackingNode[]
{
ChangeTrackingNode.AllOtherNodes,
new ChangeTrackingNode("Email", "Read")
};
}
else
{
array = new ChangeTrackingNode[]
{
ChangeTrackingNode.AllNodes
};
}
GenericDictionaryData <DerivedData <ISyncItemId>, ISyncItemId, FolderSync.ClientStateInformation> genericDictionaryData = (GenericDictionaryData <DerivedData <ISyncItemId>, ISyncItemId, FolderSync.ClientStateInformation>) this.syncState[SyncStateProp.ClientState];
if (!genericDictionaryData.Data.ContainsKey(syncItemId))
{
genericDictionaryData.Data[syncItemId] = new FolderSync.ClientStateInformation();
}
FolderSync.ClientStateInformation clientStateInformation = genericDictionaryData.Data[syncItemId];
clientStateInformation.ChangeTrackingInformation = new int?[array.Length];
clientStateInformation.ClientHasItem = true;
}
}
// Token: 0x06000D0A RID: 3338 RVA: 0x0004713C File Offset: 0x0004533C
private StoreObjectId GetXsoItemId(string syncFolderId, string syncItemId)
{
FolderSyncState folderSyncState;
if (this.loadedSyncStates.ContainsKey(syncFolderId))
{
folderSyncState = (FolderSyncState)this.loadedSyncStates[syncFolderId];
}
else
{
folderSyncState = base.SyncStateStorage.GetFolderSyncState(syncFolderId);
if (folderSyncState == null)
{
return(null);
}
if (folderSyncState.CustomVersion != null && folderSyncState.CustomVersion.Value > 9)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "SyncStateVersionMismatch");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.SyncStateVersionInvalid, EASServerStrings.MismatchSyncStateError, true);
}
this.loadedSyncStates.Add(syncFolderId, folderSyncState);
}
ItemIdMapping itemIdMapping = (ItemIdMapping)folderSyncState[CustomStateDatumType.IdMapping];
if (itemIdMapping == null)
{
return(null);
}
MailboxSyncItemId mailboxSyncItemId = itemIdMapping[syncItemId] as MailboxSyncItemId;
if (mailboxSyncItemId != null)
{
return((StoreObjectId)mailboxSyncItemId.NativeId);
}
return(null);
}
// Token: 0x060008E7 RID: 2279 RVA: 0x00035378 File Offset: 0x00033578
public virtual void DeserializeData(BinaryReader reader, ComponentDataPool componentDataPool)
{
if (componentDataPool.ExternalVersion < 1)
{
GenericDictionaryData <StringData, string, StoreObjectIdData, StoreObjectId> genericDictionaryData = new GenericDictionaryData <StringData, string, StoreObjectIdData, StoreObjectId>();
genericDictionaryData.DeserializeData(reader, componentDataPool);
Dictionary <string, StoreObjectId> data = genericDictionaryData.Data;
this.syncIdToMailboxIdTable = new Dictionary <string, ISyncItemId>(data.Count);
using (Dictionary <string, StoreObjectId> .Enumerator enumerator = data.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <string, StoreObjectId> keyValuePair = enumerator.Current;
this.syncIdToMailboxIdTable[keyValuePair.Key] = MailboxSyncItemId.CreateForNewItem(keyValuePair.Value);
}
goto IL_92;
}
}
GenericDictionaryData <StringData, string, DerivedData <ISyncItemId>, ISyncItemId> genericDictionaryData2 = new GenericDictionaryData <StringData, string, DerivedData <ISyncItemId>, ISyncItemId>();
genericDictionaryData2.DeserializeData(reader, componentDataPool);
this.syncIdToMailboxIdTable = genericDictionaryData2.Data;
IL_92:
this.mailboxIdToSyncIdTable = new Dictionary <ISyncItemId, string>(this.syncIdToMailboxIdTable.Count);
foreach (KeyValuePair <string, ISyncItemId> keyValuePair2 in this.syncIdToMailboxIdTable)
{
this.mailboxIdToSyncIdTable.Add(keyValuePair2.Value, keyValuePair2.Key);
}
GenericListData <StringData, string> genericListData = new GenericListData <StringData, string>();
genericListData.DeserializeData(reader, componentDataPool);
this.deletedItems = genericListData.Data;
genericListData.DeserializeData(reader, componentDataPool);
this.addedItems = genericListData.Data;
this.uniqueCounter = reader.ReadInt64();
}
// Token: 0x0600052E RID: 1326 RVA: 0x0001E8B4 File Offset: 0x0001CAB4
protected override void ProcessCommand(MailboxSession mailboxSession, XmlDocument doc)
{
if (base.CollectionRequest.CollectionId == null)
{
base.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidURLParameters");
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false);
}
mailboxSession.Delete(DeleteItemFlags.SoftDelete, new StoreObjectId[]
{
base.CollectionRequest.CollectionId
});
FolderIdMapping folderIdMapping = (FolderIdMapping)base.SyncState[CustomStateDatumType.IdMapping];
folderIdMapping.Delete(new ISyncItemId[]
{
MailboxSyncItemId.CreateForNewItem(base.CollectionRequest.CollectionId)
});
XmlNode xmlNode = doc.CreateElement("Response", "FolderHierarchy:");
XmlNode xmlNode2 = doc.CreateElement("Status", "FolderHierarchy:");
xmlNode2.InnerText = "1";
doc.AppendChild(xmlNode);
xmlNode.AppendChild(xmlNode2);
}
// Token: 0x060004C8 RID: 1224 RVA: 0x0001D6DC File Offset: 0x0001B8DC
protected override void ProcessCommand(MailboxSession mailboxSession, XmlDocument doc)
{
if (base.CollectionRequest.CollectionName == null || base.CollectionRequest.ParentId == null)
{
base.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidURLParameters");
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false);
}
AirSyncDiagnostics.TraceDebug <string, StoreObjectId>(ExTraceGlobals.RequestsTracer, this, "Creating collection with name {0} and parent Id {1}.", base.CollectionRequest.CollectionName, base.CollectionRequest.ParentId);
using (Folder folder = Folder.Create(mailboxSession, base.CollectionRequest.ParentId, StoreObjectType.Folder))
{
folder.DisplayName = base.CollectionRequest.CollectionName;
folder.ClassName = "IPF.Note";
folder.Save();
XmlNode xmlNode = doc.CreateElement("Response", "FolderHierarchy:");
XmlNode xmlNode2 = doc.CreateElement("Status", "FolderHierarchy:");
XmlNode xmlNode3 = doc.CreateElement("Folder", "FolderHierarchy:");
XmlNode xmlNode4 = doc.CreateElement("ServerId", "FolderHierarchy:");
xmlNode2.InnerText = "1";
folder.Load();
xmlNode4.InnerText = ((FolderIdMapping)base.SyncState[CustomStateDatumType.IdMapping]).Add(MailboxSyncItemId.CreateForNewItem(folder.Id.ObjectId));
doc.AppendChild(xmlNode);
xmlNode.AppendChild(xmlNode2);
xmlNode.AppendChild(xmlNode3);
xmlNode3.AppendChild(xmlNode4);
}
}
// 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);
}
}
}
// Token: 0x06000CEA RID: 3306 RVA: 0x00045C70 File Offset: 0x00043E70
private bool LegacyRespond(StoreObjectId itemId, string requestId, string userResponse, bool usingLongId)
{
MeetingRequest meetingRequest = null;
CalendarItemBase calendarItemBase = null;
StoreObjectId storeObjectId = null;
StoreObjectId storeObjectId2 = null;
Item item = null;
try
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRItems);
try
{
item = Item.Bind(base.MailboxSession, itemId, null);
}
catch (ObjectNotFoundException)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolVersionMismatch, userResponse, "Cannot find the meeting-request as specified in the reqest.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ItemNotFound");
return(false);
}
meetingRequest = (item as MeetingRequest);
if (base.Version >= 141 && meetingRequest == null)
{
calendarItemBase = (item as CalendarItemBase);
if (calendarItemBase != null)
{
calendarItemBase.OpenAsReadWrite();
}
}
if (meetingRequest == null && calendarItemBase == null)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolVersionMismatch, userResponse, "The item is not meeting-request or calendar item.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ItemNotValid");
return(false);
}
item = null;
if (meetingRequest != null)
{
if (meetingRequest.IsOrganizer())
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "The organizer of this meeting request is the mailbox owner. Checking meetingRequest.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MRIsOrganizer");
return(false);
}
if (meetingRequest.IsDelegated())
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "Cannot respond to a delegated meeting request. Use Outlook", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MRIsDelegated");
return(false);
}
if (meetingRequest.IsOutOfDate())
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "Cannot respond to a OutOfDated meeting request.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MRIsOutOfDate");
return(false);
}
meetingRequest.OpenAsReadWrite();
storeObjectId = meetingRequest.Id.ObjectId;
calendarItemBase = meetingRequest.UpdateCalendarItem(false);
}
if (calendarItemBase == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NullCalItemInMRCmd");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ServerError, null, false);
}
if (calendarItemBase.IsOrganizer())
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "The organizer of this meeting request is the mailbox owner. Checking calendarItem.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CalIsOrganizer");
return(false);
}
if (calendarItemBase.IsCancelled)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "Cannot respond to a canceled meeting.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CalIsCancelled");
return(false);
}
if (userResponse != null)
{
ResponseType responseType;
if (!(userResponse == "1"))
{
if (!(userResponse == "2"))
{
if (!(userResponse == "3"))
{
goto IL_22F;
}
responseType = ResponseType.Decline;
}
else
{
responseType = ResponseType.Tentative;
}
}
else
{
responseType = ResponseType.Accept;
}
try
{
using (calendarItemBase.RespondToMeetingRequest(responseType))
{
}
}
catch (SaveConflictException ex)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "A conflict calendar item has been detected: " + ex.Message, usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "SavedWithConflicts");
return(false);
}
calendarItemBase.Load();
if (meetingRequest != null)
{
meetingRequest.Save(SaveMode.ResolveConflicts);
}
if (responseType != ResponseType.Decline)
{
if (calendarItemBase is CalendarItemOccurrence)
{
storeObjectId2 = ((CalendarItemOccurrence)calendarItemBase).MasterId.ObjectId;
}
else
{
storeObjectId2 = calendarItemBase.Id.ObjectId;
}
}
else
{
base.MailboxSession.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
calendarItemBase.Id
});
}
calendarItemBase.Dispose();
calendarItemBase = null;
if (storeObjectId != null)
{
base.MailboxSession.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
storeObjectId
});
}
goto IL_339;
}
IL_22F:
throw new ArgumentException(string.Format("Unexpected userResponse value \"{0}\"", userResponse));
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
}
if (meetingRequest != null)
{
meetingRequest.Dispose();
}
if (item != null)
{
item.Dispose();
}
}
IL_339:
string calendarId = null;
if (storeObjectId2 != null)
{
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(storeObjectId2);
if (this.CalendarItemIdMapping.Contains(mailboxSyncItemId))
{
calendarId = this.CalendarItemIdMapping[mailboxSyncItemId];
}
else
{
calendarId = this.CalendarItemIdMapping.Add(mailboxSyncItemId);
this.calendarSyncStateChangedFlag = true;
}
}
this.AppendXmlNode(requestId, StatusCode.Success, calendarId, userResponse, usingLongId);
return(true);
}
// Token: 0x06000CE9 RID: 3305 RVA: 0x000459B0 File Offset: 0x00043BB0
private bool Respond(StoreObjectId itemId, string requestId, MeetingResponseCommand.RequestNodeData response, bool usingLongId)
{
if (base.Version <= 141)
{
return(this.LegacyRespond(itemId, requestId, response.UserResponse, usingLongId));
}
if (response.RespondToEventParameters == null)
{
throw new InvalidOperationException("Response.RespondToEventParameters must not be null at this point.");
}
StoreObjectId storeObjectId = null;
string calendarId = null;
if (this.CalendaringContainer == null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Set default CalendaringContainer");
this.CalendaringContainer = new CalendaringContainer(base.MailboxSession, null);
}
if (this.MailboxGuid == Guid.Empty)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Set default MailboxGuid");
this.MailboxGuid = base.MailboxSession.MailboxGuid;
}
string key = EntitySyncItem.GetKey(this.MailboxGuid, itemId);
IEvents events;
if (itemId.ObjectType == StoreObjectType.CalendarItem || itemId.ObjectType == StoreObjectType.CalendarItemOccurrence || itemId.ObjectType == StoreObjectType.CalendarItemSeries)
{
storeObjectId = itemId;
events = EntitySyncItem.GetEvents(this.CalendaringContainer, base.MailboxSession, itemId);
}
else
{
if (itemId.ObjectType != StoreObjectType.MeetingRequest)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolVersionMismatch, response.UserResponse, "The item is not meeting-request or calendar item.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UnsupportedObjectType" + itemId.ObjectType);
return(false);
}
using (MeetingMessage meetingMessage = MeetingMessage.Bind(base.MailboxSession, itemId))
{
if (meetingMessage == null)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolVersionMismatch, response.UserResponse, "Cannot find the meeting-request as specified in the reqest.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ItemNotFound");
return(false);
}
using (CalendarItemBase correlatedItem = meetingMessage.GetCorrelatedItem())
{
if (meetingMessage == null)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolVersionMismatch, response.UserResponse, "Cannot find the correlated meeitng item.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NullCalItemInMRCmd");
return(false);
}
storeObjectId = correlatedItem.Id.ObjectId;
}
}
response.RespondToEventParameters.MeetingRequestIdToBeDeleted = key;
key = EntitySyncItem.GetKey(this.MailboxGuid, storeObjectId);
events = this.CalendaringContainer.Calendars.Default.Events;
}
try
{
events.Respond(key, response.RespondToEventParameters, null);
}
catch (LocalizedException ex)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, response.UserResponse, ex.Message, usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "EntityRespondError");
return(false);
}
if (storeObjectId != null)
{
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(storeObjectId);
if (this.CalendarItemIdMapping.Contains(mailboxSyncItemId))
{
calendarId = this.CalendarItemIdMapping[mailboxSyncItemId];
}
else
{
calendarId = this.CalendarItemIdMapping.Add(mailboxSyncItemId);
this.calendarSyncStateChangedFlag = true;
}
}
this.AppendXmlNode(requestId, StatusCode.Success, calendarId, response.UserResponse, usingLongId);
return(true);
}
// Token: 0x06000CE3 RID: 3299 RVA: 0x00044E4C File Offset: 0x0004304C
internal void ProcessCommand()
{
foreach (MeetingResponseCommand.RequestNodeData requestNodeData in this.longIdRequests)
{
StoreObjectId storeObjectId = null;
try
{
storeObjectId = StoreObjectId.Deserialize(HttpUtility.UrlDecode(requestNodeData.RequestId));
if (requestNodeData.InstanceId != ExDateTime.MinValue)
{
storeObjectId = this.GetOccurenceId(storeObjectId, requestNodeData.InstanceId);
}
}
catch (ArgumentException)
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRErrors);
this.AppendNonSuccessXmlNode(requestNodeData.RequestId, StatusCode.Sync_ProtocolVersionMismatch, requestNodeData.UserResponse, string.Format(CultureInfo.InvariantCulture, "The LongId '{0}' in the reqest is invalid!", new object[]
{
requestNodeData.RequestId
}), true);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidLongId");
base.PartialFailure = true;
continue;
}
catch (CorruptDataException)
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRErrors);
this.AppendNonSuccessXmlNode(requestNodeData.RequestId, StatusCode.Sync_ProtocolVersionMismatch, requestNodeData.UserResponse, string.Format(CultureInfo.InvariantCulture, "The LongId '{0}' in the reqest is invalid!", new object[]
{
requestNodeData.RequestId
}), true);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidLongId2");
base.PartialFailure = true;
continue;
}
catch (FormatException)
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRErrors);
this.AppendNonSuccessXmlNode(requestNodeData.RequestId, StatusCode.Sync_ProtocolVersionMismatch, requestNodeData.UserResponse, string.Format(CultureInfo.InvariantCulture, "The LongId '{0}' in the reqest is invalid!", new object[]
{
requestNodeData.RequestId
}), true);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidLongId3");
base.PartialFailure = true;
continue;
}
catch (AirSyncPermanentException ex)
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRErrors);
AirSyncDiagnostics.TraceDebug <string, string>(ExTraceGlobals.RequestsTracer, this, "Exception caught while processing LongId {0}\r\n{1}", requestNodeData.RequestId, ex.ToString());
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, (!string.IsNullOrEmpty(ex.ErrorStringForProtocolLogger)) ? ex.ErrorStringForProtocolLogger : "InvalidLongId4");
this.AppendNonSuccessXmlNode(requestNodeData.RequestId, ex.AirSyncStatusCode, requestNodeData.UserResponse, ex.ErrorStringForProtocolLogger, true);
base.PartialFailure = true;
continue;
}
try
{
if (!this.Respond(storeObjectId, requestNodeData.RequestId, requestNodeData, true))
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRErrors);
}
}
catch (AirSyncPermanentException)
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRErrors);
base.PartialFailure = true;
throw;
}
}
foreach (string text in this.shortIdRequests.Keys)
{
IList <MeetingResponseCommand.RequestNodeData> list = this.shortIdRequests[text];
using (FolderSyncState folderSyncState = base.SyncStateStorage.GetFolderSyncState(text))
{
for (int i = 0; i < list.Count; i++)
{
try
{
string requestId = list[i].RequestId;
if (folderSyncState == null || folderSyncState[CustomStateDatumType.IdMapping] == null)
{
this.AppendNonSuccessXmlNode(list[i].RequestId, StatusCode.Sync_ProtocolVersionMismatch, list[i].UserResponse, string.Format(CultureInfo.InvariantCulture, "The CollectionId '{0}' in the reqest has not been synced yet.", new object[]
{
text
}), false);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CollectionNotSynced");
}
else
{
StoreObjectId storeObjectId2 = null;
MailboxSyncItemId mailboxSyncItemId = ((ItemIdMapping)folderSyncState[CustomStateDatumType.IdMapping])[requestId] as MailboxSyncItemId;
if (mailboxSyncItemId != null)
{
if (list[i].InstanceId == ExDateTime.MinValue)
{
storeObjectId2 = (StoreObjectId)mailboxSyncItemId.NativeId;
}
else
{
storeObjectId2 = this.GetOccurenceId((StoreObjectId)mailboxSyncItemId.NativeId, list[i].InstanceId);
}
}
if (storeObjectId2 == null)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolVersionMismatch, list[i].UserResponse, string.Format(CultureInfo.InvariantCulture, "Cannot look up the meeting-request '{0}' from ItemIdMapping.", new object[]
{
requestId
}), false);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidRequestId");
}
else if (!this.Respond(storeObjectId2, requestId, list[i], false))
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRErrors);
}
}
}
catch (AirSyncPermanentException ex2)
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRErrors);
AirSyncDiagnostics.TraceDebug <string, string>(ExTraceGlobals.RequestsTracer, this, "Exception caught while processing meeting-request {0}\r\n{1}", list[i].RequestId, ex2.ToString());
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, (!string.IsNullOrEmpty(ex2.ErrorStringForProtocolLogger)) ? ex2.ErrorStringForProtocolLogger : "InvalidLongId4");
this.AppendNonSuccessXmlNode(list[i].RequestId, ex2.AirSyncStatusCode, list[i].UserResponse, ex2.ErrorStringForProtocolLogger, false);
base.PartialFailure = true;
}
}
}
}
}
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: 0x0600088E RID: 2190 RVA: 0x00032DC8 File Offset: 0x00030FC8
private void LoadSyncState(int syncKey)
{
FolderIdMappingSyncStateInfo syncStateInfo = new FolderIdMappingSyncStateInfo();
if (syncKey == 0)
{
base.SendServerUpgradeHeader = true;
this.folderIdMappingSyncState = base.SyncStateStorage.GetCustomSyncState(syncStateInfo, new PropertyDefinition[0]);
if (this.folderIdMappingSyncState == null || this.folderIdMappingSyncState[CustomStateDatumType.IdMapping] == null)
{
CustomSyncState customSyncState = base.SyncStateStorage.GetCustomSyncState(new GlobalSyncStateInfo(), new PropertyDefinition[0]);
if (customSyncState == null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Could not find policy sync state. Deleting all sync states.");
base.SyncStateStorage.DeleteAllSyncStates();
}
else
{
customSyncState.Dispose();
using (FolderHierarchySyncState folderHierarchySyncState = base.SyncStateStorage.GetFolderHierarchySyncState())
{
if (folderHierarchySyncState != null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Deleting all sync states.");
base.SyncStateStorage.DeleteAllSyncStates();
}
}
}
this.folderIdMappingSyncState = base.SyncStateStorage.CreateCustomSyncState(syncStateInfo);
this.folderIdMappingSyncState[CustomStateDatumType.IdMapping] = new FolderIdMapping();
this.folderHierarchySyncState = base.SyncStateStorage.CreateFolderHierarchySyncState();
}
else
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Deleting folder hierarchy sync state.");
base.SyncStateStorage.DeleteFolderHierarchySyncState();
this.folderHierarchySyncState = base.SyncStateStorage.CreateFolderHierarchySyncState();
((FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping]).CommitChanges();
}
this.folderIdMappingSyncState[CustomStateDatumType.FullFolderTree] = new FolderTree();
this.folderIdMappingSyncState[CustomStateDatumType.RecoveryFullFolderTree] = this.folderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
base.InitializeSyncStatusSyncState();
base.SyncStatusSyncData.ClearClientCategoryHash();
this.shouldSaveSyncStatus = true;
Interlocked.Exchange(ref this.validToCommitSyncStatusSyncState, 1);
}
else
{
this.folderIdMappingSyncState = base.SyncStateStorage.GetCustomSyncState(syncStateInfo, new PropertyDefinition[0]);
this.folderHierarchySyncState = base.SyncStateStorage.GetFolderHierarchySyncState();
if (this.folderHierarchySyncState == null || this.folderIdMappingSyncState == null || this.folderIdMappingSyncState[CustomStateDatumType.IdMapping] == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NoHierarchyState");
throw new AirSyncPermanentException(StatusCode.Sync_OutOfDisk, this.ConstructErrorXml(StatusCode.Sync_OutOfDisk), null, false);
}
FolderIdMapping folderIdMapping = (FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping];
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Inbox);
MailboxSyncItemId mailboxId = MailboxSyncItemId.CreateForNewItem(defaultFolderId);
if (!folderIdMapping.Contains(mailboxId))
{
base.SyncStateStorage.DeleteAllSyncStates();
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InboxStoreObjectIdChanged");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.SyncStateCorrupt, new LocalizedString("The sync state is corrupt. It is most likely due to a recent mailbox migration."), false);
}
}
if (this.folderHierarchySyncState.CustomVersion != null && this.folderHierarchySyncState.CustomVersion.Value > 5)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "SyncStateVersionMismatch");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.SyncStateVersionInvalid, EASServerStrings.MismatchSyncStateError, true);
}
}
// Token: 0x06001561 RID: 5473 RVA: 0x0007D91C File Offset: 0x0007BB1C
protected StoreObjectId GetSmartItemId()
{
this.ParseXmlRequest();
string collectionId = this.CollectionId;
string itemId = this.ItemId;
string longId = this.LongId;
StoreObjectId storeObjectId = null;
FolderSyncState folderSyncState = null;
StoreObjectId result;
try
{
if (longId != null)
{
if (base.Version < 120)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "LongIdSupportedinV12Only");
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false);
}
try
{
storeObjectId = StoreObjectId.Deserialize(longId);
goto IL_1F1;
}
catch (ArgumentException innerException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidLongId");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.InvalidIDs, innerException, false);
}
catch (FormatException innerException2)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidLongId2");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.InvalidIDs, innerException2, false);
}
catch (CorruptDataException innerException3)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidLongId3");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.InvalidIDs, innerException3, false);
}
}
if (collectionId == null)
{
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Inbox);
MailboxSyncProviderFactory syncProviderFactory = new MailboxSyncProviderFactory(base.MailboxSession, defaultFolderId);
folderSyncState = base.SyncStateStorage.GetFolderSyncState(syncProviderFactory);
}
else
{
SyncCollection.CollectionTypes collectionType = AirSyncUtility.GetCollectionType(collectionId);
if (collectionType != SyncCollection.CollectionTypes.Mailbox && collectionType != SyncCollection.CollectionTypes.Unknown)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "SendFromVirtualFolder");
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false);
}
folderSyncState = base.SyncStateStorage.GetFolderSyncState(collectionId);
}
if (folderSyncState == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "SyncStateNotFound");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.SyncStateNotFound, null, false);
}
ItemIdMapping itemIdMapping = (ItemIdMapping)folderSyncState[CustomStateDatumType.IdMapping];
if (itemIdMapping == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ItemIdMappingNotFound");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ItemNotFound, null, false);
}
MailboxSyncItemId mailboxSyncItemId = itemIdMapping[itemId] as MailboxSyncItemId;
storeObjectId = ((mailboxSyncItemId == null) ? null : ((StoreObjectId)mailboxSyncItemId.NativeId));
if (storeObjectId == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ItemIdMappingNotFound");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ItemNotFound, null, false);
}
folderSyncState.Dispose();
folderSyncState = null;
IL_1F1:
result = storeObjectId;
}
finally
{
if (folderSyncState != null)
{
folderSyncState.Dispose();
}
}
return(result);
}
// Token: 0x060013E0 RID: 5088 RVA: 0x00072734 File Offset: 0x00070934
public IEnumerator <Attachment12Data> GetEnumerator()
{
Item message = base.XsoItem as Item;
Attachment12Data attachmentData = null;
if (message == null)
{
throw new UnexpectedTypeException("Item", base.XsoItem);
}
MeetingRequest meetingRequest = base.XsoItem as MeetingRequest;
if (meetingRequest == null || !meetingRequest.IsDelegated())
{
string idbase = null;
if (this.idmapping != null)
{
idbase = this.idmapping[MailboxSyncItemId.CreateForNewItem(message.Id.ObjectId)];
}
if (idbase == null)
{
idbase = message.Id.ObjectId.ToBase64String();
}
if (message is MessageItem && ((MessageItem)message).IsRestricted && !BodyConversionUtilities.IsMessageRestrictedAndDecoded(message) && !BodyConversionUtilities.IsIRMFailedToDecode(message))
{
object prop = message.TryGetProperty(MessageItemSchema.DRMLicense);
if (prop is byte[][])
{
byte[][] license = (byte[][])prop;
if (license.Length > 0)
{
attachmentData = new Attachment14Data();
attachmentData.DisplayName = "message.rpmsg.license";
attachmentData.Method = 1;
attachmentData.EstimatedDataSize = (long)license[0].Length;
attachmentData.IsInline = false;
attachmentData.FileReference = HttpUtility.UrlEncode(idbase + ":DRMLicense");
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.XsoTracer, this, "Add DRM license as attachment, message is MessageItem {0}, message.IsRestricted {1}, IsDecoded {2}, FailedToDecode {3}", new object[]
{
message is MessageItem,
((MessageItem)message).IsRestricted,
BodyConversionUtilities.IsMessageRestrictedAndDecoded(message),
BodyConversionUtilities.IsIRMFailedToDecode(message)
});
yield return(attachmentData);
}
else
{
AirSyncDiagnostics.TraceDebug <int>(ExTraceGlobals.XsoTracer, this, "The license property on the DRM message is incorrect. Length = {0}", license.Length);
}
}
else
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.XsoTracer, this, "The license property on the DRM message is incorrect. prop = {0}", new object[]
{
prop
});
}
}
AttachmentCollection attachmentCollection = null;
if (BodyConversionUtilities.IsMessageRestrictedAndDecoded(message))
{
attachmentCollection = ((RightsManagedMessageItem)message).ProtectedAttachmentCollection;
}
else
{
if (BodyConversionUtilities.IsIRMFailedToDecode(message))
{
goto IL_3FC;
}
attachmentCollection = message.AttachmentCollection;
}
int index = -1;
foreach (AttachmentHandle handle in attachmentCollection)
{
using (Attachment attachment = attachmentCollection.Open(handle))
{
if (BodyUtility.IsClearSigned(message) && (string.Equals(attachment.FileName, "smime.p7m", StringComparison.OrdinalIgnoreCase) || string.Equals(attachment.ContentType, "multipart/signed", StringComparison.OrdinalIgnoreCase)))
{
continue;
}
attachmentData = this.GetAttachmentData(message, attachment, idbase, ref index);
}
if (attachmentData != null)
{
yield return(attachmentData);
}
}
}
IL_3FC:
yield break;
}
internal void Prepopulate(Folder folder)
{
if (folder == null)
{
throw new ArgumentNullException("folder");
}
this.prepopulate = true;
if (this.CustomFilterState == null)
{
this.CustomFilterState = new Dictionary <ISyncItemId, DateTimeCustomSyncFilter.FilterState>();
}
using (QueryResult queryResult = folder.ItemQuery(ItemQueryType.None, null, null, new PropertyDefinition[]
{
ItemSchema.Id,
CalendarItemInstanceSchema.EndTime,
CalendarItemBaseSchema.CalendarItemType,
StoreObjectSchema.ItemClass,
ItemSchema.Subject,
CalendarItemInstanceSchema.StartTime
}))
{
bool flag = false;
while (!flag)
{
object[][] rows = queryResult.GetRows(10000);
flag = (rows.Length == 0);
for (int i = 0; i < rows.Length; i++)
{
StoreObjectId storeObjectId = null;
DateTimeCustomSyncFilter.FilterState filterState = null;
ISyncItemId key = null;
try
{
storeObjectId = ((VersionedId)rows[i][0]).ObjectId;
string itemClass = rows[i][3] as string;
key = MailboxSyncItemId.CreateForNewItem(storeObjectId);
if (!this.CustomFilterState.ContainsKey(key))
{
filterState = new DateTimeCustomSyncFilter.FilterState();
this.CustomFilterState[key] = filterState;
}
else
{
filterState = this.CustomFilterState[key];
}
if (!ObjectClass.IsCalendarItem(itemClass))
{
filterState.IsCalendarItem = false;
}
else
{
filterState.IsCalendarItem = true;
if (!(rows[i][2] is CalendarItemType))
{
filterState.IsCalendarItem = false;
}
else
{
filterState.IsRecurring = (CalendarItemType.RecurringMaster == (CalendarItemType)rows[i][2]);
if (filterState.IsRecurring)
{
using (CalendarItem calendarItem = CalendarItem.Bind(folder.Session, storeObjectId))
{
if (calendarItem.Recurrence != null)
{
if (calendarItem.Recurrence.Range is NoEndRecurrenceRange)
{
filterState.DoesRecurrenceEnd = false;
}
else
{
filterState.DoesRecurrenceEnd = true;
OccurrenceInfo lastOccurrence = calendarItem.Recurrence.GetLastOccurrence();
filterState.EndTime = lastOccurrence.EndTime;
}
}
else
{
filterState.IsCalendarItem = false;
}
goto IL_1E6;
}
}
if (!(rows[i][1] is ExDateTime))
{
filterState.IsCalendarItem = false;
}
else
{
filterState.EndTime = (ExDateTime)rows[i][1];
}
IL_1E6 :;
}
}
}
catch (Exception ex)
{
if (ex is ObjectNotFoundException)
{
this.CustomFilterState.Remove(key);
}
else
{
if (!SyncCommand.IsItemSyncTolerableException(ex))
{
throw;
}
string text = "Unknown";
ExDateTime exDateTime = ExDateTime.MinValue;
try
{
text = (rows[i][4] as string);
exDateTime = (ExDateTime)rows[i][5];
}
catch
{
}
AirSyncUtility.ExceptionToStringHelper exceptionToStringHelper = new AirSyncUtility.ExceptionToStringHelper(ex);
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Exception was caught in Prepopulate. Item id=\"{0}\", subject=\"{1}\", meetingTime={2}\r\n{3}\r\nIgnoring exception and proceeding to next item.", new object[]
{
(storeObjectId != null) ? storeObjectId : "null",
text,
exDateTime,
exceptionToStringHelper
});
if (filterState != null)
{
filterState.IsCalendarItem = false;
}
}
}
}
}
}
}