public static void Create()
{
using (YomContainer container = new YomContainer())
{
container.Database.Create();
}
string connectionstring = ConfigurationManager.ConnectionStrings["YomContainer"].ConnectionString;
EntityConnectionStringBuilder builder = new EntityConnectionStringBuilder(connectionstring);
string providerconnectionstring = builder.ProviderConnectionString;
Process process = new Process();
process.StartInfo.FileName = @"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\aspnet_regsql.exe";
process.StartInfo.Arguments = string.Format("-A mr -C \"{0}\"", providerconnectionstring);
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.Start();
Console.WriteLine(process.StandardOutput.ReadToEnd());
Console.ReadKey();
}
public void Mantenimiento(string Accion, string NOMBRE, int IDENTIFICACION, int Telefono, int Id)
{
try
{
System.Data.EntityClient.EntityConnectionStringBuilder e = new System.Data.EntityClient.EntityConnectionStringBuilder(s);
string ProviderConnectionString = e.ProviderConnectionString;
SqlConnection con = new SqlConnection(ProviderConnectionString);
SqlCommand cmd = new SqlCommand("STPR_CLIENTES_PRUEBA_MANTENIMIENTO", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@ACCION", SqlDbType.VarChar).Value = Accion;
cmd.Parameters.Add("@NOMBRE", SqlDbType.VarChar).Value = NOMBRE;
cmd.Parameters.Add("@IDENTIFICACION", SqlDbType.Int).Value = IDENTIFICACION;
cmd.Parameters.Add("@TELEFONO", SqlDbType.Int).Value = Telefono;
cmd.Parameters.Add("@ID", SqlDbType.Int).Value = Id;
cmd.Parameters.Add("@P_Mensaje", SqlDbType.VarChar).Value = "I";
con.Open();
cmd.ExecuteNonQuery();
con.Close();
}
catch (Exception ex)
{
}
}
/// <summary>
/// Retrieves and builds an entity connection string given one specified in web.config.
/// </summary>
/// <returns>Connection String for a store that is intended to host tokens.</returns>
internal static string GetEntityConnectionString()
{
string cs = string.Empty;
System.Configuration.Configuration rootWebConfig = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("/MyWebSiteRoot");
System.Configuration.ConnectionStringSettings connString;
if (rootWebConfig.ConnectionStrings.ConnectionStrings.Count > 0)
{
connString = rootWebConfig.ConnectionStrings.ConnectionStrings["AppTokenStorage"];
if (connString != null)
{
cs = connString.ConnectionString;
}
else
{
throw new Exception("No connection string named 'AppTokenStorage' was declared in web.config.");
}
}
EntityConnectionStringBuilder ecsb = new EntityConnectionStringBuilder();
ecsb.ProviderConnectionString = cs + ";MultipleActiveResultSets=True;Application Name=EntityFramework";
ecsb.Provider = "System.Data.SqlClient";
ecsb.Metadata = "res://*/TokenStore.csdl|res://*/TokenStore.ssdl|res://*/TokenStore.msl";
return ecsb.ToString();
}
//-------------------------------------------------------------------------------------------
protected void Page_Load(object sender, EventArgs e)
{
IsPublic = true;
if (Request.UserHostAddress != "127.0.0.1" || ConfigurationManager.AppSettings["install_mode"] == "false")
{
Response.Write("This page is unavailable to the general internet. Please visit from the server machine.");
Response.End();
}
WeavverMaster.SetToolbarVisibility(false);
WeavverMaster.FormTitle = "Weavver First-Time Set-Up";
WeavverMaster.FormDescription = "This wizard will help you configure Weavver for your first use.";
//"Notice: To deploy the schema you need to change your web.config setting 'install_mode' from false to true to install Weavver.";
//NHibernate.Cfg.ConfigurationSchema.HibernateConfiguration cfg = (NHibernate.Cfg.ConfigurationSchema.HibernateConfiguration)ConfigurationManager.GetSection("hibernate-configuration");
//string con1 = ConfigurationManager.ConnectionStrings["weavver"].ConnectionString;
//string con2 = cfg.SessionFactory.Properties["connection.connection_string"];
//if (con1 != con2)
//{
// ShowError("Your connection strings are out of sync. Please fix this in the web.config file.");
//}
string connectionString = ConfigurationManager.ConnectionStrings["WeavverEntityContainer"].ConnectionString;
var entityBuilder = new System.Data.EntityClient.EntityConnectionStringBuilder(connectionString);
var sqlBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder(entityBuilder.ProviderConnectionString);
DatabaseHost.Text = sqlBuilder.DataSource;
DatabaseUsername.Text = sqlBuilder.UserID;
DatabaseName.Text = sqlBuilder.InitialCatalog;
}
public HERBProject_DataBaseEntities GetEntitiesContext()
{
// Initialize Entity Connection String Builder
EntityConnectionStringBuilder entityConnectionStringBuilder = new EntityConnectionStringBuilder();
// Set the provider name
entityConnectionStringBuilder.Provider = "System.Data.SqlClient";
// Set the provider-specific connection string
entityConnectionStringBuilder.ProviderConnectionString = _connectionString;
entityConnectionStringBuilder.ProviderConnectionString += ";MultipleActiveResultSets=True";
// Set the Metadata location
entityConnectionStringBuilder.Metadata = string.Format("{0}|{1}|{2}",
"res://*/Repositories.CustomBoundedRepository.HERBProject_DataBase.csdl",
"res://*/Repositories.CustomBoundedRepository.HERBProject_DataBase.ssdl",
"res://*/Repositories.CustomBoundedRepository.HERBProject_DataBase.msl");
// Build Entity Connection
EntityConnection entityConnection = new EntityConnection(entityConnectionStringBuilder.ToString());
// Initialize Entity Object
return new HERBProject_DataBaseEntities(entityConnection)
{
CommandTimeout = _commandTimeOut
};
}
//-------------------------------------------------------------------------------------------
protected void TestConnection_Click(object sender, EventArgs e)
{
try
{
string connectionString = ConfigurationManager.ConnectionStrings["WeavverEntityContainer"].ConnectionString;
var entityBuilder = new System.Data.EntityClient.EntityConnectionStringBuilder(connectionString);
SqlConnection data = new SqlConnection(entityBuilder.ProviderConnectionString);
data.Open();
if (data.State == ConnectionState.Open)
{
DBStatus.Text = "The connection works.";
data.Close();
TestConnection.BackColor = System.Drawing.Color.LightGreen;
}
else
{
DBStatus.Text = "Weavver can not connect to your DB. Please check the database settings again.";
TestConnection.BackColor = System.Drawing.Color.Coral;
}
}
catch (Exception ex)
{
DBStatus.Text = "The connection failed with this message:<br /><br />" + ex.Message;
TestConnection.BackColor = System.Drawing.Color.Coral;
}
}
public string GetConnectionString(string connection)
{
string connectionString = connection;
try
{
DataConnectionConfiguration dcs = new DataConnectionConfiguration(null);
DataConnectionDialog dcd = new DataConnectionDialog();
//EF CONN STR to SQL CONNECTION
EntityConnectionStringBuilder efstr = new EntityConnectionStringBuilder(connection);
dcs.LoadConfiguration(dcd);
dcd.ConnectionString = efstr.ProviderConnectionString;
if (DataConnectionDialog.Show(dcd) == System.Windows.Forms.DialogResult.OK)
{
connectionString = dcd.ConnectionString;
}
dcs.SaveConfiguration(dcd);
//SQL CONNECTION TO EF CONN STR
SqlConnectionStringBuilder sqlstr = new SqlConnectionStringBuilder(dcd.ConnectionString);
efstr.ProviderConnectionString = sqlstr.ConnectionString;
connectionString = efstr.ConnectionString;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return connectionString;
}
// Метод для асинхронного создания подключения к БД
private async Task<bool> DbConnectAsync(string dbname)
{
try
{
// Создаем строку подключения
EntityConnectionStringBuilder ConnectionString = new EntityConnectionStringBuilder();
ConnectionString.ProviderConnectionString = "data source=" + Uchet.Properties.Settings.Default.dbDir
+ dbname;
ConnectionString.Provider = Uchet.Properties.Settings.Default.dbProvider;
ConnectionString.Metadata = @Uchet.Properties.Settings.Default.dbMetadata;
// Асинхронно создаем подключение
await Task.Run(() => {
this.DB = new DBEntity(ConnectionString.ToString());
// Задаем DataSource для таблиц в соответствии с таблицами БД приложения
this.Invoke((Action)delegate{
gearCountEntityBindingSource.DataSource = DB.GC.ToList<GearCountEntity>();
gearCountEntityBindingSource.DataSource = DB.GC.Local.ToBindingList<GearCountEntity>();
gearPriceEntityBindingSource.DataSource = DB.GP.ToList<GearPriceEntity>();
gearSumEntityBindingSource.DataSource = DB.GS.ToList<GearSumEntity>();
gearSumEntityBindingSource.DataSource = DB.GS.Local.ToBindingList<GearSumEntity>();
});
});
return true;
}
catch (Exception exeption)
{
MessageBox.Show(exeption.Message, "Ошибка!");
}
return false;
}
//-------------------------------------------------------------------------------------------
protected void Page_Load(object sender, EventArgs e)
{
IsPublic = true;
if (Request.UserHostAddress != "127.0.0.1" || ConfigurationManager.AppSettings["install_mode"] == "false")
{
Response.Write("This page is unavailable to the general internet. Please visit from the server machine.");
Response.End();
}
WeavverMaster.SetToolbarVisibility(false);
WeavverMaster.FormTitle = "Weavver First-Time Set-Up";
WeavverMaster.FormDescription = "This wizard will help you configure Weavver for your first use.";
//"Notice: To deploy the schema you need to change your web.config setting 'install_mode' from false to true to install Weavver.";
//NHibernate.Cfg.ConfigurationSchema.HibernateConfiguration cfg = (NHibernate.Cfg.ConfigurationSchema.HibernateConfiguration)ConfigurationManager.GetSection("hibernate-configuration");
//string con1 = ConfigurationManager.ConnectionStrings["weavver"].ConnectionString;
//string con2 = cfg.SessionFactory.Properties["connection.connection_string"];
//if (con1 != con2)
//{
// ShowError("Your connection strings are out of sync. Please fix this in the web.config file.");
//}
string connectionString = ConfigurationManager.ConnectionStrings["WeavverEntityContainer"].ConnectionString;
var entityBuilder = new System.Data.EntityClient.EntityConnectionStringBuilder(connectionString);
var sqlBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder(entityBuilder.ProviderConnectionString);
DatabaseHost.Text = sqlBuilder.DataSource;
DatabaseUsername.Text = sqlBuilder.UserID;
DatabaseName.Text = sqlBuilder.InitialCatalog;
}
public static ResetDatabase CreateFromEFConnectionString(string efConnStr)
{
var builder = new EntityConnectionStringBuilder(efConnStr);
var connStr = builder.ProviderConnectionString;
var conn = new SqlConnectionAdapterUsingSqlConnection(new SqlConnection(connStr));
return new ResetDatabase(conn);
}
/// <summary>
/// Gets the entity framework connection string.
/// </summary>
/// <param name="contextType">Type of the context.</param>
/// <param name="connectionString">The connection string.</param>
/// <returns>The entity framework connection string.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="contextType"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">The <paramref name="connectionString" /> is <c>null</c> or whitespace.</exception>
public static string GetEntityFrameworkConnectionString(Type contextType, string connectionString)
{
Argument.IsNotNull("contextType", contextType);
Argument.IsNotNullOrWhitespace("connectionString", connectionString);
if (connectionString.Contains("res://"))
{
// already EF connection string
return connectionString;
}
var fullName = contextType.FullName;
if (fullName.EndsWith("Container"))
{
fullName = fullName.Substring(0, fullName.Length - "Container".Length);
}
var assemblyNameParts = contextType.Assembly.GetName().Name.Split(new[] { '.' });
foreach (var assemblyNamePart in assemblyNameParts)
{
string itemToReplace = string.Format("{0}.", assemblyNamePart);
if (fullName.StartsWith(itemToReplace))
{
fullName = fullName.Remove(0, itemToReplace.Length);
}
}
var connectionBuilder = new EntityConnectionStringBuilder();
connectionBuilder.Provider = "System.Data.SqlClient";
connectionBuilder.Metadata = string.Format("res://*/{0}.csdl|res://*/{0}.ssdl|res://*/{0}.msl", fullName);
connectionBuilder.ProviderConnectionString = connectionString;
return connectionBuilder.ToString();
}
/// <summary>
/// Creates the entity connection with wrappers.
/// </summary>
/// <param name="entityConnectionString">The original entity connection string. This may also be a single word, e.g., "MyEntities", in which case it is translated into "name=MyEntities" and looked up in the application configuration.</param>
/// <param name="wrapperProviders">List for wrapper providers.</param>
/// <returns>EntityConnection object which is based on a chain of providers.</returns>
public static EntityConnection CreateEntityConnectionWithWrappers(string entityConnectionString, params string[] wrapperProviders)
{
// If there is only a single word in the connection string, treat it as the value for Name.
if (!entityConnectionString.Contains('='))
entityConnectionString = "name=" + entityConnectionString;
EntityConnectionStringBuilder ecsb = new EntityConnectionStringBuilder(entityConnectionString);
// if connection string is name=EntryName, look up entry in the config file and parse it
if (!String.IsNullOrEmpty(ecsb.Name))
{
var connStr = ConfigurationManager.ConnectionStrings[ecsb.Name];
if (connStr == null)
{
throw new ArgumentException("Specified named connection string '" + ecsb.Name + "' was not found in the configuration file.");
}
ecsb.ConnectionString = connStr.ConnectionString;
}
var workspace = metadataWorkspaceMemoizer.GetOrAdd(ecsb.ConnectionString, _ => CreateWrappedMetadataWorkspace(ecsb.Metadata, wrapperProviders));
var storeConnection = DbProviderFactories.GetFactory(ecsb.Provider).CreateConnection();
storeConnection.ConnectionString = ecsb.ProviderConnectionString;
var newEntityConnection = new EntityConnection(workspace, DbConnectionWrapper.WrapConnection(storeConnection, wrapperProviders));
return newEntityConnection;
}
private EntityConnectionStringBuilder GetEntityBuilder()
{
SqlConnectionStringBuilder sqlBuilder =
new SqlConnectionStringBuilder();
// Set the properties for the data source.
sqlBuilder.DataSource = serverName;
sqlBuilder.InitialCatalog = databaseName;
sqlBuilder.IntegratedSecurity = true;
//sqlBuilder.UserID = user;
//sqlBuilder.Password = pwd;
// Build the SqlConnection connection string.
string providerString = sqlBuilder.ToString();
// Initialize the EntityConnectionStringBuilder.
EntityConnectionStringBuilder entityBuilder =
new EntityConnectionStringBuilder();
//Set the provider name.
entityBuilder.Provider = providerName;
// Set the provider-specific connection string.
entityBuilder.ProviderConnectionString = providerString;
// Set the Metadata location.
entityBuilder.Metadata = @"res://*/MyEntities.csdl|
res://*/MyEntities.ssdl|
res://*/MyEntities.msl";
return entityBuilder;
}
public static EntityConnection GetConnectionString(object EntityName)
{
//YhG0j6YPoCtgND/RMckmpg==
string InitialCatalog = "profile";
//string DataSource = WebConfigEncryption.Decrypt(ConfigurationManager.AppSettings["DataSource"].ToString());
string UserID = "postgres";
string Password = "******";
string SchemaName = "user";
Dictionary <string, string> Dict_EntitySchema = new Dictionary <string, string>();
NpgsqlConnectionStringBuilder sb = new NpgsqlConnectionStringBuilder();
sb.Host = "127.0.0.1";
sb.Port = 5432;
sb.Database = "iristest";
sb.Username = "******";
sb.Password = "******";
sb.Timeout = 20;
sb.CommandTimeout = 20;
var connString = new System.Data.EntityClient.EntityConnectionStringBuilder
{
Metadata = string.Format("res://*/{0}.csdl|res://*/{0}.ssdl|res://*/{0}.msl", EntityName.ToString()),
Provider = "Npgsql",
ProviderConnectionString = sb.ConnectionString
};
return(CreateConnection(SchemaName, connString, EntityName.ToString(), Dict_EntitySchema));
}
public ConnectionString(IConfigurationManager configuration, string name, string edmFilesPath,
string ssdlFileName, string csdlFileName, string mslFileName)
{
if(String.IsNullOrEmpty(edmFilesPath))
{
edmFilesPath=_demFilesPath;
}
if(String.IsNullOrEmpty(ssdlFileName))
{
ssdlFileName=_ssdlFileName;
}
if(String.IsNullOrEmpty(csdlFileName))
{
csdlFileName=_csdlFileName;
}
if(String.IsNullOrEmpty(mslFileName))
{
mslFileName=_mslFileName;
}
string providerConnectionString=configuration.GetConnectionString(name);
string providerName=configuration.GetProviderName(name);
string metadata = String.Format(CultureInfo.InvariantCulture,
_demMetadataFormat, edmFilesPath, csdlFileName, ssdlFileName, mslFileName);
_entityBuilder = new EntityConnectionStringBuilder
{
ProviderConnectionString = providerConnectionString,
Provider = providerName,
Metadata = metadata
};
}
/// <summary>
/// Creates the entity connection with wrappers.
/// </summary>
/// <param name="entityConnectionString">The original entity connection string.</param>
/// <param name="wrapperProviders">List for wrapper providers.</param>
/// <returns>EntityConnection object which is based on a chain of providers.</returns>
public static EntityConnection CreateEntityConnectionWithWrappers(string entityConnectionString, params string[] wrapperProviders)
{
EntityConnectionStringBuilder ecsb = new EntityConnectionStringBuilder(entityConnectionString);
// if connection string is name=EntryName, look up entry in the config file and parse it
if (!String.IsNullOrEmpty(ecsb.Name))
{
var connStr = System.Configuration.ConfigurationManager.ConnectionStrings[ecsb.Name];
if (connStr == null)
{
throw new ArgumentException("Specified named connection string '" + ecsb.Name + "' was not found in the configuration file.");
}
ecsb.ConnectionString = connStr.ConnectionString;
}
MetadataWorkspace workspace;
if (!metadataWorkspaceMemoizer.TryGetValue(ecsb.ConnectionString, out workspace))
{
workspace = CreateWrappedMetadataWorkspace(ecsb.Metadata, wrapperProviders);
metadataWorkspaceMemoizer.Add(ecsb.ConnectionString, workspace);
}
var storeConnection = DbProviderFactories.GetFactory(ecsb.Provider).CreateConnection();
storeConnection.ConnectionString = ecsb.ProviderConnectionString;
var newEntityConnection = new EntityConnection(workspace, DBConnectionWrapper.WrapConnection(storeConnection, wrapperProviders));
return newEntityConnection;
}
public DBConnection()
{
// Specify the provider name, server and database.
// Initialize the connection string builder for the
// underlying provider.
SqlConnectionStringBuilder sqlBuilder =
new SqlConnectionStringBuilder();
// Set the properties for the data source.
sqlBuilder.DataSource = serverName;
sqlBuilder.InitialCatalog = databaseName;
sqlBuilder.IntegratedSecurity = true;
// Build the SqlConnection connection string.
string providerString = sqlBuilder.ToString();
// Initialize the EntityConnectionStringBuilder.
EntityConnectionStringBuilder entityBuilder =
new EntityConnectionStringBuilder();
//Set the provider name.
entityBuilder.Provider = providerName;
// Set the provider-specific connection string.
entityBuilder.ProviderConnectionString = providerString;
// Set the Metadata location.
entityBuilder.Metadata =@"res://*/ShoeShopEntity.csdl|res://*/ShoeShopEntity.ssdl|res://*/ShoeShopEntity.msl";
entity = new SHOESHOPEntities(entityBuilder.ToString());
}
public void Insert(string Accion, string NOMBRE, int IDENTIFICACION, int Telefono, int Id)
{
try
{
string s = System.Configuration.ConfigurationManager.ConnectionStrings["ClientesEntities"].ConnectionString;
System.Data.EntityClient.EntityConnectionStringBuilder e = new System.Data.EntityClient.EntityConnectionStringBuilder(s);
string ProviderConnectionString = e.ProviderConnectionString;
SqlConnection con = new SqlConnection(ProviderConnectionString);
SqlCommand cmd = new SqlCommand("STPR_CLIENTES_PRUEBA_MANTENIMIENTE", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@ACCION", SqlDbType.VarChar).Value = "I";
cmd.Parameters.Add("@NOMBRE", SqlDbType.VarChar).Value = NOMBRE;
cmd.Parameters.Add("@IDENTIFICACION", SqlDbType.Int).Value = IDENTIFICACION;
cmd.Parameters.Add("@TELEFONO", SqlDbType.Int).Value = Telefono;
cmd.Parameters.Add("@ID", SqlDbType.Int).Value = Id;
cmd.Parameters.Add("@P_Mensaje", SqlDbType.VarChar).Value = "I";
con.Open();
cmd.ExecuteNonQuery();
con.Close();
}
catch (Exception ex)
{
//MessageBox.Show(" Datos No Insertado" + ex.Message);
}
}
// Обработчик загрузки страницы
protected void Page_Load(object sender, EventArgs e)
{
// Формируем список городов для просмотра
// погодных данных
CityList.Add(new City("Челябинск", 0));
CityList.Add(new City("Москва", 1));
CityList.Add(new City("Самара", 2));
// Формируем список погодных сервисов
EntityConnectionStringBuilder ConnectionString =
new EntityConnectionStringBuilder();
ConnectionString.ProviderConnectionString =
@"data source=|DataDirectory|YahooWeatherDB.sqlite";
ConnectionString.Provider = @"System.Data.SQLite";
ConnectionString.Metadata =
@"res://*/Model1.csdl|res://*/Model1.ssdl|res://*/Model1.msl";
WeatherServiceList.Add(new WeatherService("Yahoo! Weather",
ConnectionString.ToString()));
ConnectionString.ProviderConnectionString =
@"data source=|DataDirectory|YandexWeatherDB.sqlite";
WeatherServiceList.Add(new WeatherService("Яндекс Погода",
ConnectionString.ToString()));
// Привязываем список городов и погодных сервисов
// к элементам интерфейса
foreach (City item in CityList)
if (!CityDropDownList.Items.Contains(new ListItem(item.Name)))
CityDropDownList.Items.Add(new ListItem(item.Name));
foreach (var item in WeatherServiceList)
if (!ServiceDropDownList.Items.Contains(new ListItem(item.Name)))
ServiceDropDownList.Items.Add(new ListItem(item.Name));
}
protected override string CreateConnectionString()
{
// Specify the provider name, server and database.
string providerName = "System.Data.SqlClient";
string serverName = ".\\SQLEXPRESS";
string databaseName = "ZMTdb";
// Initialize the connection string builder for the
// underlying provider.
SqlConnectionStringBuilder sqlBuilder = new SqlConnectionStringBuilder();
// Set the properties for the data source.
sqlBuilder.DataSource = serverName;
sqlBuilder.InitialCatalog = databaseName;
sqlBuilder.IntegratedSecurity = true;
// Build the SqlConnection connection string.
string providerString = sqlBuilder.ToString();
// Initialize the EntityConnectionStringBuilder.
EntityConnectionStringBuilder entityBuilder = new EntityConnectionStringBuilder();
//Set the provider name.
entityBuilder.Provider = providerName;
// Set the provider-specific connection string.
entityBuilder.ProviderConnectionString = providerString;
// Set the Metadata location.
entityBuilder.Metadata = @"res://EF_ZMTdbConnection/EF_ZMTdbModel.csdl|res://EF_ZMTdbConnection/EF_ZMTdbModel.ssdl|res://EF_ZMTdbConnection/EF_ZMTdbModel.msl";
return entityBuilder.ToString();
}
public static string CreateInstance(string filePrefix, string connectionString)
{
System.Data.EntityClient.EntityConnectionStringBuilder csb = new System.Data.EntityClient.EntityConnectionStringBuilder();
csb.Metadata = "res://*/" + filePrefix + ".csdl|res://*/" + filePrefix + ".ssdl|res://*/" + filePrefix + ".msl";
csb.Provider = "Npgsql";
csb.ProviderConnectionString = connectionString;
return(csb.ToString());
}
public static string createInstanceConString()
{
EntityConnectionStringBuilder sb = new EntityConnectionStringBuilder();
sb.Metadata = "res://*/CarPooling.csdl|res://*/CarPooling.ssdl|res://*/CarPooling.msl";
sb.Provider = "System.Data.SqlClient";
sb.ProviderConnectionString = @"data source=SCSBWIN-119391\SQLEXPRESS;initial catalog=VDSI_CARP;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework";
return sb.ConnectionString;
}
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 LocalMachine(string databaseName)
{
var entityBuilder = new EntityConnectionStringBuilder();
entityBuilder.Provider = "System.Data.SqlClient";
entityBuilder.ProviderConnectionString =
string.Format("data source=.;initial catalog={0};persist security info=True;user id=sa;password=d3hPOTraPC;multipleactiveresultsets=True;App={0}", databaseName);
entityBuilder.Metadata = "res://*/Domain.csdl|res://*/Domain.ssdl|res://*/Domain.msl";
return entityBuilder.ToString();
}
public static void SetConnection(String conn)
{
var cb = new EntityConnectionStringBuilder();
cb.Provider = "System.Data.SqlClient";
cb.ProviderConnectionString = conn;
cb.Metadata = "res://*/DataModel.csdl|res://*/DataModel.ssdl|res://*/DataModel.msl";
_connrction = new EntityConnection(cb.ConnectionString);
}
public static EntityConnection Get(string schema)
{
var b = new EntityConnectionStringBuilder();
b.Metadata = string.Format("res://*/{0}.csdl|res://*/{0}.ssdl|res://*/{0}.msl", schema);
b.Provider = "System.Data.SqlClient";
b.ProviderConnectionString = ConfigurationManager.ConnectionStrings["Bnh.Entities"].ConnectionString + "multipleactiveresultsets=True;App=EntityFramework";
return new EntityConnection(b.ConnectionString);
}
public string SetEntityConnection(string serverName, string initInstanceName)
{
EntityConnectionStringBuilder enityBuilder = new EntityConnectionStringBuilder();
enityBuilder.Provider = "System.Data.SqlClient";
enityBuilder.Metadata = @"res://*/Model1.csdl|res://*/Model1.ssdl|res://*/Model1.msl";
enityBuilder.ProviderConnectionString = "Data Source=" + serverName + "\\" + initInstanceName + ";Initial Catalog=ozyrys;Integrated Security=SSPI;multipleactiveresultsets=True;App=EntityFramework";
sqlConn = enityBuilder.ToString();
return sqlConn;
}
public void DBReadWriteTest_1()
{
// Подключаемся к БД
EntityConnectionStringBuilder ConnectionString = new EntityConnectionStringBuilder();
ConnectionString.ProviderConnectionString =
@"data source=../../Test_Data/DBReadWriteTest_1/testDB.sqlite";
ConnectionString.Provider = @"System.Data.SQLite";
ConnectionString.Metadata = @"res://*/Model1.csdl|res://*/Model1.ssdl|res://*/Model1.msl";
WeatherDBEntity testDB = new WeatherDBEntity(ConnectionString.ToString());
// Очистка таблиц БД
foreach (var item in testDB.City1Entity)
testDB.City1Entity.Remove(item);
foreach (var item in testDB.City2Entity)
testDB.City2Entity.Remove(item);
foreach (var item in testDB.City3Entity)
testDB.City3Entity.Remove(item);
// Сохраняем состояние БД
testDB.SaveChanges();
// Создаем записи в таблицы БД
// Запись в таблицу 1-ого города
City1Entity City1Item = new City1Entity();
City1Item.Date = "29.06.2014";
City1Item.Temperature = "24";
City1Item.Pressure = "748";
City1Item.Wetness = "28";
City1Item.Wind = "с/з 10";
City1Item.Clouds = "Облачно";
testDB.City1Entity.Add(City1Item);
// Запись в таблицу 2-ого города
City2Entity City2Item = new City2Entity();
City2Item.Date = "30.07.2015";
City2Item.Temperature = "26";
City2Item.Pressure = "749";
City2Item.Wetness = "30";
City2Item.Wind = "с/в 3";
City2Item.Clouds = "Ясно";
testDB.City2Entity.Add(City2Item);
// Запись в таблицу 3-ого города
City3Entity City3Item = new City3Entity();
City3Item.Date = "05.03.2014";
City3Item.Temperature = "30";
City3Item.Pressure = "750";
City3Item.Wetness = "20";
City3Item.Wind = "ю/в 5";
City3Item.Clouds = "Пасмурно";
testDB.City3Entity.Add(City3Item);
// Сохраняем состояние БД
testDB.SaveChanges();
// Читаем записи из таблиц БД и сравниваем с ожидаемым результатом
Assert.AreEqual<City1Entity>(City1Item, testDB.City1Entity.ToList<City1Entity>()[0]);
Assert.AreEqual<City2Entity>(City2Item, testDB.City2Entity.ToList<City2Entity>()[0]);
Assert.AreEqual<City3Entity>(City3Item, testDB.City3Entity.ToList<City3Entity>()[0]);
}
//To Set Connection String for Entity (query using LINQ)
public string setEntityPath(string path)
{
EntityConnectionStringBuilder conn = new EntityConnectionStringBuilder();
conn.Metadata = @"res://*/Model1.csdl|res://*/Model1.ssdl|res://*/Model1.msl";
conn.Provider = "System.Data.SQLite";
conn.ProviderConnectionString = new SqlConnectionStringBuilder() { DataSource = linqpath }.ConnectionString;
string str = conn.ConnectionString;
//MessageBox.Show(conn.ConnectionString);
return str;
}
public static string GetConnectionString()
{
string baseConnectionString = ConfigurationManager.ConnectionStrings["ApplicationServices"].ConnectionString;
var entityBuilder = new EntityConnectionStringBuilder();
entityBuilder.Provider = "System.Data.SqlClient";
entityBuilder.ProviderConnectionString = baseConnectionString;
entityBuilder.Metadata = @"res://*/SceneCRM.csdl|res://*/SceneCRM.ssdl|res://*/SceneCRM.msl";
return entityBuilder.ToString();
}
public static DNNAwesomeEntities Instance()
{
var entityBuilder = new System.Data.EntityClient.EntityConnectionStringBuilder();
entityBuilder.ProviderConnectionString = DotNetNuke.Common.Utilities.Config.GetConnectionString();
entityBuilder.Metadata = "res://*/";
entityBuilder.Provider = "System.Data.SqlClient";
return(new DNNAwesomeEntities(entityBuilder.ToString()));
}
public static string GetConnectionStringEF()
{
EntityConnectionStringBuilder entityConnectionString = new EntityConnectionStringBuilder();
SqlConnectionStringBuilder sqlConnectionStringBuilder = new SqlConnectionStringBuilder("data source=localhost;initial catalog=MyBlog;persist security info=True;user id=sa;password=andheri788;MultipleActiveResultSets=True;App=EntityFramework");
entityConnectionString.ProviderConnectionString = sqlConnectionStringBuilder.ToString();
entityConnectionString.Metadata = "res://*/MyBlog.csdl|res://*/MyBlog.ssdl|res://*/MyBlog.msl";
entityConnectionString.Provider = "System.Data.SqlClient";
return entityConnectionString.ToString();
}
/// <summary>
/// Creates the connection string.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <param name="model">The model.</param>
/// <param name="sqlConnectionString">The SQL connection string.</param>
/// <returns></returns>
public static EntityConnection CreateConnectionString(Assembly assembly, string model, string sqlConnectionString)
{
var entityconnectionBuilder = new EntityConnectionStringBuilder
{
Provider = "System.Data.SqlClient",
ProviderConnectionString = sqlConnectionString,
Metadata = string.Format("res://{0}/{1}.csdl|res://{0}/{1}.ssdl|res://{0}/{1}.msl", assembly.GetName().Name, model)
};
return new EntityConnection(entityconnectionBuilder.ToString());
}
private Contexto()
{
EntityConnectionStringBuilder connerctionString = new EntityConnectionStringBuilder();
connerctionString.Provider = "System.Data.SQLite";
connerctionString.Metadata =
String.Format(@"res://{0}/{1}Cemfs.csdl|res://{0}/{1}Cemfs.ssdl|res://{0}/{1}Cemfs.msl",
Assembly.GetExecutingAssembly().GetName().Name, "Entidades.");
connerctionString.ProviderConnectionString =
String.Format(@"data source={0}App_Data\banco\CemfsDb.sdb;", Constantes.DiretorioAplicacao);
container = new ContainerEntidades(new EntityConnection(connerctionString.ConnectionString));
}
protected YomContainer GetYomContainer()
{
var connectionstring = System.Web.Configuration.WebConfigurationManager.ConnectionStrings["YomContainer"].ConnectionString;
EntityConnectionStringBuilder builder = new EntityConnectionStringBuilder();
builder.Metadata="res://*/Data.EF.Yom.csdl|res://*/Data.EF.Yom.ssdl|res://*/Data.EF.Yom.msl";
builder.Provider="System.Data.SqlClient";
builder.ProviderConnectionString=connectionstring;
return new YomContainer(builder.ConnectionString);
}
public static string GetDbContextConnectionString(DatabaseModel model, string assemblyFullName, string dbContextName)
{
EntityConnectionStringBuilder ecb = new EntityConnectionStringBuilder();
ecb.Metadata = string.Format("res://{0}/{1}.csdl|res://{0}/{1}.ssdl|res://{0}/{1}.msl",
assemblyFullName, dbContextName);
//ecb.Metadata = string.Format("res://*/{0}.csdl|res://*/{0}.ssdl|res://*/{0}.msl", dbContextName);
ecb.Provider = "System.Data.SqlClient";
ecb.ProviderConnectionString = ConnectionStringFactory.GetSqlConnectionString(model);
return ecb.ConnectionString;
}
public DataTable SearchClient(string NOMBRE)
{
DataTable clientInfoDT = new DataTable();
clientInfoDT.Columns.Add("ID", typeof(string));
clientInfoDT.Columns.Add("NOMBRE_COMPLETO", typeof(string));
clientInfoDT.Columns.Add("IDENTIFICACION", typeof(string));
clientInfoDT.Columns.Add("TELEFONO", typeof(string));
try
{
string s = System.Configuration.ConfigurationManager.ConnectionStrings["ClientesEntities"].ConnectionString;
System.Data.EntityClient.EntityConnectionStringBuilder e = new System.Data.EntityClient.EntityConnectionStringBuilder(s);
string ProviderConnectionString = e.ProviderConnectionString;
string ConnectionString = ConfigurationManager.ConnectionStrings["ClientesEntities"].ConnectionString;
SqlConnection con = new SqlConnection(ProviderConnectionString);
SqlDataReader reader;
string query = @"SELECT * FROM [dbo].[udfProductInYear](@model_year);";
SqlCommand cmd = new SqlCommand(query, con);
SqlParameter param1 = new SqlParameter();
param1.ParameterName = "@model_year";
param1.SqlDbType = SqlDbType.VarChar;
param1.Value = NOMBRE;
cmd.Parameters.Add(param1);
con.Open();
reader = cmd.ExecuteReader();
while (reader.Read())
{
DataRow row = clientInfoDT.NewRow();
row["ID"] = reader["ID"].ToString();
row["NOMBRE_COMPLETO"] = reader["NOMBRE_COMPLETO"].ToString();
row["IDENTIFICACION"] = reader["IDENTIFICACION"].ToString();
row["TELEFONO"] = reader["TELEFONO"].ToString();
clientInfoDT.Rows.Add(row);
}
con.Close();
}
catch (Exception ex)
{
}
return(clientInfoDT);
}
private void create_db()
{
saveFileDialog1.ShowDialog();
var path = saveFileDialog1.FileName;
//var name = System.IO.Path.GetFileName(path);
SQLiteConnection.CreateFile(path);
SQLiteFactory factory = DbProviderFactories.GetFactory("System.Data.SQLite") as SQLiteFactory;
SQLiteConnection connection = factory.CreateConnection() as SQLiteConnection;
connection.ConnectionString = "Data Source=" + path;
connection.Open();
SQLiteCommand command = new SQLiteCommand(connection);
command.CommandText = @"CREATE TABLE [Ciphers_Table] ( [ID] integer PRIMARY KEY AUTOINCREMENT NOT NULL,
[Cycle] text,
[Current_pos] text,
[Start_set] text ); ";
command.CommandType = CommandType.Text;
command.ExecuteNonQuery();
connection.Close();
//создали базу
System.Data.SQLite.SQLiteConnectionStringBuilder connect = new SQLiteConnectionStringBuilder("Data Source=" + path);
System.Data.EntityClient.EntityConnectionStringBuilder entity_connect = new System.Data.EntityClient.EntityConnectionStringBuilder();
entity_connect.Provider = @"System.Data.SQLite";
entity_connect.ProviderConnectionString = connect.ConnectionString;
entity_connect.Metadata = @"res://*/DB_Model.csdl|res://*/DB_Model.ssdl|res://*/DB_Model.msl";
data_source = new Cipher_catEntities(entity_connect.ConnectionString);
MessageBox.Show("База удачно создана и подключена");
//data_source.Ciphers_Table.AddObject(new Ciphers_Table
//{
// Current_pos = "test",
// Cycle = "test",
// Start_set = "test"
//});
//data_source.SaveChanges();
}
/// <summary>
/// Recreates the local caching DB if it doesn't exist.
/// </summary>
private static void InitLocalImageDb()
{
var ee = new System.Data.EntityClient.EntityConnectionStringBuilder();
var builder = new EntityConnectionStringBuilder(ConfigurationManager.ConnectionStrings["BinariesEntities"].ConnectionString);
using (var connection = new SQLiteConnection(builder.ProviderConnectionString))
using (var command = connection.CreateCommand())
{
connection.Open(); //Automatically creates sqlite datbase if none exists
var table = connection.GetSchema("Tables").Select("Table_Name = 'Binaries'");
if (table.Length <= 0)
{
command.CommandText =
"CREATE TABLE [Binaries] (" +
"[ComponentUri] NVARCHAR(100) UNIQUE NOT NULL PRIMARY KEY," +
"[Path] NVARCHAR(512) UNIQUE NOT NULL," +
"[Content] BLOB NOT NULL," +
"[LastPublishedDate] TIMESTAMP NOT NULL" +
")";
command.ExecuteNonQuery();
}
var uriIndex = connection.GetSchema("Indexes").Select("Index_Name = 'IDX_BINARIES_COMPONENTURI'");
if (uriIndex.Length <= 0)
{
command.CommandText =
"CREATE INDEX [IDX_BINARIES_COMPONENTURI] ON [Binaries](" +
"[ComponentUri] DESC" +
")";
command.ExecuteNonQuery();
}
var pathIndex = connection.GetSchema("Indexes").Select("Index_Name = 'IDX_BINARIES_PATH'");
if (pathIndex.Length <= 0)
{
command.CommandText =
"CREATE INDEX [IDX_BINARIES_PATH] ON [Binaries](" +
"[Path] DESC" +
")";
command.ExecuteNonQuery();
}
}
}
public List <CEntidades.CLIENTES> BuscarCliente(string NOMBRE = "")
{
List <CEntidades.CLIENTES> listclient = new List <CEntidades.CLIENTES>();
try
{
//cambio de pruebas
//otro cambio
System.Data.EntityClient.EntityConnectionStringBuilder e = new System.Data.EntityClient.EntityConnectionStringBuilder(s);
string ProviderConnectionString = e.ProviderConnectionString;
string ConnectionString = ConfigurationManager.ConnectionStrings["Clientes_AREntities"].ConnectionString;
SqlConnection con = new SqlConnection(ProviderConnectionString);
SqlDataReader reader;
string query = @"SELECT * FROM [dbo].[FTN_CLIENTES_PRUEBA_LISTA_CLIENTES](@NOMBRE);";
SqlCommand cmd = new SqlCommand(query, con);
SqlParameter param1 = new SqlParameter();
param1.ParameterName = "@NOMBRE";
param1.SqlDbType = SqlDbType.VarChar;
param1.Value = NOMBRE;
cmd.Parameters.Add(param1);
con.Open();
reader = cmd.ExecuteReader();
while (reader.Read())
{
CEntidades.CLIENTES client = new CEntidades.CLIENTES();
client.ID = int.Parse(reader["ID"].ToString());
client.NOMBRE_COMPLETO = reader["NOMBRE_COMPLETO"].ToString();
client.IDENTIFICACION = int.Parse(reader["IDENTIFICACION"].ToString());
client.TELEFONO = int.Parse(reader["TELEFONO"].ToString());
listclient.Add(client);
}
con.Close();
}
catch (Exception ex)
{
}
return(listclient);
}
public static bool GetConnectionStringBuilder(string aConnectionString, out string aServerIP, out string aDatabaseName, out string aUserID, out string aPassword)
{
SqlConnectionStringBuilder connBuilder = null;
aServerIP = "";
aDatabaseName = "";
aUserID = "";
aPassword = "";
try
{
System.Data.EntityClient.EntityConnectionStringBuilder entityConnectionBuilder = null;
//first assuming that provided connection string is of Entity Framework
try
{
entityConnectionBuilder = new System.Data.EntityClient.EntityConnectionStringBuilder(aConnectionString);
}
catch (Exception ex)
{
//ingnoring the exception
}
string sqlConnectionString = entityConnectionBuilder != null ? entityConnectionBuilder.ProviderConnectionString
: aConnectionString;
connBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder(sqlConnectionString);
aServerIP = connBuilder.DataSource;
aDatabaseName = connBuilder.InitialCatalog;
aUserID = connBuilder.UserID;
aPassword = connBuilder.Password;
return(true);
}
catch (Exception ex)
{
//ignoring the exception. since may be the provided connection string is invalid
return(false);
}
}
//-------------------------------------------------------------------------------------------
private void ConfigureDatabase()
{
using (WeavverEntityContainer data = new WeavverEntityContainer())
{
// Run SQL Deploy script
string connectionString = ConfigurationManager.ConnectionStrings["WeavverEntityContainer"].ConnectionString;
var entityBuilder = new System.Data.EntityClient.EntityConnectionStringBuilder(connectionString);
SqlConnection connection = new SqlConnection(entityBuilder.ProviderConnectionString);
connection.Open();
string script = System.IO.File.ReadAllText(Server.MapPath(@"\bin\Database.sql")); //data.CreateDatabaseScript();
script = script.Replace("%dalpath%", Server.MapPath(@"\bin\Weavver.DAL.dll"));
script = script.Replace("%databasename%", connection.Database);
string[] blocks = System.Text.RegularExpressions.Regex.Split(script, "\nGO");
foreach (string block in blocks)
{
if (block.Trim() != String.Empty)
{
SqlCommand createDb = new SqlCommand(block, connection);
try
{
createDb.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception("Block: " + block, ex);
}
}
}
// CREATE INITIAL DATA
Guid orgId = Guid.NewGuid();
Session["SelectedOrganizationId"] = orgId;
// deploy first org
Weavver.Data.Logistics_Organizations org = new Weavver.Data.Logistics_Organizations();
org.Id = orgId;
org.OrganizationId = org.Id; // THIS IS OVERRIDDEN ANYWAY BY AUDITUTILITY AS A SECURITY PRECAUTION
org.OrganizationType = "Personal";
org.Name = Organization.Text;
org.VanityURL = "default";
org.EIN = "";
org.Founded = DateTime.UtcNow;
org.Bio = "This is a sample organization.";
org.CreatedAt = DateTime.UtcNow;
org.CreatedBy = Guid.Empty;
org.UpdatedAt = DateTime.UtcNow;
org.UpdatedBy = Guid.Empty;
data.Logistics_Organizations.AddObject(org);
data.SaveChanges();
Weavver.Data.System_Users user = new Weavver.Data.System_Users();
user.Id = orgId;
user.OrganizationId = org.Id; // THIS IS OVERRIDDEN ANYWAY BY AUDITUTILITY AS A SECURITY PRECAUTION
user.FirstName = "Enlightened";
user.LastName = "User";
user.Activated = true;
user.Locked = false;
user.Username = Username.Text;
user.Password = Password.Text;
user.CreatedAt = DateTime.UtcNow;
user.CreatedBy = Guid.Empty;
user.UpdatedAt = DateTime.UtcNow;
user.UpdatedBy = Guid.Empty;
data.System_Users.AddObject(user);
data.SaveChanges();
Roles.ApplicationName = orgId.ToString();
string adminuser = user.Username;
Roles.CreateRole("Administrators");
Roles.AddUsersToRoles(new string[] { adminuser }, new string[] { "Administrators" });
Roles.CreateRole("Accountants");
Roles.AddUsersToRoles(new string[] { adminuser }, new string[] { "Accountants" });
if (data.SaveChanges() > 0)
{
Response.Redirect("~/install/step2");
}
}
}
