diff options
Diffstat (limited to 'FireBase/Offline')
-rw-r--r-- | FireBase/Offline/ConcurrentOfflineDatabase.cs | 207 | ||||
-rw-r--r-- | FireBase/Offline/DatabaseExtensions.cs | 195 | ||||
-rw-r--r-- | FireBase/Offline/ISetHandler.cs | 11 | ||||
-rw-r--r-- | FireBase/Offline/InitialPullStrategy.cs | 23 | ||||
-rw-r--r-- | FireBase/Offline/Internals/MemberAccessVisitor.cs | 51 | ||||
-rw-r--r-- | FireBase/Offline/OfflineCacheAdapter.cs | 165 | ||||
-rw-r--r-- | FireBase/Offline/OfflineDatabase.cs | 201 | ||||
-rw-r--r-- | FireBase/Offline/OfflineEntry.cs | 116 | ||||
-rw-r--r-- | FireBase/Offline/RealtimeDatabase.cs | 459 | ||||
-rw-r--r-- | FireBase/Offline/SetHandler.cs | 24 | ||||
-rw-r--r-- | FireBase/Offline/StreamingOptions.cs | 21 | ||||
-rw-r--r-- | FireBase/Offline/SyncOptions.cs | 28 |
12 files changed, 1501 insertions, 0 deletions
diff --git a/FireBase/Offline/ConcurrentOfflineDatabase.cs b/FireBase/Offline/ConcurrentOfflineDatabase.cs new file mode 100644 index 0000000..226892d --- /dev/null +++ b/FireBase/Offline/ConcurrentOfflineDatabase.cs @@ -0,0 +1,207 @@ +namespace Firebase.Database.Offline +{ + using System; + using System.Collections; + using System.Collections.Concurrent; + using System.Collections.Generic; + using System.IO; + using System.Linq; + + using LiteDB; + + /// <summary> + /// The offline database. + /// </summary> + public class ConcurrentOfflineDatabase : IDictionary<string, OfflineEntry> + { + private readonly LiteRepository db; + private readonly ConcurrentDictionary<string, OfflineEntry> ccache; + + /// <summary> + /// Initializes a new instance of the <see cref="OfflineDatabase"/> class. + /// </summary> + /// <param name="itemType"> The item type which is used to determine the database file name. </param> + /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param> + public ConcurrentOfflineDatabase(Type itemType, string filenameModifier) + { + var fullName = this.GetFileName(itemType.ToString()); + if(fullName.Length > 100) + { + fullName = fullName.Substring(0, 100); + } + + BsonMapper mapper = BsonMapper.Global; + mapper.Entity<OfflineEntry>().Id(o => o.Key); + + string root = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); + string filename = fullName + filenameModifier + ".db"; + var path = Path.Combine(root, filename); + this.db = new LiteRepository(new LiteDatabase(path, mapper)); + + var cache = db.Database + .GetCollection<OfflineEntry>() + .FindAll() + .ToDictionary(o => o.Key, o => o); + + this.ccache = new ConcurrentDictionary<string, OfflineEntry>(cache); + + } + + /// <summary> + /// Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>. + /// </summary> + /// <returns> The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>. </returns> + public int Count => this.ccache.Count; + + /// <summary> + /// Gets a value indicating whether this is a read-only collection. + /// </summary> + public bool IsReadOnly => false; + + /// <summary> + /// Gets an <see cref="T:System.Collections.Generic.ICollection`1"/> containing the keys of the <see cref="T:System.Collections.Generic.IDictionary`2"/>. + /// </summary> + /// <returns> An <see cref="T:System.Collections.Generic.ICollection`1"/> containing the keys of the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns> + public ICollection<string> Keys => this.ccache.Keys; + + /// <summary> + /// Gets an <see cref="T:System.Collections.Generic.ICollection`1"/> containing the values in the <see cref="T:System.Collections.Generic.IDictionary`2"/>. + /// </summary> + /// <returns> An <see cref="T:System.Collections.Generic.ICollection`1"/> containing the values in the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns> + public ICollection<OfflineEntry> Values => this.ccache.Values; + + /// <summary> + /// Gets or sets the element with the specified key. + /// </summary> + /// <param name="key">The key of the element to get or set.</param> + /// <returns> The element with the specified key. </returns> + public OfflineEntry this[string key] + { + get + { + return this.ccache[key]; + } + + set + { + this.ccache.AddOrUpdate(key, value, (k, existing) => value); + this.db.Upsert(value); + } + } + + /// <summary> + /// Returns an enumerator that iterates through the collection. + /// </summary> + /// <returns> An enumerator that can be used to iterate through the collection. </returns> + public IEnumerator<KeyValuePair<string, OfflineEntry>> GetEnumerator() + { + return this.ccache.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return this.GetEnumerator(); + } + + /// <summary> + /// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"/>. + /// </summary> + /// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param> + public void Add(KeyValuePair<string, OfflineEntry> item) + { + this.Add(item.Key, item.Value); + } + + /// <summary> + /// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>. + /// </summary> + public void Clear() + { + this.ccache.Clear(); + this.db.Delete<OfflineEntry>(Query.All()); + } + + /// <summary> + /// Determines whether the <see cref="T:System.Collections.Generic.ICollection`1"/> contains a specific value. + /// </summary> + /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param> + /// <returns> True if <paramref name="item"/> is found in the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. </returns> + public bool Contains(KeyValuePair<string, OfflineEntry> item) + { + return this.ContainsKey(item.Key); + } + + /// <summary> + /// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1"/> to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index. + /// </summary> + /// <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1"/>. The <see cref="T:System.Array"/> must have zero-based indexing.</param> + /// <param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param> + public void CopyTo(KeyValuePair<string, OfflineEntry>[] array, int arrayIndex) + { + this.ccache.ToList().CopyTo(array, arrayIndex); + } + + /// <summary> + /// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>. + /// </summary> + /// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param> + /// <returns> True if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>. </returns> + public bool Remove(KeyValuePair<string, OfflineEntry> item) + { + return this.Remove(item.Key); + } + + /// <summary> + /// Determines whether the <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key. + /// </summary> + /// <param name="key">The key to locate in the <see cref="T:System.Collections.Generic.IDictionary`2"/>.</param> + /// <returns> True if the <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the key; otherwise, false. </returns> + public bool ContainsKey(string key) + { + return this.ccache.ContainsKey(key); + } + + /// <summary> + /// Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2"/>. + /// </summary> + /// <param name="key">The object to use as the key of the element to add.</param> + /// <param name="value">The object to use as the value of the element to add.</param> + public void Add(string key, OfflineEntry value) + { + this.ccache.AddOrUpdate(key, value, (k, existing) => value); + this.db.Upsert(value); + } + + /// <summary> + /// Removes the element with the specified key from the <see cref="T:System.Collections.Generic.IDictionary`2"/>. + /// </summary> + /// <param name="key">The key of the element to remove.</param> + /// <returns> True if the element is successfully removed; otherwise, false. This method also returns false if <paramref name="key"/> was not found in the original <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns> + public bool Remove(string key) + { + this.ccache.TryRemove(key, out OfflineEntry _); + return this.db.Delete<OfflineEntry>(key); + } + + /// <summary> + /// Gets the value associated with the specified key. + /// </summary> + /// <param name="key">The key whose value to get.</param><param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the <paramref name="value"/> parameter. This parameter is passed uninitialized.</param> + /// <returns> True if the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key; otherwise, false. </returns> + public bool TryGetValue(string key, out OfflineEntry value) + { + return this.ccache.TryGetValue(key, out value); + } + + private string GetFileName(string fileName) + { + var invalidChars = new[] { '`', '[', ',', '=' }; + foreach(char c in invalidChars.Concat(System.IO.Path.GetInvalidFileNameChars()).Distinct()) + { + fileName = fileName.Replace(c, '_'); + } + + return fileName; + } + } +} diff --git a/FireBase/Offline/DatabaseExtensions.cs b/FireBase/Offline/DatabaseExtensions.cs new file mode 100644 index 0000000..4b04314 --- /dev/null +++ b/FireBase/Offline/DatabaseExtensions.cs @@ -0,0 +1,195 @@ +namespace Firebase.Database.Offline +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Linq.Expressions; + using System.Reflection; + using Firebase.Database.Query; + + public static class DatabaseExtensions + { + /// <summary> + /// Create new instances of the <see cref="RealtimeDatabase{T}"/>. + /// </summary> + /// <typeparam name="T"> Type of elements. </typeparam> + /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param> + /// <param name="elementRoot"> Optional custom root element of received json items. </param> + /// <param name="streamingOptions"> Realtime streaming options. </param> + /// <param name="initialPullStrategy"> Specifies what strategy should be used for initial pulling of server data. </param> + /// <param name="pushChanges"> Specifies whether changed items should actually be pushed to the server. It this is false, then Put / Post / Delete will not affect server data. </param> + /// <returns> The <see cref="RealtimeDatabase{T}"/>. </returns> + public static RealtimeDatabase<T> AsRealtimeDatabase<T>(this ChildQuery query, string filenameModifier = "", string elementRoot = "", StreamingOptions streamingOptions = StreamingOptions.LatestOnly, InitialPullStrategy initialPullStrategy = InitialPullStrategy.MissingOnly, bool pushChanges = true) + where T : class + { + return new RealtimeDatabase<T>(query, elementRoot, query.Client.Options.OfflineDatabaseFactory, filenameModifier, streamingOptions, initialPullStrategy, pushChanges); + } + + /// <summary> + /// Create new instances of the <see cref="RealtimeDatabase{T}"/>. + /// </summary> + /// <typeparam name="T"> Type of elements. </typeparam> + /// <typeparam name="TSetHandler"> Type of the custom <see cref="ISetHandler{T}"/> to use. </typeparam> + /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param> + /// <param name="elementRoot"> Optional custom root element of received json items. </param> + /// <param name="streamingOptions"> Realtime streaming options. </param> + /// <param name="initialPullStrategy"> Specifies what strategy should be used for initial pulling of server data. </param> + /// <param name="pushChanges"> Specifies whether changed items should actually be pushed to the server. It this is false, then Put / Post / Delete will not affect server data. </param> + /// <returns> The <see cref="RealtimeDatabase{T}"/>. </returns> + public static RealtimeDatabase<T> AsRealtimeDatabase<T, TSetHandler>(this ChildQuery query, string filenameModifier = "", string elementRoot = "", StreamingOptions streamingOptions = StreamingOptions.LatestOnly, InitialPullStrategy initialPullStrategy = InitialPullStrategy.MissingOnly, bool pushChanges = true) + where T : class + where TSetHandler : ISetHandler<T>, new() + { + return new RealtimeDatabase<T>(query, elementRoot, query.Client.Options.OfflineDatabaseFactory, filenameModifier, streamingOptions, initialPullStrategy, pushChanges, Activator.CreateInstance<TSetHandler>()); + } + + /// <summary> + /// Overwrites existing object with given key leaving any missing properties intact in firebase. + /// </summary> + /// <param name="key"> The key. </param> + /// <param name="obj"> The object to set. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public static void Patch<T>(this RealtimeDatabase<T> db, string key, T obj, bool syncOnline = true, int priority = 1) + where T: class + { + db.Set(key, obj, syncOnline ? SyncOptions.Patch : SyncOptions.None, priority); + } + + /// <summary> + /// Overwrites existing object with given key. + /// </summary> + /// <param name="key"> The key. </param> + /// <param name="obj"> The object to set. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public static void Put<T>(this RealtimeDatabase<T> db, string key, T obj, bool syncOnline = true, int priority = 1) + where T: class + { + db.Set(key, obj, syncOnline ? SyncOptions.Put : SyncOptions.None, priority); + } + + /// <summary> + /// Adds a new entity to the Database. + /// </summary> + /// <param name="obj"> The object to add. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + /// <returns> The generated key for this object. </returns> + public static string Post<T>(this RealtimeDatabase<T> db, T obj, bool syncOnline = true, int priority = 1) + where T: class + { + var key = FirebaseKeyGenerator.Next(); + + db.Set(key, obj, syncOnline ? SyncOptions.Put : SyncOptions.None, priority); + + return key; + } + + /// <summary> + /// Deletes the entity with the given key. + /// </summary> + /// <param name="key"> The key. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public static void Delete<T>(this RealtimeDatabase<T> db, string key, bool syncOnline = true, int priority = 1) + where T: class + { + db.Set(key, null, syncOnline ? SyncOptions.Put : SyncOptions.None, priority); + } + + /// <summary> + /// Do a Put for a nested property specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>. + /// </summary> + /// <typeparam name="T"> Type of the root elements. </typeparam> + /// <typeparam name="TProperty"> Type of the property being modified</typeparam> + /// <param name="db"> Database instance. </param> + /// <param name="key"> Key of the root element to modify. </param> + /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param> + /// <param name="value"> Value to put. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public static void Put<T, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, TProperty>> propertyExpression, TProperty value, bool syncOnline = true, int priority = 1) + where T: class + { + db.Set(key, propertyExpression, value, syncOnline ? SyncOptions.Put : SyncOptions.None, priority); + } + + /// <summary> + /// Do a Patch for a nested property specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>. + /// </summary> + /// <typeparam name="T"> Type of the root elements. </typeparam> + /// <typeparam name="TProperty"> Type of the property being modified</typeparam> + /// <param name="db"> Database instance. </param> + /// <param name="key"> Key of the root element to modify. </param> + /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param> + /// <param name="value"> Value to patch. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public static void Patch<T, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, TProperty>> propertyExpression, TProperty value, bool syncOnline = true, int priority = 1) + where T: class + { + db.Set(key, propertyExpression, value, syncOnline ? SyncOptions.Patch : SyncOptions.None, priority); + } + + /// <summary> + /// Delete a nested property specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>. This basically does a Put with null value. + /// </summary> + /// <typeparam name="T"> Type of the root elements. </typeparam> + /// <typeparam name="TProperty"> Type of the property being modified</typeparam> + /// <param name="db"> Database instance. </param> + /// <param name="key"> Key of the root element to modify. </param> + /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param> + /// <param name="value"> Value to put. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public static void Delete<T, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, TProperty>> propertyExpression, bool syncOnline = true, int priority = 1) + where T: class + where TProperty: class + { + db.Set(key, propertyExpression, null, syncOnline ? SyncOptions.Put : SyncOptions.None, priority); + } + + /// <summary> + /// Post a new entity into the nested dictionary specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>. + /// The key of the new entity is automatically generated. + /// </summary> + /// <typeparam name="T"> Type of the root elements. </typeparam> + /// <typeparam name="TSelector"> Type of the dictionary being modified</typeparam> + /// <typeparam name="TProperty"> Type of the value within the dictionary being modified</typeparam> + /// <param name="db"> Database instance. </param> + /// <param name="key"> Key of the root element to modify. </param> + /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param> + /// <param name="value"> Value to put. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public static void Post<T, TSelector, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, TSelector>> propertyExpression, TProperty value, bool syncOnline = true, int priority = 1) + where T: class + where TSelector: IDictionary<string, TProperty> + { + var nextKey = FirebaseKeyGenerator.Next(); + var expression = Expression.Lambda<Func<T, TProperty>>(Expression.Call(propertyExpression.Body, typeof(TSelector).GetRuntimeMethod("get_Item", new[] { typeof(string) }), Expression.Constant(nextKey)), propertyExpression.Parameters); + db.Set(key, expression, value, syncOnline ? SyncOptions.Put : SyncOptions.None, priority); + } + + /// <summary> + /// Delete an entity with key <paramref name="dictionaryKey"/> in the nested dictionary specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>. + /// The key of the new entity is automatically generated. + /// </summary> + /// <typeparam name="T"> Type of the root elements. </typeparam> + /// <typeparam name="TSelector"> Type of the dictionary being modified</typeparam> + /// <typeparam name="TProperty"> Type of the value within the dictionary being modified</typeparam> + /// <param name="db"> Database instance. </param> + /// <param name="key"> Key of the root element to modify. </param> + /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param> + /// <param name="dictionaryKey"> Key within the nested dictionary to delete. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public static void Delete<T, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, IDictionary<string, TProperty>>> propertyExpression, string dictionaryKey, bool syncOnline = true, int priority = 1) + where T: class + { + var expression = Expression.Lambda<Func<T, TProperty>>(Expression.Call(propertyExpression.Body, typeof(IDictionary<string, TProperty>).GetRuntimeMethod("get_Item", new[] { typeof(string) }), Expression.Constant(dictionaryKey)), propertyExpression.Parameters); + db.Set(key, expression, null, syncOnline ? SyncOptions.Put : SyncOptions.None, priority); + } + } +} diff --git a/FireBase/Offline/ISetHandler.cs b/FireBase/Offline/ISetHandler.cs new file mode 100644 index 0000000..477c36b --- /dev/null +++ b/FireBase/Offline/ISetHandler.cs @@ -0,0 +1,11 @@ +namespace Firebase.Database.Offline +{ + using Firebase.Database.Query; + + using System.Threading.Tasks; + + public interface ISetHandler<in T> + { + Task SetAsync(ChildQuery query, string key, OfflineEntry entry); + } +} diff --git a/FireBase/Offline/InitialPullStrategy.cs b/FireBase/Offline/InitialPullStrategy.cs new file mode 100644 index 0000000..70f6b8c --- /dev/null +++ b/FireBase/Offline/InitialPullStrategy.cs @@ -0,0 +1,23 @@ +namespace Firebase.Database.Offline +{ + /// <summary> + /// Specifies the strategy for initial pull of server data. + /// </summary> + public enum InitialPullStrategy + { + /// <summary> + /// Don't pull anything. + /// </summary> + None, + + /// <summary> + /// Pull only what isn't already stored offline. + /// </summary> + MissingOnly, + + /// <summary> + /// Pull everything that exists on the server. + /// </summary> + Everything, + } +} diff --git a/FireBase/Offline/Internals/MemberAccessVisitor.cs b/FireBase/Offline/Internals/MemberAccessVisitor.cs new file mode 100644 index 0000000..1f7cb11 --- /dev/null +++ b/FireBase/Offline/Internals/MemberAccessVisitor.cs @@ -0,0 +1,51 @@ +namespace Firebase.Database.Offline.Internals +{ + using System.Collections.Generic; + using System.Linq.Expressions; + using System.Reflection; + + using Newtonsoft.Json; + + public class MemberAccessVisitor : ExpressionVisitor + { + private readonly IList<string> propertyNames = new List<string>(); + + private bool wasDictionaryAccess; + + public IEnumerable<string> PropertyNames => this.propertyNames; + + public MemberAccessVisitor() + { + } + + public override Expression Visit(Expression expr) + { + if (expr?.NodeType == ExpressionType.MemberAccess) + { + if (this.wasDictionaryAccess) + { + this.wasDictionaryAccess = false; + } + else + { + var memberExpr = (MemberExpression)expr; + var jsonAttr = memberExpr.Member.GetCustomAttribute<JsonPropertyAttribute>(); + + this.propertyNames.Add(jsonAttr?.PropertyName ?? memberExpr.Member.Name); + } + } + else if (expr?.NodeType == ExpressionType.Call) + { + var callExpr = (MethodCallExpression)expr; + if (callExpr.Method.Name == "get_Item" && callExpr.Arguments.Count == 1) + { + var e = Expression.Lambda(callExpr.Arguments[0]).Compile(); + this.propertyNames.Add(e.DynamicInvoke().ToString()); + this.wasDictionaryAccess = callExpr.Arguments[0].NodeType == ExpressionType.MemberAccess; + } + } + + return base.Visit(expr); + } + } +} diff --git a/FireBase/Offline/OfflineCacheAdapter.cs b/FireBase/Offline/OfflineCacheAdapter.cs new file mode 100644 index 0000000..a3761a0 --- /dev/null +++ b/FireBase/Offline/OfflineCacheAdapter.cs @@ -0,0 +1,165 @@ +namespace Firebase.Database.Offline +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Linq; + + internal class OfflineCacheAdapter<TKey, T> : IDictionary<string, T>, IDictionary + { + private readonly IDictionary<string, OfflineEntry> database; + + public OfflineCacheAdapter(IDictionary<string, OfflineEntry> database) + { + this.database = database; + } + + public void CopyTo(Array array, int index) + { + throw new NotImplementedException(); + } + + public int Count => this.database.Count; + + public bool IsSynchronized { get; } + + public object SyncRoot { get; } + + public bool IsReadOnly => this.database.IsReadOnly; + + object IDictionary.this[object key] + { + get + { + return this.database[key.ToString()].Deserialize<T>(); + } + + set + { + var keyString = key.ToString(); + if (this.database.ContainsKey(keyString)) + { + this.database[keyString] = new OfflineEntry(keyString, value, this.database[keyString].Priority, this.database[keyString].SyncOptions); + } + else + { + this.database[keyString] = new OfflineEntry(keyString, value, 1, SyncOptions.None); + } + } + } + + public ICollection<string> Keys => this.database.Keys; + + ICollection IDictionary.Values { get; } + + ICollection IDictionary.Keys { get; } + + public ICollection<T> Values => this.database.Values.Select(o => o.Deserialize<T>()).ToList(); + + public T this[string key] + { + get + { + return this.database[key].Deserialize<T>(); + } + + set + { + if (this.database.ContainsKey(key)) + { + this.database[key] = new OfflineEntry(key, value, this.database[key].Priority, this.database[key].SyncOptions); + } + else + { + this.database[key] = new OfflineEntry(key, value, 1, SyncOptions.None); + } + } + } + + public bool Contains(object key) + { + return this.ContainsKey(key.ToString()); + } + + IDictionaryEnumerator IDictionary.GetEnumerator() + { + throw new NotImplementedException(); + } + + public void Remove(object key) + { + this.Remove(key.ToString()); + } + + public bool IsFixedSize => false; + + public IEnumerator<KeyValuePair<string, T>> GetEnumerator() + { + return this.database.Select(d => new KeyValuePair<string, T>(d.Key, d.Value.Deserialize<T>())).GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return this.GetEnumerator(); + } + + public void Add(KeyValuePair<string, T> item) + { + this.Add(item.Key, item.Value); + } + + public void Add(object key, object value) + { + this.Add(key.ToString(), (T)value); + } + + public void Clear() + { + this.database.Clear(); + } + + public bool Contains(KeyValuePair<string, T> item) + { + return this.ContainsKey(item.Key); + } + + public void CopyTo(KeyValuePair<string, T>[] array, int arrayIndex) + { + throw new NotImplementedException(); + } + + public bool Remove(KeyValuePair<string, T> item) + { + return this.database.Remove(item.Key); + } + + public void Add(string key, T value) + { + this.database.Add(key, new OfflineEntry(key, value, 1, SyncOptions.None)); + } + + public bool ContainsKey(string key) + { + return this.database.ContainsKey(key); + } + + public bool Remove(string key) + { + return this.database.Remove(key); + } + + public bool TryGetValue(string key, out T value) + { + OfflineEntry val; + + if (this.database.TryGetValue(key, out val)) + { + value = val.Deserialize<T>(); + return true; + } + + value = default(T); + return false; + } + } +} diff --git a/FireBase/Offline/OfflineDatabase.cs b/FireBase/Offline/OfflineDatabase.cs new file mode 100644 index 0000000..9cebf9c --- /dev/null +++ b/FireBase/Offline/OfflineDatabase.cs @@ -0,0 +1,201 @@ +namespace Firebase.Database.Offline +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.IO; + using System.Linq; + + using LiteDB; + + /// <summary> + /// The offline database. + /// </summary> + public class OfflineDatabase : IDictionary<string, OfflineEntry> + { + private readonly LiteRepository db; + private readonly IDictionary<string, OfflineEntry> cache; + + /// <summary> + /// Initializes a new instance of the <see cref="OfflineDatabase"/> class. + /// </summary> + /// <param name="itemType"> The item type which is used to determine the database file name. </param> + /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param> + public OfflineDatabase(Type itemType, string filenameModifier) + { + var fullName = this.GetFileName(itemType.ToString()); + if(fullName.Length > 100) + { + fullName = fullName.Substring(0, 100); + } + + BsonMapper mapper = BsonMapper.Global; + mapper.Entity<OfflineEntry>().Id(o => o.Key); + + string root = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); + string filename = fullName + filenameModifier + ".db"; + var path = Path.Combine(root, filename); + this.db = new LiteRepository(new LiteDatabase(path, mapper)); + + this.cache = db.Database.GetCollection<OfflineEntry>().FindAll() + .ToDictionary(o => o.Key, o => o); + } + + /// <summary> + /// Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>. + /// </summary> + /// <returns> The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>. </returns> + public int Count => this.cache.Count; + + /// <summary> + /// Gets a value indicating whether this is a read-only collection. + /// </summary> + public bool IsReadOnly => this.cache.IsReadOnly; + + /// <summary> + /// Gets an <see cref="T:System.Collections.Generic.ICollection`1"/> containing the keys of the <see cref="T:System.Collections.Generic.IDictionary`2"/>. + /// </summary> + /// <returns> An <see cref="T:System.Collections.Generic.ICollection`1"/> containing the keys of the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns> + public ICollection<string> Keys => this.cache.Keys; + + /// <summary> + /// Gets an <see cref="T:System.Collections.Generic.ICollection`1"/> containing the values in the <see cref="T:System.Collections.Generic.IDictionary`2"/>. + /// </summary> + /// <returns> An <see cref="T:System.Collections.Generic.ICollection`1"/> containing the values in the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns> + public ICollection<OfflineEntry> Values => this.cache.Values; + + /// <summary> + /// Gets or sets the element with the specified key. + /// </summary> + /// <param name="key">The key of the element to get or set.</param> + /// <returns> The element with the specified key. </returns> + public OfflineEntry this[string key] + { + get + { + return this.cache[key]; + } + + set + { + this.cache[key] = value; + this.db.Upsert(value); + } + } + + /// <summary> + /// Returns an enumerator that iterates through the collection. + /// </summary> + /// <returns> An enumerator that can be used to iterate through the collection. </returns> + public IEnumerator<KeyValuePair<string, OfflineEntry>> GetEnumerator() + { + return this.cache.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return this.GetEnumerator(); + } + + /// <summary> + /// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"/>. + /// </summary> + /// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param> + public void Add(KeyValuePair<string, OfflineEntry> item) + { + this.Add(item.Key, item.Value); + } + + /// <summary> + /// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>. + /// </summary> + public void Clear() + { + this.cache.Clear(); + this.db.Delete<OfflineEntry>(Query.All()); + } + + /// <summary> + /// Determines whether the <see cref="T:System.Collections.Generic.ICollection`1"/> contains a specific value. + /// </summary> + /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param> + /// <returns> True if <paramref name="item"/> is found in the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. </returns> + public bool Contains(KeyValuePair<string, OfflineEntry> item) + { + return this.ContainsKey(item.Key); + } + + /// <summary> + /// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1"/> to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index. + /// </summary> + /// <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1"/>. The <see cref="T:System.Array"/> must have zero-based indexing.</param> + /// <param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param> + public void CopyTo(KeyValuePair<string, OfflineEntry>[] array, int arrayIndex) + { + this.cache.CopyTo(array, arrayIndex); + } + + /// <summary> + /// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>. + /// </summary> + /// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param> + /// <returns> True if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>. </returns> + public bool Remove(KeyValuePair<string, OfflineEntry> item) + { + return this.Remove(item.Key); + } + + /// <summary> + /// Determines whether the <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key. + /// </summary> + /// <param name="key">The key to locate in the <see cref="T:System.Collections.Generic.IDictionary`2"/>.</param> + /// <returns> True if the <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the key; otherwise, false. </returns> + public bool ContainsKey(string key) + { + return this.cache.ContainsKey(key); + } + + /// <summary> + /// Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2"/>. + /// </summary> + /// <param name="key">The object to use as the key of the element to add.</param> + /// <param name="value">The object to use as the value of the element to add.</param> + public void Add(string key, OfflineEntry value) + { + this.cache.Add(key, value); + this.db.Insert(value); + } + + /// <summary> + /// Removes the element with the specified key from the <see cref="T:System.Collections.Generic.IDictionary`2"/>. + /// </summary> + /// <param name="key">The key of the element to remove.</param> + /// <returns> True if the element is successfully removed; otherwise, false. This method also returns false if <paramref name="key"/> was not found in the original <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns> + public bool Remove(string key) + { + this.cache.Remove(key); + return this.db.Delete<OfflineEntry>(key); + } + + /// <summary> + /// Gets the value associated with the specified key. + /// </summary> + /// <param name="key">The key whose value to get.</param><param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the <paramref name="value"/> parameter. This parameter is passed uninitialized.</param> + /// <returns> True if the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key; otherwise, false. </returns> + public bool TryGetValue(string key, out OfflineEntry value) + { + return this.cache.TryGetValue(key, out value); + } + + private string GetFileName(string fileName) + { + var invalidChars = new[] { '`', '[', ',', '=' }; + foreach(char c in invalidChars.Concat(System.IO.Path.GetInvalidFileNameChars()).Distinct()) + { + fileName = fileName.Replace(c, '_'); + } + + return fileName; + } + } +} diff --git a/FireBase/Offline/OfflineEntry.cs b/FireBase/Offline/OfflineEntry.cs new file mode 100644 index 0000000..3b862cb --- /dev/null +++ b/FireBase/Offline/OfflineEntry.cs @@ -0,0 +1,116 @@ +namespace Firebase.Database.Offline +{ + using System; + + using Newtonsoft.Json; + + /// <summary> + /// Represents an object stored in offline storage. + /// </summary> + public class OfflineEntry + { + private object dataInstance; + + /// <summary> + /// Initializes a new instance of the <see cref="OfflineEntry"/> class with an already serialized object. + /// </summary> + /// <param name="key"> The key. </param> + /// <param name="obj"> The object. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + /// <param name="syncOptions"> The sync options. </param> + public OfflineEntry(string key, object obj, string data, int priority, SyncOptions syncOptions, bool isPartial = false) + { + this.Key = key; + this.Priority = priority; + this.Data = data; + this.Timestamp = DateTime.UtcNow; + this.SyncOptions = syncOptions; + this.IsPartial = isPartial; + + this.dataInstance = obj; + } + + /// <summary> + /// Initializes a new instance of the <see cref="OfflineEntry"/> class. + /// </summary> + /// <param name="key"> The key. </param> + /// <param name="obj"> The object. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + /// <param name="syncOptions"> The sync options. </param> + public OfflineEntry(string key, object obj, int priority, SyncOptions syncOptions, bool isPartial = false) + : this(key, obj, JsonConvert.SerializeObject(obj), priority, syncOptions, isPartial) + { + } + + /// <summary> + /// Initializes a new instance of the <see cref="OfflineEntry"/> class. + /// </summary> + public OfflineEntry() + { + } + + /// <summary> + /// Gets or sets the key of this entry. + /// </summary> + public string Key + { + get; + set; + } + + /// <summary> + /// Gets or sets the priority. Objects with higher priority will be synced first. Higher number indicates higher priority. + /// </summary> + public int Priority + { + get; + set; + } + + /// <summary> + /// Gets or sets the timestamp when this entry was last touched. + /// </summary> + public DateTime Timestamp + { + get; + set; + } + + /// <summary> + /// Gets or sets the <see cref="SyncOptions"/> which define what sync state this entry is in. + /// </summary> + public SyncOptions SyncOptions + { + get; + set; + } + + /// <summary> + /// Gets or sets serialized JSON data. + /// </summary> + public string Data + { + get; + set; + } + + /// <summary> + /// Specifies whether this is only a partial object. + /// </summary> + public bool IsPartial + { + get; + set; + } + + /// <summary> + /// Deserializes <see cref="Data"/> into <typeparamref name="T"/>. The result is cached. + /// </summary> + /// <typeparam name="T"> Type of object to deserialize into. </typeparam> + /// <returns> Instance of <typeparamref name="T"/>. </returns> + public T Deserialize<T>() + { + return (T)(this.dataInstance ?? (this.dataInstance = JsonConvert.DeserializeObject<T>(this.Data))); + } + } +} diff --git a/FireBase/Offline/RealtimeDatabase.cs b/FireBase/Offline/RealtimeDatabase.cs new file mode 100644 index 0000000..61a7010 --- /dev/null +++ b/FireBase/Offline/RealtimeDatabase.cs @@ -0,0 +1,459 @@ +namespace Firebase.Database.Offline +{ + using System; + using System.Collections.Generic; + using System.Linq; + using System.Reactive.Linq; + using System.Reactive.Subjects; + using System.Threading; + using System.Threading.Tasks; + + using Firebase.Database.Extensions; + using Firebase.Database.Query; + using Firebase.Database.Streaming; + using System.Reactive.Threading.Tasks; + using System.Linq.Expressions; + using Internals; + using Newtonsoft.Json; + using System.Reflection; + using System.Reactive.Disposables; + + /// <summary> + /// The real-time Database which synchronizes online and offline data. + /// </summary> + /// <typeparam name="T"> Type of entities. </typeparam> + public partial class RealtimeDatabase<T> : IDisposable where T : class + { + private readonly ChildQuery childQuery; + private readonly string elementRoot; + private readonly StreamingOptions streamingOptions; + private readonly Subject<FirebaseEvent<T>> subject; + private readonly InitialPullStrategy initialPullStrategy; + private readonly bool pushChanges; + private readonly FirebaseCache<T> firebaseCache; + + private bool isSyncRunning; + private IObservable<FirebaseEvent<T>> observable; + private FirebaseSubscription<T> firebaseSubscription; + + /// <summary> + /// Initializes a new instance of the <see cref="RealtimeDatabase{T}"/> class. + /// </summary> + /// <param name="childQuery"> The child query. </param> + /// <param name="elementRoot"> The element Root. </param> + /// <param name="offlineDatabaseFactory"> The offline database factory. </param> + /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param> + /// <param name="streamChanges"> Specifies whether changes should be streamed from the server. </param> + /// <param name="pullEverythingOnStart"> Specifies if everything should be pull from the online storage on start. It only makes sense when <see cref="streamChanges"/> is set to true. </param> + /// <param name="pushChanges"> Specifies whether changed items should actually be pushed to the server. If this is false, then Put / Post / Delete will not affect server data. </param> + public RealtimeDatabase(ChildQuery childQuery, string elementRoot, Func<Type, string, IDictionary<string, OfflineEntry>> offlineDatabaseFactory, string filenameModifier, StreamingOptions streamingOptions, InitialPullStrategy initialPullStrategy, bool pushChanges, ISetHandler<T> setHandler = null) + { + this.childQuery = childQuery; + this.elementRoot = elementRoot; + this.streamingOptions = streamingOptions; + this.initialPullStrategy = initialPullStrategy; + this.pushChanges = pushChanges; + this.Database = offlineDatabaseFactory(typeof(T), filenameModifier); + this.firebaseCache = new FirebaseCache<T>(new OfflineCacheAdapter<string, T>(this.Database)); + this.subject = new Subject<FirebaseEvent<T>>(); + + this.PutHandler = setHandler ?? new SetHandler<T>(); + + this.isSyncRunning = true; + Task.Factory.StartNew(this.SynchronizeThread, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); + } + + /// <summary> + /// Event raised whenever an exception is thrown in the synchronization thread. Exception thrown in there are swallowed, so this event is the only way to get to them. + /// </summary> + public event EventHandler<ExceptionEventArgs> SyncExceptionThrown; + + /// <summary> + /// Gets the backing Database. + /// </summary> + public IDictionary<string, OfflineEntry> Database + { + get; + private set; + } + + public ISetHandler<T> PutHandler + { + private get; + set; + } + + /// <summary> + /// Overwrites existing object with given key. + /// </summary> + /// <param name="key"> The key. </param> + /// <param name="obj"> The object to set. </param> + /// <param name="syncOnline"> Indicates whether the item should be synced online. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public void Set(string key, T obj, SyncOptions syncOptions, int priority = 1) + { + this.SetAndRaise(key, new OfflineEntry(key, obj, priority, syncOptions)); + } + + public void Set<TProperty>(string key, Expression<Func<T, TProperty>> propertyExpression, object value, SyncOptions syncOptions, int priority = 1) + { + var fullKey = this.GenerateFullKey(key, propertyExpression, syncOptions); + var serializedObject = JsonConvert.SerializeObject(value).Trim('"', '\\'); + + if (fullKey.Item3) + { + if (typeof(TProperty) != typeof(string) || value == null) + { + // don't escape non-string primitives and null; + serializedObject = $"{{ \"{fullKey.Item2}\" : {serializedObject} }}"; + } + else + { + serializedObject = $"{{ \"{fullKey.Item2}\" : \"{serializedObject}\" }}"; + } + } + + var setObject = this.firebaseCache.PushData("/" + fullKey.Item1, serializedObject).First(); + + if (!this.Database.ContainsKey(key) || this.Database[key].SyncOptions != SyncOptions.Patch && this.Database[key].SyncOptions != SyncOptions.Put) + { + this.Database[fullKey.Item1] = new OfflineEntry(fullKey.Item1, value, serializedObject, priority, syncOptions, true); + } + + this.subject.OnNext(new FirebaseEvent<T>(key, setObject.Object, setObject == null ? FirebaseEventType.Delete : FirebaseEventType.InsertOrUpdate, FirebaseEventSource.Offline)); + } + + /// <summary> + /// Fetches an object with the given key and adds it to the Database. + /// </summary> + /// <param name="key"> The key. </param> + /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> + public void Pull(string key, int priority = 1) + { + if (!this.Database.ContainsKey(key)) + { + this.Database[key] = new OfflineEntry(key, null, priority, SyncOptions.Pull); + } + else if (this.Database[key].SyncOptions == SyncOptions.None) + { + // pull only if push isn't pending + this.Database[key].SyncOptions = SyncOptions.Pull; + } + } + + /// <summary> + /// Fetches everything from the remote database. + /// </summary> + public async Task PullAsync() + { + var existingEntries = await this.childQuery + .OnceAsync<T>() + .ToObservable() + .RetryAfterDelay<IReadOnlyCollection<FirebaseObject<T>>, FirebaseException>( + this.childQuery.Client.Options.SyncPeriod, + ex => ex.StatusCode == System.Net.HttpStatusCode.OK) // OK implies the request couldn't complete due to network error. + .Select(e => this.ResetDatabaseFromInitial(e, false)) + .SelectMany(e => e) + .Do(e => + { + this.Database[e.Key] = new OfflineEntry(e.Key, e.Object, 1, SyncOptions.None); + this.subject.OnNext(new FirebaseEvent<T>(e.Key, e.Object, FirebaseEventType.InsertOrUpdate, FirebaseEventSource.OnlinePull)); + }) + .ToList(); + + // Remove items not stored online + foreach (var item in this.Database.Keys.Except(existingEntries.Select(f => f.Key)).ToList()) + { + this.Database.Remove(item); + this.subject.OnNext(new FirebaseEvent<T>(item, null, FirebaseEventType.Delete, FirebaseEventSource.OnlinePull)); + } + } + + /// <summary> + /// Retrieves all offline items currently stored in local database. + /// </summary> + public IEnumerable<FirebaseObject<T>> Once() + { + return this.Database + .Where(kvp => !string.IsNullOrEmpty(kvp.Value.Data) && kvp.Value.Data != "null" && !kvp.Value.IsPartial) + .Select(kvp => new FirebaseObject<T>(kvp.Key, kvp.Value.Deserialize<T>())) + .ToList(); + } + + /// <summary> + /// Starts observing the real-time Database. Events will be fired both when change is done locally and remotely. + /// </summary> + /// <returns> Stream of <see cref="FirebaseEvent{T}"/>. </returns> + public IObservable<FirebaseEvent<T>> AsObservable() + { + if (!this.isSyncRunning) + { + this.isSyncRunning = true; + Task.Factory.StartNew(this.SynchronizeThread, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); + } + + if (this.observable == null) + { + var initialData = Observable.Return(FirebaseEvent<T>.Empty(FirebaseEventSource.Offline)); + if(this.Database.TryGetValue(this.elementRoot, out OfflineEntry oe)) + { + initialData = Observable.Return(oe) + .Where(offlineEntry => !string.IsNullOrEmpty(offlineEntry.Data) && offlineEntry.Data != "null" && !offlineEntry.IsPartial) + .Select(offlineEntry => new FirebaseEvent<T>(offlineEntry.Key, offlineEntry.Deserialize<T>(), FirebaseEventType.InsertOrUpdate, FirebaseEventSource.Offline)); + } + else if(this.Database.Count > 0) + { + initialData = this.Database + .Where(kvp => !string.IsNullOrEmpty(kvp.Value.Data) && kvp.Value.Data != "null" && !kvp.Value.IsPartial) + .Select(kvp => new FirebaseEvent<T>(kvp.Key, kvp.Value.Deserialize<T>(), FirebaseEventType.InsertOrUpdate, FirebaseEventSource.Offline)) + .ToList() + .ToObservable(); + } + + this.observable = initialData + .Merge(this.subject) + .Merge(this.GetInitialPullObservable() + .RetryAfterDelay<IReadOnlyCollection<FirebaseObject<T>>, FirebaseException>( + this.childQuery.Client.Options.SyncPeriod, + ex => ex.StatusCode == System.Net.HttpStatusCode.OK) // OK implies the request couldn't complete due to network error. + .Select(e => this.ResetDatabaseFromInitial(e)) + .SelectMany(e => e) + .Do(this.SetObjectFromInitialPull) + .Select(e => new FirebaseEvent<T>(e.Key, e.Object, e.Object == null ? FirebaseEventType.Delete : FirebaseEventType.InsertOrUpdate, FirebaseEventSource.OnlineInitial)) + .Concat(Observable.Create<FirebaseEvent<T>>(observer => this.InitializeStreamingSubscription(observer)))) + .Do(next => { }, e => this.observable = null, () => this.observable = null) + .Replay() + .RefCount(); + } + + return this.observable; + } + + public void Dispose() + { + this.subject.OnCompleted(); + this.firebaseSubscription?.Dispose(); + } + + private IReadOnlyCollection<FirebaseObject<T>> ResetDatabaseFromInitial(IReadOnlyCollection<FirebaseObject<T>> collection, bool onlyWhenInitialEverything = true) + { + if (onlyWhenInitialEverything && this.initialPullStrategy != InitialPullStrategy.Everything) + { + return collection; + } + + // items which are in local db, but not in the online collection + var extra = this.Once() + .Select(f => f.Key) + .Except(collection.Select(c => c.Key)) + .Select(k => new FirebaseObject<T>(k, null)); + + return collection.Concat(extra).ToList(); + } + + private void SetObjectFromInitialPull(FirebaseObject<T> e) + { + // set object with no sync only if it doesn't exist yet + // and the InitialPullStrategy != Everything + // this attempts to deal with scenario when you are offline, have local changes and go online + // in this case having the InitialPullStrategy set to everything would basically purge all local changes + if (!this.Database.ContainsKey(e.Key) || this.Database[e.Key].SyncOptions == SyncOptions.None || this.Database[e.Key].SyncOptions == SyncOptions.Pull || this.initialPullStrategy != InitialPullStrategy.Everything) + { + this.Database[e.Key] = new OfflineEntry(e.Key, e.Object, 1, SyncOptions.None); + } + } + + private IObservable<IReadOnlyCollection<FirebaseObject<T>>> GetInitialPullObservable() + { + FirebaseQuery query; + switch (this.initialPullStrategy) + { + case InitialPullStrategy.MissingOnly: + query = this.childQuery.OrderByKey().StartAt(() => this.GetLatestKey()); + break; + case InitialPullStrategy.Everything: + query = this.childQuery; + break; + case InitialPullStrategy.None: + default: + return Observable.Empty<IReadOnlyCollection<FirebaseEvent<T>>>(); + } + + if (string.IsNullOrWhiteSpace(this.elementRoot)) + { + return Observable.Defer(() => query.OnceAsync<T>().ToObservable()); + } + + // there is an element root, which indicates the target location is not a collection but a single element + return Observable.Defer(async () => Observable.Return(await query.OnceSingleAsync<T>()).Select(e => new[] { new FirebaseObject<T>(this.elementRoot, e) })); + } + + private IDisposable InitializeStreamingSubscription(IObserver<FirebaseEvent<T>> observer) + { + var completeDisposable = Disposable.Create(() => this.isSyncRunning = false); + + switch (this.streamingOptions) + { + case StreamingOptions.LatestOnly: + // stream since the latest key + var queryLatest = this.childQuery.OrderByKey().StartAt(() => this.GetLatestKey()); + this.firebaseSubscription = new FirebaseSubscription<T>(observer, queryLatest, this.elementRoot, this.firebaseCache); + this.firebaseSubscription.ExceptionThrown += this.StreamingExceptionThrown; + + return new CompositeDisposable(this.firebaseSubscription.Run(), completeDisposable); + case StreamingOptions.Everything: + // stream everything + var queryAll = this.childQuery; + this.firebaseSubscription = new FirebaseSubscription<T>(observer, queryAll, this.elementRoot, this.firebaseCache); + this.firebaseSubscription.ExceptionThrown += this.StreamingExceptionThrown; + + return new CompositeDisposable(this.firebaseSubscription.Run(), completeDisposable); + default: + break; + } + + return completeDisposable; + } + + private void SetAndRaise(string key, OfflineEntry obj, FirebaseEventSource eventSource = FirebaseEventSource.Offline) + { + this.Database[key] = obj; + this.subject.OnNext(new FirebaseEvent<T>(key, obj?.Deserialize<T>(), string.IsNullOrEmpty(obj?.Data) || obj?.Data == "null" ? FirebaseEventType.Delete : FirebaseEventType.InsertOrUpdate, eventSource)); + } + + private async void SynchronizeThread() + { + while (this.isSyncRunning) + { + try + { + var validEntries = this.Database.Where(e => e.Value != null); + await this.PullEntriesAsync(validEntries.Where(kvp => kvp.Value.SyncOptions == SyncOptions.Pull)); + + if (this.pushChanges) + { + await this.PushEntriesAsync(validEntries.Where(kvp => kvp.Value.SyncOptions == SyncOptions.Put || kvp.Value.SyncOptions == SyncOptions.Patch)); + } + } + catch (Exception ex) + { + this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex)); + } + + await Task.Delay(this.childQuery.Client.Options.SyncPeriod); + } + } + + private string GetLatestKey() + { + var key = this.Database.OrderBy(o => o.Key, StringComparer.Ordinal).LastOrDefault().Key ?? string.Empty; + + if (!string.IsNullOrWhiteSpace(key)) + { + key = key.Substring(0, key.Length - 1) + (char)(key[key.Length - 1] + 1); + } + + return key; + } + + private async Task PushEntriesAsync(IEnumerable<KeyValuePair<string, OfflineEntry>> pushEntries) + { + var groups = pushEntries.GroupBy(pair => pair.Value.Priority).OrderByDescending(kvp => kvp.Key).ToList(); + + foreach (var group in groups) + { + var tasks = group.OrderBy(kvp => kvp.Value.IsPartial).Select(kvp => + kvp.Value.IsPartial ? + this.ResetSyncAfterPush(this.PutHandler.SetAsync(this.childQuery, kvp.Key, kvp.Value), kvp.Key) : + this.ResetSyncAfterPush(this.PutHandler.SetAsync(this.childQuery, kvp.Key, kvp.Value), kvp.Key, kvp.Value.Deserialize<T>())); + + try + { + await Task.WhenAll(tasks).WithAggregateException(); + } + catch (Exception ex) + { + this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex)); + } + } + } + + private async Task PullEntriesAsync(IEnumerable<KeyValuePair<string, OfflineEntry>> pullEntries) + { + var taskGroups = pullEntries.GroupBy(pair => pair.Value.Priority).OrderByDescending(kvp => kvp.Key); + + foreach (var group in taskGroups) + { + var tasks = group.Select(pair => this.ResetAfterPull(this.childQuery.Child(pair.Key == this.elementRoot ? string.Empty : pair.Key).OnceSingleAsync<T>(), pair.Key, pair.Value)); + + try + { + await Task.WhenAll(tasks).WithAggregateException(); + } + catch (Exception ex) + { + this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex)); + } + } + } + + private async Task ResetAfterPull(Task<T> task, string key, OfflineEntry entry) + { + await task; + this.SetAndRaise(key, new OfflineEntry(key, task.Result, entry.Priority, SyncOptions.None), FirebaseEventSource.OnlinePull); + } + + private async Task ResetSyncAfterPush(Task task, string key, T obj) + { + await this.ResetSyncAfterPush(task, key); + + if (this.streamingOptions == StreamingOptions.None) + { + this.subject.OnNext(new FirebaseEvent<T>(key, obj, obj == null ? FirebaseEventType.Delete : FirebaseEventType.InsertOrUpdate, FirebaseEventSource.OnlinePush)); + } + } + + private async Task ResetSyncAfterPush(Task task, string key) + { + await task; + this.ResetSyncOptions(key); + } + + private void ResetSyncOptions(string key) + { + var item = this.Database[key]; + + if (item.IsPartial) + { + this.Database.Remove(key); + } + else + { + item.SyncOptions = SyncOptions.None; + this.Database[key] = item; + } + } + + private void StreamingExceptionThrown(object sender, ExceptionEventArgs<FirebaseException> e) + { + this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(e.Exception)); + } + + private Tuple<string, string, bool> GenerateFullKey<TProperty>(string key, Expression<Func<T, TProperty>> propertyGetter, SyncOptions syncOptions) + { + var visitor = new MemberAccessVisitor(); + visitor.Visit(propertyGetter); + var propertyType = typeof(TProperty).GetTypeInfo(); + var prefix = key == string.Empty ? string.Empty : key + "/"; + + // primitive types + if (syncOptions == SyncOptions.Patch && (propertyType.IsPrimitive || Nullable.GetUnderlyingType(typeof(TProperty)) != null || typeof(TProperty) == typeof(string))) + { + return Tuple.Create(prefix + string.Join("/", visitor.PropertyNames.Skip(1).Reverse()), visitor.PropertyNames.First(), true); + } + + return Tuple.Create(prefix + string.Join("/", visitor.PropertyNames.Reverse()), visitor.PropertyNames.First(), false); + } + + } +} diff --git a/FireBase/Offline/SetHandler.cs b/FireBase/Offline/SetHandler.cs new file mode 100644 index 0000000..1efa7b6 --- /dev/null +++ b/FireBase/Offline/SetHandler.cs @@ -0,0 +1,24 @@ +namespace Firebase.Database.Offline +{ + using Firebase.Database.Query; + + using System.Threading.Tasks; + + public class SetHandler<T> : ISetHandler<T> + { + public virtual async Task SetAsync(ChildQuery query, string key, OfflineEntry entry) + { + using (var child = query.Child(key)) + { + if (entry.SyncOptions == SyncOptions.Put) + { + await child.PutAsync(entry.Data); + } + else + { + await child.PatchAsync(entry.Data); + } + } + } + } +} diff --git a/FireBase/Offline/StreamingOptions.cs b/FireBase/Offline/StreamingOptions.cs new file mode 100644 index 0000000..9ed4e54 --- /dev/null +++ b/FireBase/Offline/StreamingOptions.cs @@ -0,0 +1,21 @@ +namespace Firebase.Database.Offline +{ + public enum StreamingOptions + { + /// <summary> + /// No realtime streaming. + /// </summary> + None, + + /// <summary> + /// Streaming of only new items - not the existing ones. + /// </summary> + LatestOnly, + + /// <summary> + /// Streaming of all items. This will also pull all existing items on start, so be mindful about the number of items in your DB. + /// When used, consider not setting the <see cref="InitialPullStrategy"/> to <see cref="InitialPullStrategy.Everything"/> because you would pointlessly pull everything twice. + /// </summary> + Everything + } +} diff --git a/FireBase/Offline/SyncOptions.cs b/FireBase/Offline/SyncOptions.cs new file mode 100644 index 0000000..b2f382a --- /dev/null +++ b/FireBase/Offline/SyncOptions.cs @@ -0,0 +1,28 @@ +namespace Firebase.Database.Offline +{ + /// <summary> + /// Specifies type of sync requested for given data. + /// </summary> + public enum SyncOptions + { + /// <summary> + /// No sync needed for given data. + /// </summary> + None, + + /// <summary> + /// Data should be pulled from firebase. + /// </summary> + Pull, + + /// <summary> + /// Data should be put to firebase. + /// </summary> + Put, + + /// <summary> + /// Data should be patched in firebase. + /// </summary> + Patch + } +} |