public void PopulateDatabasList()
{
try
{
//Databases.Add()
//cmbsrcDatabase.Items.Clear();
using (var conn = new ConnectionHelper(ServerName, UserName, Password, authenticationType))
{
using (var reader = new SqlCommand("select name from sys.databases WHERE name NOT IN ('master', 'tempdb', 'model', 'msdb');", conn.GetConnection()).ExecuteReader())
{
while (reader.Read())
{
Databases.Add(reader["name"].ToString());
}
}
}
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
ExMessage = ex.InnerException.Message;
}
else
{
ExMessage = ex.Message;
}
}
}
/// <summary>
/// Deserialize the object
/// </summary>
public virtual void DeserializeJson(JToken inputObject)
{
if (inputObject == null || inputObject.Type == JTokenType.Null)
{
return;
}
var collsValue = inputObject["_colls"];
if (collsValue != null && collsValue.Type != JTokenType.Null)
{
Colls = ((string)collsValue);
}
var etagValue = inputObject["_etag"];
if (etagValue != null && etagValue.Type != JTokenType.Null)
{
Etag = ((string)etagValue);
}
var ridValue = inputObject["_rid"];
if (ridValue != null && ridValue.Type != JTokenType.Null)
{
Rid = ((string)ridValue);
}
var selfValue = inputObject["_self"];
if (selfValue != null && selfValue.Type != JTokenType.Null)
{
Self = ((string)selfValue);
}
var tsValue = inputObject["_ts"];
if (tsValue != null && tsValue.Type != JTokenType.Null)
{
Ts = ((string)tsValue);
}
var usersValue = inputObject["_users"];
if (usersValue != null && usersValue.Type != JTokenType.Null)
{
Users = ((string)usersValue);
}
var databasesSequence = inputObject["Databases"];
if (databasesSequence != null && databasesSequence.Type != JTokenType.Null)
{
foreach (var databasesValue in ((JArray)databasesSequence))
{
var database = new Database();
database.DeserializeJson(databasesValue);
Databases.Add(database);
}
}
var idValue = inputObject["id"];
if (idValue != null && idValue.Type != JTokenType.Null)
{
Id = ((string)idValue);
}
}
public ActionResult Create(CreateDatabaseModel model)
{
if (Databases.GetList().Count(d => d.Owner.ID == UserAccount.ID && d.Name == model.Name) != 0)
{
ModelState.AddModelError("Name", String.Format("You already have database with name '{0}'.", model.Name));
}
if (ModelState.IsValid)
{
Database database = new Database
{
Name = model.Name,
Revision = 1,
OwnerID = UserAccount.ID,
PublicIdentifier = Guid.NewGuid().ToString()
};
Databases.Add(database);
DatabaseRevision revision = new DatabaseRevision
{
DatabaseID = database.ID,
Content = model.Content,
Timestamp = DateTime.Now,
Revision = 1
};
Revisions.Add(revision);
ShowMessage("Database created");
return(RedirectToAction("index"));
}
return(View(model));
}
public WizardSelectDatabaseViewModel(WizardSelectDatabaseModel model, string host, int port, string username, string password)
{
WizardSelectDatabase = model;
OkCommand = new Command(Ok);
CancelCommand = new Command(CancelCmd);
var connStr = new MySqlConnectionStringBuilder();
connStr.Server = host;
connStr.Port = (uint)port;
connStr.UserID = username;
connStr.Password = password;
using (var connection = new MySqlConnection(connStr.ToString()))
{
connection.Open();
using (var returnVal = new MySqlDataAdapter("SHOW DATABASES", connection))
{
var dataTable = new DataTable();
returnVal.Fill(dataTable);
foreach (DataRow row in dataTable.Rows)
{
for (int i = 0; i < row.ItemArray.Length; i++)
{
Databases.Add(row.ItemArray[i].ToString());
}
}
}
}
}
public void AddDatabase(Data.Database db)
{
if (!Databases.Contains(db))
{
Databases.Add(db);
}
}
private void ReadAndConvertConnectionStrings()
{
IConfigurationBuilder builder = new ConfigurationBuilder().AddJsonFile("connectionString.json");
IConfiguration connectionStringConfiguration = builder.Build();
Databases.Clear();
IConfigurationSection loop = connectionStringConfiguration.GetSection("ConnectionStrings");
foreach (var item in loop.GetChildren())
{
string newConnectionString = builder.Build().GetConnectionString(item.Key);
SqlConnectionStringBuilder decoder = new SqlConnectionStringBuilder(newConnectionString);
ConnectionString tempConnectionString = new ConnectionString();
if (item.Key != null && item.Key == settings.StartupDatabase)
{
tempConnectionString.Default = true;
}
tempConnectionString.Database = decoder.InitialCatalog;
tempConnectionString.Identifier = item.Key;
tempConnectionString.Server = decoder.DataSource;
tempConnectionString.Trusted_Connection = decoder.IntegratedSecurity;
Databases.Add(tempConnectionString);
}
}
public async Task GetDatabases()
{
await foreach (var database in _data.GetDatabasesAsync(Model.Server, Model.UserName, Model.Password))
{
Databases.Add(database);
}
}
public async void LoadDatabasesAsync()
{
Databases.Clear();
LoadConnection = true;
Cores.ConnectionCore cc = new Cores.ConnectionCore(connection);
var databases = await Task.Run(() => cc.DataBases());
foreach (var dbName in databases)
{
var db = new Database
{
DatabaseName = dbName,
ParentTreeBase = this,
Tables = new ObservableCollection <Table>()
};
var tables = await Task.Run(() => cc.Tables(dbName));
foreach (var tableName in tables)
{
db.Tables.Add(new Table()
{
TableName = tableName, ParentTreeBase = this, DataBaseName = db.DatabaseName
});
}
Databases.Add(db);
}
if (cc.Errors.Count > 0)
{
Errors = cc.Errors;
}
LoadConnection = false;
}
public void ReloadDatabases()
{
Databases.Clear();
foreach (Database db in _server.Databases)
{
Databases.Add(new DatabaseInfoNew(this, db));
}
}
/// <summary>
/// Adds a database to the collection
/// </summary>
/// <param name="server"></param>
public void AddDatabase(InputDatabase server)
{
var viewModel = new DmsDatabaseServerViewModel(server);
Databases.Add(viewModel);
FilteredDatabases.Add(viewModel);
BuildOrganismsList(Databases);
}
/// <summary>
/// Create collection on active database.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="database"></param>
/// <returns></returns>
public int CreateCollection <T>() where T : class, new()
{
var tableName = Utilities.Shared.AttributeExtension.TableNameAttributeValidate(typeof(T));
ActiveDatabase.CreateCollection(tableName);
Databases.Add(tableName);
return(1);
}
public void Load(string location)
{
if (File.Exists(location))
{
XmlDocument doc = new XmlDocument();
StreamReader sr = new StreamReader(location);
doc.LoadXml(sr.ReadToEnd());
sr.Close();
XmlElement conf = doc.GetElementsByTagName("Configuration")[0] as XmlElement;
if (conf != null)
{
WindowHeight = XmlHelper.GetAttributeInt(conf, "WindowHeight", WindowHeight);
CultureInfo culture = XmlHelper.GetAttributeCulture(conf, "Culture", Thread.CurrentThread.CurrentCulture);
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
ExitMode = XmlHelper.GetAttributeEnum <ExitMode>(conf, "ExitMode", ExitMode);
}
foreach (XmlElement db in doc.GetElementsByTagName("Database"))
{
Database item = new Database(XmlHelper.GetAttributeValue(db, "Location"));
string passwordEncrypted = XmlHelper.GetAttributeValue(db, "Password");
if (passwordEncrypted != null)
{
item.SavePassword = true;
string password;
if (CryptoHelper.Decrypt(passwordEncrypted, ManagerFactory.PasswordCrypto, out password))
{
item.RequiresPassword = true;
item.Password = password;
item.Load();
}
}
Databases.Add(item);
}
Resource.Load("Resources/Resources");
Languages = new List <Language>();
foreach (CultureInfo item in Resources.GetSupportedLocales("Resources/Resources", ManagerFactory.DefaultLocale))
{
Languages.Add(new Language()
{
Name = item.NativeName, Code = item.Name
});
}
}
else
{
Database database = new Database();
database.Name = ManagerFactory.DefaultDatabaseName;
database.Location = Path.Combine(Environment.CurrentDirectory, ManagerFactory.DefaultDatabaseName + ManagerFactory.DatabaseExtension);
Databases.Add(database);
}
}
public void AddDatabase(DbToolDatabase database)
{
if (Databases.Any(d => d.Name.EqualsIgnoreCase(database.Name)))
{
throw new UserException(ExceptionType.DatabaseAlreadyExists, database.Name);
}
Databases.Add(database);
database.Parent = this;
}
public void LoadXml(String xml)
{
XmlDocument xDoc = new XmlDocument();
xDoc.LoadXml(xml);
XmlNode settingsNode = null;
for (int i = 0; i < xDoc.ChildNodes.Count; i++)
{
if (xDoc.ChildNodes[i].Name == "Settings")
{
settingsNode = xDoc.ChildNodes[i];
}
}
if (settingsNode != null)
{
for (int i = 0; i < settingsNode.ChildNodes.Count; i++)
{
XmlNode cNode = settingsNode.ChildNodes[i];
switch (cNode.Name)
{
case "UserRegistration":
bool val = false;
bool.TryParse(cNode.InnerText, out val);
UserRegistration = val;
break;
case "Users":
Users.Clear();
foreach (XmlNode child in cNode.ChildNodes)
{
Users.Add(Data.User.LoadXml(child));
}
break;
case "Databases":
Databases.Clear();
foreach (XmlNode child in cNode.ChildNodes)
{
Databases.Add(Data.Database.LoadXml(child));
}
break;
case "Groups":
Groups.Clear();
foreach (XmlNode child in cNode.ChildNodes)
{
Groups.Add(child.InnerText);
}
break;
}
}
}
}
/// <summary>
/// Sets the current server.
/// </summary>
/// <param name="serverName">Name of the server.</param>
/// <param name="integratedSecurity">if set to <c>true</c> [integrated security].</param>
/// <param name="userName">Name of the user.</param>
/// <param name="password">The password.</param>
public void SetCurrentServer(string serverName, bool integratedSecurity, string userName, string password)
{
var databaseName = "master";
var builder = new SqlConnectionStringBuilder();
builder.DataSource = serverName;
builder.ApplicationName = "Internals Viewer";
builder.InitialCatalog = databaseName;
if (!integratedSecurity)
{
builder.UserID = userName;
builder.Password = password;
}
else
{
builder.IntegratedSecurity = true;
}
ConnectionString = builder.ConnectionString;
using (var conn = new SqlConnection(builder.ConnectionString))
{
conn.Open();
CheckVersion(conn);
CheckSysAdmin(conn);
conn.Close();
}
var databasesDataTable = DataAccess.GetDataTable(CurrentConnection().ConnectionString,
Properties.Resources.SQL_Databases,
"master",
"Databases",
CommandType.Text);
Databases.Clear();
foreach (DataRow r in databasesDataTable.Rows)
{
Databases.Add(new Database(ConnectionString,
(int)r["database_id"],
(string)r["name"],
(byte)r["state"],
(byte)r["compatibility_level"]));
}
currentDatabase = Databases.Find(d => d.Name == databaseName);
}
public Databases Databases()
{
var query = "select name from sys.databases where database_id > 4;";
var results = session.Query(query);
var databases = new Databases();
foreach (var row in results.Rows)
{
databases.Add((string)row[0]);
}
return(databases);
}
private void AddDatabase(PcDatabase db)
{
// In reallity use the factory pattern to resolve the depencency of the ViewModel and assing the
// database to it
var viewModel = new DatabaseViewModel(eventAggregator)
{
Database = db
};
// Register to the close command of all TabItem ViewModels, so we can close then all with a single command
CloseAllCommand.RegisterCommand(viewModel.CloseCommand);
Databases.Add(viewModel);
}
void LoadDatabases(System.Action continueWith = null)
{
Databases.Clear();
Databases.Add(NewDbSource);
_asyncWorker.Start(() => GetDatabases().OrderBy(r => r.ResourceName), databases =>
{
foreach (var database in databases)
{
Databases.Add(database);
}
continueWith?.Invoke();
});
}
public DatabaseCollection(TreeView tv)
{
base.useNamespaces = true;
this.Databases = new List <DatabaseElement>();
this.Queries = new List <QueryElement>();
foreach (TreeNode node in tv.Nodes)
{
System.Windows.Forms.MessageBox.Show(node.Tag.ToString());
if (node.Tag is DatabaseCollection)
{
TreeNode[] nodes = tv.Nodes.Find(ref_asm_node, true);
bool hasit = nodes.Length > 0;
Global.statR("DC");
if (hasit)
{
MessageBox.Show("we have assembly entries");
TreeNode found = nodes[0];
}
DatabaseCollection dc = node.Tag as DatabaseCollection;
Global.statR("we're moving past the continue statement at DatabaseCollection level");
foreach (TreeNode node1 in node.Nodes)
{
if (node1.Tag is DatabaseElement)
{
Databases.Add(new DatabaseElement(node1));
}
else
if (node1.Tag == (queryContainer))
{
foreach (TreeNode qnode in node1.Nodes)
{
QueryElement element = QueryElement.FromNode(qnode);
Queries.Add(element);
}
}
else
if (node1.Tag is QueryElement)
{
Queries.Add(QueryElement.FromNode(node1));
}
#if ASMREF
else if (node1.Tag is ReferenceAssemblyCollection)
{
Assemblies = node1.Tag as ReferenceAssemblyCollection;
}
#endif
}
}
}
}
private void LoadDatabases(IEnumerable <DataBaseModel> databases)
{
int counter = 0;
foreach (DataBaseModel item in databases)
{
item.ConnectionModel = SourceConnection;
Databases.Add(item);
if (counter % 3 == 0)
{
System.Windows.Forms.Application.DoEvents();
}
counter++;
}
}
public void FromXml(XmlNode node)
{
Name = node.Attributes["name"].Value.ToString();
XmlNodeList list = node.SelectNodes("databases/database");
foreach (XmlNode dbnode in list)
{
QDatabase db = new QDatabase(Parent.EnvType, Name);
db.Deserialize(dbnode);
if (!Databases.Any(D => D.FullName == db.FullName))
{
Databases.Add(db);
}
}
}
public IDatabase Add(string name)
{
if (Databases.Where(db => db.Name == name).Count() != 0)
{
throw new Exception("A database with the same name already exists");
}
try {
IDatabase newdb = new DataBase(NameToFile(name));
Log.Information("Creating new database " + newdb.Name);
Databases.Add(newdb);
return(newdb);
} catch (Exception ex) {
Log.Exception(ex);
return(null);
}
}
public void LoadDatabase(string[] files)
{
if (files != null && files.Length > 0)
{
foreach (var item in files)
{
SqliteInfo sqliteInfo = ParseInfo(item);
if (sqliteInfo != null && !Databases.Contains(sqliteInfo))
{
Databases.Add(sqliteInfo);
}
}
}
JoinInfo();
Search();
}
public void GetTables()
{
try
{
string BaseDirectoryPath = AppDomain.CurrentDomain.BaseDirectory;
string path = BaseDirectoryPath + "plugs\\BackUpTables.json";
string jsonData = File.ReadAllText(path);
BackUpConfig = JsonConvert.DeserializeObject <BackUpConfig>(jsonData);
if (BackUpConfig.TablesConfig == null)
{
BackUpConfig.TablesConfig = new List <TablesConfig>()
{
};
}
TaskBackUpPath = BackUpConfig.SavePath;//文件保存路径
EnvironmentInfo.TaskBackUpPath = BackUpConfig.SavePath;
if (!Directory.Exists(TaskBackUpPath))
{
Directory.CreateDirectory(TaskBackUpPath);
}
MySqlBinPath = BaseDirectoryPath;//如果不是在服务器上，那么可能无法获取到mysqldump文件
#region 获取当前数据库服务器下的所有非系统数据库
string sql = $"SHOW DATABASES WHERE `Database` NOT IN ('mysql', 'performance_schema', 'information_schema', 'sys');";
DataTable dt = MySqlHelper.ExecuteDataset(EnvironmentInfo.ConnectionString, sql).Tables[0];
foreach (DataRow dr in dt.Rows)
{
BackUpDatabase database = new BackUpDatabase()
{
DatabaseName = dr["DATABASE"].ToString()
};
Databases.Add(database);
//默认选中2.x数据库，触发选中事件，展示左侧数据库表
if (dr["DATABASE"].ToString() == EnvironmentInfo.DbConnEntity.DbName)
{
SetTables(database.DatabaseName);
}
}
#endregion
}
catch (Exception ex)
{
ShowMessage(ex.ToString());
}
}
public void SetActiveByName(string name)
{
foreach (DataBase db in Databases)
{
if (db.Name == name)
{
Log.Information("Selecting active database " + db.Name);
ActiveDB = db;
return;
}
}
DataBase newdb = new DataBase(NameToFile(name));
Log.Information("Creating new database " + newdb.Name);
Databases.Add(newdb);
ActiveDB = newdb;
}
private void mnuAddDatabase_Click(object sender, RoutedEventArgs e)
{
ConnectionWizardWindow connectionWizardWindow = new ConnectionWizardWindow();
connectionWizardWindow.Owner = Application.Current.MainWindow;
connectionWizardWindow.ShowDialog();
if (connectionWizardWindow.DialogResult.Value)
{
connectionWizardWindow.SelectedDatabase.LoadDatabase();
if (Databases.FirstOrDefault(database => database.ConnectionString == connectionWizardWindow.SelectedDatabase.ConnectionString) == null)
{
Databases.Add(connectionWizardWindow.SelectedDatabase);
}
}
}
public void OpenDatabase(string path)
{
if (Databases.FirstOrDefault(a => a.Location == path) != null)
{
return;
}
if (!File.Exists(path))
{
MessageBox.Show(
"Cannot open database, file not found.",
"File not found",
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
string password = null;
if (DatabaseReference.IsDbPasswordProtected(path))
{
if (InputBoxWindow.ShowDialog("Database is password protected, enter password:"******"Database password.", "", out password) != true)
{
return;
}
}
if (PathDefinitions.RecentFiles.Contains(path))
{
PathDefinitions.RecentFiles.Remove(path);
}
PathDefinitions.RecentFiles.Insert(0, path);
try
{
Databases.Add(new DatabaseReference(path, password));
}
catch (Exception e)
{
MessageBox.Show("Failed to open database:" + Environment.NewLine + e.Message, "Database Error", MessageBoxButton.OK, MessageBoxImage.Error);
logger.Error(e, "Failed to process update: ");
return;
}
}
/// <summary>
/// Add database to generator queue.
/// </summary>
public void AddDatabase(Database database)
{
// Validate.
if (database == null)
{
throw new ArgumentNullException(nameof(database), "Database object can not be null.");
}
// Validate duplicate database.
if (this.Databases.Where(x => x.ConnectionString == database.ConnectionString).Any())
{
throw new EntityWorksGeneratorException(string.Format("Unable to add database model. " +
"Database model with identical connection string already exists. Connection string: '{0}'. " +
"Please check your entity works generator configuration.", database.ConnectionString));
}
// Set database.
Databases.Add(database);
}
/// <summary>
/// Sets up the system
/// </summary>
/// <param name="AssemblyUsing">Assembly to set up</param>
private void Setup(Assembly AssemblyUsing)
{
if (Databases == null)
{
Databases = new System.Collections.Generic.List <IDatabase>();
}
IEnumerable <Type> Types = AssemblyUsing.Types(typeof(IDatabase));
foreach (Type Type in Types)
{
IDatabase TempObject = (IDatabase)Activator.CreateInstance(Type);
if (!string.IsNullOrEmpty(TempObject.ConnectionString))
{
SQLHelper.Database(TempObject.ConnectionString, TempObject.Name);
Databases.Add(TempObject);
}
}
Manager = new Reflection.AOP.AOPManager();
}
/// <summary>
/// Returns an <see cref="AppDatabase"/> instance unique to the current calling thread.
/// <para>If no <see cref="AppDatabase"/> exist yet for the current thread, a new instance will be created.</para>
/// </summary>
/// <seealso cref="DisposeDatabases"/>
public static AppDatabase GetDatabase()
{
// Lock the databases property to prevent conflicts from the DisposeDatabases method
lock (Databases)
{
// Get the id of the thread that called this method
var threadId = Thread.CurrentThread.ManagedThreadId;
// Create a new AppDatabase if it doesn't exist yet
if (!Databases.ContainsKey(threadId))
{
Databases.Add(threadId, new AppDatabase());
Program.Log.Fine($"Opened connection to '{Databases[threadId].Connection.DataSource}'.");
}
// Return an AppDatabase from the cache
return(Databases[threadId]);
}
}
