private void UpgradeSyncStateTable()
{
ExTraceGlobals.MethodEnterExitTracer.TraceDebug((long)this.GetHashCode(), "SyncCalendarFolderSyncState.UpgradeSyncStateTable called");
ISyncWatermark watermark = base.Contains(SyncStateProp.CurMaxWatermark) ? ((ISyncWatermark) base[SyncStateProp.CurMaxWatermark]) : null;
base.Version = 1;
base.InitializeSyncStateTable();
this.Watermark = watermark;
}
public override bool GetNewOperations(ISyncWatermark minSyncWatermark, ISyncWatermark maxSyncWatermark, bool enumerateDeletes, int numOperations, QueryFilter filter, Dictionary <ISyncItemId, ServerManifestEntry> newServerManifest)
{
if (maxSyncWatermark != null)
{
throw new NotSupportedException("First Time Sync behavior needs to be accessed via the FirstTimeSync method. Only call GetNewOperations for ICS changes.");
}
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.SyncProcessTracer, this, "[FirstTimeSyncProvider.GetNewOperations] Getting new ICS operations");
return(base.GetNewOperations(minSyncWatermark, maxSyncWatermark, enumerateDeletes, numOperations, filter, newServerManifest));
}
public ISyncWatermark GetMaxItemWatermark(ISyncWatermark currentWatermark)
{
this.CheckDisposed("GetMaxItemWatermark");
if (this.entryList.Count <= this.maxNumEntries)
{
return(RecipientInfoCacheSyncWatermark.Create(this.entryList, this.recipientInfoCache.LastModifiedTime));
}
if (!this.entryListIsSorted)
{
this.entryList.Sort();
this.entryListIsSorted = true;
}
return(RecipientInfoCacheSyncWatermark.Create(this.entryList.GetRange(this.entryList.Count - this.maxNumEntries, this.maxNumEntries), this.recipientInfoCache.LastModifiedTime));
}
public override bool GetNewOperations(ISyncWatermark minSyncWatermark, ISyncWatermark maxSyncWatermark, bool enumerateDeletes, int numOperations, QueryFilter filter, Dictionary <ISyncItemId, ServerManifestEntry> newServerManifest)
{
base.CheckDisposed("GetNewOperations");
AirSyncDiagnostics.TraceInfo <int>(ExTraceGlobals.RequestsTracer, this, "EntitySyncProvider.GetNewOperations. numOperations = {0}", numOperations);
if (newServerManifest == null)
{
throw new ArgumentNullException("newServerManifest");
}
if (!enumerateDeletes)
{
throw new NotImplementedException("enumerateDeletes is false!");
}
if (filter != null)
{
throw new NotImplementedException("filter is non-null! Filters are not supported on EntitySyncProvider");
}
SyncCalendar syncCalendar = new SyncCalendar(this.CalendarSyncState, base.Folder.Session, base.Folder.Id.ObjectId, (CalendarFolder folder) => EntitySyncProvider.PropertiesToSync, this.WindowStart, this.WindowEnd, false, numOperations);
IFolderSyncState folderSyncState;
IList <KeyValuePair <StoreId, LocalizedException> > list;
SyncCalendarResponse syncCalendarResponse = syncCalendar.Execute(out folderSyncState, out list);
AirSyncDiagnostics.TraceInfo <IFolderSyncState>(ExTraceGlobals.RequestsTracer, this, "newSyncState:{0}", folderSyncState);
SyncCalendarFolderSyncState syncCalendarFolderSyncState = (SyncCalendarFolderSyncState)folderSyncState;
this.CalendarSyncState = new AirSyncCalendarSyncState(syncCalendarFolderSyncState.SerializeAsBase64String(), syncCalendarResponse.QueryResumptionPoint, syncCalendarResponse.OldWindowEnd);
if (list.Count > 0 && Command.CurrentCommand.MailboxLogger != null)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (KeyValuePair <StoreId, LocalizedException> keyValuePair in list)
{
stringBuilder.AppendFormat("Exception caught for item {0}\r\n{1}\r\n\r\n", keyValuePair.Key, keyValuePair.Value);
}
Command.CurrentCommand.MailboxLogger.SetData(MailboxLogDataName.CalendarSync_Exception, stringBuilder.ToString());
}
AirSyncDiagnostics.TraceInfo <int>(ExTraceGlobals.RequestsTracer, this, "DeletedItems:{0}", syncCalendarResponse.DeletedItems.Count);
foreach (StoreId storeId in syncCalendarResponse.DeletedItems)
{
ISyncItemId syncItemId = EntitySyncItemId.CreateFromId(storeId);
newServerManifest.Add(syncItemId, new ServerManifestEntry(ChangeType.Delete, syncItemId, null));
}
this.CopyListToDictionary(syncCalendarResponse.UpdatedItems, "UpdatedItems", newServerManifest);
this.CopyListToDictionary(syncCalendarResponse.RecurrenceMastersWithInstances, "RecurrenceMastersWithInstances", newServerManifest);
this.CopyListToDictionary(syncCalendarResponse.RecurrenceMastersWithoutInstances, "RecurrenceMastersWithoutInstances", newServerManifest);
this.CopyListToDictionary(syncCalendarResponse.UnchangedRecurrenceMastersWithInstances, "UnchangedRecurrenceMastersWithInstances", newServerManifest);
AirSyncDiagnostics.TraceInfo <bool>(ExTraceGlobals.RequestsTracer, this, "MoreAvailable:{0}", !syncCalendarResponse.IncludesLastItemInRange);
return(!syncCalendarResponse.IncludesLastItemInRange);
}
public ISyncWatermark GetMaxItemWatermark(ISyncWatermark currentWatermark)
{
this.CheckDisposed("GetMaxItemWatermark");
MailboxSyncWatermark mailboxSyncWatermark = MailboxSyncWatermark.Create();
mailboxSyncWatermark.IcsState = this.CatchUpIcsState((MailboxSyncWatermark)currentWatermark);
using (QueryResult queryResult = this.folder.ItemQuery(ItemQueryType.None, null, MailboxSyncProvider.sortByArticleIdDescending, MailboxSyncProvider.queryColumns))
{
object[][] rows = queryResult.GetRows(1);
if (rows.Length != 0)
{
StoreObjectId objectId = ((VersionedId)rows[0][1]).ObjectId;
mailboxSyncWatermark.ChangeNumber = (int)rows[0][0];
}
}
return(mailboxSyncWatermark);
}
public bool GetNewOperations(ISyncWatermark minSyncWatermark, ISyncWatermark maxSyncWatermark, bool enumerateDeletes, int numOperations, QueryFilter filter, Dictionary <ISyncItemId, ServerManifestEntry> newServerManifest)
{
this.CheckDisposed("GetNewOperations");
AirSyncDiagnostics.TraceInfo <int>(ExTraceGlobals.SyncTracer, this, "RecipientInfoCacheSyncProvider.GetNewOperations. numOperations = {0}", numOperations);
if (newServerManifest == null)
{
throw new ArgumentNullException("newServerManifest");
}
if (!enumerateDeletes)
{
throw new NotImplementedException("enumerateDeletes is false!");
}
if (filter != null)
{
throw new NotImplementedException("filter is non-null! Filters are not supported on RecipientInfoCacheSyncProvider");
}
return(this.ComputeNewItems(minSyncWatermark as RecipientInfoCacheSyncWatermark, maxSyncWatermark as RecipientInfoCacheSyncWatermark, numOperations, newServerManifest));
}
public virtual bool GetNewOperations(ISyncWatermark minSyncWatermark, ISyncWatermark maxSyncWatermark, bool enumerateDeletes, int numOperations, QueryFilter filter, Dictionary <ISyncItemId, ServerManifestEntry> newServerManifest)
{
if (numOperations < 0 && numOperations != -1)
{
throw new ArgumentException("numOperations is not valid, value = " + numOperations);
}
this.CheckDisposed("GetNewOperations");
MailboxSyncWatermark minWatermark = minSyncWatermark as MailboxSyncWatermark;
MailboxSyncWatermark maxWatermark = maxSyncWatermark as MailboxSyncWatermark;
if (filter != null)
{
this.SyncLogger.Information <int>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "MailboxSyncProvider.GetNewOperations. numOperations = {0} With filter", numOperations);
return(this.GetNewOperationsWithFilter(minWatermark, maxWatermark, numOperations, filter, newServerManifest));
}
this.SyncLogger.Information <int>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "MailboxSyncProvider.GetNewOperations. numOperations = {0} with ICS", numOperations);
return(this.IcsGetNewOperations(minWatermark, enumerateDeletes, numOperations, newServerManifest));
}
protected override void CommitPreviousState()
{
ISyncWatermark prevMaxWatermark;
ISyncWatermark prevFTSMaxWatermark;
Dictionary <ISyncItemId, ServerManifestEntry> prevServerManifest;
string prevFilterId;
Dictionary <ISyncItemId, ServerManifestEntry> prevDelayedServerOperationQueue;
ISyncWatermark prevSnapShotWatermark;
bool prevLastSyncConversationMode;
(this.acknowledgeModifications as FirstTimeFolderSync.FirstTimeAcknowledgeModifications).CommitPreviousState(out prevMaxWatermark, out prevFTSMaxWatermark, out prevServerManifest, out prevFilterId, out prevDelayedServerOperationQueue, out prevSnapShotWatermark, out prevLastSyncConversationMode);
base.PrevMaxWatermark = prevMaxWatermark;
this.PrevFTSMaxWatermark = prevFTSMaxWatermark;
base.PrevServerManifest = prevServerManifest;
base.PrevFilterId = prevFilterId;
base.PrevDelayedServerOperationQueue = prevDelayedServerOperationQueue;
base.PrevSnapShotWatermark = prevSnapShotWatermark;
base.PrevLastSyncConversationMode = prevLastSyncConversationMode;
}
public void SavePreviousState(ISyncWatermark prevMaxWatermark, ISyncWatermark prevFTSMaxWatermark, Dictionary <ISyncItemId, ServerManifestEntry> prevServerManifest, string prevFilterId, Dictionary <ISyncItemId, ServerManifestEntry> prevDelayedServerOperationQueue, ISyncWatermark prevSnapShotWatermark, bool prevLastSyncConversationMode)
{
base.SavePreviousState(prevMaxWatermark, prevServerManifest, prevFilterId, prevDelayedServerOperationQueue, prevSnapShotWatermark, prevLastSyncConversationMode);
this.prevFTSMaxWatermark = prevFTSMaxWatermark;
}
public void CommitPreviousState(out ISyncWatermark prevMaxWatermark, out ISyncWatermark prevFTSMaxWatermark, out Dictionary <ISyncItemId, ServerManifestEntry> prevServerManifest, out string prevFilterId, out Dictionary <ISyncItemId, ServerManifestEntry> prevDelayedServerOperationQueue, out ISyncWatermark prevSnapShotWatermark, out bool prevLastSyncConversationMode)
{
base.CommitPreviousState(out prevMaxWatermark, out prevServerManifest, out prevFilterId, out prevDelayedServerOperationQueue, out prevSnapShotWatermark, out prevLastSyncConversationMode);
prevFTSMaxWatermark = this.prevFTSMaxWatermark;
}
public ServerManifestEntry CreateItemChangeManifestEntry(ISyncItemId syncItemId, ISyncWatermark watermark)
{
return(new ServerManifestEntry(syncItemId)
{
Watermark = watermark,
ChangeType = ChangeType.Add
});
}
// Token: 0x060010ED RID: 4333 RVA: 0x00046494 File Offset: 0x00044694
private bool DoIcsSync(HashSet <StoreId> syncItemsHashSet, IList <SyncCalendarItemType> updatedItemsList, IList <SyncCalendarItemType> recurrenceMastersWithInstances, IList <SyncCalendarItemType> recurrenceMastersWithoutInstances, IDictionary <StoreId, SyncCalendarItemType> unchangedRecurrenceMastersWithInstances, IList <StoreId> deletedItemsList, ISyncWatermark watermark, ISyncProvider syncProvider, int maxCount, IList <KeyValuePair <StoreId, LocalizedException> > caughtExceptions, out int addedItems)
{
ExTraceGlobals.SyncCalendarTracer.TraceDebug((long)this.GetHashCode(), "XsoSyncCalendar.DoIcsSync: Start");
addedItems = 0;
int num = (maxCount == 1) ? 1 : ((int)(0.8 * (double)maxCount));
Dictionary <ISyncItemId, ServerManifestEntry> dictionary = new Dictionary <ISyncItemId, ServerManifestEntry>();
bool flag = false;
do
{
ExTraceGlobals.SyncCalendarTracer.TraceDebug <int>((long)this.GetHashCode(), "XsoSyncCalendar.DoIcsSync: Requesting {0} changes from ICS", 100);
int numOperations = Math.Min(num - addedItems, 100);
flag = syncProvider.GetNewOperations(watermark, null, true, numOperations, null, dictionary);
ExTraceGlobals.SyncCalendarTracer.TraceDebug <int>((long)this.GetHashCode(), "XsoSyncCalendar.DoIcsSync: Received {0} entries from ICS", dictionary.Count);
foreach (ServerManifestEntry serverManifestEntry in dictionary.Values)
{
StoreObjectId id = (StoreObjectId)serverManifestEntry.Id.NativeId;
switch (serverManifestEntry.ChangeType)
{
case ChangeType.Add:
case ChangeType.Change:
addedItems += this.AddNewOrChangedItems(id, updatedItemsList, recurrenceMastersWithInstances, recurrenceMastersWithoutInstances, unchangedRecurrenceMastersWithInstances, deletedItemsList, syncItemsHashSet, caughtExceptions);
continue;
case ChangeType.Delete:
addedItems += this.AddDeletedItem(id, syncItemsHashSet, deletedItemsList);
continue;
}
ExTraceGlobals.SyncCalendarTracer.TraceWarning <ChangeType>((long)this.GetHashCode(), "XsoSyncCalendar.DoIcsSyncs unknown/unexpected sync change type {0}", serverManifestEntry.ChangeType);
}
}while (flag && num > addedItems);
ExTraceGlobals.SyncCalendarTracer.TraceDebug((long)this.GetHashCode(), "XsoSyncCalendar.DoIcsSync: End");
return(flag);
}
public ServerManifestEntry(ChangeType changeType, ISyncItemId id, ISyncWatermark watermark = null)
{
this.ChangeType = changeType;
this.itemId = id;
this.Watermark = watermark;
}
