private void Initialize()
{
var connStrBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder
{
DataSource = @"dev13-don\SANDBOX",
InitialCatalog = "NHHierarchy",
IntegratedSecurity = true
};
// Chonfigure NH
Config = new NHibernateConfig(connStrBuilder.ConnectionString);
// Create database structure
Config.UpdateDatabase(true);
// Create test entries
using (var s = Config.SessionFactory.OpenSession())
{
using (var tr = s.BeginTransaction())
{
PopulateData(s);
tr.Commit();
}
}
}
public TeenDataHelper()
{
StringBuilder sb = new StringBuilder();
string ModelPath = "Entity.TeenData.TeensDB";
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.ApplicationName = "EntityFrameWork";
csb.InitialCatalog = "TeenData";
csb.Password = Password;
csb.UserID = UserName;
csb.IntegratedSecurity = false;
csb.DataSource = ServerAddress;
sb.Append("metadata=");
sb.Append("res://*/"); sb.Append(ModelPath); sb.Append(".csdl|");
sb.Append("res://*/"); sb.Append(ModelPath); sb.Append(".ssdl|");
sb.Append("res://*/"); sb.Append(ModelPath); sb.Append(".msl;");
sb.Append("provider=System.Data.SqlClient;");
sb.Append("provider connection string=\"");
sb.Append(csb.ToString());
sb.Append(";MultipleActiveResultSets=True;");
sb.Append("App=EntityFramework\"");
EntityConnStr = sb.ToString();
}
private void test_connection_btn_Click(object sender, EventArgs e)
{
var bldr = new System.Data.SqlClient.SqlConnectionStringBuilder();
bldr.DataSource = serverTextBox.Text;
bldr.InitialCatalog = dbNameTextBox.Text;
bldr.IntegratedSecurity = windows_auth_cb.Checked;
if (sql_auth_cb.Checked)
{
bldr.UserID = username_tb.Text;
bldr.Password = password_tb.Text;
}
bldr.ConnectTimeout = 5;
var conn = new System.Data.SqlClient.SqlConnection(bldr.ConnectionString);
var success = false;
try
{
conn.Open();
var cmd = conn.CreateCommand();
cmd.CommandText = "select 1";
cmd.ExecuteScalar();
success = true;
}
catch (Exception ex)
{
MessageBox.Show("Test connection failed because of an error in initializing provider. " + ex.Message,
"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
if (success)
{
MessageBox.Show("Test connection succeeded.", "CutOptima",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
/// <summary>
/// 恢复自动选择的服务器地址
/// </summary>
public static void DeselectAutomaticServer()
{
if (s_changetoAutomaticNames.Count == 0)
return;
try
{
foreach (ConnectionStringSettings i in ConfigurationManager.ConnectionStrings)
{
try
{
if (s_changetoAutomaticNames.Contains(i.Name))
{
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.ConnectionString = i.ConnectionString;
builder.DataSource = s_defaultServer;
ChangeConnectionString(i.Name, builder.ConnectionString, i.ProviderName);
s_changetoAutomaticNames.Remove(i.Name);
}
}
catch (Exception)
{
}
}
}
catch (Exception ex)
{
ExceptionProcess.ProcessWithResume(ex);
}
}
public static string GetConnectionString()
{
if (fac is System.Data.SqlClient.SqlClientFactory)
{
System.Data.SqlClient.SqlConnectionStringBuilder sb = new System.Data.SqlClient.SqlConnectionStringBuilder();
sb.DataSource = Environment.MachineName;
sb.InitialCatalog = "COR_Basic_Demo";
sb.DataSource = "CORDB2014";
sb.InitialCatalog = "COR_Basic_Post";
sb.IntegratedSecurity = true;
sb.MultipleActiveResultSets = true;
sb.PersistSecurityInfo = false;
sb.Pooling = true;
sb.PacketSize = 4096;
sb.ApplicationName = "ODataTest";
return sb.ConnectionString;
}
Npgsql.NpgsqlConnectionStringBuilder csb = new Npgsql.NpgsqlConnectionStringBuilder();
csb.Host = "127.0.0.1";
csb.Port = 5432;
csb.Database = "blogz";
// csb.IntegratedSecurity = false;
// CREATE ROLE alibaba LOGIN PASSWORD 'OpenSesame' SUPERUSER INHERIT CREATEDB CREATEROLE REPLICATION;
csb.UserName = "******";
csb.Password = "******";
csb.CommandTimeout = 300;
csb.ApplicationName = "ODataTest";
return csb.ConnectionString;
}
public static System.Data.DataTable GetDataTable(string strSQL)
{
System.Data.DataTable dt = new System.Data.DataTable();
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.DataSource = System.Environment.MachineName;
csb.DataSource = @"VMSTZHDB08\SZH_DBH_1";
csb.InitialCatalog = "HBD_CAFM_V3";
csb.DataSource = "CORDB2008R2";
csb.InitialCatalog = "Roomplanning";
// csb.DataSource = "cordb2014";
// csb.InitialCatalog = "ReportServer";
csb.DataSource = @"CORDB2008R2";
csb.InitialCatalog = "COR_Basic_SwissLife";
csb.IntegratedSecurity = true;
using (System.Data.Common.DbDataAdapter da = new System.Data.SqlClient.SqlDataAdapter(strSQL, csb.ConnectionString))
{
da.Fill(dt);
}
return dt;
}
public static void ExecuteNonQuery(string strSQL)
{
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.DataSource = System.Environment.MachineName;
csb.InitialCatalog = "TestDB";
csb.IntegratedSecurity = true;
string conString = csb.ConnectionString;
using (System.Data.IDbConnection con = new System.Data.SqlClient.SqlConnection(conString))
{
using (System.Data.IDbCommand cmd = con.CreateCommand())
{
cmd.CommandText = strSQL;
if (cmd.Connection.State != System.Data.ConnectionState.Open)
cmd.Connection.Open();
cmd.ExecuteNonQuery();
if (cmd.Connection.State != System.Data.ConnectionState.Closed)
cmd.Connection.Close();
} // End Using cmd
} // End Using con
}
private void Initialize(string connectionString, bool useCache, string FileName)
{
ConnectionBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder(connectionString);
this.UseCache = useCache;
this.MetadataKey = ConnectionBuilder.ConnectionString.GetHashCode().ToString();
this.FileName = FileName;
}
public static string GetEnityConnectionString(string providerConnectionString, string entityType, string directory)
{
System.Data.SqlClient.SqlConnectionStringBuilder scsb = new System.Data.SqlClient.SqlConnectionStringBuilder(providerConnectionString);
EntityConnectionStringBuilder ecb = new EntityConnectionStringBuilder();
ecb.Metadata = string.Format(@"metadata={0}\{1}.csdl|{0}\{1}.ssdl|{0}\{1}.msl", directory, entityType);
ecb.Provider = "System.Data.SqlClient";
ecb.ProviderConnectionString = scsb.ConnectionString;
return ecb.ConnectionString;
}
public static string GetEnityConnectionString(string providerConnectionString, string metadata)
{
System.Data.SqlClient.SqlConnectionStringBuilder scsb = new System.Data.SqlClient.SqlConnectionStringBuilder(providerConnectionString);
EntityConnectionStringBuilder ecb = new EntityConnectionStringBuilder();
ecb.Metadata = metadata;
ecb.Provider = "System.Data.SqlClient";
ecb.ProviderConnectionString = scsb.ConnectionString;
return ecb.ConnectionString;
}
public static string GetConnectionString()
{
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.DataSource = System.Environment.MachineName;
csb.InitialCatalog = "RoomPlanning";
csb.IntegratedSecurity = true;
return csb.ConnectionString;
}
private static string Construct(string username, string password)
{
var builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.DataSource = CloudConfigurationManager.GetSetting("MS.DHC.Data.Server");
builder.InitialCatalog = CloudConfigurationManager.GetSetting("MS.DHC.Data.Database");
builder.UserID = username;
builder.Password = password;
return builder.ConnectionString;
}
public static string GetEnityConnectionString(string providerConnectionString, string entityType, string assembly, string nameSpace)
{
if (string.IsNullOrWhiteSpace(assembly))
assembly = "*";
if (string.IsNullOrWhiteSpace(nameSpace))
nameSpace = "Models";
System.Data.SqlClient.SqlConnectionStringBuilder scsb = new System.Data.SqlClient.SqlConnectionStringBuilder(providerConnectionString);
EntityConnectionStringBuilder ecb = new EntityConnectionStringBuilder();
ecb.Metadata = string.Format(@"res://{0}/{1}.{2}.csdl|res://{0}/{1}.{2}.ssdl|res://{0}/{1}.{2}.msl", assembly, nameSpace, entityType);
ecb.Provider = "System.Data.SqlClient";
ecb.ProviderConnectionString = scsb.ConnectionString;
return ecb.ConnectionString;
}
public GeneratedArchiveDatabaseReportForm(WindowInfo windowInfo)
{
this.Name = windowInfo.Name;
this.Text = windowInfo.Text;
IList<WindowTabInfo> tabInfos = ADInfoBll.Instance.GetWindowTabInfosByWindowId(windowInfo.Name);
if (tabInfos == null)
{
throw new ArgumentException("there is no windowTab with windowId of " + windowInfo.Name);
}
if (tabInfos.Count == 0)
{
throw new ArgumentException("There should be at least one TabInfo in WindowInfo with name is " + windowInfo.Name + "!");
}
if (tabInfos.Count > 1)
{
throw new ArgumentException("There should be at most one TabInfo in WindowInfo with name is " + windowInfo.Name + "!");
}
ISearchManager smMaster = ServiceProvider.GetService<IManagerFactory>().GenerateSearchManager(tabInfos[0], null);
IDisplayManager dmMaster = ServiceProvider.GetService<IManagerFactory>().GenerateDisplayManager(tabInfos[0], smMaster);
smMaster.DataLoading += new EventHandler<DataLoadingEventArgs>(smMaster_DataLoading);
ReportInfo reportInfo = ADInfoBll.Instance.GetReportInfo(windowInfo.Name);
CrystalDecisions.CrystalReports.Engine.ReportDocument reportDocument = ReportHelper.CreateReportDocument(reportInfo.ReportDocument);
this.ReportViewer.CrystalHelper.ReportSource = reportDocument;
// Now only support Sql
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings[SecurityHelper.DataConnectionStringName].ConnectionString;
this.ReportViewer.CrystalHelper.ServerName = builder.DataSource;
this.ReportViewer.CrystalHelper.DatabaseName = builder.InitialCatalog;
this.ReportViewer.CrystalHelper.UserId = builder.UserID;
this.ReportViewer.CrystalHelper.Password = builder.Password;
this.ReportViewer.CrystalHelper.IntegratedSecurity = builder.IntegratedSecurity;
GeneratedArchiveSeeForm.InitializeWindowProcess(windowInfo, this);
ArchiveSearchForm searchForm = null;
this.SetSearchPanel(() =>
{
if (searchForm == null)
{
searchForm = new ArchiveSearchForm(this, smMaster, tabInfos[0]);
}
return searchForm;
});
}
public VFSModelPersister(string serverName, string databaseName, string userName, string password)
{
var connStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder()
{
DataSource = serverName,
InitialCatalog = databaseName,
UserID = userName,
Password = password
};
dbConnectionString = connStringBuilder.ToString();
OpenDbConnection();
CloseConnection();
}
/// <summary>
/// GetServerDatabaseName
/// </summary>
/// <returns></returns>
public static string GetServerDatabaseName(string connectionString)
{
string serverName = string.Empty;
string dbName = string.Empty;
try
{
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.ConnectionString = connectionString;
serverName = builder.DataSource;
dbName = builder.InitialCatalog;
}
catch (Exception)
{
}
return serverName + ";" + dbName;
}
public static System.Data.DataTable GetDataTable(string strSQL)
{
System.Data.DataTable dt = new System.Data.DataTable();
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.DataSource = System.Environment.MachineName;
csb.DataSource = @"VMSTZHDB08\SZH_DBH_1";
csb.InitialCatalog = "HBD_CAFM_V3";
csb.IntegratedSecurity = true;
using (System.Data.Common.DbDataAdapter da = new System.Data.SqlClient.SqlDataAdapter(strSQL, csb.ConnectionString))
{
da.Fill(dt);
}
return dt;
}
/// <summary>
/// Get Server Name from .config
/// </summary>
/// <returns></returns>
public static string GetServerName(string connectionString)
{
string serverName = null;
try
{
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.ConnectionString = connectionString;
serverName = builder.DataSource;
int idx = serverName.IndexOf(',');
if (idx != -1)
{
serverName = serverName.Substring(0, idx);
}
serverName = serverName.Trim();
}
catch (Exception)
{
}
return serverName;
}
} // End Function GetConnectionString
public static string GetEntityConnectionString()
{
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder(GetConnectionString());
System.Data.EntityClient.EntityConnectionStringBuilder ecb = new System.Data.EntityClient.EntityConnectionStringBuilder();
// http://itstu.blogspot.ch/2008/07/to-load-specified-metadata-resource.html
// The standard metadata string looks like this:
// metadata=res://*/Model.csdl|res://*/Model.ssdl|res://*/Model.msl
// However, in some (including mine) Entity Framework get confused and does not know which dll to look in.
// Therefore, change the metadata string to:
// metadata=res://nameOfDll/Model.csdl|res://nameOfDll/Model.ssdl|res://nameOfDll/Model.msl
string ass = System.IO.Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetExecutingAssembly().Location);
ecb.Metadata = @"res://*/COR_Basic_Demo.csdl|res://*/COR_Basic_Demo.ssdl|res://*/COR_Basic_Demo.msl".Replace("*", ass);
ecb.Provider = "System.Data.SqlClient";
ecb.ProviderConnectionString = csb.ConnectionString;
return(ecb.ConnectionString);
} // End Function GetEntityConnectionString
private void RestoreDatabase(string filename)
{
string path = Path.Combine(Server.MapPath("~"), ConfigurationManager.AppSettings["BackupFolder"]);
string filePath = Path.Combine(path, filename);
BackupDB("-" + RandomGenerator.GenerateRandomText(5));
var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder(connectionString);
string database = builder.InitialCatalog;
builder.InitialCatalog = "master";
builder.ConnectTimeout = 10;
var service = new BackupService(builder.ConnectionString, path);
if (System.IO.File.Exists(filePath))
{
service.RestoreDatabase(database, filePath);
}
}
private void BApplyClick(object sender, EventArgs e)
{
if (this.tbConfPass.Text == this.tbPass.Text)
{
Properties.Settings.Default.Port = Convert.ToInt32(this.nudPort.Value);
var builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder["Data Source"] = this.tbDataSource.Text;
////builder["Integrated Security"] = true;
builder["Initial Catalog"] = this.tbInitCat.Text;
builder["User ID"] = this.tbUser.Text;
builder["Password"] = this.tbPass.Text;
////Properties.Settings.Default.String1 = Crypto.Crypto1.encStrDef(builder.ConnectionString);
Properties.Settings.Default.Save();
}
else
{
MessageBox.Show(@"DB Connection: passwords do not match");
}
}
bool TestSQLServer(string server, string port, string database, string userID, string password, int connectionTimeout)
{
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.DataSource = server + (string.IsNullOrWhiteSpace(port) ? string.Empty : ", " + port);
builder.InitialCatalog = database;
builder.ConnectTimeout = connectionTimeout;
if (!string.IsNullOrWhiteSpace(userID))
{
builder.UserID = userID;
builder.Password = password;
}
else
{
builder.IntegratedSecurity = true;
}
using (var conn = new System.Data.SqlClient.SqlConnection(builder.ToString()))
{
return(TestConnection(conn));
}
}
public static QueryComposer.Adapters.SummaryQuery.PrevalenceModelAdapter CreatePrevSummaryModelAdapterAdapter(string connectionString)
{
var connectionStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder(connectionString);
var adapterSettings = new Dictionary <string, object>()
{
{ "Server", connectionStringBuilder.DataSource },
{ "UserID", connectionStringBuilder.UserID },
{ "Password", connectionStringBuilder.Password },
{ "Database", connectionStringBuilder.InitialCatalog },
{ "DataProvider", Lpp.Dns.DataMart.Model.Settings.SQLProvider.SQLServer.ToString() }
};
var adapter = new QueryComposer.Adapters.SummaryQuery.PrevalenceModelAdapter(new RequestMetadata
{
CreatedOn = DateTime.UtcNow,
MSRequestID = "Unit Test Request"
});
adapter.Initialize(adapterSettings, Guid.NewGuid().ToString("D"));
return(adapter);
}
/// <summary>
/// 把nbzsServer设置到自动选择的服务器地址上
/// </summary>
public static void SelectAutomaticServer()
{
s_changetoAutomaticNames.Clear();
try
{
string selectedServer = null;
foreach (ConnectionStringSettings i in ConfigurationManager.ConnectionStrings)
{
try
{
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.ConnectionString = i.ConnectionString;
if (builder.DataSource == s_defaultServer)
{
if (string.IsNullOrEmpty(selectedServer))
{
selectedServer = GetAutomaticServer();
if (string.IsNullOrEmpty(selectedServer))
{
return;
}
}
builder.DataSource = selectedServer + ", 8033";
ChangeConnectionString(i.Name, builder.ConnectionString, i.ProviderName);
s_changetoAutomaticNames.Add(i.Name);
}
}
catch (Exception)
{
}
}
}
catch (Exception ex)
{
ExceptionProcess.ProcessWithResume(ex);
}
}
void xmlKaydet(System.Data.SqlClient.SqlConnectionStringBuilder bld)
{
XmlDocument doc = new XmlDocument();
//doc.Load("Aresv2.exe.config");
doc.Load(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
foreach (XmlElement xElement in doc.DocumentElement)
{
if (xElement.Name == "connectionStrings")
{
//setting the coonection string
xElement.FirstChild.Attributes[1].Value = bld.ConnectionString;
}
}
//writing the connection string in config file
//XmlDocument doc = new XmlDocument();
//doc.Load("Aresv2.exe.config");
using (XmlNodeList nl = doc.SelectNodes("/configuration/userSettings/Aresv2.Properties.Settings/setting/value"))
nl[2].InnerText = ceGelistiriciModu.Checked.ToString(); // Geliştirici Modu
using (XmlNodeList nl = doc.SelectNodes("/configuration/userSettings/Aresv2.Properties.Settings/setting/value"))
{
nl[0].InnerText = txtKullaniciAdi.Text;
nl[1].InnerText = txtKullaniciSifre.Text;
}
//doc.Save("Aresv2.exe.config");
Aresv2.Properties.Settings.Default.KullaniciAdi = txtKullaniciAdi.EditValue.ToString();
Aresv2.Properties.Settings.Default.KullaniciSifresi = txtKullaniciSifre.EditValue.ToString();
//SqlConnections.BaglantiyiKapat();
doc.Save(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
MessageBox.Show("Kapatıp yeniden açman lazım hamısına");
}
/// <summary>
/// Click event for Test button
/// </summary>
/// <param name="sender">sender</param>
/// <param name="e">e</param>
protected override void btnTest_Click(object sender, EventArgs e)
{
string database = this.cmbServerName.Text;
Epi.Data.SqlServer.SqlDatabase db = new SqlDatabase();
//db.ConnectionString = this.DbConnectionStringBuilder.ToString();
dbConnectionStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder();
dbConnectionStringBuilder.DataSource = cmbServerName.Text;
dbConnectionStringBuilder.InitialCatalog = cmbDatabaseName.Text;
dbConnectionStringBuilder.UserID = txtUserName.Text;
if (rdbWindowsAuthentication.Checked)
{
dbConnectionStringBuilder.IntegratedSecurity = true;
}
else
{
dbConnectionStringBuilder.UserID = txtUserName.Text;
dbConnectionStringBuilder.Password = txtPassword.Text;
}
db.ConnectionString = this.DbConnectionStringBuilder.ToString();
try
{
if (db.TestConnection())
{
MessageBox.Show("Connection OK!"); // TODO: hard coded string.
}
else
{
MessageBox.Show("Connection failed."); // TODO: hard coded string.
}
}
catch (Exception ex)
{
MessageBox.Show("Connection failed: " + ex.Message); // TODO: hard coded string
}
}
public string getDataBase()
{
String dbname = "";
try
{
string connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["ASIS_PRODEntities"].ConnectionString;
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"(?<=\bconnection string="")[^""]*");
System.Text.RegularExpressions.Match match = regex.Match(connectionString);
string title = match.Value;
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder(title);
dbname = builder.InitialCatalog;
}
catch (Exception)
{
dbname = "";
}
return(dbname);
}
public static System.Data.Common.DbConnection GetConnection()
{
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.DataSource = "DESKTOP-4P9UFE8";
csb.InitialCatalog = "GeoData";
csb.IntegratedSecurity = true;
if (!csb.IntegratedSecurity)
{
csb.UserID = "GeoDataWebServices";
csb.Password = "******";
}
if (System.StringComparer.OrdinalIgnoreCase.Equals(System.Environment.UserDomainName, "COR"))
{
csb.DataSource = "COR-W81-101";
}
return(new System.Data.SqlClient.SqlConnection(csb.ConnectionString));
}
private static string GetConnectionString()
{
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.DataSource = TestPlotly.SecretManager.GetSecret <string>("DataSource");
csb.InitialCatalog = "Redmine";
csb.UserID = TestPlotly.SecretManager.GetSecret <string>("DefaultDbUser");
csb.Password = TestPlotly.SecretManager.GetSecret <string>("DefaultDbPassword");
csb.PacketSize = 4096;
csb.PersistSecurityInfo = false;
csb.ApplicationName = "BlueMine";
csb.ConnectTimeout = 15;
csb.Pooling = true;
csb.MinPoolSize = 1;
csb.MaxPoolSize = 100;
csb.MultipleActiveResultSets = false;
csb.WorkstationID = System.Environment.MachineName;
return(csb.ConnectionString);
}
private string MakeConnectionString()
{
var conn = new System.Data.SqlClient.SqlConnectionStringBuilder
{
DataSource = this.Server,
InitialCatalog = this.DBName
};
var cred = new [] {
new[] { this.AdminName, this.AdminPassword },
new[] { this.LoginName, this.LoginPassword }
}
.Where(s => !string.IsNullOrEmpty(s[0]) && !string.IsNullOrEmpty(s[1]))
.FirstOrDefault();
conn.IntegratedSecurity = cred == null;
if (cred != null)
{
conn.UserID = cred[0];
conn.Password = cred[1];
}
return(conn.ConnectionString);
}
public static string GetConnectionString()
{
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.DataSource = System.Environment.MachineName;
if (System.StringComparer.OrdinalIgnoreCase.Equals("COR", System.Environment.UserDomainName))
{
csb.DataSource += @"\SqlExpress";
}
csb.InitialCatalog = "COR_Basic_Demo_V4";
csb.InitialCatalog = "SwissRe_Test_V4";
csb.IntegratedSecurity = System.StringComparer.OrdinalIgnoreCase.Equals(System.Environment.UserDomainName, "COR");
if (!csb.IntegratedSecurity)
{
csb.UserID = SecretManager.GetSecret <string>("DefaultDbUser");
csb.Password = SecretManager.GetSecret <string>("DefaultDbPassword");
}
return(csb.ToString());
}
/// <summary>
/// Form loaded, populate the controls
/// </summary>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
try
{
// Parse the string
this.ConnectionStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder(this.ConnectionString);
}
catch (Exception Ex)
{
// If error, say it, and clear the connection string
MessageBox.Show(Ex.Message);
this.ConnectionStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder();
}
// Set the controls
this.DataSourceComboBox.Text = this.ConnectionStringBuilder.DataSource;
this.integratedSecurityCheckBox.Checked = this.ConnectionStringBuilder.IntegratedSecurity;
this.userIDTextBox.Text = this.ConnectionStringBuilder.UserID;
this.passwordTextBox.Text = this.ConnectionStringBuilder.Password;
this.SavePwCheckBox.Checked = this.ConnectionStringBuilder.PersistSecurityInfo;
this.CatalogTextBox.Text = this.ConnectionStringBuilder.InitialCatalog;
}
/// <summary>
/// Determines whether the application is running under Temp database mode.
/// </summary>
public static bool IsActive()
{
if (isActive.HasValue)
{
return(isActive.Value);
}
var connectionString = Config.GetConnectionString("AppDatabase");
if (connectionString.IsEmpty())
{
isActive = false;
return(false);
}
var db = new System.Data.SqlClient.SqlConnectionStringBuilder(connectionString).InitialCatalog
.ToLowerOrEmpty().TrimStart("[").TrimEnd("]").Trim('`');
isActive = db.EndsWith(".temp");
return(isActive.Value);
}
public void Run()
{
ThreadPool.QueueUserWorkItem((o) =>
{
Console.WriteLine("Webserver running...");
try
{
while (_listener.IsListening)
{
ThreadPool.QueueUserWorkItem(async (c) =>
{
var ctx = c as HttpListenerContext;
try
{
await _responderMethod(ctx.Request, new Progress<string>(rstr =>
{
byte[] buf = Encoding.UTF8.GetBytes(rstr);
ctx.Response.ContentLength64 = buf.Length;
ctx.Response.OutputStream.Write(buf, 0, buf.Length);
});
System.Diagnostics.Trace.Write(ctx.Request.QueryString);
//ctx.Request.QueryString
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
}
catch (Exception error)
{
string ttt = error.ToString();
} // suppress any exceptions
finally
{
// always close the stream
ctx.Response.OutputStream.Close();
}
}, _listener.GetContext());
}
}
catch { } // suppress any exceptions
});
}
/// <summary>
/// Get Server Name from .config
/// </summary>
/// <returns></returns>
public static string GetServerName(string connectionString)
{
string serverName = null;
try
{
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.ConnectionString = connectionString;
serverName = builder.DataSource;
int idx = serverName.IndexOf(',');
if (idx != -1)
{
serverName = serverName.Substring(0, idx);
}
serverName = serverName.Trim();
}
catch (Exception)
{
}
return(serverName);
}
public void Read(string cprNumber, string connectionString)
{
// Create data provider
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder(connectionString);
E_MDataProvider emProvider = new E_MDataProvider();
emProvider.ConfigurationProperties = new Dictionary <string, string>();
foreach (var configurationKey in emProvider.ConfigurationKeys)
{
if (builder.ContainsKey(configurationKey.Name))
{
emProvider.ConfigurationProperties[configurationKey.Name] = builder[configurationKey.Name].ToString();
}
}
QualityLevel?ql;
var registration = emProvider.Read(new CprBroker.Schemas.PersonIdentifier()
{
CprNumber = cprNumber
}, null, (cpr) => Guid.NewGuid(), out ql);
Assert.NotNull(registration);
}
public void CmdAddDatabase(IWin32Window owner)
{
/*
* Можно использовать стандартное окно для формирования строки подключения
*
* Сохранить полученную строку подключения в списке строк подключения
* Отобразить новую строку подключения в окне выбора строк подключения
*/
// TODO: Change dialog caption from New Database to Locate Database
AddDatabaseForm dialog = new AddDatabaseForm();
if (dialog.ShowDialog(owner) != DialogResult.OK)
{
return;
}
var builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.DataSource = dialog.Server;
builder.InitialCatalog = dialog.DbLocation;
AddDatabase(builder.ConnectionString);
}
/// <summary>
/// Pega a string de conecão
/// </summary>
/// <returns>Um string</returns>
internal string GetConnString()
{
if (ConnectionParameter.IsHostedEnvironment && ConnectionParameter.TrustedConnection)
{
return(string.Format(@"
server={0};
Initial Catalog={1};
MultipleActiveResultSets=false;Trusted_Connection=Yes;",
ConnectionParameter.Server,
ConnectionParameter.CompanyDb));
}
else if (ConnectionParameter.IsHostedEnvironment &&
!ConnectionParameter.TrustedConnection)
{
var sqlConnStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder();
sqlConnStringBuilder.DataSource = ConnectionParameter.Server;
sqlConnStringBuilder.UserID = ConnectionParameter.DBUser;
sqlConnStringBuilder.Password = ConnectionParameter.DBPassword;
sqlConnStringBuilder.InitialCatalog = ConnectionParameter.CompanyDb;
sqlConnStringBuilder.ConnectTimeout = ConnectionParameter.ConnectionTimeout;
return(sqlConnStringBuilder.ToString());
}
else
{
var sqlConnStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder();
sqlConnStringBuilder.DataSource = ConnectionParameter.Server;
sqlConnStringBuilder.UserID = ConnectionParameter.DBUser;
sqlConnStringBuilder.Password = ConnectionParameter.DBPassword;
sqlConnStringBuilder.InitialCatalog = ConnectionParameter.Database;
sqlConnStringBuilder.ConnectTimeout = ConnectionParameter.ConnectionTimeout == 0
? 15
: ConnectionParameter.ConnectionTimeout;
return(sqlConnStringBuilder.ToString());
}
}
/// <summary>
/// Click event for Test button
/// </summary>
/// <param name="sender">sender</param>
/// <param name="e">e</param>
protected override void btnTest_Click(object sender, EventArgs e)
{
string database = this.cmbServerName.Text;
Epi.Data.SqlServer.SqlDatabase db = new SqlDatabase();
//db.ConnectionString = this.DbConnectionStringBuilder.ToString();
dbConnectionStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder();
dbConnectionStringBuilder.DataSource = cmbServerName.Text;
dbConnectionStringBuilder.InitialCatalog = cmbDatabaseName.Text;
dbConnectionStringBuilder.UserID = txtUserName.Text;
if (rdbWindowsAuthentication.Checked)
{
dbConnectionStringBuilder.IntegratedSecurity = true;
}
else
{
dbConnectionStringBuilder.UserID = txtUserName.Text;
dbConnectionStringBuilder.Password = txtPassword.Text;
}
db.ConnectionString = this.DbConnectionStringBuilder.ToString();
try
{
if (db.TestConnection())
{
MessageBox.Show("Connection OK!"); // TODO: hard coded string.
}
else
{
MessageBox.Show("Connection failed."); // TODO: hard coded string.
}
}
catch (Exception ex)
{
MessageBox.Show("Connection failed: " + ex.Message); // TODO: hard coded string
}
}
public string getconnection()
{
try
{
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder["Server"] = "tcp:dmgc57lzfu.database.windows.net,1433";
builder["User ID"] = "eyeweradmin@dmgc57lzfu";
builder["Password"] = "******";
builder["Database"] = "rangerdb";
builder["Trusted_Connection"] = false;
builder["Integrated Security"] = false;
builder["Encrypt"] = true;
builder["Connection Timeout"] = 60;
conString = builder.ConnectionString;
}
catch (Exception)
{
throw;
}
return(conString);
}
private static string GetMsCs()
{
var csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
if (System.Environment.OSVersion.Platform == System.PlatformID.Unix)
{
csb.DataSource = System.Environment.MachineName + ",2019";
}
else
{
// csb.DataSource = System.Environment.MachineName + @"\SQLEXPRESS";
csb.DataSource = System.Environment.MachineName;
}
csb.InitialCatalog = "COR_Basic_Demo_V4";
csb.IntegratedSecurity = System.Environment.OSVersion.Platform != System.PlatformID.Unix;
if (!csb.IntegratedSecurity)
{
csb.UserID = TestPlotly.SecretManager.GetSecret <string>("DefaultDbUser");
csb.Password = TestPlotly.SecretManager.GetSecret <string>("DefaultDbPassword");
}
csb.PacketSize = 4096;
csb.PersistSecurityInfo = false;
csb.ApplicationName = "BlueMine";
csb.ConnectTimeout = 15;
csb.Pooling = true;
csb.MinPoolSize = 1;
csb.MaxPoolSize = 100;
csb.MultipleActiveResultSets = false;
csb.WorkstationID = System.Environment.MachineName;
string cs = csb.ConnectionString;
csb = null;
return(cs);
} // End Function GetMsCs
public ConnectionInformation(string connectionString)
{
System.Data.SqlClient.SqlConnectionStringBuilder sqlConnString = null;
try
{
sqlConnString = new System.Data.SqlClient.SqlConnectionStringBuilder(connectionString);
}
catch
{
throw new Data.DataException(string.Format("Invalid connection string: {0} , the version of sqlclient is less than 0.8.2.9!",
connectionString));
}
if (string.IsNullOrEmpty(sqlConnString.InitialCatalog))
{
throw new Data.DataException("Database name is empty");
}
string databaseName = sqlConnString.InitialCatalog;
string userId = Hubble.Framework.Security.DesEncryption.Decrypt(Global.Setting.Config.DesKey,
sqlConnString.UserID);
string password = Hubble.Framework.Security.DesEncryption.Decrypt(Global.Setting.Config.DesKey,
sqlConnString.Password);
Global.UserRightProvider.Verify(userId, password);
if (!Global.Setting.DatabaseExists(databaseName))
{
throw new Data.DataException(string.Format("Database name: {0} does not exist",
databaseName));
}
_DatabaseName = databaseName;
_UserName = userId;
}
/// <summary>
/// This method will create data base for given parameters supplied by caller.
/// </summary>
/// <param name="serverName">Name of the server where database has to be created</param>
/// <param name="databaseName">Name of database</param>
/// <param name="userName">SQL user name</param>
/// <param name="password">SQL password</param>
/// <returns>void</returns>
public static bool CreateDb(string serverName, string databaseName, string userName, string password)
{
bool integratedSecurity = !(!string.IsNullOrEmpty(userName) || !string.IsNullOrEmpty(password));
var builder = new System.Data.SqlClient.SqlConnectionStringBuilder
{
DataSource = serverName,
UserID = userName,
Password = password,
InitialCatalog = databaseName,
IntegratedSecurity = integratedSecurity,
};
var db = new SrcDbContext(builder.ConnectionString);
var dbInitializer = new MigrateDbToLatestInitializerConnString <SrcDbContext, SRC.DomainModel.ORMapping.Migrations.Configuration>(builder.ConnectionString);
//following uses strategy to "CreateIfNotExist<>"
dbInitializer.InitializeDatabase(db);
return(true);
}
//private const string conStr = "";
public static IDbConnection OpenConnection()
{
var cBuilder = new MySqlConnectionStringBuilder();
cBuilder.Server = "localhost";
cBuilder.UserID = "root";
cBuilder.Password = "******";
cBuilder.Database = "classicmodels";
var conStr = cBuilder.ToString();
var connection = new MySqlConnection(conStr);
connection.Open();
return(connection);
System.Data.SqlClient.SqlConnectionStringBuilder builder =
new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.DataSource = "";
builder.UserID = "";
builder.Password = "";
builder.InitialCatalog = "";
}
public async Task <IEnumerable <string> > Get()
{
var databases = new List <string>();
var connectionStringBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder();
connectionStringBuilder.DataSource = ConnectionInfo.Host;
connectionStringBuilder.UserID = ConnectionInfo.Username;
connectionStringBuilder.Password = ConnectionInfo.Password;
connectionStringBuilder.InitialCatalog = "master";
using (var sqlConnection = new System.Data.SqlClient.SqlConnection(connectionStringBuilder.ConnectionString))
using (var sqlCommand = new Amazon.XRay.Recorder.Handlers.SqlServer.TraceableSqlCommand("SELECT name from sys.databases", sqlConnection, true))
{
sqlCommand.Connection.Open();
using (var reader = sqlCommand.ExecuteReader())
{
while (reader.Read())
{
databases.Add(reader.GetString(0));
}
}
}
return(databases);
}
public bool CmdCheckConnection(IWin32Window owner, String server, LocationType locType, String dbLocation)
{
var builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.DataSource = server;
builder.IntegratedSecurity = true;
builder.AsynchronousProcessing = true;
switch (locType)
{
case LocationType.Name:
builder.InitialCatalog = dbLocation;
break;
case LocationType.Path:
builder.AttachDBFilename = dbLocation;
break;
default:
Debug.Fail("Invalid case: " + locType.ToString());
break;
}
return(CheckConnectionString(owner, builder.ToString()));
}
private static DbConnection GetDBConn(string server, string m, string db, bool i, string user, string psw)
{
if (m == "msft")
{
System.Data.SqlClient.SqlConnectionStringBuilder cb = new System.Data.SqlClient.SqlConnectionStringBuilder();
cb.DataSource = server;
cb.InitialCatalog = db;
if (i)
{
cb.IntegratedSecurity = true;
}
else
{
cb.UserID = user;
cb.Password = psw;
}
return(new System.Data.SqlClient.SqlConnection(cb.ConnectionString));
}
else
{
throw new NotSupportedException(m + " is not supported");
}
}
public void MaybeDoesSomething_WithGoodNames()
{
// Setup
var csBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder()
{
IntegratedSecurity = true,
DataSource = "AppDvSqlLi1",
InitialCatalog = "brett_data"
};
List <CollegeWithGoodNames> collegeList;
using (var connection = new System.Data.SqlClient.SqlConnection(csBuilder.ConnectionString))
using (ConnectionOpener.Open(connection))
using (var command = connection.CreateCommand("SELECT * FROM college"))
{
// Act
collegeList = command.ToList <CollegeWithGoodNames>();
}
// Verify
Assert.IsTrue(collegeList.Count > 0);
}
private void btnImprimir_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
DevExpress.XtraReports.UI.XtraReport report = DevExpress.XtraReports.UI.XtraReport.FromFile("./Reportes/rptSolicitudCompra.repx", true);
SqlDataSource sqlDataSource = report.DataSource as SqlDataSource;
SqlDataSource ds = report.DataSource as SqlDataSource;
ds.ConnectionName = "DataSource";
String sNameConexion = (Security.Esquema.Compania == "CEDETSA") ? "StringConCedetsa" : "StringConDasa";
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder(System.Configuration.ConfigurationManager.ConnectionStrings[sNameConexion].ConnectionString);
ds.ConnectionParameters = new DevExpress.DataAccess.ConnectionParameters.MsSqlConnectionParameters(builder.DataSource, builder.InitialCatalog, builder.UserID, builder.Password, MsSqlAuthorizationType.SqlServer);
// Obtain a parameter, and set its value.
report.Parameters["IDOrdenCompra"].Value = this.IDOrdenCompra;
// Show the report's print preview.
DevExpress.XtraReports.UI.ReportPrintTool tool = new DevExpress.XtraReports.UI.ReportPrintTool(report);
tool.ShowPreview();
}
private static string generateString(string serverName, bool isWindowsAuth, string userId, string password, DbBase type, string dbname = "")
{
var stringbuilder = new System.Data.SqlClient.SqlConnectionStringBuilder()
{
DataSource = serverName,
InitialCatalog = Configure.DEFAULT_DATABASE_NAME
};
if (!string.IsNullOrEmpty(dbname))
{
stringbuilder.InitialCatalog = dbname;
}
if (!isWindowsAuth)
{
stringbuilder.UserID = userId;
stringbuilder.Password = password;
}
else
{
stringbuilder.IntegratedSecurity = true;
}
return(stringbuilder.ConnectionString);
}
public string getEFConnStr()
{
/*初始化*/
System.Data.SqlClient.SqlConnectionStringBuilder objSCSB = null;
try
{
objSCSB = new System.Data.SqlClient.SqlConnectionStringBuilder();
objSCSB.DataSource = DecryptOfTripleDES(ConfigurationManager.AppSettings["SqlSvrIP"].ToString());
objSCSB.InitialCatalog = DecryptOfTripleDES(ConfigurationManager.AppSettings["InitialDB"].ToString());
objSCSB.UserID = DecryptOfTripleDES(ConfigurationManager.AppSettings["SqlDBAcct"].ToString());
objSCSB.Password = DecryptOfTripleDES(ConfigurationManager.AppSettings["SqlDBPwd"].ToString());
return(objSCSB.ConnectionString);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
objSCSB.Clear();
objSCSB = null;
}
}
public SiebelDB(Program.Options options)
{
_options = options;
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.DataSource = _options.DbServer;
builder.UserID = _options.Username;
builder.Password = _options.Password;
builder.InitialCatalog = _options.Database;
if (_options.Verbose)
{
Console.WriteLine("Connecting to: '{0}'", builder.ConnectionString);
}
db = new DataContext(builder.ConnectionString);
}
private void cbSourceDatabase_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
string sourceDatabase = this.cbSourceDatabase.SelectedValue as string;
if (String.IsNullOrEmpty(sourceDatabase) || sourceDatabase == "< Select Database >")
{
this.lblSourceTable.Visibility = Visibility.Hidden;
this.cbSourceTable.Visibility = Visibility.Hidden;
this.lblSourceTableContent.Visibility = Visibility.Hidden;
this.dgSourceTableContent.Visibility = Visibility.Hidden;
this._SourceTables = null;
return;
}
this._SourceTables = new List<string>();
this._SourceTables.Add("< Select Table >");
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.DataSource = this.txtDbHost.Text;
builder.InitialCatalog = this.cbSourceDatabase.SelectedValue.ToString();
builder.UserID = this.txtDbUsername.Text;
builder.Password = this.txtDbPassword.Password;
using (System.Data.SqlClient.SqlConnection connection = new System.Data.SqlClient.SqlConnection(builder.ConnectionString))
{
connection.Open();
System.Data.DataTable schema = connection.GetSchema("Tables");
foreach (System.Data.DataRow row in schema.Rows)
{
this._SourceTables.Add(row[2].ToString());
}
}
this.cbSourceTable.ItemsSource = this._SourceTables;
string sourceTable = Functions.GetFromIsolatedStorage(Functions.GetId(this.txtDbHost.Text, sourceDatabase, "SourceTable"));
if (!String.IsNullOrEmpty(sourceTable))
{
this.cbSourceTable.SelectedIndex = this._SourceTables.FindIndex(x => x == sourceTable);
}
if (this.cbSourceTable.SelectedIndex < 0 || this.cbSourceTable.Visibility == Visibility.Visible)
{
this.cbSourceTable.SelectedIndex = 0;
this.lblSourceTableContent.Visibility = Visibility.Hidden;
this.dgSourceTableContent.Visibility = Visibility.Hidden;
}
if (this._SourceTables.Count > 1)
{
this.lblSourceTable.Visibility = Visibility.Visible;
this.cbSourceTable.Visibility = Visibility.Visible;
//save to isolated stoage
Functions.SaveToIsolatedStorage(Functions.GetId(this.txtDbHost.Text, "SourceDatabase"), sourceDatabase);
}
this.ChangeButtonsVisibility();
}
private void cbSourceTable_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
string sourceTable = this.cbSourceTable.SelectedValue as string;
if (String.IsNullOrEmpty(sourceTable) || sourceTable == "< Select Table >")
{
this.lblSourceTableContent.Visibility = Visibility.Hidden;
this.dgSourceTableContent.Visibility = Visibility.Hidden;
return;
}
System.Data.SqlClient.SqlConnectionStringBuilder builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.DataSource = this.txtDbHost.Text;
builder.InitialCatalog = this.cbSourceDatabase.SelectedValue.ToString();
builder.UserID = this.txtDbUsername.Text;
builder.Password = this.txtDbPassword.Password;
using (System.Data.SqlClient.SqlConnection connection = new System.Data.SqlClient.SqlConnection(builder.ConnectionString))
{
connection.Open();
System.Data.SqlClient.SqlCommand command = new System.Data.SqlClient.SqlCommand();
command.Connection = connection;
command.CommandType = System.Data.CommandType.Text;
command.CommandText = string.Format("select * from [{0}]", sourceTable);
System.Data.SqlClient.SqlDataAdapter sda = new System.Data.SqlClient.SqlDataAdapter(command);
System.Data.DataTable dt = new System.Data.DataTable(sourceTable);
sda.Fill(dt);
dgSourceTableContent.ItemsSource = dt.DefaultView;
}
this._SourceSchemaFields = Functions.GetDatabaseTableFields(this.txtDbHost.Text, this.txtDbUsername.Text, this.txtDbPassword.Password, this.cbSourceDatabase.SelectedValue.ToString(), sourceTable);
if (this.cbSourceDatabase.SelectedIndex > 0 && this.cbSourceTable.SelectedIndex > 0 && this.cbTargetSchema.SelectedIndex > 0)
{
ItemInfo targetSchema = this.cbTargetSchema.SelectedValue as ItemInfo;
if (targetSchema != null)
{
this.HistoryMapping = Functions.GetHistoryMapping(Functions.GetId(this.txtHost.Text, this.cbSourceDatabase.SelectedValue.ToString(), sourceTable, targetSchema.TcmId));
}
this.SetCustomImporters();
this.SetCustomNameTransformers();
this.chkLocalize.IsChecked = Functions.GetFromIsolatedStorage(Functions.GetId(this.txtDbHost.Text, this.cbSourceDatabase.SelectedValue.ToString(), sourceTable, "Localize")).ToLower() == "true";
}
//save to isolated stoage
Functions.SaveToIsolatedStorage(Functions.GetId(this.txtDbHost.Text, this.cbSourceDatabase.SelectedValue.ToString(), "SourceTable"), sourceTable);
this.lblSourceTableContent.Visibility = Visibility.Visible;
this.dgSourceTableContent.Visibility = Visibility.Visible;
this.ChangeButtonsVisibility();
}
private static System.Data.SqlClient.SqlConnection Connection()
{
var csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.DataSource = Server;
csb.InitialCatalog = Database;
if (User == null)
{
csb.IntegratedSecurity = true;
}
else
{
csb.IntegratedSecurity = false;
csb.UserID = User;
csb.Password = Password;
}
var conn= new System.Data.SqlClient.SqlConnection(csb.ToString());
conn.Open();
return conn;
}
private void repositoryItemLookUpEditCRRep_ButtonClick(object sender, DevExpress.XtraEditors.Controls.ButtonPressedEventArgs e)
{
if (e.Button.Kind != DevExpress.XtraEditors.Controls.ButtonPredefines.OK)
return;
RepCRGeneralFrm RepForm = new RepCRGeneralFrm();
if (mbReports.EditValue == null)
return;
CrystalDecisions.Shared.TableLogOnInfos crtableLogoninfos = new CrystalDecisions.Shared.TableLogOnInfos();
CrystalDecisions.Shared.TableLogOnInfo crtableLogoninfo = new CrystalDecisions.Shared.TableLogOnInfo();
CrystalDecisions.Shared.ConnectionInfo crConnectionInfo = new CrystalDecisions.Shared.ConnectionInfo();
CrystalDecisions.CrystalReports.Engine.Tables CrTables = MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.Database.Tables;
System.Data.SqlClient.SqlConnectionStringBuilder ConString = new System.Data.SqlClient.SqlConnectionStringBuilder(MyCL.SqlConStr);
crConnectionInfo.ServerName = ConString.DataSource;
crConnectionInfo.DatabaseName = "AATSdata";
crConnectionInfo.UserID = ConString.UserID;
crConnectionInfo.Password = ConString.Password;
MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections[0].SetConnection(ConString.DataSource, "AATSdata", ConString.UserID, ConString.Password);
MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.SetDatabaseLogon(ConString.UserID, ConString.Password, ConString.DataSource, "AATSdata", true);
foreach (CrystalDecisions.Shared.IConnectionInfo info in MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections)
{
info.SetConnection(ConString.DataSource, "AATSdata", ConString.UserID, ConString.Password);
}
foreach (CrystalDecisions.CrystalReports.Engine.ReportDocument sub in MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.Subreports)
{
foreach (CrystalDecisions.Shared.IConnectionInfo info in sub.DataSourceConnections)
{
info.SetConnection(ConString.DataSource, "AATSdata", ConString.UserID, ConString.Password);
}
}
foreach (CrystalDecisions.CrystalReports.Engine.Table CrTable in CrTables)
{
crtableLogoninfo = CrTable.LogOnInfo;
crtableLogoninfo.ConnectionInfo = crConnectionInfo;
CrTable.ApplyLogOnInfo(crtableLogoninfo);
}
RepForm.CRViewer.ReportSource = MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport;
RepForm.CRViewer.Refresh();
RepForm.ReportName = MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].RepCaption;
RepForm.MdiParent = this;
RepForm.Show();
return;
//Assign ConnectionString to Report
//System.Data.SqlClient.SqlConnectionStringBuilder ConString = new System.Data.SqlClient.SqlConnectionStringBuilder(MyCL.SqlConStr);
MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections[0].SetConnection(ConString.DataSource, ConString.InitialCatalog, ConString.UserID, ConString.Password);
MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.SetDatabaseLogon(ConString.UserID, ConString.Password, ConString.DataSource, ConString.InitialCatalog, true);
MessageBox.Show(MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections[0].ServerName);
MessageBox.Show(MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections[0].DatabaseName);
MessageBox.Show(MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections[0].UserID);
MessageBox.Show(MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections[0].Password.ToString());
//Assign Report to Viewer
RepForm.CRViewer.ReportSource = MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport;
RepForm.ReportName = MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].RepCaption;
RepForm.MdiParent = this;
RepForm.Show();
}
private void navBarItemDeployRpt_LinkClicked(object sender, DevExpress.XtraNavBar.NavBarLinkEventArgs e)
{
try
{
if (!FXFW.SqlDB.ChangeBasicSSRSAuthType())
MessageBox.Show("لم يتم تعديل صلاحيات خادم التقارير ", "خطـــــــــــاء", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "خطـــــــــــاء", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
FXFW.Settings rpt = new FXFW.Settings();
string reportserver = FXFW.SqlDB.ReportURL.Replace("http://", "");
reportserver = reportserver.Substring(0, reportserver.IndexOf("/"));
string[] arr = FXFW.SqlDB.ReportURL.Split(Convert.ToChar("/"));
rpt.GlobalSettings(reportserver, arr[arr.Length - 1]);
System.Data.SqlClient.SqlConnectionStringBuilder constring = new System.Data.SqlClient.SqlConnectionStringBuilder(FXFW.SqlDB.SqlConStr);
string constringpro = string.Format(@"data source={0};initial catalog={1}", constring.DataSource, constring.InitialCatalog);
rpt.CreateDataSource("DataSourceStAccount", true, true, "Data Sources", constringpro, FXFW.Settings.CredentialRetrievalValues.Store, false, constring.UserID, constring.Password);
FXFW.Settings.Report[] reports = null;
foreach (FXFW.SqlDB.SQLReportsStr item in FXFW.SqlDB.SQLRep)
{
if (reports == null)
Array.Resize<FXFW.Settings.Report>(ref reports, 1);
else
Array.Resize<FXFW.Settings.Report>(ref reports, reports.Length + 1);
reports[reports.Length - 1].Name = item.RepFileName.Replace(".rdl", "");
reports[reports.Length - 1].FilePathValue = @"\rdl\" + item.RepFileName;
}
rpt.CreateReport("GroupDS", "DataSourceStAccount", FXFW.SqlDB.ReportPath, 10080, reports);
FXFW.SqlDB.DeploySSRSReports(rpt);
FXFW.SqlDB.ChangePublicSSRSAuthType();
}
internal ConnectionDebug(string connectionString)
{
csb = new System.Data.SqlClient.SqlConnectionStringBuilder(connectionString);
}
private string MakeConnectionString()
{
var conn = new System.Data.SqlClient.SqlConnectionStringBuilder
{
DataSource = this.Server,
InitialCatalog = this.DBName
};
var cred = new [] {
new[]{this.AdminName, this.AdminPassword},
new[]{this.LoginName, this.LoginPassword}}
.Where(s => !string.IsNullOrEmpty(s[0]) && !string.IsNullOrEmpty(s[1]))
.FirstOrDefault();
conn.IntegratedSecurity = cred == null;
if (cred != null)
{
conn.UserID = cred[0];
conn.Password = cred[1];
}
return conn.ConnectionString;
}
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/html";
context.Response.Output.Write(
Kiwi.GfmMarkdownConverter.ToHtml(context.Server.MapPath("~/Test.gfm"))
);
return;
context.Response.ContentType = "text/plain";
context.Response.Write("Hello World");
System.Data.SqlClient.SqlConnectionStringBuilder csb = new System.Data.SqlClient.SqlConnectionStringBuilder();
csb.InitialCatalog = "SqLite";
csb.InitialCatalog = "COR_Basic_Demo";
csb.DataSource = System.Environment.MachineName;
csb.IntegratedSecurity = true;
string cmd = "SELECT * FROM T_SYS_Ref_MimeTypes";
System.Data.SqlClient.SqlDataAdapter da = new System.Data.SqlClient.SqlDataAdapter(cmd, csb.ConnectionString);
System.Data.DataTable dt = new System.Data.DataTable();
da.Fill(dt);
dt.TableName = "T_SYS_Ref_MimeTypes";
dt.Columns.Remove("MIME_IsAllowed");
System.Console.WriteLine(dt.Rows.Count);
string JSON = Tools.Serialization.JSON.SerializePretty(dt);
System.IO.File.WriteAllText(@"D:\MimeTypes.json", JSON, System.Text.Encoding.UTF8);
return;
/*
SqliteConnection con = new SqliteConnection();
string dbFilename = @"SqliteTest3.db";
dbFilename = @"C:\Users\Administrator\Documents\Visual Studio 2015\Projects\csharp-sqlite\Community.CsharpSqlite.SQLiteClient\bin\Debug\SqliteTest3.db";
string cs = string.Format("Version=3,uri=file:{0}", dbFilename);
Console.WriteLine("Set connection String: {0}", cs);
// if (System.IO.File.Exists(dbFilename)) System.IO.File.Delete(dbFilename);
con.ConnectionString = cs;
con.Open();
//System.Data.IDbCommand cmd = con.CreateCommand();
//cmd.CommandText = "CREATE TABLE TEST_TABLE ( COLA INTEGER, COLB TEXT, COLC DATETIME )";
//cmd.ExecuteNonQuery();
*/
/*
System.Data.IDataReader reader = cmd.ExecuteReader();
int r = 0;
Console.WriteLine("Read the data...");
while (reader.Read())
{
Console.WriteLine(" Row: {0}", r);
int i = reader.GetInt32(reader.GetOrdinal("COLA"));
Console.WriteLine(" COLA: {0}", i);
string s = reader.GetString(reader.GetOrdinal("COLB"));
Console.WriteLine(" COLB: {0}", s);
DateTime dt = reader.GetDateTime(reader.GetOrdinal("COLC"));
Console.WriteLine(" COLB: {0}", dt.ToString("MM/dd/yyyy HH:mm:ss"));
r++;
}
*/
//SqliteCommand command = new SqliteCommand("PRAGMA table_info('TEST_TABLE')", con);
/*
string ins = SqliteInsertGenerator.GetInsertCommand(dt);
SqliteCommand command = new SqliteCommand(ins, con);
command.Prepare();
con.Open();
foreach (System.Data.DataRow dr in dt.Rows)
{
command.Parameters.Clear();
foreach (System.Data.DataColumn dc in dt.Columns)
{
command.Parameters.Add("@"+dc.ColumnName, dr[dc.ColumnName]);
}
command.ExecuteNonQuery();
}
// con.Close();
Console.WriteLine("Close and cleanup...");
con.Close();
con = null;
*/
}
