/// <summary>
/// 连接字符串
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ConnectDB_Click(object sender, RoutedEventArgs e)
{
if (!this.ViewModel.TestConnectionion())
{
MessageBox.Show("选择的数据库连接不上，请重新填写");
return;
}
DatabaseMeta dbMeta = null;
switch (this.ViewModel.DBTypeSelectIndex)
{
case 0:
dbMeta = DatabaseMeta.CreateByMysql(this.ViewModel.ConnectionString);
break;
case 1:
dbMeta = DatabaseMeta.CreateBySqlserver(this.ViewModel.ConnectionString);
break;
case 2:
dbMeta = DatabaseMeta.CreateBySqlite(this.ViewModel.ConnectionString);
break;
}
foreach (var item in dbMeta.Tables)
{
this.ViewModel.Tables.Add(new TableSelectModel()
{
IsSelected = true, TableName = item.TableName, Meta = item
});
}
}
private void TestMeta(IDatabase database)
{
DatabaseMeta meta = new DatabaseMeta(1);
bool success = database.UpsertMeta(meta);
Assert.True(success);
DatabaseMeta selectedMeta = database.SelectMeta(1);
Assert.NotNull(selectedMeta);
}
public async Task RunAsync()
{
Console.WriteLine($"Begin downloading data to folder: {_baseFolder}");
var cosmosMeta = new CosmosMeta();
cosmosMeta.Databases = new List <DatabaseMeta>();
var databases = await _client.ReadDatabaseFeedAsync();
foreach (var db in databases)
{
Console.WriteLine($"Procerssing database: {db.Id}");
var dbMeta = new DatabaseMeta();
dbMeta.DBSchema = db;
dbMeta.CollectionSchemas = new List <DocumentCollection>();
// Create a folder for each database.
string dbFolder = Path.Combine(_baseFolder, db.Id);
Directory.CreateDirectory(dbFolder);
var collections = await _client.ReadDocumentCollectionFeedAsync(db.CollectionsLink);
foreach (var collection in collections)
{
Console.WriteLine($"Procerssing collection: {collection.Id}");
dbMeta.CollectionSchemas.Add(collection);
var docs = await _client.ReadDocumentFeedAsync(collection.DocumentsLink);
var serilized = JsonConvert.SerializeObject(docs);
// Create a file for each data base.
string collectionFile = Path.Combine(dbFolder, collection.Id + ".json");
try
{
File.WriteAllText(collectionFile, serilized);
}
catch { }
}
cosmosMeta.Databases.Add(dbMeta);
}
string metaFile = Path.Combine(_baseFolder, Constants.MetaFileName);
try
{
File.WriteAllText(metaFile, JsonConvert.SerializeObject(cosmosMeta));
}
catch { }
Console.WriteLine($"Finished downloading data to folder: {_baseFolder}");
}
private void UpdateDatabase(int version)
{
DatabaseMeta meta = Database.SelectMeta(version);
if (meta == null)
{
meta = new DatabaseMeta(version);
Database.UpsertMeta(meta);
}
if (!meta.ReadItemData)
{
ItemDataBin itemDataBin = new ItemDataBin();
itemDataBin.Read(Path.Combine(Utils.RelativeApplicationDirectory(), "Data/ItemData.bin"));
_logger.Info("Loading: {0} items from ItemData.bin", itemDataBin.Entries.Count);
foreach (Item item in itemDataBin.Entries)
{
Database.UpsertItem(item);
}
meta.ReadItemData = true;
Database.UpsertMeta(meta);
}
if (!meta.ReadQuestData)
{
QuestDataBin questDataBin = new QuestDataBin();
questDataBin.Read(Path.Combine(Utils.RelativeApplicationDirectory(), "Data/Quest_data.bin"));
_logger.Info("Loading: {0} quests from Quest_data.bin", questDataBin.Entries.Count);
foreach (Quest quest in questDataBin.Entries)
{
Database.UpsertQuest(quest);
}
meta.ReadQuestData = true;
Database.UpsertMeta(meta);
}
if (!meta.ReadSongData)
{
MusicDataBin musicDataBin = new MusicDataBin();
musicDataBin.Read(Path.Combine(Utils.RelativeApplicationDirectory(), "Data/music_data.bin"));
_logger.Info("Loading: {0} songs from music_data.bin", musicDataBin.Entries.Count);
foreach (Song song in musicDataBin.Entries)
{
Database.UpsertSong(song);
}
meta.ReadSongData = true;
Database.UpsertMeta(meta);
}
}
public ContractOrderDictionary(DatabaseMeta meta)
{
if (meta == null)
{
return;
}
foreach (var proc in meta.Procedures)
{
var maxRequestOrder = 1;
foreach (var requestItem in proc.Request)
{
SetIndex(GetRequestItemKey(proc.SpName, requestItem.Name), requestItem.Order);
maxRequestOrder = Math.Max(requestItem.Order, maxRequestOrder);
if (requestItem.TVP != null)
{
var maxTvpOrder = 1;
foreach (var tvpItem in requestItem.TVP)
{
SetIndex(GetRequestTvpKey(proc.SpName, requestItem.Name, tvpItem.Name), tvpItem.Order);
maxTvpOrder = Math.Max(tvpItem.Order, maxTvpOrder);
}
SetIndex(GetRequestTvpMaxKey(proc.SpName, requestItem.Name), maxTvpOrder);
}
}
//save the max index of request class
SetIndex(GetRequestMaxKey(proc.SpName), maxRequestOrder);
var maxResponseOrder = 3;
foreach (var respItem in proc.Responses)
{
SetIndex(GetResponseItemKey(proc.SpName, respItem.Name), respItem.Order);
maxResponseOrder = Math.Max(respItem.Order, maxResponseOrder);
var maxParamOrder = 1;
foreach (var param in respItem.Params)
{
SetIndex(GetResponseResultItemKey(proc.SpName, respItem.Name, param.Name), param.Order);
maxResponseOrder = Math.Max(param.Order, maxParamOrder);
}
SetIndex(GetResponseResultMaxKey(proc.SpName, respItem.Name), maxParamOrder);
}
SetIndex(GetResponseMaxKey(proc.SpName), maxResponseOrder);
}
}
public List <DatabaseMeta> GetTables()
{
using (SqlConnection connection = new SqlConnection(this.ConnectionString))
{
connection.Open();
DataTable schema = connection.GetSchema("Tables");
List <DatabaseMeta> TableNames = new List <DatabaseMeta>();
foreach (DataRow row in schema.Rows)
{
DatabaseMeta databaseMeta = new DatabaseMeta();
databaseMeta.DatabaseName = row[0].ToString();
databaseMeta.TableSchemaName = row[1].ToString();
databaseMeta.TableName = row[2].ToString();
databaseMeta.TableType = row[3].ToString();
TableNames.Add(databaseMeta);
}
return(TableNames);
}
}
public bool EditDatabase(int databaseId, DatabaseMeta databaseMeta)
{
var database = Model.Databases.Get(databaseId);
Model.DatabasesMeta.Update(database.DatabaseMetaId, databaseMeta);
SetDatabaseAsModified(databaseId);
return true;
}
