internal static void ParseCommandLineArguments(CommandLineOptions options, CommandLineParser parser, ConnectionStringSettingsCollection connectionStrings, out string connectionString, out string[] excludedTables)
{
if (parser.Parameters.Length < 1 || // expect at least the target
parser.UnhandledSwitches.Length > 0)
{
throw new InvalidCommandLineArgumentException("Invalid command line arguments. Specify the target." + Environment.NewLine + Environment.NewLine + GetUsageMessage(parser),
InvalidArgumentsExitCode);
}
// connection string
string target = parser.Parameters[0];
ConnectionStringSettings settings = connectionStrings[target];
if (settings == null)
{
throw new InvalidCommandLineArgumentException(string.Format(CultureInfo.CurrentCulture,
"Missing target: '{0}'. Could not find entry in the configuration file.", target),
InvalidTargetExitCode);
}
connectionString = settings.ConnectionString;
if (connectionString == null)
{
throw new InvalidCommandLineArgumentException(string.Format(CultureInfo.CurrentCulture,
"Empty target: '{0}'. The entry in the configuration file is empty.", target),
InvalidTargetExitCode);
}
// additional parameters
excludedTables = (options.Exclude ?? string.Empty).Split(',');
}
public void Approve(ConnectionStringSettingsCollection connectionStrings)
{
foreach (ConnectionStringSettings settings in connectionStrings)
{
try
{
using (var connection = DbProviderFactories.GetFactory(settings.ProviderName).CreateConnection())
{
Guard.AgainstNull(connection, "connection");
// ReSharper disable PossibleNullReferenceException
connection.ConnectionString = settings.ConnectionString;
// ReSharper restore PossibleNullReferenceException
connection.Open();
}
_log.Information(string.Format(DataResources.ConnectionStringApproved, settings.Name));
}
catch (Exception ex)
{
var message = string.Format(DataResources.DbConnectionOpenException, settings.Name, ex.Message);
_log.Error(message);
throw new DataException(message);
}
}
}
public void ConnectionStrings_ShouldCallConnectionStringsOfTheWrappedConfigurationManager()
{
using(ShimsContext.Create())
{
bool connectionStringsIsCalled = false;
var shimConnectionStrings = new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("ConnectionName", "ConnectionStringValue")
};
ShimConfigurationManager.ConnectionStringsGet = delegate
{
connectionStringsIsCalled = true;
return shimConnectionStrings;
};
Assert.IsFalse(connectionStringsIsCalled);
var connectionStrings = new ConfigurationManagerWrapper().ConnectionStrings.ToArray();
Assert.AreEqual(1, connectionStrings.Count());
Assert.AreEqual(shimConnectionStrings[0], connectionStrings.ElementAt(0));
Assert.IsTrue(connectionStringsIsCalled);
}
}
public void LoadConfigurations()
{
appSettings = new NameValueCollection();
connSettings = new ConnectionStringSettingsCollection();
var areaDir = new DirectoryInfo(HttpContext.Current.Server.MapPath("~/Modules"));
if(areaDir.Exists)
{
foreach(var dir in areaDir.GetDirectories())
{
var file = dir.GetFiles("web.config").FirstOrDefault();
if(file != null)
{
var config = WebConfigurationManager.OpenWebConfiguration(string.Format("/Modules/{0}/web.config", dir.Name));
var settings = config.AppSettings.Settings;
foreach(var key in settings.AllKeys)
{
appSettings.Add(string.Format("{0}.{1}", dir.Name, key), settings[key] == null ? "" : settings[key].ToString());
}
var conns = config.ConnectionStrings.ConnectionStrings;
foreach(ConnectionStringSettings conn in conns)
{
ConnectionStringSettings c = new ConnectionStringSettings(conn.Name, conn.ConnectionString, conn.ProviderName);
connSettings.Add(c);
}
}
}
}
}
/// <summary>
/// Tony.2014.09.11
/// 获取到连接字符串，如果配置了XCode.ConnConfigFile项则优先使用，否则使用ConnectionStrings节
/// </summary>
/// <returns></returns>
private static ConnectionStringSettingsCollection GetConnectionStrings()
{
String connFile = Config.GetConfig<String>("XCode.ConnConfigFile");
if (String.IsNullOrWhiteSpace(connFile))
{
return ConfigurationManager.ConnectionStrings;
}
else
{
ConnectionStringSettingsCollection cnsc = new ConnectionStringSettingsCollection();
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(connFile);
foreach (XmlNode conn in xmlDoc.SelectNodes("/connectionStrings/add"))
{
ConnectionStringSettings css = new ConnectionStringSettings();
css.Name = conn.Attributes["name"] == null ? String.Empty : conn.Attributes["name"].Value;
css.ConnectionString = conn.Attributes["connectionString"] == null ? String.Empty : conn.Attributes["connectionString"].Value;
css.ProviderName = conn.Attributes["providerName"] == null ? String.Empty : conn.Attributes["providerName"].Value;
cnsc.Add(css);
}
}
catch (Exception ex)
{
XTrace.WriteLine("无法从XCode.ConnConfigFile配置节中获取到ConnectionStrings，异常详情：{0}", ex.ToString());
}
return cnsc;
}
}
public ApplicationSettings()
{
config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
General = (GeneralSettings)config.GetSection("general");
SerialPorts = (SerialPortSettings)config.GetSection("serialPorts");
Plugins = (PluginSettings)config.GetSection("plugin");
ConnectionStrings = config.ConnectionStrings.ConnectionStrings;
}
public static IConfigurationBuilder AddConnectionStrings(this IConfigurationBuilder configurationBuilder, ConnectionStringSettingsCollection connectionStrings)
{
if (configurationBuilder == null)
{
throw new ArgumentNullException(nameof(configurationBuilder));
}
return configurationBuilder.Add(new ConnectionStringsConfigurationProvider(connectionStrings));
}
public override ConnectionStringSettingsCollection GetConnectionStrings(string[] names)
{
Cat.LogEvent("LoadDataSource.Source", "service");
logger.Info("Load data source from service.");
ConnectionStringSettingsCollection coll = new ConnectionStringSettingsCollection();
try
{
var json = DynamicJson.Parse(SendRequest(names));
Cat.LogEvent("LoadDataSource.StatusCode", json.status);
logger.Info("Response data status code is " + json.status);
if (json.status != "200")
throw new Exception("The status code returned from data source service is " + json.status);
foreach (var item in json.data)
{
if (item.IsDefined("errorCode") && Convert.ToString(item.errorCode) != "200")
{
var name = Convert.ToString(item.name);
var errorCode = Convert.ToString(item.errorCode);
var message = Convert.ToString(item.errorMessage);
Cat.LogEvent("LoadDataSource.Entry", name, errorCode, message);
Cat.LogEvent("LoadDataSource.Entry.StatusCode", errorCode);
logger.Error("Data source - " + name, string.Format("ErrorCode:{0}, Message:{1}", errorCode, message));
}
else
{
var name = Convert.ToString(item.name);
coll.Add(new ConnectionStringSettings(name, Decrypt(name, Convert.ToString(item.connectionString)), Convert.ToString(item.providerName)));
Cat.LogEvent("LoadDataSource.Entry", name);
Cat.LogEvent("LoadDataSource.Entry.StatusCode", "200");
logger.Info("Data source - " + name, "ok");
}
}
succeed = true;
return coll;
}
catch (Exception ex)
{
if (!ConfigHelper.UseLocalOnServiceNotAvailable || succeed)
throw;
var msg = "Error occured during loading data from service, attempts to read local file.";
Cat.LogError(msg, ex);
logger.Error(msg, ex);
}
coll = DataSourceProvider.GetProvider(DataSourceType.Local).GetConnectionStrings(names);
return coll;
}
private static IReadOnlyDictionary<IConnectionStringIdentity, string> CreateConnectionStringMappings(ConnectionStringSettingsCollection configuration) =>
new Dictionary<IConnectionStringIdentity, string>
{
{ ErmTestConnectionStringIdentity.Instance, configuration[ConnectionStringName.Erm].ConnectionString },
{ FactsTestConnectionStringIdentity.Instance, configuration[ConnectionStringName.Facts].ConnectionString },
{ CustomerIntelligenceTestConnectionStringIdentity.Instance, configuration[ConnectionStringName.CustomerIntelligence].ConnectionString },
{ BitTestConnectionStringIdentity.Instance, configuration[ConnectionStringName.Bit].ConnectionString },
{ StatisticsTestConnectionStringIdentity.Instance, configuration[ConnectionStringName.Statistics].ConnectionString },
{ ErmMasterConnectionStringIdentity.Instance, configuration[ConnectionStringName.ErmMaster].ConnectionString },
};
public ConnectionStringConfigurationHacker()
{
_connectionStrings = ConfigurationManager.ConnectionStrings;
var fi = typeof(ConfigurationElementCollection)
.GetField(
"bReadOnly",
System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic
);
fi.SetValue(_connectionStrings, false);
}
private static IReadOnlyDictionary<IConnectionStringIdentity, string> CreateConnectionStringMappings(ConnectionStringSettingsCollection configuration)
{
var available = configuration.Cast<ConnectionStringSettings>().ToDictionary(x => x.Name, x => x.ConnectionString);
var known = new Dictionary<string, IConnectionStringIdentity>
{
{ ConnectionStringName.Erm, ErmConnectionStringIdentity.Instance },
{ ConnectionStringName.Facts, FactsConnectionStringIdentity.Instance },
{ ConnectionStringName.CustomerIntelligence, CustomerIntelligenceConnectionStringIdentity.Instance },
};
return available.Join(known, x => x.Key, x => x.Key, (x, y) => Tuple.Create(y.Value, x.Value)).ToDictionary(x => x.Item1, x => x.Item2);
}
public void TestInitialize()
{
Mock.SetupStatic(typeof(HttpContext));
Mock.SetupStatic(typeof(ConfigurationManager));
var connectionStrings = new ConnectionStringSettingsCollection();
connectionStrings.Add(new ConnectionStringSettings(CONNECTION_STRING_NAME, CONNECTION_STRING));
Mock.Arrange(() => ConfigurationManager.ConnectionStrings)
.Returns(connectionStrings)
.MustBeCalled();
}
private static ConnectionStringSettings GetConnectionStringSettings(ConnectionStringSettingsCollection section)
{
for (var i = 1; i < section.Count; i++) {
Console.WriteLine("{0} - {1}", i, ConfigurationManager.ConnectionStrings[i].Name);
Console.WriteLine(section[i].ConnectionString);
Console.WriteLine();
}
int index;
while (!Int32.TryParse(Console.ReadLine(), out index)) {
Console.WriteLine(ConsoleRunner.INVALID_NUMBER);
}
return ConfigurationManager.ConnectionStrings[index];
}
/// <summary>
/// Reads connection string.
/// </summary>
public static string ReadConnectionString(ConnectionStringSettingsCollection source, string name)
{
ConnectionStringSettings settings = source[name];
if (settings != null)
{
string str = settings.ConnectionString;
if (!String.IsNullOrEmpty(str))
{
return str;
}
}
string message = String.Format("Connection string '{0}' is not found.", name);
throw new ConfigurationErrorsException(message);
}
public void Cerrar()
{
//string[] datosArchivoConfig = Funcion.leerArchivo(@"\\Aircontrol\c\Program Files (x86)\AIRCONTROL\Conexion.shc");
//string[] servidorPuerto = datosArchivoConfig[0].Split(':');
//connection = new SqlConnection("Data Source=DESKTOP-FUFA7EG\\ANDRES;Initial Catalog=BDComiSuper2;Integrated Security=True");
//connection = new SqlConnection("Data Source=DJSERATO\\SQLEXPRESS;Initial Catalog=BDComiSuper2;Integrated Security=True");
System.Configuration.ConnectionStringSettingsCollection connec = ConfigurationManager.ConnectionStrings;
String con = connec[1].ToString();
connection = new SqlConnection(con);
//connection = new SqlConnection("data source = DESKTOP-GH9GHBJ, 1433; initial catalog = BDComiSuper2;Integrated Security=True");
connection.Close();
}
/// <summary>
/// 根据连接字符串的名称查找连接字符串
/// </summary>
/// <param name="connName"></param>
/// <returns></returns>
public static String GetConnString(String connName)
{
if (m_ConnStrings == null)
{
m_ConnStrings = GetConnectionStrings();
}
foreach (ConnectionStringSettings item in m_ConnStrings)
{
if (item.Name == connName)
return item.ConnectionString;
}
return String.Empty;
}
public void DeleteAll()
{
using (SchoolDBEntities pb = conn.GetContext())
{
System.Configuration.ConnectionStringSettingsCollection connectionStrings =
WebConfigurationManager.ConnectionStrings as ConnectionStringSettingsCollection;
if (connectionStrings.Count > 0)
{
System.Data.Linq.DataContext db = new System.Data.Linq.DataContext(connectionStrings["ConnectionString"].ConnectionString);
db.ExecuteCommand("TRUNCATE TABLE CityInfo");
}
}
}
internal AppConfig(
ConnectionStringSettingsCollection connectionStrings,
KeyValueConfigurationCollection appSettings,
EntityFrameworkSection entityFrameworkSettings,
ProviderServicesFactory providerServicesFactory = null)
{
DebugCheck.NotNull(connectionStrings);
_connectionStrings = connectionStrings;
_appSettings = appSettings ?? new KeyValueConfigurationCollection();
_entityFrameworkSettings = entityFrameworkSettings ?? new EntityFrameworkSection();
_providerServicesFactory = providerServicesFactory ?? new ProviderServicesFactory();
_providerServices = new Lazy<IList<NamedDbProviderService>>(
() => _entityFrameworkSettings
.Providers
.OfType<ProviderElement>()
.Select(
e => new NamedDbProviderService(
e.InvariantName,
_providerServicesFactory.GetInstance(e.ProviderTypeName, e.InvariantName)))
.ToList());
if (_entityFrameworkSettings.DefaultConnectionFactory.ElementInformation.IsPresent)
{
_defaultConnectionFactory = new Lazy<IDbConnectionFactory>(
() =>
{
var setting = _entityFrameworkSettings.DefaultConnectionFactory;
try
{
var type = setting.GetFactoryType();
var args = setting.Parameters.GetTypedParameterValues();
return (IDbConnectionFactory)Activator.CreateInstance(type, args);
}
catch (Exception ex)
{
throw new InvalidOperationException(
Strings.SetConnectionFactoryFromConfigFailed(setting.FactoryTypeName), ex);
}
}, isThreadSafe: true);
}
else
{
_defaultConnectionFactory = _defaultDefaultConnectionFactory;
}
}
public static void ClassInitialize(TestContext context)
{
ServiceLocator.Initialize();
manager1 = Isolate.Fake.Instance<IConfigurationManager>();
NameValueCollection appSettings1 = new NameValueCollection();
appSettings1.Add("Test1", "Value1");
manager1.AppSettings = appSettings1;
ServiceLocator.RegisterInstance<IConfigurationManager>("manager1", manager1);
manager2 = Isolate.Fake.Instance<IConfigurationManager>();
NameValueCollection appSettings2 = new NameValueCollection();
appSettings2.Add("Test2", "Value2");
manager2.AppSettings = appSettings2;
ConnectionStringSettingsCollection connectionStrings2 = new ConnectionStringSettingsCollection();
connectionStrings2.Add(new ConnectionStringSettings("ConnectionString", "ConnectionStringTest"));
manager2.ConnectionStrings = connectionStrings2;
ServiceLocator.RegisterInstance<IConfigurationManager>("manager2", manager2);
}
public override ConnectionStringSettingsCollection GetConnectionStrings(string[] names)
{
if (succeed)
return new ConnectionStringSettingsCollection();
Cat.LogEvent("LoadDataSource.Source", "local");
logger.Info("Load data source from local.");
var coll = new ConnectionStringSettingsCollection();
var nameList = new List<string>(names).ConvertAll(n => n.ToLower());
var settings = new XmlReaderSettings();
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.IgnoreWhitespace = true;
settings.IgnoreComments = true;
settings.IgnoreProcessingInstructions = true;
using (var reader = XmlReader.Create(filePath, settings))
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "add")
{
string name = reader.GetAttribute("name");
if (name != null)
{
int index = nameList.IndexOf(name.ToLower());
if (index > -1)
{
var connStr = FetchConnectionString(name, reader);
connStr.ConnectionString = decryptor.DecryptConnectionString(connStr.Name, connStr.ConnectionString);
coll.Add(connStr);
Cat.LogEvent("LoadDataSource.Entry", name);
logger.Info("Data source - " + name, "ok");
nameList.RemoveAt(index);
if (nameList.Count == 0)
break;
}
}
}
}
}
succeed = true;
return coll;
}
public void AddsConnectionStrings(string name, string connectionString, string providerName)
{
var connectionStrings = new ConnectionStringSettingsCollection
{
new ConnectionStringSettings { Name = name, ConnectionString = connectionString, ProviderName = providerName }
};
var provider = new ConnectionStringsConfigurationProvider(connectionStrings);
provider.Load();
string configurationConnectionString;
Assert.True(provider.TryGet($"Data:{name}:ConnectionString", out configurationConnectionString));
Assert.Equal(connectionString, configurationConnectionString);
string configurationProviderName;
Assert.True(provider.TryGet($"Data:{name}:ProviderName", out configurationProviderName));
Assert.Equal(providerName, configurationProviderName);
}
private static ConnectionStringSettings GetConnectionStringSettings(ConnectionStringSettingsCollection section)
{
Console.WriteLine("You have to provide a connectionstring and a database provider. I couldn't detect them, so pick one from app.config:");
Console.WriteLine("");
for (var i = 0; i < section.Count; i++) {
Console.WriteLine("{0} - {1}", i, section[i].Name);
Console.WriteLine(section[i].ConnectionString);
Console.WriteLine();
}
Console.Write("> ");
int index;
while (!Int32.TryParse(Console.ReadLine(), out index)) {
Console.WriteLine(ConsoleRunner.INVALID_NUMBER);
}
Console.WriteLine("");
Console.WriteLine("--------------------------------");
return section[index];
}
public void conectarBDFact()
{
try
{
//string[] datosArchivoConfig = Funcion.leerArchivo(@"\\Aircontrol\c\Program Files (x86)\AIRCONTROL\Conexion.shc");
//string[] servidorPuerto = datosArchivoConfig[0].Split(':');
//connection = new SqlConnection("Data Source=DJSERATO\\SQLEXPRESS;Initial Catalog=BDFacturacionElectronica;Integrated Security=True");
System.Configuration.ConnectionStringSettingsCollection connec = ConfigurationManager.ConnectionStrings;
String con = connec[2].ToString();
connection = new SqlConnection(con);
connection.Open();
}
catch (SqlException ex)
{
MessageBox.Show("Error al conectarse a la Base De Datos " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
}
}
public void conectarBDFact()
{
try
{
//string[] datosArchivoConfig = Funcion.leerArchivo(@"\\Aircontrol\c\Program Files (x86)\AIRCONTROL\Conexion.shc");
//string[] servidorPuerto = datosArchivoConfig[0].Split(':');
//connection = new SqlConnection("data source = AIRCONTROL, 1433; initial catalog = BDComisariato; user id = COMI; password = server@1;");
System.Configuration.ConnectionStringSettingsCollection connec = ConfigurationManager.ConnectionStrings;
String con = connec[2].ToString();
connection = new SqlConnection(con);
//connection = new SqlConnection("data source = SERVER, 1433; initial catalog = BDComisariato; user id = COMI; password = server@1;");
connection.Open();
}
catch (SqlException ex)
{
MessageBox.Show("Error al conectarse a la Base De Datos " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
}
}
internal static void ParseCommandLineArguments(CommandLineOptions options, CommandLineParser parser, ConnectionStringSettingsCollection connectionStrings,
out string connectionString,
out string migrationNamespace,
out string moduleName,
out string versioningTableName,
out string versioningTableSchema,
out string[] includedSchemas,
out string[] excludedTables,
out bool includeData)
{
if (parser.Parameters.Length < 1 || // expect at least the target
parser.UnhandledSwitches.Length > 0)
{
throw new InvalidCommandLineArgumentException("Invalid command line arguments. Specify the target." + Environment.NewLine + Environment.NewLine + GetUsageMessage(parser),
InvalidArgumentsExitCode);
}
// connection string
string target = parser.Parameters[0];
ConnectionStringSettings settings = connectionStrings[target];
if (settings == null)
{
throw new InvalidCommandLineArgumentException(string.Format(CultureInfo.CurrentCulture,
"Missing target: '{0}'. Could not find entry in the configuration file.", target),
InvalidTargetExitCode);
}
connectionString = settings.ConnectionString;
if (connectionString == null)
{
throw new InvalidCommandLineArgumentException(string.Format(CultureInfo.CurrentCulture,
"Empty target: '{0}'. The entry in the configuration file is empty.", target),
InvalidTargetExitCode);
}
// additional parameters
migrationNamespace = options.Namespace;
moduleName = options.ModuleName;
versioningTableName = options.VersioningTableName;
versioningTableSchema = options.VersioningTableSchema;
includedSchemas = (options.Schemas ?? string.Empty).Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
excludedTables = (options.Exclude ?? string.Empty).Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
includeData = options.IncludeData;
}
/// <summary>
/// Gets the connection string based on the underlying data configuration.
/// </summary>
/// <returns>Returns the connection string as a <see cref="string"/>.</returns>
public static string GetConnectionString()
{
var dbConfiguration = DaDataConfigurationManager.GetConfiguration();
var dbConnection = dbConfiguration.DbConnection;
var configurationSource = DaDataConfigurationManager.ConfigurationSource;
string connectionString = string.Empty;
if (configurationSource != null)
{
System.Configuration.ConnectionStringSettingsCollection connectionStrings = DaDataConfigurationManager.ConfigurationSource.GetConnectionStrings();
if (connectionStrings != null)
{
ConnectionStringSettings connectionStringSettings = null;
try
{
connectionStringSettings = connectionStrings[dbConnection];
}
catch (Exception)
{
// Ignore the exception as it simply means that the connection string doesn't exist in the configuration.
}
if (connectionStringSettings == null)
{
connectionStringSettings = new ConnectionStringSettings()
{
Name = dbConnection,
ProviderName = "System.Data.SqlClient",
ConnectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=DevAccelerateDb;Integrated Security=True"
};
}
connectionString = connectionStringSettings.ConnectionString;
}
}
return(connectionString);
}
/// <summary>
/// 添加连接字符串
/// </summary>
/// <param name="connStrings"><see cref="ConnectionStringSettingsCollection"/> 实例</param>
internal static void AddConnectionStrings(ConnectionStringSettingsCollection connStrings)
{
if (connStrings == null || connStrings.Count == 0)
return;
var newCollection = new ConnectionStringSettingsCollection();
foreach (ConnectionStringSettings connStr in connStrings)
{
newCollection.Add(connStr);
}
foreach (ConnectionStringSettings connStr in instance.collection)
{
if (newCollection[connStr.Name] == null)
newCollection.Add(new ConnectionStringSettings(connStr.Name, connStr.ConnectionString, connStr.ProviderName));
}
instance.collection = newCollection;
}
/// <summary>
/// Merges two ConnectionStringSettingsCollections.
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
public static ConnectionStringSettingsCollection Merge(this ConnectionStringSettingsCollection first, ConnectionStringSettingsCollection second)
{
if (second == null)
return first;
if (ReferenceEquals(first, second))
return first;
foreach (ConnectionStringSettings item in second)
{
ConnectionStringSettings itemInSecond = item;
ConnectionStringSettings existingItem = first.Cast<ConnectionStringSettings>().FirstOrDefault(x => x.Name == itemInSecond.Name);
if (existingItem != null)
{
first.Remove(item);
}
first.Add(item);
}
return first;
}
public DataTable Getexeldata()
{
List <VTelContact> result = new List <VTelContact>();
using (PersonsDBEntities ent = conn.GetContext())
{
System.Configuration.ConnectionStringSettingsCollection connectionStrings =
WebConfigurationManager.ConnectionStrings as ConnectionStringSettingsCollection;
if (connectionStrings.Count > 0)
{
DataContext db = new DataContext(connectionStrings["ConnectionString"].ConnectionString);
result = db.ExecuteQuery <VTelContact>(
string.Format(
"SELECT * from VTelContacts"
)
).ToList();
}
}
return(PersonTools.ToDataTable(result));
}
public SqlService(String ConnectionStringName, Int16 secondsToTimeOut)
{
sqlExecuted = false;
System.Configuration.ConnectionStringSettingsCollection connections = System.Configuration.ConfigurationManager.ConnectionStrings;
if (connections == null)
{
sqlMessage = "APLPXServices.sqlService, Invalid App.config: SQL Connections section missing or invalid";
}
else
{
try {
System.Configuration.ConnectionStringSettings connectionString = ConfigurationManager.ConnectionStrings[ConnectionStringName];
if (connectionString == null)
{
sqlMessage = "APLPXServices.sqlService, Invalid App.config: SQL Connection name " + ConnectionStringName + " missing or invalid";
}
else
{
sqlConnection = new System.Data.SqlClient.SqlConnection(ConfigurationManager.ConnectionStrings[ConnectionStringName].ConnectionString.ToString());
sqlConnection.Open();
if (sqlConnection.State == System.Data.ConnectionState.Open)
{
sqlConnected = true; sqlExecuted = true; sqlCommandTimeOut = secondsToTimeOut;
}
sqlMessage = "APLPXServices.sqlService initialized, connection status: " + sqlConnection.State.ToString();
}
}
catch (System.Configuration.ConfigurationException ex1) {
sqlMessage = "APLPXServices.sqlService, Invalid configuration, " + ex1.Source + ", " + ex1.Message;
}
catch (System.Data.SqlClient.SqlException ex2) {
sqlMessage = "APLPXServices.sqlService, Invalid connection, " + ex2.Source + ", " + ex2.Message;
}
catch (System.Exception ex3) {
sqlMessage = "APLPXServices.sqlService, " + ex3.Source + ", " + ex3.Message;
}
}
}
internal AppConfig(
ConnectionStringSettingsCollection connectionStrings,
KeyValueConfigurationCollection appSettings,
EntityFrameworkSection entityFrameworkSettings)
{
//Contract.Requires(connectionStrings != null);
_connectionStrings = connectionStrings;
_appSettings = appSettings;
_entityFrameworkSettings = entityFrameworkSettings ?? new EntityFrameworkSection();
if (_entityFrameworkSettings.DefaultConnectionFactory.ElementInformation.IsPresent)
{
_defaultConnectionFactory = new Lazy<IDbConnectionFactory>(
() =>
{
var setting = _entityFrameworkSettings.DefaultConnectionFactory;
try
{
var type = setting.GetFactoryType();
var args = setting.Parameters.GetTypedParameterValues();
return (IDbConnectionFactory)Activator.CreateInstance(type, args);
}
catch (Exception ex)
{
throw new InvalidOperationException(
Strings.SetConnectionFactoryFromConfigFailed(setting.FactoryTypeName), ex);
}
}, isThreadSafe: true);
}
else
{
_defaultConnectionFactory = _defaultDefaultConnectionFactory;
}
}
internal ConnectionStrings(ConnectionStringSettingsCollection connectionStrings)
{
this.connectionStrings = connectionStrings;
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties)
{
SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();
string sectionName = this.GetSectionName(context);
IDictionary dictionary = this.Store.ReadSettings(sectionName, false);
IDictionary dictionary2 = this.Store.ReadSettings(sectionName, true);
ConnectionStringSettingsCollection settingss = this.Store.ReadConnectionStrings();
foreach (SettingsProperty property in properties)
{
string name = property.Name;
SettingsPropertyValue value2 = new SettingsPropertyValue(property);
SpecialSettingAttribute attribute = property.Attributes[typeof(SpecialSettingAttribute)] as SpecialSettingAttribute;
if ((attribute != null) ? (attribute.SpecialSetting == SpecialSetting.ConnectionString) : false)
{
string str3 = sectionName + "." + name;
if ((settingss != null) && (settingss[str3] != null))
{
value2.PropertyValue = settingss[str3].ConnectionString;
}
else if ((property.DefaultValue != null) && (property.DefaultValue is string))
{
value2.PropertyValue = property.DefaultValue;
}
else
{
value2.PropertyValue = string.Empty;
}
value2.IsDirty = false;
values.Add(value2);
}
else
{
bool flag2 = this.IsUserSetting(property);
if (flag2 && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
throw new ConfigurationErrorsException(System.SR.GetString("UserSettingsNotSupported"));
}
IDictionary dictionary3 = flag2 ? dictionary2 : dictionary;
if (dictionary3.Contains(name))
{
StoredSetting setting = (StoredSetting)dictionary3[name];
string innerXml = setting.Value.InnerXml;
if (setting.SerializeAs == SettingsSerializeAs.String)
{
innerXml = this.Escaper.Unescape(innerXml);
}
value2.SerializedValue = innerXml;
}
else if (property.DefaultValue != null)
{
value2.SerializedValue = property.DefaultValue;
}
else
{
value2.PropertyValue = null;
}
value2.IsDirty = false;
values.Add(value2);
}
}
return(values);
}
/// <summary>
/// Abstract SettingsProvider method
/// </summary>
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties)
{
SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();
string sectionName = GetSectionName(context);
// Look for this section in both applicationSettingsGroup and userSettingsGroup
IDictionary appSettings = ClientSettingsStore.ReadSettings(sectionName, false);
IDictionary userSettings = ClientSettingsStore.ReadSettings(sectionName, true);
ConnectionStringSettingsCollection connStrings = ClientSettingsStore.ReadConnectionStrings();
// Now map each SettingProperty to the right StoredSetting and deserialize the value if found.
foreach (SettingsProperty setting in properties)
{
string settingName = setting.Name;
SettingsPropertyValue value = new SettingsPropertyValue(setting);
// First look for and handle "special" settings
SpecialSettingAttribute attr = setting.Attributes[typeof(SpecialSettingAttribute)] as SpecialSettingAttribute;
bool isConnString = (attr != null) ? (attr.SpecialSetting == SpecialSetting.ConnectionString) : false;
if (isConnString)
{
string connStringName = sectionName + "." + settingName;
if (connStrings != null && connStrings[connStringName] != null)
{
value.PropertyValue = connStrings[connStringName].ConnectionString;
}
else if (setting.DefaultValue != null && setting.DefaultValue is string)
{
value.PropertyValue = setting.DefaultValue;
}
else
{
//No value found and no default specified
value.PropertyValue = string.Empty;
}
value.IsDirty = false; //reset IsDirty so that it is correct when SetPropertyValues is called
values.Add(value);
continue;
}
// Not a "special" setting
bool isUserSetting = IsUserSetting(setting);
if (isUserSetting && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
// We encountered a user setting, but the current configuration system does not support
// user settings.
throw new ConfigurationErrorsException(SR.UserSettingsNotSupported);
}
IDictionary settings = isUserSetting ? userSettings : appSettings;
if (settings.Contains(settingName))
{
StoredSetting ss = (StoredSetting)settings[settingName];
string valueString = ss.Value.InnerXml;
// We need to un-escape string serialized values
if (ss.SerializeAs == SettingsSerializeAs.String)
{
valueString = Escaper.Unescape(valueString);
}
value.SerializedValue = valueString;
}
else if (setting.DefaultValue != null)
{
value.SerializedValue = setting.DefaultValue;
}
else
{
//No value found and no default specified
value.PropertyValue = null;
}
value.IsDirty = false; //reset IsDirty so that it is correct when SetPropertyValues is called
values.Add(value);
}
return(values);
}
protected override ConfigurationSection Arrange_GetLocalSourceSection()
{
ConnectionStringSettingsCollection localConnectionStrings = new ConnectionStringSettingsCollection();
localConnectionStrings.Add(new ConnectionStringSettings("name1", "overwrite"));
localConnectionStrings.Add(new ConnectionStringSettings("name3", "connstr3"));
localConnectionStrings.EmitClear = true;
return new DummySectionWithCollections
{
ConnectionStringSettingsCollection = localConnectionStrings
};
}
protected override ConfigurationSection Arrange_GetParentSourceSection()
{
ConnectionStringSettingsCollection parentConnectionStrings = new ConnectionStringSettingsCollection();
parentConnectionStrings.Add(new ConnectionStringSettings("name1", "connstr1"));
parentConnectionStrings.Add(new ConnectionStringSettings("name2", "connstr2"));
return new DummySectionWithCollections
{
ConnectionStringSettingsCollection = parentConnectionStrings
};
}
private ConnectionStringSettingsCollection GetConnectionStrings()
{
var result = new ConnectionStringSettingsCollection();
var section = GetSection("connectionStrings") as ConnectionStringsSection;
if (section != null)
{
foreach (ConnectionStringSettings settings in section.ConnectionStrings)
result.Add(settings);
}
return result;
}
static Configuration()
{
System.Configuration.ConnectionStringSettingsCollection coll = System.Web.Configuration.WebConfigurationManager.ConnectionStrings;
siteDBConnection = coll["SiteDBConnection"].ConnectionString;
}
/// <summary>
/// Initializes a new instance of AppConfig based on supplied connection strings
/// The default configuration for database initializers and default connection factory will be used
/// </summary>
/// <param name="connectionStrings"> Connection strings to be used </param>
public AppConfig(ConnectionStringSettingsCollection connectionStrings)
: this(connectionStrings, null, null)
{
DebugCheck.NotNull(connectionStrings);
}
/// <summary>
/// Initializes a new instance of AppConfig based on supplied connection strings
/// The default configuration for database initializers and default connection factory will be used
/// </summary>
/// <param name="connectionStrings">Connection strings to be used</param>
public AppConfig(ConnectionStringSettingsCollection connectionStrings)
: this(connectionStrings, null, null)
{
//Contract.Requires(connectionStrings != null);
}
