public Tuple <bool, IReadOnlyList <AtemDevice> > AddDevice(string address, int port)
{
var id = AtemDeviceExt.Id(address, port);
lock (_devices)
{
if (_devices.TryGetValue(id, out AtemDevice device))
{
device.Remember = true;
device.Enabled = true;
_dbDevices.Upsert(id, device);
// startup connection
SetupConnection(device);
}
else
{
var doc = _devices[id] = new AtemDevice(new AtemDeviceInfo(id, "", DateTime.MinValue, address, port, new List <string>()))
{
Remember = true, // Remember anything created manually
Enabled = true, // Enable for connections
};
_dbDevices.Upsert(id, doc);
// startup connection
SetupConnection(doc);
}
return(Tuple.Create(true, ListDevices()));
}
}
protected override void ProcessRecord()
{
if (!Connection.CollectionExists(Collection))
{
WriteWarning($"Collection\t['{Collection}'] does not exist");
}
else
{
Table = Connection.GetCollection(Collection);
try
{
if (ParameterSetName == "ID")
{
Table.Upsert(ID, Document);
}
else if (ParameterSetName == "Array")
{
Table.Upsert(BsonDocumentArray);
}
else
{
Table.Upsert(Document);
}
}
catch (Exception)
{
throw;
}
}
}
public int Upsertion()
{
var count = _fileMetaCollection.Upsert(_data);
DatabaseInstance.Checkpoint();
return(count);
}
public async ValueTask PreLoad()
{
foreach (var layer in layers.Values)
{
var entries = EntryDataDto.Convert(layer.GetPreloadEntries());
collection.Upsert(entries);
}
}
public bool Save(BusinessCard model, bool references = true)
{
var upserted = false;
using (var scope = TransactionScopeOption.Required.CreateTransactionScope())
{
upserted = cards.Upsert(model);
scope.Complete();
}
return(upserted);
}
private void UpdateData(ILiteCollection <Album> collection)
{
logger.LogInformation("Updating the data ...");
var updatedAlbum = collection
.Include(x => x.Songs)
.FindOne(x => x.Title == "Issues");
updatedAlbum.Year = 2021;
updatedAlbum.Songs.Add(new Song
{
TrackNumber = 3,
Title = "Trash",
Length = new TimeSpan(0, 3, 27),
});
collection.Update(updatedAlbum);
// Partial update of multiple documents.
collection.UpdateMany(album => new Album {
Title = "Updated: " + album.Title
}, album => album.Year >= 2020);
// Upsert
var docForUpsert = new Album
{
Year = 1999,
Title = "Wishmaster",
Artist = "Nightwish",
Songs = new List <Song>
{
new()
{
TrackNumber = 1,
Title = "She Is My Sin",
Length = new TimeSpan(0, 4, 46),
},
},
};
collection.Upsert(docForUpsert);
docForUpsert.Year = 2000;
docForUpsert.Songs.Add(new()
{
TrackNumber = 2,
Title = "02 - The Kinslayer",
Length = new TimeSpan(0, 3, 58),
});
// This works, because first upsert has filled Id property in the document.
collection.Upsert(docForUpsert);
}
public void Set(ProviderSettingsType type, bool value)
{
var doc = new BsonDocument {
["_id"] = (int)type,
["value"] = value
};
_collection.Upsert(doc);
}
public Task <bool> SetAdminInfo(Login loginInfo)
{
var tempLogin = _loginCollection.FindAll().FirstOrDefault();
if (tempLogin != null)
{
tempLogin.UserName = loginInfo.UserName;
tempLogin.Password = KiwiCryptography.HashPassword(loginInfo.Password);
return(Task.FromResult(_loginCollection.Upsert(tempLogin)));
}
return(Task.FromResult(_loginCollection.Upsert(loginInfo)));
}
public virtual void Update(T entity)
{
entity.CreatedDate = DateTime.Now;
entity.UpdatedDate = DateTime.Now;
Collection.Upsert(entity);
}
public void AddFavorite(string objectId, string category)
{
myStoredFavorites.Upsert(new StoredFavorite {
AddedOn = DateTime.UtcNow, Category = category, ObjectId = objectId
});
OnCategoryContentsChanged?.Invoke(category);
}
public async Task <Manifest> GetManifest()
{
Manifest latest = _manifest.Find(r => true).OrderByDescending(r => r.DateTime).FirstOrDefault();
if (latest != null && !(DateTime.Now - latest.DateTime >= TimeSpan.FromMinutes(15)))
{
return(latest);
}
try
{
if (latest != null && GetCommitHash() == await GetGithubHash())
{
return(latest);
}
}
catch (RateLimitExceededException)
{
// Github throttle error
}
latest = await FetchManifest();
_manifest.Upsert(latest);
return(latest);
}
/// <summary>
/// Upserts a record into the local db collection
/// </summary>
/// <param name="runId"></param>
/// <param name="schemaKeys"></param>
/// <param name="recordMap"></param>
/// <param name="recordKeysMap"></param>
/// <param name="realtimeRecordsCollection"></param>
/// <returns>boolean indicating if record changed</returns>
private static bool UpsertRealTimeRecord(string runId, List <string> schemaKeys,
Dictionary <string, object> recordMap,
Dictionary <string, object> recordKeysMap, ILiteCollection <RealTimeRecord> realtimeRecordsCollection)
{
// build local db entry
var recordId = GetRecordKeyEntry(schemaKeys, recordMap);
var recordHash = GetRecordHash(recordMap);
// Create new real time record
var realTimeRecord = new RealTimeRecord
{
Id = recordId,
RunId = runId,
RecordKeysMap = recordKeysMap,
RecordDataHash = recordHash
};
// get previous real time record
var previousRealTimeRecord =
realtimeRecordsCollection.FindById(GetRecordKeyEntry(schemaKeys, recordMap));
// upsert new record into db
realtimeRecordsCollection.Upsert(realTimeRecord);
return(previousRealTimeRecord == null ||
previousRealTimeRecord.RecordDataHash != realTimeRecord.RecordDataHash);
}
public void SaveAccountMappings(IEnumerable <AccountMapping> accounts)
{
foreach (var accountMapping in accounts)
{
_accountMappings.Upsert(accountMapping);
}
}
/// <summary>
/// Save Vn Characters to db
/// </summary>
/// <param name="characters"></param>
/// <param name="vnid"></param>
public static void SaveVnCharacters(ICollection <Character> characters, uint vnid)
{
try
{
if (characters == null || characters.Count < 1)
{
return;
}
var cred = CredentialManager.GetCredentials(App.CredDb);
if (cred == null || cred.UserName.Length < 1)
{
return;
}
using (var db = new LiteDatabase($"{App.GetDbStringWithoutPass}'{cred.Password}'"))
{
var dbCharInfo = db.GetCollection <VnCharacterInfo>(DbVnCharacter.VnCharacter.ToString());
ILiteCollection <VnCharacterTraits> dbCharTraits = db.GetCollection <VnCharacterTraits>(DbVnCharacter.VnCharacter_Traits.ToString());
if (characters.Count > 0)
{
List <VnCharacterInfo> vnCharactersList = new List <VnCharacterInfo>();
List <VnCharacterTraits> vnCharacterTraitsList = new List <VnCharacterTraits>();
foreach (Character vnCharacter in characters)
{
var prevVnCharacter = dbCharInfo.Query().Where(x => x.CharacterId == vnCharacter.Id);
var character = prevVnCharacter.FirstOrDefault() ?? new VnCharacterInfo();
character.VnId = vnid;
character.CharacterId = vnCharacter.Id;
character.Name = vnCharacter.Name;
character.Original = vnCharacter.OriginalName;
character.Gender = vnCharacter.Gender.ToString();
character.BloodType = vnCharacter.BloodType.ToString();
character.Age = vnCharacter.Age.ToString();
character.Birthday = SimpleDateConverter.ConvertSimpleDate(vnCharacter.Birthday);
character.Aliases = CsvConverter.ConvertToCsv(vnCharacter.Aliases);
character.Description = vnCharacter.Description;
character.ImageLink = !string.IsNullOrEmpty(vnCharacter.Image) ? vnCharacter.Image : string.Empty;
character.ImageRating = vnCharacter.ImageRating;
character.Bust = Convert.ToInt32(vnCharacter.Bust, CultureInfo.InvariantCulture);
character.Waist = Convert.ToInt32(vnCharacter.Waist, CultureInfo.InvariantCulture);
character.Hip = Convert.ToInt32(vnCharacter.Hip, CultureInfo.InvariantCulture);
character.Height = Convert.ToInt32(vnCharacter.Height, CultureInfo.InvariantCulture);
character.Weight = Convert.ToInt32(vnCharacter.Weight, CultureInfo.InvariantCulture);
vnCharactersList.Add(character);
vnCharacterTraitsList.AddRange(FormatVnCharacterTraits(vnCharacter, dbCharTraits));
}
dbCharInfo.Upsert(vnCharactersList);
dbCharTraits.Upsert(vnCharacterTraitsList);
}
}
}
catch (Exception e)
{
App.Logger.Error(e, "Failed to save VnCharacters");
SentryHelper.SendException(e, null, SentryLevel.Error);
}
}
public void SetSetting(ISetting value)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
_settings.Upsert((Setting)value);
}
public override void Save(Portfolio portfolio)
{
_portfolios.Upsert(portfolio);
foreach (var item in portfolio.Children)
{
Save(item);
}
}
public void Save(T obj)
{
if (obj.Id.Equals(Guid.Empty))
{
throw new Exception("Guid.Empty used as identifier");
}
Collection.Upsert(obj);
}
public void UpdatePreference(string name, object value)
{
var preference = new PreferenceValue {
Name = name,
Value = value
};
_collection.Upsert(preference);
}
public void SaveEntities <TEntity>(IEnumerable <TEntity> entities)
{
using (LiteDatabase db = new LiteDatabase(_appSettings.LightDbConnection))
{
ILiteCollection <TEntity> col = db.GetCollection <TEntity>(typeof(TEntity).Name);
col.Upsert(entities);
}
}
public Task SavePost(Post post)
{
post.LastModified = DateTime.Now;
var taskResult = Task.FromResult(_postCollection.Upsert(post));
UpdateCache();
return(taskResult);
}
/// <summary>
/// Set the specified cacheKey, cacheValue and expiration.
/// </summary>
/// <returns>The set.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override void BaseSet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
_cache.Upsert(new CacheItem
{
cachekey = cacheKey,
name = _name,
cachevalue = Newtonsoft.Json.JsonConvert.SerializeObject(cacheValue),
expiration = DateTimeOffset.UtcNow.Add(expiration).ToUnixTimeSeconds()
});
}
public async Task LoadImageAsync(string url, Action <Texture2D?> onDone)
{
try
{
if (!myFileDatabase.FileStorage.Exists(url))
{
onDone(null);
return;
}
await Task.Run(() => { }).ConfigureAwait(false);
using var imageStream = myFileDatabase.FileStorage.OpenRead(url);
using var image = await Image.LoadAsync <Rgba32>(imageStream).ConfigureAwait(false);
var newImageInfo = new StoredImageInfo {
Id = url, LastAccessed = DateTime.UtcNow
};
myImageInfos.Upsert(newImageInfo);
await TaskUtilities.YieldToMainThread();
try
{
onDone(CreateTextureFromImage(image));
}
catch (Exception ex)
{
MelonLogger.Error($"Exception in onDone callback: {ex}");
}
}
catch (Exception ex)
{
if (MelonDebug.IsEnabled())
{
MelonLogger.Warning($"Exception in image load, will delete offending image: {ex}");
}
myFileDatabase.FileStorage.Delete(url);
myImageInfos.Delete(url);
onDone(AssetsHandler.PreviewLoading.texture);
}
}
public T UpdateData <T>(T data) where T : IdentifiableData
{
using (LiteDatabase db = new LiteDatabase(_location))
{
ILiteCollection <T> servers = db.GetCollection <T>(typeof(T).Name);
servers.DeleteMany(x => x.Id == data.Id);
servers.Upsert(data);
return(data);
}
}
public IndexSortAndFilterTest()
{
_tempFile = new TempFile();
_database = new LiteDatabase(_tempFile.Filename);
_collection = _database.GetCollection <Item>("items");
_collection.Upsert(new Item()
{
Id = "C", Value = "Value 1"
});
_collection.Upsert(new Item()
{
Id = "A", Value = "Value 2"
});
_collection.Upsert(new Item()
{
Id = "B", Value = "Value 1"
});
_collection.EnsureIndex("idx_value", x => x.Value);
}
/// <summary>
/// Set the specified cacheKey, cacheValue and expiration.
/// </summary>
/// <returns>The set.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override void BaseSet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
var exp = expiration.Ticks / 10000000;
_cache.Upsert(new CacheItem
{
cachekey = cacheKey,
name = _name,
cachevalue = Newtonsoft.Json.JsonConvert.SerializeObject(cacheValue),
expiration = expiration.Ticks / 10000000
});
}
public void SaveNonVolatileVars()
{
lock (DbLock)
{
//save my internal state
BsonDocument state = new BsonDocument();
state["_id"] = "TradingAlgoState";
state["State"] = Db.Mapper.Serialize(State);
//Save derived state
state["DerivedClassState"] = Db.Mapper.Serialize(GetState());
//save module states
state["Sentry"] = Db.Mapper.Serialize(Sentry.GetState());
state["Allocator"] = Db.Mapper.Serialize(Allocator.GetState());
state["Executor"] = Db.Mapper.Serialize(Executor.GetState());
state["RiskManager"] = Db.Mapper.Serialize(RiskManager.GetState());
Db.GetCollection("State").Upsert(state);
foreach (var symData in SymbolsData.Values)
{
Db.GetCollection <SymbolData>("SymbolsData").Upsert(symData);
}
Db.BeginTrans();
foreach (var op in ActiveOperations.Where(op => op.IsChanged))
{
DbActiveOperations.Upsert(op);
}
foreach (var op in ClosedOperations.Where(op => op.IsChanged))
{
DbClosedOperations.Upsert(op);
}
Db.Commit();
Db.Checkpoint();
}
}
private void LoadRecommendationFromCache(SettingsPreferences settings
, ILiteCollection <RecommendationAnimes> recommendationAnimesCollection, RecommendationAnimes recommendationsCache)
{
recommendationsCache.Recommendations = recommendationsCache.Recommendations
.Where(recommendation => !App.liteDB.GetCollection <FavoritedAnime>()
.Exists(favoritedAnime => recommendation.MalId == favoritedAnime.Anime.MalId))
.ToList();
RecommendationAnimes = recommendationsCache;
HasRecommendations = RecommendationAnimes.Recommendations.Count() != 0;
recommendationAnimesCollection.Upsert(0, recommendationsCache);
}
public int Upsert(Produce produce)
{
int returnValue = 0;
using (var db = new LiteDatabase(_connection))
{
ILiteCollection <Produce> col = db.GetCollection <Produce>("produce");
col.Upsert(produce);
returnValue = produce.Id;
}
return(returnValue);
}
public async Task <string> GetGithubHash()
{
Reference reference = await _github.Git.Reference.Get(REPOSITORY_OWNER, REPOSITORY_NAME, "heads/master");
string hash = reference.Object.Sha;
Repository latest = _repository.Find(r => true).OrderByDescending(r => r.DateTime).FirstOrDefault() ??
new Repository();
latest.CommitHash = hash;
latest.DateTime = DateTime.Now;
_repository.Upsert(latest);
return(hash);
}
public bool SaveEntry <T>(T entry, bool overwrite = false)
{
using (var db = new LiteDatabase(_connectionString))
{
ILiteCollection <T> collection = db.GetCollection <T>();
if (overwrite)
{
return(collection.Upsert(entry));
}
else
{
var insert = collection.Insert(entry);
return(!insert.IsNull);
}
}
}
