/// <summary> /// Updates or inserts a stream in the local cache. /// </summary> /// <param name="stream"></param> /// <param name="restApi"></param> public static void AddOrUpdateStream(SpeckleStream stream, string restApi) { LocalContext.Init(); var bytes = SpeckleCore.Converter.getBytes(stream.ToJson()); var combinedHash = Converter.getMd5Hash(stream._id + restApi); var cacheRes = Database.Table <CachedStream>().Where(existing => existing.CombinedHash == combinedHash).ToList(); if (cacheRes.Count >= 1) { var toUpdate = cacheRes[0]; toUpdate.Bytes = bytes; toUpdate.UpdatedOn = DateTime.Now; Database.Update(toUpdate); } else { var toCache = new CachedStream() { CombinedHash = combinedHash, Bytes = bytes, RestApi = restApi, StreamId = stream.StreamId, AddedOn = DateTime.Now, UpdatedOn = DateTime.Now }; Database.Insert(toCache); } //throw new NotImplementedException(); }
/// <summary> /// Does a cache check on a list of speckle object placeholders. It will populate the original list with any objects it can find in the cache. If none are found, the list is returned unmodified. /// </summary> /// <param name="objs">Speckle object placeholders to check against the cache.</param> /// <param name="restApi">The rest api these objects are expected to come from.</param> /// <returns></returns> public static List <SpeckleObject> GetCachedObjects(List <SpeckleObject> objs, string restApi) { LocalContext.Init(); var MaxSqlVars = 900; var combinedHashes = objs.Select(obj => Converter.getMd5Hash(obj._id + restApi)).ToList(); var partitionedList = new List <List <string> >(); for (int i = 0; i < combinedHashes.Count; i += MaxSqlVars) { partitionedList.Add(combinedHashes.GetRange(i, Math.Min(MaxSqlVars, combinedHashes.Count - i))); } var fullRes = new List <SpeckleObject>(); foreach (var subList in partitionedList) { var res = Database.Table <CachedObject>().Where(obj => subList.Contains(obj.CombinedHash)).Select(o => o.ToSpeckle()).ToList(); fullRes.AddRange(res); } // populate the original list with whatever objects we found in the database. for (int i = 0; i < objs.Count; i++) { var placeholder = objs[i]; var myObject = fullRes.Find(o => o._id == placeholder._id); if (myObject != null) { objs[i] = myObject; } } return(objs); }
/// <summary> /// Sets an account as being the default one, and de-sets defaultness on all others. /// </summary> /// <param name="account"></param> public static void SetDefaultAccount(Account account) { LocalContext.Init(); Database.Execute("UPDATE Account SET IsDefault=0"); account.IsDefault = true; Database.Update(account); }
/// <summary> /// Sets an account as being the default one, and de-sets defaultness on all others. /// </summary> /// <param name="account"></param> public static void SetDefaultAccount(Account account) { LocalContext.Init(); ClearDefaultAccount(); account.IsDefault = true; Database.Update(account); }
/// <summary> /// Gets a stream from the local cache. /// </summary> /// <param name="streamId"></param> /// <param name="restApi"></param> /// <returns>Null, if nothing found, or the speckle stream.</returns> public static SpeckleStream GetStream(string streamId, string restApi) { LocalContext.Init(); var combinedHash = Converter.getMd5Hash(streamId + restApi); var res = Database.Table <CachedStream>().Where(str => str.CombinedHash == combinedHash).ToArray(); if (res.Length > 0) { return(res[0].ToSpeckle()); } return(null); }
/// <summary> /// Returns the default account, if any. Otherwise throws an error. /// </summary> /// <returns></returns> public static Account GetDefaultAccount( ) { LocalContext.Init(); var res = Database.Query <Account>("SELECT * FROM Account WHERE IsDefault='true' LIMIT 1"); if (res.Count == 1) { return(res[0]); } else { throw new Exception("No default account set."); } }
/// <summary> /// If more accounts present, will return the first one only. /// </summary> /// <param name="email"></param> /// <param name="restApi"></param> /// <returns>null if no account is found.</returns> public static Account GetAccountByEmailAndRestApi(string email, string restApi) { LocalContext.Init(); var res = Database.Query <Account>(String.Format("SELECT * from Account WHERE RestApi = '{0}' AND Email='{1}'", restApi, email)); if (res.Count >= 1) { return(res[0]); } else { return(null); //throw new Exception("Could not find account."); } }
/// <summary> /// Returns true/false depending on wether the user has enabled telemetry. /// </summary> /// <returns></returns> public static bool GetTelemetrySettings( ) { LocalContext.Init(); var settings = Database.Query <TelemetrySettings>("SELECT * FROM TelemetrySettings").FirstOrDefault(); if (settings != null) { return(settings.Enabled); } else { var ts = new TelemetrySettings(); Database.Insert(ts); return(true); // defaults to true } }
/// <summary> /// Enables or disables telemetry. /// </summary> /// <param name="status"></param> public static void SetTelemetrySettings(bool status) { LocalContext.Init(); var settings = Database.Query <TelemetrySettings>("SELECT * FROM TelemetrySettings").FirstOrDefault(); if (settings != null) { settings.Enabled = status; Database.Update(settings); } else { var ts = new TelemetrySettings(); ts.Enabled = status; Database.Insert(ts); } }
/// <summary> /// Adds an object that has been sent by a sender in the local cache. /// This does not store the full object, it's just a log that it has been sent /// to a server so it does not get sent again. /// </summary> /// <param name="obj">Object to store as sent ref in the local database.</param> /// <param name="restApi">The server's url.</param> public static void AddSentObject(SpeckleObject obj, string restApi) { LocalContext.Init(); var sentObj = new SentObject() { RestApi = restApi, DatabaseId = obj._id, Hash = obj.Hash }; try { Database.Insert(sentObj); } catch (Exception e) { var dick = e; // object was already there, no panic! } }
public static void Initialize( ) { if (IsInit) { return; } IsInit = true; LocalContext.Init(); Assembiles = new SpeckleKitLoader().GetAssemblies(); var types = new List <Type>(); foreach (var assembly in Assembiles) { types.AddRange(FindDerivedTypes(assembly, typeof(SpeckleObject)).ToList()); } types.Add(typeof(SpeckleObject)); Types = types; }
public static void Initialize(string pathToKits = null) { if (IsInit) { return; } IsInit = true; LocalContext.Init(); Assembiles = new SpeckleKitLoader(pathToKits).GetAssemblies(); var types = new List <Type>(); foreach (var assembly in Assembiles) { types.AddRange(FindDerivedTypes(assembly, typeof(SpeckleObject)).ToList()); } types.Add(typeof(SpeckleObject)); Types = types; //////////////////////////////////////////////////////////////////////////////////////////////////// /// /// /// /// /// Hello devs! Uncomment the line below to disable telemetry. /// /// This will make speckle sad, but it's your call. /// /// See community discussions here: /// /// https://speckle-works.slack.com/archives/C4TE17LGH/p1567520201017900 /// /// https://discourse.speckle.works/t/community-consultation-time-telemetry/410 /// /// /// /// /// //////////////////////////////////////////////////////////////////////////////////////////////////// // LocalContext.SetTelemetrySettings( false ); // Note: if telemetry settings is set to false, then this will do nothing. SpeckleTelemetry.Initialize(); }
/// <summary> /// Replaces any objects in the given list with placeholders if they're found in the local cache, as this means they were sent before and most probably exist on the server. /// </summary> /// <param name="objs"></param> /// <param name="restApi"></param> /// <returns>(Optinoal) The modified list.</returns> public static List <SpeckleObject> PruneExistingObjects(List <SpeckleObject> objs, string restApi) { LocalContext.Init(); // MAX SQL Vars is 900 var MaxSqlVars = 900; var objHashes = objs.Select(obj => true ? obj.Hash : restApi).ToList(); var partitionedList = new List <List <string> >(); for (int i = 0; i < objHashes.Count; i += MaxSqlVars) { partitionedList.Add(objHashes.GetRange(i, Math.Min(MaxSqlVars, objHashes.Count - i))); } var fullRes = new List <SentObject>(); foreach (var subList in partitionedList) { var res = Database.Table <SentObject>().Where(obj => subList.Contains(obj.Hash) && obj.RestApi == restApi).ToList(); fullRes.AddRange(res); } for (int i = 0; i < objs.Count; i++) { var placeholder = objs[i]; var myObject = fullRes.Find(o => o.Hash == objs[i].Hash); if (myObject != null) { objs[i] = new SpecklePlaceholder() { _id = myObject.DatabaseId }; } } return(objs); }
/// <summary> /// Adds a speckle object to the local cache. /// </summary> /// <param name="obj">The object to add.</param> /// <param name="restApi">The server url of where it has been persisted.</param> public static void AddCachedObject(SpeckleObject obj, string restApi) { LocalContext.Init(); var bytes = SpeckleCore.Converter.getBytes(obj); var combinedHash = Converter.getMd5Hash(obj._id + restApi); var cached = new CachedObject() { RestApi = restApi, Bytes = bytes, DatabaseId = obj._id, CombinedHash = combinedHash, Hash = obj.Hash, AddedOn = DateTime.Now }; try { Database.Insert(cached); } catch { // object was already there } }
/// <summary> /// Purges the streams table. WARNING: Don't do this unless you know what you're doing. /// </summary> public static void PurgeCachedStreams( ) { LocalContext.Init(); Database?.Execute("DELETE FROM CachedStream"); }
/// <summary> /// Purges the accounts. WARNING: Don't do this unless you know what you're doing. /// </summary> public static void PurgeAccounts( ) { LocalContext.Init(); Database?.Execute("DELETE FROM Account"); }
/// <summary> /// Purges the sent objects table. WARNING: Don't do this unless you know what you're doing. /// </summary> public static void PurgeSentObjects( ) { LocalContext.Init(); Database?.Execute("DELETE FROM SentObject"); }
/// <summary> /// Clears any default account. (You will no longer have a default account) /// </summary> /// <param name="account"></param> public static void ClearDefaultAccount() { LocalContext.Init(); Database.Execute("UPDATE Account SET IsDefault=0"); }
/// <summary> /// Udates an account by its primary key. /// </summary> /// <param name="account"></param> public static void UpdateAccount(Account account) { LocalContext.Init(); Database.Update(account); }
/// <summary> /// Adds a new account. /// </summary> /// <param name="account"></param> public static void AddAccount(Account account) { LocalContext.Init(); var res = Database.Insert(account); }
public static void RemoveAccount(Account ac) { LocalContext.Init(); Database.Delete <Account>(ac.AccountId); }
/// <summary> /// Gets all accounts present. /// </summary> /// <returns></returns> public static List <Account> GetAllAccounts( ) { LocalContext.Init(); return(Database.Query <Account>("SELECT * FROM Account")); }
/// <summary> /// Gets all the accounts associated with the provided rest api. /// </summary> /// <param name="RestApi"></param> /// <returns></returns> public static List <Account> GetAccountsByRestApi(string RestApi) { LocalContext.Init(); return(Database.Query <Account>("SELECT * from Account WHERE RestApi = ?", RestApi)); }
/// <summary> /// Gets all the accounts associated with the provided email. /// </summary> /// <param name="email"></param> /// <returns></returns> public static List <Account> GetAccountsByEmail(string email) { LocalContext.Init(); return(Database.Query <Account>("SELECT * from Account WHERE Email = ?", email)); }