/// <summary>
/// Method called when an upload changes response is received.
/// </summary>
/// <param name="anchor">Anchor returned from upload response</param>
/// <param name="conflicts">List of conflicts that occurred</param>
/// <param name="updatedItems">List of items that were updated on upload</param>
/// <param name="context">Storage context associated with the cache data</param>
public void AddUploadChanges(byte[] anchor, IEnumerable<Conflict> conflicts, IEnumerable<OfflineEntity> updatedItems, WinEightContext context)
{
// For each of the uploaded entities, reset the state. No save can happen
// once sync is started, so this is ok.
foreach (OfflineCollection collection in Collections.Values)
{
collection.ResetSavedEntitiesToUnmodified();
}
// Grab the sync conflicts and errors
List<SyncConflict> syncConflicts = new List<SyncConflict>();
List<SyncError> syncErrors = new List<SyncError>();
foreach (Conflict conflict in conflicts)
{
if (conflict is SyncConflict)
{
syncConflicts.Add((SyncConflict)conflict);
}
else if (conflict is SyncError)
{
syncErrors.Add((SyncError)conflict);
}
else
{
throw new ArgumentException("Unexpected conflict type returned in upload response");
}
}
// Add the conflicts and errors.
AddConflicts(syncConflicts, context);
AddErrors(syncErrors, context);
DownloadedChanges(anchor, updatedItems);
}
/// <summary>
/// Clears out the context so that conflicts cannot be resolved multiple times.
/// </summary>
internal void ClearContext()
{
context = null;
}
/// <summary>
/// Constructor which intializes the StoreConflict with the specified context.
/// </summary>
/// <param name="context"></param>
internal OfflineConflict(WinEightContext context)
{
this.context = context;
}
/// <summary>
/// Sets the sync error, providing the cache data so that the error can be removed if ClearSyncerror
/// is called.
/// </summary>
///<param name="c">IsolatedStorageOfflineContext</param>
/// <param name="se">error to set.</param>
internal void SetSyncError(WinEightContext c, SyncError se)
{
SyncError oldError = this.syncError;
this.context = c;
this.syncError = se;
OnPropertyChanged("SyncError");
if (oldError == null)
{
OnPropertyChanged("HasSyncError");
}
}
/// <summary>
/// Sets the sync conflict, providing the cache data so that the conflict can be removed if ClearSyncConflict
/// is called.
/// </summary>
///<param name="c">IsolatedStorageOfflineContext</param>
/// <param name="sc">conflict to set.</param>
internal void SetSyncConflict(WinEightContext c, SyncConflict sc)
{
SyncConflict oldConflict = this.syncConflict;
this.context = c;
this.syncConflict = sc;
OnPropertyChanged("SyncConflict");
if (oldConflict == null)
{
OnPropertyChanged("HasSyncConflict");
}
}
public abstract SyncError MapSyncError(OfflineEntity entity, SyncError error,
WinEightContext context);
public abstract SyncConflict MapSyncConflict(OfflineEntity entity, SyncConflict conflict,
WinEightContext context);
private async void ClearSyncConflict(SyncConflict syncConflict, WinEightContext context)
{
RemoveSyncConflict(syncConflict);
await context.ClearSyncConflict(syncConflict);
}
private async void ClearSyncError(SyncError syncError, WinEightContext context)
{
RemoveSyncError(syncError);
await context.ClearSyncError(syncError);
}
public void AddSerializedError(SyncError error, WinEightContext context)
{
SyncError oldError = (SyncError)Collections[error.ErrorEntity.GetType()].MapSyncError((OfflineEntity)error.LiveEntity, error, context);
SyncErrors.Add(error);
if (oldError != null)
{
ClearSyncError(oldError,context);
}
}
/// <summary>
/// Adds a error to the list of in-memory
/// </summary>
/// <param name="error"></param>
/// <param name="context">Context for the conflict is being added</param>
public void AddSyncError(SyncError error, WinEightContext context)
{
OfflineEntity entity = Collections[error.LiveEntity.GetType()].AddOrUpdateSyncEntity((OfflineEntity)error.LiveEntity);
SyncError oldError = Collections[error.LiveEntity.GetType()].MapSyncError(entity, error, context);
SyncErrors.Add(error);
if (oldError != null)
{
ClearSyncError(oldError, context);
}
}
/// <summary>
/// Adds sync errors to the data.
/// </summary>
/// <param name="errors">List of errors to add</param>
/// <param name="context">Context used to clear conflicts</param>
public void AddErrors(IEnumerable<SyncError> errors, WinEightContext context)
{
foreach (SyncError error in errors)
{
AddSyncError(error, context);
}
}
public void AddSerializedConflict(SyncConflict conflict, WinEightContext context)
{
Type entityType = conflict.LiveEntity.GetType();
OfflineEntity entity = Collections[entityType].AddOrUpdateSyncEntity((OfflineEntity)conflict.LiveEntity);
SyncConflict oldConflict = (SyncConflict)Collections[entityType].MapSyncConflict(entity, conflict, context);
SyncConflicts.Add(conflict);
if (oldConflict != null)
ClearSyncConflict(oldConflict, context);
}
/// <summary>
/// Adds sync conflicts to the data.
/// </summary>
/// <param name="conflicts">List of SyncConflict objects</param>
/// <param name="context">IsolatedStorageOfflineSyncProvider</param>
public void AddConflicts(IEnumerable<SyncConflict> conflicts, WinEightContext context)
{
foreach (SyncConflict conflict in conflicts)
{
AddSyncConflict(conflict, context);
}
}
