/// <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));
}
