/// <summary>
/// Insert or Update the user's contact. Public key is a primary key.
/// </summary>
/// <param name="name">Person's name or reference</param>
/// <param name="publicKey">Valid Bitcoin-compatible Publickey (string)</param>
/// <returns>An inserted or updated contact record.</returns>
public Contact UpsertContact(string name, string publicKey)
{
try
{
var mycontact = collection.Find(c => c.Address == publicKey).FirstOrDefault();
if (mycontact == null)
{
mycontact = new Contact()
{
Name = name,
Address = publicKey,
AddressHash = new BitcoinPubKeyAddress(publicKey, MainNetwork).Hash.ToBytes()
};
}
else
{
mycontact.Name = name;
}
collection.Upsert(mycontact);
collection.EnsureIndex(c => c.Address);
collection.EnsureIndex(c => c.AddressHash);
collection.EnsureIndex(c => c.AddressHashString);
return(mycontact);
}
catch (Exception)
{
return(null);
}
}
public void EnsureIndex(LiteCollection <Order> collection)
{
collection.EnsureIndex(x => x.ID);
collection.EnsureIndex(x => x.ClientID);
collection.EnsureIndex(x => x.ProductID);
collection.EnsureIndex(x => x.Price);
}
public void EnsureIndex(LiteCollection <Product> collection)
{
collection.EnsureIndex(x => x.ID);
collection.EnsureIndex(x => x.Title);
collection.EnsureIndex(x => x.Count);
collection.EnsureIndex(x => x.Price);
}
public AuthDbLdb(LiteDatabase database)
{
_db = database;
_accounts = _db.GetCollection <AccountDataLdb>("accounts");
_accounts.EnsureIndex(a => a.Username, new IndexOptions()
{
Unique = true, IgnoreCase = true, TrimWhitespace = true
});
_accounts.EnsureIndex(a => a.Email, new IndexOptions()
{
Unique = true, IgnoreCase = true, TrimWhitespace = true
});
_resetCodes = _db.GetCollection <PasswordResetData>("resets");
_resetCodes.EnsureIndex(a => a.Email, new IndexOptions()
{
Unique = true, IgnoreCase = true, TrimWhitespace = true
});
_emailConfirmations = _db.GetCollection <EmailConfirmationData>("emailConf");
_emailConfirmations.EnsureIndex(a => a.Email, new IndexOptions()
{
Unique = true, IgnoreCase = true, TrimWhitespace = true
});
}
public virtual async void CreateDB()
{
try
{
db = new LiteDatabase("filename=" + ApplicationData.Current.LocalFolder.Path + @"\breadplayer.db;journal=false;");
IsValid = db.DbVersion.ToString() != "";
if (IsValid)
{
tracks = db.GetCollection <Mediafile>("tracks");
playlists = db.GetCollection <Playlist>("playlists");
recent = db.GetCollection <Mediafile>("recent");
tracks.EnsureIndex(t => t.Title);
tracks.EnsureIndex(t => t.LeadArtist);
}
else
{
await ApplicationData.Current.ClearAsync();
CreateDB();
}
GetTrackCount();
}
catch (Exception)
{
await ApplicationData.Current.ClearAsync();
CreateDB();
}
}
public DocumentStoreDatabaseService(string dbPath, string collectionName)
{
DB = StaticDocumentDatabase.GetDatabase(dbPath.ToLower() + ".db");
currentCollection = DB.GetCollection <IDbRecord>(collectionName);
currentCollection.EnsureIndex(t => t.Id);
currentCollection.EnsureIndex(t => t.TextSearchKey);
}
public HistoryManager(HistoryManagerData hmd)
{
Formatter = new SmartHistoryFormatter();
historyManagerData = hmd;
#region CheckUpgrade
AudioLogEntry[] moveData = null;
var upgrader = new Deprecated.HistoryFile();
// check if the old history database system can open it
try
{
upgrader.OpenFile(historyManagerData.HistoryFile);
Log.Write(Log.Level.Info, "Found old history database vesion, upgrading now.");
moveData = upgrader
.GetAll()
.Select(x => new AudioLogEntry((int)x.Id, x.AudioResource)
{
PlayCount = x.PlayCount,
Timestamp = x.Timestamp,
UserInvokeId = x.UserInvokeId,
})
.ToArray();
// the old database allowed 0-id, while the new one kinda doesn't
var nullIdEntity = moveData.FirstOrDefault(x => x.Id == 0);
if (nullIdEntity != null)
{
nullIdEntity.Id = moveData.Select(x => x.Id).Max() + 1;
}
upgrader.CloseFile();
upgrader.BackupFile();
upgrader.historyFile.Delete();
}
// if not it is already the new one or corrupted
catch (FormatException) { }
finally
{
upgrader.Dispose();
}
#endregion
Util.Init(ref unusedIds);
var historyFile = new FileInfo(hmd.HistoryFile);
database = new LiteDatabase(historyFile.FullName);
audioLogEntries = database.GetCollection <AudioLogEntry>(AudioLogEntriesTable);
audioLogEntries.EnsureIndex(x => x.AudioResource.ResourceTitle);
audioLogEntries.EnsureIndex(x => x.AudioResource.UniqueId, true);
RestoreFromFile();
#region CheckUpgrade
if (moveData != null)
{
audioLogEntries.Insert(moveData);
}
#endregion
}
public static void EnsureIndexes(this LiteCollection <BusinessCard> collection)
{
collection.EnsureIndex(x => x.Id, true);
collection.EnsureIndex(x => x.FirstName);
collection.EnsureIndex(x => x.LastName);
collection.EnsureIndex(x => x.BirthDay);
}
public LiteDbService()
{
_db = new LiteDatabase(Path.Combine(FileSystem.AppDataDirectory, "covid19.db"));
_collection = _db.GetCollection <T>();
_collection.EnsureIndex("country");
_collection.EnsureIndex("countryPtBR");
}
protected override void EnsureIndeces(LiteCollection <FundRequestDTO> coll)
{
coll.EnsureIndex(_ => _.SerialNum);
//coll.EnsureIndex(_ => _.RequestDate);
coll.EnsureIndex(_ => _.DateOffset);
coll.EnsureIndex(_ => _.BankAccountId);
}
private void DoIndexing(LiteCollection <ApplicationsModel> collections)
{
collections.EnsureIndex(x => x.Id);
collections.EnsureIndex(x => x.Name);
collections.EnsureIndex(x => x.ConnectionString);
collections.EnsureIndex(x => x.IsActive);
}
public virtual async void CreateDB()
{
try
{
IsValid = StaticDatabase.DB.Engine != null;
if (IsValid)
{
tracks = StaticDatabase.DB.GetCollection <Mediafile>("tracks");
playlists = StaticDatabase.DB.GetCollection <Playlist>("playlists");
recent = StaticDatabase.DB.GetCollection <Mediafile>("recent");
tracks.EnsureIndex(t => t.Title);
tracks.EnsureIndex(t => t.LeadArtist);
}
else
{
await ApplicationData.Current.ClearAsync();
CreateDB();
}
GetTrackCount();
}
catch (Exception)
{
await ApplicationData.Current.ClearAsync();
CreateDB();
}
}
/// <summary>
/// Constructor
/// - initializes LiteDB database
/// - opens collects for transactions and blocks, and ensures indexes
/// </summary>
/// <param name="fileName"></param>
public DatabaseConsumer(string fileName) : base()
{
var database = new LiteDatabase(fileName);
_transactions = database.GetCollection <Transaction>("transactions");
_transactions.EnsureIndex(x => x.TXIDHex, true);
_blocks = database.GetCollection <Block>("block");
_blocks.EnsureIndex(x => x.BlockHash, true);
_blocks.EnsureIndex(x => x.Height);
_subscriptions = database.GetCollection <Subscription>("subscriptions");
_subscriptions.EnsureIndex(x => x.subTo, true);
var mapper = BsonMapper.Global;
// exclude fields Transactions and LengthMatch from block database storage
mapper.Entity <Block>().Ignore(x => x.Transactions).Ignore(x => x.LengthMatch);
// exclude field LengthMatch from block database storage
mapper.Entity <Transaction>().Ignore(x => x.LengthMatch);
// get the chaintip hash
var chainTip = _blocks.FindOne(x => x.IsChainTip);
if (chainTip != null)
{
_chainTipHash = chainTip.BlockHash;
}
}
/// <inheritdoc/>
public override void ForkStateReferences <T>(
Guid sourceChainId,
Guid destinationChainId,
Block <T> branchPoint)
{
string srcCollId = StateRefId(sourceChainId);
string dstCollId = StateRefId(destinationChainId);
LiteCollection <StateRefDoc> srcColl = _db.GetCollection <StateRefDoc>(srcCollId),
dstColl = _db.GetCollection <StateRefDoc>(dstCollId);
Query srcQuery = Query.And(
Query.GT("BlockIndex", 0),
Query.LTE("BlockIndex", branchPoint.Index)
);
IEnumerable <StateRefDoc> srcStateRefs = srcColl.Find(srcQuery);
dstColl.InsertBulk(srcStateRefs);
if (!dstColl.Exists(_ => true) && CountIndex(sourceChainId) < 1)
{
throw new ChainIdNotFoundException(
sourceChainId,
"The source chain to be forked does not exist."
);
}
dstColl.EnsureIndex("AddressString");
dstColl.EnsureIndex("BlockIndex");
_lastStateRefCaches.Remove(destinationChainId);
}
/// <summary>
/// Uses the provided database collection
/// </summary>
/// <param name="collection">A LiteDB collection.</param>
/// <param name="transactional">Whether the queue should use transaction logic, default true</param>
public LiteQueue(LiteCollection <QueueEntry <T> > collection, bool transactional = true)
{
_collection = collection;
_transactional = transactional;
_collection.EnsureIndex(x => x.Id);
_collection.EnsureIndex(x => x.IsCheckedOut);
}
/// <inheritdoc/>
public override void ForkStateReferences <T>(
Guid sourceChainId,
Guid destinationChainId,
Block <T> branchPoint)
{
string srcCollId = StateRefId(sourceChainId);
string dstCollId = StateRefId(destinationChainId);
LiteCollection <StateRefDoc> srcColl = _liteDb.GetCollection <StateRefDoc>(srcCollId),
dstColl = _liteDb.GetCollection <StateRefDoc>(dstCollId);
dstColl.InsertBulk(srcColl.Find(Query.LTE("BlockIndex", branchPoint.Index)));
if (!dstColl.Exists(_ => true) && CountIndex(sourceChainId) < 1)
{
throw new ChainIdNotFoundException(
sourceChainId,
"The source chain to be forked does not exist."
);
}
dstColl.EnsureIndex(nameof(StateRefDoc.StateKey));
dstColl.EnsureIndex(nameof(StateRefDoc.BlockIndex));
_lastStateRefCaches.Remove(destinationChainId);
}
public void EnsureIndex(LiteCollection <ServiceTicket> collection)
{
collection.EnsureIndex(x => x.ID);
collection.EnsureIndex(x => x.ClientID);
collection.EnsureIndex(x => x.Title);
collection.EnsureIndex(x => x.Problem);
collection.EnsureIndex(x => x.Price);
}
public TokenManager(DbStore database)
{
dbTokenList = database.GetCollection <DbApiToken>(ApiTokenTable);
dbTokenList.EnsureIndex(x => x.UserUid, true);
dbTokenList.EnsureIndex(x => x.Token, true);
database.GetMetaData(ApiTokenTable);
}
private void bulkInsert(LiteCollection <BsonDocument> liteCollection, IEnumerable <BsonDocument> IFCBson)
{
//用List<>
liteCollection.Insert(IFCBson);
liteCollection.EnsureIndex("_P21id");
liteCollection.EnsureIndex("_EntityName");
liteCollection.EnsureIndex("GlobalId");
}
private void DoIndexing(LiteCollection <QueryModel> collections)
{
collections.EnsureIndex(x => x.Id);
collections.EnsureIndex(x => x.ApplicationId);
collections.EnsureIndex(x => x.Name);
collections.EnsureIndex(x => x.Query);
collections.EnsureIndex(x => x.IsActive);
}
public void EnsureIndex(LiteCollection <Client> collection)
{
collection.EnsureIndex(x => x.ID);
collection.EnsureIndex(x => x.Name);
collection.EnsureIndex(x => x.Adress);
collection.EnsureIndex(x => x.Phone);
collection.EnsureIndex(x => x.Discount);
}
public void Initialize()
{
dbTokenList = Database.GetCollection <DbApiToken>(ApiTokenTable);
dbTokenList.EnsureIndex(x => x.UserUid, true);
dbTokenList.EnsureIndex(x => x.Token, true);
Database.GetMetaData(ApiTokenTable);
}
private void Initialize()
{
var meta = database.GetMetaData(AudioLogEntriesTable);
if (meta.Version > CurrentHistoryVersion)
{
Log.Error("Database table \"{0}\" is higher than the current version. (table:{1}, app:{2}). " +
"Please download the latest TS3AudioBot to read the history.", AudioLogEntriesTable, meta.Version, CurrentHistoryVersion);
return;
}
audioLogEntries = database.GetCollection <AudioLogEntry>(AudioLogEntriesTable);
audioLogEntries.EnsureIndex(x => x.AudioResource.UniqueId, true);
audioLogEntries.EnsureIndex(x => x.Timestamp);
audioLogEntries.EnsureIndex(ResourceTitleQueryColumn,
$"LOWER($.{nameof(AudioLogEntry.AudioResource)}.{nameof(AudioResource.ResourceTitle)})");
RestoreFromFile();
if (meta.Version == CurrentHistoryVersion)
{
return;
}
if (audioLogEntries.Count() == 0)
{
meta.Version = CurrentHistoryVersion;
database.UpdateMetaData(meta);
return;
}
// Content upgrade
switch (meta.Version)
{
case 0:
var all = audioLogEntries.FindAll().ToArray();
foreach (var audioLogEntry in all)
{
switch (audioLogEntry.AudioResource.AudioType)
{
case "MediaLink": audioLogEntry.AudioResource.AudioType = "media"; break;
case "Youtube": audioLogEntry.AudioResource.AudioType = "youtube"; break;
case "Soundcloud": audioLogEntry.AudioResource.AudioType = "soundcloud"; break;
case "Twitch": audioLogEntry.AudioResource.AudioType = "twitch"; break;
}
}
audioLogEntries.Update(all);
meta.Version = 1;
database.UpdateMetaData(meta);
goto default;
default:
Log.Info("Database table \"{0}\" upgraded to {1}", AudioLogEntriesTable, meta.Version);
break;
}
}
public void CreateDB()
{
db = new LiteDatabase("filename=" + ApplicationData.Current.LocalFolder.Path + @"\breadplayer.db;journal=false;");
tracks = db.GetCollection <Mediafile>("tracks");
playlists = db.GetCollection <Playlist>("playlists");
recent = db.GetCollection <Mediafile>("recent");
tracks.EnsureIndex(t => t.Title);
tracks.EnsureIndex(t => t.LeadArtist);
}
public LiteDbContentRepository(IOptions <LiteDbContentOptions> options, IHostingEnvironment env)
{
var file = $"{env.ContentRootPath}/{options.Value.DataFile}";
_db = new LiteDatabase(file);
_contentCollection = _db.GetCollection <Content>();
_contentCollection.EnsureIndex(x => x.ParentId);
_contentCollection.EnsureIndex(x => x.Urls);
}
public TrackItemService(LiteDatabase db = null)
{
var homedir = Environment.GetEnvironmentVariable("TRACKMAT_HOME", EnvironmentVariableTarget.User) ?? Environment.GetEnvironmentVariable("TRACKMAT_HOME");
Db = db ?? new LiteDatabase(Path.Combine(homedir, "trackmat.db"));
TrackItems = Db.GetCollection <TrackItem>();
TrackItems.EnsureIndex(item => item.Item);
TrackItems.EnsureIndex(item => item.Date);
}
public void GlobalSetupSimpleIndexBaseline()
{
DatabaseInstance = new LiteDatabase(ConnectionString);
_fileMetaCollection = DatabaseInstance.GetCollection <FileMetaBase>();
_fileMetaCollection.EnsureIndex(fileMeta => fileMeta.ShouldBeShown);
_fileMetaCollection.EnsureIndex(fileMeta => fileMeta.IsFavorite);
_fileMetaCollection.Insert(FileMetaGenerator <FileMetaBase> .GenerateList(N)); // executed once per each N value
}
public void InsertTag(StorageTag tag)
{
lock (dbLock)
{
_tagCollection.Insert(tag);
_tagCollection.EnsureIndex(x => x.TagName);
_tagCollection.EnsureIndex(x => x.ProjectId);
}
}
public void InsertImage(StorageImage image)
{
lock (dbLock)
{
_storageCollection.Insert(image);
_storageCollection.EnsureIndex(x => x.FullFileName);
_storageCollection.EnsureIndex(x => x.ProjectId);
}
}
/// <summary>
/// Метод проверяет существует ли такой контрагент в базе
/// </summary>
/// <param name="_inn"></param>
/// <param name="_kpp"></param>
/// <returns></returns>
public bool CheckExist(string _inn, string _kpp)
{
LiteCollection <Contractor> collection = database.GetCollection <Contractor>("contractors");
collection.EnsureIndex(a => a.INN);
collection.EnsureIndex(a => a.KPP);
bool result = collection.Exists(a => a.INN == _inn && a.KPP == _kpp);
return(result);
}
public DbRepo(string dp, ILogger logger, IJsonSerializer json = null)
{
DataPath = dp;
//LitePlatform.Initialize(new LitePlatformFullDotNet());
var data = Path.Combine(DataPath, dataName);
_logger = logger;
_json = json;
if (File.Exists(Path.Combine(DataPath, "Emby.Kodi.SyncQueue.ldb")))
{
File.Delete(Path.Combine(DataPath, "Emby.Kodi.SyncQueue.ldb"));
}
if (File.Exists(Path.Combine(DataPath, "Emby.Kodi.SyncQueue.1.2.ldb")))
{
File.Delete(Path.Combine(DataPath, "Emby.Kodi.SyncQueue.1.2.ldb"));
}
if (File.Exists(Path.Combine(DataPath, "Emby.Kodi.SyncQueue.1.3.ldb")))
{
File.Delete(Path.Combine(DataPath, "Emby.Kodi.SyncQueue.1.3.ldb"));
}
if (File.Exists(Path.Combine(DataPath, "Emby.Kodi.SyncQueue.1.31.ldb")))
{
File.Delete(Path.Combine(DataPath, "Emby.Kodi.SyncQueue.1.31.ldb"));
}
if (!Directory.Exists(DataPath))
{
Directory.CreateDirectory(DataPath);
}
if (!File.Exists(data))
{
}
if (DB == null) { DB = new LiteDatabase(data); }
folders = DB.GetCollection<FolderRec>("Folders");
items = DB.GetCollection<ItemRec>("Items");
userinfos = DB.GetCollection<UserInfoRec>("UserInfos");
folders.EnsureIndex(x => x.ItemId);
folders.EnsureIndex(x => x.UserId);
folders.EnsureIndex(x => x.LastModified);
folders.EnsureIndex(x => x.Status);
folders.EnsureIndex(x => x.MediaType);
items.EnsureIndex(x => x.ItemId);
items.EnsureIndex(x => x.LastModified);
items.EnsureIndex(x => x.Status);
items.EnsureIndex(x => x.MediaType);
userinfos.EnsureIndex(x => x.ItemId);
userinfos.EnsureIndex(x => x.UserId);
userinfos.EnsureIndex(x => x.LastModified);
userinfos.EnsureIndex(x => x.MediaType);
}
public static void ClassInit(TestContext context)
{
db = new LiteDatabase(new MemoryStream());
col = db.GetCollection<TestPocoClass>("col1");
col.EnsureIndex(o => o.Key);
}
