/// <summary> /// Adds sync conflicts to the data. /// </summary> /// <param name="conflicts">List of SyncConflict objects</param> /// <param name="context">IsolatedStorageOfflineContext</param> public void AddConflicts(IEnumerable <SyncConflict> conflicts, IsolatedStorageOfflineContext context) { foreach (SyncConflict conflict in conflicts) { AddSyncConflict(conflict, 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, IsolatedStorageOfflineContext context) { foreach (SyncError error in errors) { AddSyncError(error, context); } }
/// <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<IsolatedStorageOfflineEntity> updatedItems, IsolatedStorageOfflineContext context) { // For each of the uploaded entities, reset the state. No save can happen // once sync is started, so this is ok. foreach (IsolatedStorageCollection 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); }
public DAL(IsolatedStorageOfflineContext context , String appName , String language , String userName , String userPassword , String configName , String configVersion , IDictionary<string, string> deviceInfo , ProgressDelegate p , Func<Uri, CacheControllerBehavior, AsyncWorkerManager, CacheRequestHandler> chacheRequestFactory) { this.appName = appName; this.language = language; this.configName = configName; this.configVersion = configVersion; this.onProgress = p; this.context = context; this.context.LoadCompleted += context_LoadCompleted; this.context.CacheController.SetCacheRequestFactory(chacheRequestFactory); this.context.CacheController.RefreshCompleted += CacheController_RefreshCompleted; this.context.CacheController.ControllerBehavior.Credentials = new System.Net.NetworkCredential(userName, userPassword); this.context.CacheController.ControllerBehavior.ConfigName = this.configName; this.context.CacheController.ControllerBehavior.ConfigVersion = this.configVersion; this.context.CacheController.ControllerBehavior.CoreVersion = CoreInformation.CoreVersion; this.context.CacheController.ControllerBehavior.ReadProgressCallback = ReadProgressCallback; this.context.CacheController.ControllerBehavior.DeviceInfo = deviceInfo; //this.context.CacheController.ControllerBehavior.AddScopeParameters("Outlet","{A507956F-D135-4E8A-BD7F-14B54AC1E95C}"); }
public SQLiteCacheData(IsolatedStorageSchema schema, IsolatedStorageOfflineContext context) { // Collections = new Dictionary<EntityType, IsolatedStorageCollection>(); SyncConflicts = new List<SyncConflict>(); SyncErrors = new List<SyncError>(); CreateCollections(schema, context); }
public void AddSerializedError(SyncError error, IsolatedStorageOfflineContext context) { IsolatedStorageSyncError oldError = (IsolatedStorageSyncError)Collections[error.ErrorEntity.GetType()].MapSyncError((IsolatedStorageOfflineEntity)error.LiveEntity, error, context); SyncErrors.Add(error); if (oldError != null) { ClearSyncError(oldError, context); } }
/// <summary> /// Adds a conflict to the list of in-memory /// </summary> /// <param name="conflict">Conflict to add</param> /// <param name="context">Context for which the conflict is being added</param> public void AddSyncConflict(SyncConflict conflict, IsolatedStorageOfflineContext context) { IsolatedStorageOfflineEntity entity = Collections[conflict.LiveEntity.GetType()].AddOrUpdateSyncEntity((IsolatedStorageOfflineEntity)conflict.LiveEntity); SyncConflict oldConflict = Collections[conflict.LiveEntity.GetType()].MapSyncConflict(entity, conflict, context); SyncConflicts.Add(conflict); if (oldConflict != null) { ClearSyncConflict(oldConflict, 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, IsolatedStorageOfflineContext context) { IsolatedStorageOfflineEntity entity = Collections[error.LiveEntity.GetType()].AddOrUpdateSyncEntity((IsolatedStorageOfflineEntity)error.LiveEntity); SyncError oldError = Collections[error.LiveEntity.GetType()].MapSyncError(entity, error, context); SyncErrors.Add(error); if (oldError != null) { ClearSyncError(oldError, context); } }
/// <summary> /// Sets the sync error, providing the cache data so that the error can be removed if ClearSyncerror /// is called. /// </summary> ///<param name="context">IsolatedStorageOfflineContext</param> /// <param name="syncError">error to set.</param> internal void SetSyncError(IsolatedStorageOfflineContext context, SyncError syncError) { SyncError oldError = this._syncError; this._context = context; this._syncError = syncError; OnPropertyChanged("SyncError"); if (oldError == null) { OnPropertyChanged("HasSyncError"); } }
public SQLiteStorageHandler(IsolatedStorageOfflineContext ctx, IsolatedStorageSchema schema, string cachePath, SymmetricAlgorithm encryptionAlgorithm) { _context = ctx; _schema = schema; _cachePath = cachePath; _encryptionAlgorithm = encryptionAlgorithm; _anchor = null; _knownTypes = new List<EntityType> { // new EntityType(typeof (SyncConflict)), // new EntityType(typeof (SyncError)) }; AddKnownTypes(); }
/// <summary> /// Sets the sync conflict, providing the cache data so that the conflict can be removed if ClearSyncConflict /// is called. /// </summary> ///<param name="context">IsolatedStorageOfflineContext</param> /// <param name="syncConflict">conflict to set.</param> internal void SetSyncConflict( IsolatedStorageOfflineContext context, SyncConflict syncConflict) { SyncConflict oldConflict = this._syncConflict; this._context = context; this._syncConflict = syncConflict; OnPropertyChanged("SyncConflict"); if (oldConflict == null) { OnPropertyChanged("HasSyncConflict"); } }
public void AddErrors(IEnumerable<SyncError> errors, IsolatedStorageOfflineContext 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, IsolatedStorageOfflineContext context) { foreach (SyncError error in errors) { AddSyncError(error, context); } }
/// <summary> /// Constructor which intializes the StoreConflict with the specified context. /// </summary> /// <param name="context"></param> internal StoreConflict(IsolatedStorageOfflineContext context) { this._context = context; }
private void ClearSyncConflict(SyncConflict syncConflict, IsolatedStorageOfflineContext context) { RemoveSyncConflict(syncConflict); context.StorageHandler.ClearSyncConflict((IsolatedStorageSyncConflict)syncConflict); }
public void AddSerializedError(SyncError error, IsolatedStorageOfflineContext context) { IsolatedStorageSyncError oldError = (IsolatedStorageSyncError)Collections[error.ErrorEntity.GetType()].MapSyncError((IsolatedStorageOfflineEntity)error.LiveEntity, error, context); SyncErrors.Add(error); if (oldError != null) { ClearSyncError(oldError,context); } }
public void AddSerializedConflict(SyncConflict conflict, IsolatedStorageOfflineContext context) { }
private void CreateCollections(IsolatedStorageSchema schema, IsolatedStorageOfflineContext context) { // Type collectionType = typeof(IsolatedStorageCollection<>); // foreach (EntityType t in schema.Collections) // { // // CreateInstance the generic type for the type in the collection. // Type generic = collectionType.MakeGenericType(t); // IsolatedStorageCollection collection = (IsolatedStorageCollection)Activator.CreateInstance(generic, context); // Collections[t] = collection; // } }
public void AddUploadChanges(byte[] anchor, IEnumerable<Conflict> conflicts, IEnumerable<IsolatedStorageOfflineEntity> updatedItems, IsolatedStorageOfflineContext context) { }
public abstract SyncConflict MapSyncConflict(IsolatedStorageOfflineEntity entity, SyncConflict conflict, IsolatedStorageOfflineContext context);
public void AddSerializedError(SyncError error, IsolatedStorageOfflineContext context) { }
public void AddSerializedConflict(SyncConflict conflict, IsolatedStorageOfflineContext context) { Type entityType = conflict.LiveEntity.GetType(); IsolatedStorageOfflineEntity entity = Collections[entityType].AddOrUpdateSyncEntity((IsolatedStorageOfflineEntity)conflict.LiveEntity); IsolatedStorageSyncConflict oldConflict = (IsolatedStorageSyncConflict)Collections[entityType].MapSyncConflict(entity, conflict, context); SyncConflicts.Add(conflict); if (oldConflict != null) { ClearSyncConflict(oldConflict,context); } }
private void ClearSyncConflict(SyncConflict syncConflict, IsolatedStorageOfflineContext context) { }
public abstract SyncError MapSyncError(IsolatedStorageOfflineEntity entity, SyncError error, IsolatedStorageOfflineContext context);
private void ClearSyncError(SyncError syncError, IsolatedStorageOfflineContext context) { RemoveSyncError(syncError); context.StorageHandler.ClearSyncError((IsolatedStorageSyncError)syncError); }
public void AddConflicts(IEnumerable<SyncConflict> conflicts, IsolatedStorageOfflineContext context) { }
public SQLiteCacheData Load(IsolatedStorageOfflineContext context) { return new SQLiteCacheData(_schema, context); }
/// <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 <IsolatedStorageOfflineEntity> updatedItems, IsolatedStorageOfflineContext context) { // For each of the uploaded entities, reset the state. No save can happen // once sync is started, so this is ok. foreach (IsolatedStorageCollection 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> /// Adds sync conflicts to the data. /// </summary> /// <param name="conflicts">List of SyncConflict objects</param> /// <param name="context">IsolatedStorageOfflineContext</param> public void AddConflicts(IEnumerable<SyncConflict> conflicts, IsolatedStorageOfflineContext context) { foreach (SyncConflict conflict in conflicts) { AddSyncConflict(conflict, context); } }