public void CanDeserializeSerializedConfiguration()
{
DatabaseSettings settings = new DatabaseSettings();
DbProviderMapping mappingData1 = new DbProviderMapping(providerName1, typeof(OracleDatabase));
DbProviderMapping mappingData2 = new DbProviderMapping(providerName2, typeof(SqlDatabase));
settings.DefaultDatabase = databaseName1;
settings.ProviderMappings.Add(mappingData1);
settings.ProviderMappings.Add(mappingData2);
IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
sections[DatabaseSettings.SectionName] = settings;
IConfigurationSource configurationSource
= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
DatabaseSettings roSettigs = (DatabaseSettings)configurationSource.GetSection(DatabaseSettings.SectionName);
Assert.IsNotNull(roSettigs);
Assert.AreEqual(2, roSettigs.ProviderMappings.Count);
Assert.AreEqual(databaseName1, roSettigs.DefaultDatabase);
Assert.IsNotNull(roSettigs.ProviderMappings.Get(providerName1));
Assert.AreSame(typeof(OracleDatabase), roSettigs.ProviderMappings.Get(providerName1).DatabaseType);
Assert.AreEqual(providerName1, roSettigs.ProviderMappings.Get(providerName1).DbProviderName);
}
public void SetUp()
{
provider = new DatabaseSettingsManageabilityProvider(new Dictionary<Type, ConfigurationElementManageabilityProvider>(0));
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
section = new DatabaseSettings();
}
public Settings()
{
Database = new DatabaseSettings();
LobbyServer = new LobbyServerSettings();
AuthServer = new AuthServerSettings();
GameServer = new GameServerSettings();
}
public ServerSettings()
{
Database = new DatabaseSettings()
{
Server = "localhost",
Name = "queue",
Type = DatabaseType.MsSql,
Integrated = true
};
Services = new ServicesConfig()
{
HttpService = new HttpServiceConfig()
{
Enabled = false,
Host = "localhost",
Port = 4506
},
TcpService = new TcpServiceConfig()
{
Enabled = true,
Host = "localhost",
Port = 4505
}
};
Licence = new ProductLicenceConfig()
{
LicenseType = ProductLicenceType.NonCommercial,
SerialKey = DefaultSerialKey,
RegisterKey = DefaultRegisterKey
};
Language = CultureInfo.CurrentCulture.GetLanguage();
}
/// <summary>
/// Gets the database.
/// </summary>
/// <param name="databaseName">Name of the connection string.</param>
/// <returns>The <see cref="T:Cedar.Core.Data.Database" />.</returns>
public Database GetDatabase(string databaseName)
{
Guard.ArgumentNotNullOrEmpty(databaseName, "databaseName");
ConnectionStringsSection connectionStringsSection;
if (!ConfigManager.TryGetConfigurationSection("connectionStrings", out connectionStringsSection))
{
throw new ConfigurationErrorsException(Resources.ExceptionNoConnectionStringSection);
}
ConnectionStringSettings connectionStringSettings = connectionStringsSection.ConnectionStrings[databaseName];
ValidateConnectionStringSettings(databaseName, connectionStringSettings);
DatabaseSettings databaseSettings;
if (!ConfigManager.TryGetConfigurationSection("dataConfiguration", out databaseSettings))
{
databaseSettings = new DatabaseSettings();
}
if (DbProviderFactories.GetFactoryClasses().Rows.Find(connectionStringSettings.ProviderName) == null)
{
throw new ConfigurationErrorsException(Resources.ExceptionNoProviderDefinedForConnectionString.Format(new object[]
{
databaseName
}), connectionStringSettings.ElementInformation.Source, connectionStringSettings.ElementInformation.LineNumber);
}
DatabaseData databaseData = GetDatabaseData(connectionStringSettings, databaseSettings);
Microsoft.Practices.EnterpriseLibrary.Data.Database database = databaseData.BuildDatabase();
return new DatabaseWrapper(() => database, databaseName);
}
public DatabaseSettings Build()
{
DatabaseSettings settings = new DatabaseSettings();
foreach (ProviderMappingNode node in hierarchy.FindNodesByType(databaseSectionNode, typeof(ProviderMappingNode)))
{
settings.ProviderMappings.Add(node.ProviderMapping);
}
if (null != databaseSectionNode.DefaultDatabase) settings.DefaultDatabase = databaseSectionNode.DefaultDatabase.Name;
return settings;
}
/// <summary>
/// <para>Initialize a new instance of the <see cref="DatabaseSettingsNode"/> class with a <see cref="DatabaseSettings"/> object.</para>
/// </summary>
/// <param name="databaseSettings">
/// <para>The <see cref="DatabaseSettings"/> runtime configuration.</para>
/// </param>
public DatabaseSettingsNode(DatabaseSettings databaseSettings)
: base()
{
if (databaseSettings == null)
{
throw new ArgumentNullException("databaseSettings");
}
this.databaseSettings = databaseSettings;
this.instanceRemovedHandler = new ConfigurationNodeChangedEventHandler(OnInstanceNodeRemoved);
this.instanceRenameHandler = new ConfigurationNodeChangedEventHandler(OnInstanceNodeRenamed);
}
public PRoConDatabaseProvider(DatabaseSettings settings)
{
this.databaseConfiguration = new Configuration();
this.databaseConfiguration.Properties.Add("connection.provider_class",
typeof (DriverConnectionProvider).FullName);
this.databaseConfiguration.Properties.Add("connection.driver_class", settings.DriverClass);
this.databaseConfiguration.Properties.Add("connection.connection_string", settings.ConnectionString);
this.databaseConfiguration.Properties.Add("dialect", settings.Dialect);
this.databaseConfiguration.Properties.Add("proxyfactory.factory_class",
typeof (ProxyFactoryFactory).AssemblyQualifiedName);
this.databaseConfiguration.AddInputStream(
HbmSerializer.Default.Serialize(typeof (Player).Assembly));
this.activeSessionFactory = this.databaseConfiguration.BuildSessionFactory();
}
public DatabaseSectionNodeBuilder(IServiceProvider serviceProvider, DatabaseSettings databaseSettings)
: base(serviceProvider)
{
this.databaseSettings = databaseSettings;
}
public OriginDapperRepository(IOptions <DatabaseSettings> databaseSettings)
{
_databaseSettings = databaseSettings.Value;
}
public UserService(DatabaseSettings settings, IMessagePublisher publisher)
{
_settings = settings;
_publisher = publisher;
}
public Database(
DatabaseSettings databaseSettings
)
{
_sqlConnection = new SqlConnection(databaseSettings.ConnectionString);
}
public LogConfiguration(DatabaseSettings settings) : base(settings)
{
}
public static void SetBusiness()
{
DatabaseSettings.SetDatabase();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false);
var config = builder.Build();
TokenSettings = config.GetSection("token").Get <TokenSettings>();
TokenSettings.SigningCredentials = new SigningCredentials(
new SymmetricSecurityKey(Encoding.ASCII.GetBytes(TokenSettings.Key)), SecurityAlgorithms.HmacSha256Signature);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
builder.AddUserSecrets <Startup>();
}
app.UseAuthentication();
app.UseCors(c =>
c.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
app.Use((context, next) =>
{
if (context.Request.GetUri().AbsoluteUri.Contains("localhost"))
{
if (DatabaseSettings == null)
{
DatabaseSettings = new DatabaseSettings();
config.GetSection("db:test").Bind(DatabaseSettings);
DatabaseSettings.MainConnectionString = config.GetSection("db:test:ConnectionString").Value;
}
var testDb = $"{DatabaseSettings.ConnectionString.Split("=")[1]}";
if (!File.Exists(testDb))
{
SQLiteConnection.CreateFile(testDb);
var script = File.ReadAllText(DatabaseSettings.Scripts.Main);
RepositoryBase.RunScript(script, DatabaseSettings.ConnectionString);
}
}
return(next());
});
app.Use((context, next) =>
{
string authorization = context.Request.Headers["Authorization"];
if (string.IsNullOrEmpty(authorization))
{
return(next());
}
if (authorization.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase))
{
authorization = authorization.Substring("Bearer ".Length).Trim().Replace("\"", string.Empty);
}
var handler = new JwtSecurityTokenHandler();
var token = handler.ReadJwtToken(authorization);
if (token == null)
{
context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
return(next());
}
var service = (IAccountService)app.ApplicationServices.GetService(typeof(IAccountService));
var vendor = service.GetVendorFromToken(token.Payload.Jti);
if (vendor != null)
{
var format = config.GetSection("db:db-vendor:ConnectionString").Value;
DatabaseSettings.ConnectionString = string.Format(format, vendor.Name);
DatabaseSettings.Admin = true;
}
return(next());
});
app.Use((context, next) =>
{
string vendor;
if (context.Request.Query.ContainsKey("vendor") &&
!string.IsNullOrEmpty(vendor = context.Request.Query["vendor"].ToString()))
{
var format = config.GetSection("db:db-vendor:ConnectionString").Value;
DatabaseSettings.VendorName = vendor;
DatabaseSettings.ConnectionString = string.Format(format, vendor);
DatabaseSettings.Admin = false;
}
return(next());
});
app.UseMvc(); //.Run(async (context) => { await context.Response.WriteAsync("Hello World!"); });
}
public SQLiteContactsRepository(DatabaseSettings settings)
{
m_DataContext = new SQLiteAsyncConnection(settings.ConnectionString, Flags);
InitializeDatabaseAsync(settings.ConnectionString).SafeFireAndForget(false);
}
public SqlServerDurableOutgoing(IDatabaseSession session, DatabaseSettings settings, JasperOptions options) : base(session, settings, options)
{
_session = session;
_settings = settings;
_cancellation = options.Cancellation;
}
/// <summary>
/// Create an instance of the database client.
/// </summary>
/// <param name="dbType">The type of database.</param>
/// <param name="serverIp">The IP address or hostname of the database server.</param>
/// <param name="serverPort">The TCP port of the database server.</param>
/// <param name="username">The username to use when authenticating with the database server.</param>
/// <param name="password">The password to use when authenticating with the database server.</param>
/// <param name="instance">The instance on the database server (for use with Microsoft SQL Server).</param>
/// <param name="database">The name of the database with which to connect.</param>
public DatabaseClient(
DbTypes dbType,
string serverIp,
int serverPort,
string username,
string password,
string instance,
string database)
{
if (dbType == DbTypes.Sqlite)
{
throw new ArgumentException("Use the filename constructor for Sqlite databases.");
}
if (String.IsNullOrEmpty(serverIp))
{
throw new ArgumentNullException(nameof(serverIp));
}
if (serverPort < 0)
{
throw new ArgumentOutOfRangeException(nameof(serverPort));
}
if (String.IsNullOrEmpty(database))
{
throw new ArgumentNullException(nameof(database));
}
if (dbType == DbTypes.SqlServer)
{
_Settings = new DatabaseSettings(serverIp, serverPort, username, password, instance, database);
}
else
{
if (!String.IsNullOrEmpty(instance))
{
throw new ArgumentException("Instance can only be used in database settings of type 'SqlServer'.");
}
_Settings = new DatabaseSettings(dbType, serverIp, serverPort, username, password, database);
}
_Header = "[DatabaseWrapper." + _Settings.Type.ToString() + "] ";
switch (_Settings.Type)
{
case DbTypes.Sqlite:
throw new ArgumentException("Unable to use this constructor with 'DbTypes.Sqlite'.");
case DbTypes.Mysql:
_Mysql = new Mysql.DatabaseClient(_Settings);
break;
case DbTypes.Postgresql:
_Postgresql = new Postgresql.DatabaseClient(_Settings);
break;
case DbTypes.SqlServer:
_SqlServer = new SqlServer.DatabaseClient(_Settings);
break;
default:
throw new ArgumentException("Unknown database type '" + _Settings.Type.ToString() + "'.");
}
}
protected ABaseIEntityConfiguration(DatabaseSettings settings) : base(settings)
{
}
public static IServiceCollection AddApplicationDbContext <TContext>(this IServiceCollection services, DatabaseSettings databaseSettings, ServiceLifetime serviceLifetime = ServiceLifetime.Scoped)
where TContext : DbContext
{
if (databaseSettings == null)
{
throw new ArgumentNullException(nameof(databaseSettings));
}
services
.AddSingleton(Options.Create(databaseSettings))
.AddEntityFrameworkSqlServer()
.AddDbContext <TContext>(serviceLifetime);
return(services);
}
/// <summary>
/// Gets the database settings.
/// </summary>
/// <returns></returns>
private static DatabaseSettings GetDatabaseSettings( )
{
string username = null;
string password = null;
string server = Settings.Default.DatabaseServer;
string catalog = Settings.Default.DatabaseCatalog;
bool useIntegratedSecurity = Settings.Default.DatabaseUseIntegratedSecurity;
if (!useIntegratedSecurity)
{
username = Settings.Default.DatabaseUsername;
password = Settings.Default.DatabasePassword;
}
if (string.IsNullOrEmpty(server))
{
server = "localhost";
}
if (string.IsNullOrEmpty(catalog))
{
catalog = "SoftwarePlatform";
}
var databaseSettings = new DatabaseSettings(server, catalog, username, password, useIntegratedSecurity);
var manager = new DatabaseManager(databaseSettings);
bool modified = false;
while (!manager.TestConnection( ))
{
modified = true;
databaseSettings = null;
var properties = new DatabaseProperties( );
properties.ShowDialog( );
var vm = properties.DataContext as DatabasePropertiesViewModel;
if (vm != null && vm.OkClicked)
{
databaseSettings = vm.DatabaseInfo;
manager = new DatabaseManager(databaseSettings);
}
else
{
break;
}
}
if (modified && databaseSettings != null)
{
Settings.Default.DatabaseServer = databaseSettings.ServerName;
Settings.Default.DatabaseCatalog = databaseSettings.CatalogName;
Settings.Default.DatabaseUseIntegratedSecurity = databaseSettings.UseIntegratedSecurity;
Settings.Default.DatabaseUsername = databaseSettings.Username;
Settings.Default.DatabasePassword = databaseSettings.Password;
Settings.Default.Save( );
}
return(databaseSettings);
}
public BreweryDapperRepository(IOptions <DatabaseSettings> databaseSettings)
{
_databaseSettings = databaseSettings.Value;
}
/* Called when clicking on the "settings" menu option */
private void SettingsClick(object sender, EventArgs e)
{
var frm = new DatabaseSettings();
frm.ShowDialog(this);
ConnStatus();
}
private DatabaseData GetDatabaseData(ConnectionStringSettings connectionString, DatabaseSettings databaseSettings)
{
return CreateDatabaseData(GetAttribute(GetProviderMapping(connectionString.ProviderName, databaseSettings).DatabaseType).ConfigurationType, connectionString);
}
public DatabaseRetryDecorator(ICommandHandler <TCommand> handler, DatabaseSettings config)
{
_config = config;
_handler = handler;
}
public async void EnsureSeedData(UserManager <IdentityUser> userManager, RoleManager <IdentityRole> roleManager, DatabaseSettings databaseSettings)
{
if (await roleManager.FindByNameAsync(databaseSettings.RoleSettings.UserRole) == null)
{
await roleManager.CreateAsync(new IdentityRole { Name = databaseSettings.RoleSettings.UserRole });
}
if (await roleManager.FindByNameAsync(databaseSettings.RoleSettings.AdminRole) == null)
{
await roleManager.CreateAsync(new IdentityRole { Name = databaseSettings.RoleSettings.AdminRole });
}
}
protected override IDurableIncoming buildDurableIncoming(DurableStorageSession durableStorageSession,
DatabaseSettings databaseSettings,
AdvancedSettings settings)
{
return(new PostgresqlDurableIncoming(durableStorageSession, databaseSettings, settings));
}
public SensorDataController(IOptions <DatabaseSettings> config, IDatabaseHandler <SensorData> database)
{
_database = database;
_config = config.Value;
_documentClient = new MongoClient(_config.MongoDbConnectionString);
}
public DatabaseSettingsControl(DatabaseSettings settings) : this()
{
_dbSettings = settings;
ShowSettings();
}
public GroupRepository(DatabaseSettings databaseSettings) : base(databaseSettings)
{
}
public UserRoleRepository(DatabaseSettings settings) : base(settings)
{
}
static void Main(string[] args)
{
try
{
#region Setup
Console.Write("Filename: ");
_Filename = Console.ReadLine();
if (String.IsNullOrEmpty(_Filename))
{
return;
}
_Settings = new DatabaseSettings(_Filename);
_Orm = new WatsonORM(_Settings);
_Orm.InitializeDatabase();
DebugSettings debug = new DebugSettings();
debug.DatabaseQueries = true;
debug.DatabaseResults = true;
_Orm.Logger = Logger;
_Orm.Debug = debug;
_Orm.InitializeTable(typeof(Person));
_Orm.TruncateTable(typeof(Person));
Console.WriteLine("Using table: " + _Orm.GetTableName(typeof(Person)));
#endregion
#region Create-and-Store-Records
Person p1 = new Person("Abraham", "Lincoln", Convert.ToDateTime("1/1/1980"), null, 42, null, "initial notes p1", PersonType.Human, null, false);
Person p2 = new Person("Ronald", "Reagan", Convert.ToDateTime("2/2/1981"), Convert.ToDateTime("3/3/1982"), 43, 43, "initial notes p2", PersonType.Cat, PersonType.Cat, true);
Person p3 = new Person("George", "Bush", Convert.ToDateTime("3/3/1982"), null, 44, null, "initial notes p3", PersonType.Dog, PersonType.Dog, false);
Person p4 = new Person("Barack", "Obama", Convert.ToDateTime("4/4/1983"), Convert.ToDateTime("5/5/1983"), 45, null, "initial notes p4", PersonType.Human, null, true);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Creating p1");
p1 = _Orm.Insert <Person>(p1);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Creating p2");
p2 = _Orm.Insert <Person>(p2);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Creating p3");
p3 = _Orm.Insert <Person>(p3);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Creating p4");
p4 = _Orm.Insert <Person>(p4);
#endregion
#region Select
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting many by column name");
DbExpression eSelect1 = new DbExpression("id", DbOperators.GreaterThan, 0);
List <Person> selectedList1 = _Orm.SelectMany <Person>(null, null, eSelect1);
Console.WriteLine("| Retrieved: " + selectedList1.Count + " records");
foreach (Person curr in selectedList1)
{
Console.WriteLine(" | " + curr.ToString());
}
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting many by property name");
DbExpression eSelect2 = new DbExpression(
_Orm.GetColumnName <Person>(nameof(Person.FirstName)),
DbOperators.Equals,
"Abraham");
List <Person> selectedList2 = _Orm.SelectMany <Person>(null, null, eSelect2);
Console.WriteLine("| Retrieved: " + selectedList2.Count + " records");
foreach (Person curr in selectedList2)
{
Console.WriteLine(" | " + curr.ToString());
}
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting by ID");
Person pSelected = _Orm.SelectByPrimaryKey <Person>(3);
Console.WriteLine("| Selected: " + pSelected.ToString());
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting first by column name");
DbExpression eSelect3 = new DbExpression("id", DbOperators.Equals, 4);
pSelected = _Orm.SelectFirst <Person>(eSelect3);
Console.WriteLine("| Selected: " + pSelected.ToString());
#endregion
#region Update-Records
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Updating p1");
p1.Notes = "updated notes p1";
p1 = _Orm.Update <Person>(p1);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Updating p2");
p2.Notes = "updated notes p2";
p2 = _Orm.Update <Person>(p2);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Updating p3");
p3.Notes = "updated notes p3";
p3 = _Orm.Update <Person>(p3);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Updating p4");
p4.Notes = "updated notes p4";
p4 = _Orm.Update <Person>(p4);
#endregion
#region Update-Many-Records
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Updating many records");
Dictionary <string, object> updateVals = new Dictionary <string, object>();
updateVals.Add(_Orm.GetColumnName <Person>("Notes"), "Updated during update many!");
_Orm.UpdateMany <Person>(eSelect1, updateVals);
#endregion
#region Select
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting many, test 1");
selectedList1 = _Orm.SelectMany <Person>(null, null, eSelect1);
Console.WriteLine("| Retrieved: " + selectedList1.Count + " records");
foreach (Person curr in selectedList1)
{
Console.WriteLine(" | " + curr.ToString());
}
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting by ID");
pSelected = _Orm.SelectByPrimaryKey <Person>(3);
Console.WriteLine("| Selected: " + pSelected.ToString());
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting first");
pSelected = _Orm.SelectFirst <Person>(eSelect2);
Console.WriteLine("| Selected: " + pSelected.ToString());
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting between, test 1");
DbExpression eSelect4 = DbExpression.Between("id", new List <object> {
2, 4
});
selectedList1 = _Orm.SelectMany <Person>(null, null, eSelect4);
Console.WriteLine("| Retrieved: " + selectedList1.Count + " records");
foreach (Person curr in selectedList1)
{
Console.WriteLine(" | " + curr.ToString());
}
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting by persontype");
DbExpression eSelect5 = new DbExpression("persontype", DbOperators.Equals, PersonType.Dog);
selectedList1 = _Orm.SelectMany <Person>(null, null, eSelect5);
Console.WriteLine("| Retrieved: " + selectedList1.Count + " records");
foreach (Person curr in selectedList1)
{
Console.WriteLine(" | " + curr.ToString());
}
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting handsome people");
DbExpression eSelect6 = new DbExpression("ishandsome", DbOperators.Equals, true);
selectedList1 = _Orm.SelectMany <Person>(null, null, eSelect6);
Console.WriteLine("| Retrieved: " + selectedList1.Count + " records");
foreach (Person curr in selectedList1)
{
Console.WriteLine(" | " + curr.ToString());
}
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Selecting by reverse ID order");
DbExpression eSelect7 = new DbExpression("id", DbOperators.GreaterThan, 0);
DbResultOrder[] resultOrder = new DbResultOrder[1];
resultOrder[0] = new DbResultOrder("id", DbOrderDirection.Descending);
selectedList1 = _Orm.SelectMany <Person>(null, null, eSelect7, resultOrder);
Console.WriteLine("| Retrieved: " + selectedList1.Count + " records");
foreach (Person curr in selectedList1)
{
Console.WriteLine(" | " + curr.ToString());
}
#endregion
#region Exception
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Catching exception and displaying query");
try
{
_Orm.Query("SELECT * FROM person (((");
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
Console.WriteLine("Query : " + e.Data["Query"]);
}
#endregion
#region Delete-Records
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Deleting p1");
_Orm.Delete <Person>(p1);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Deleting p2");
_Orm.DeleteByPrimaryKey <Person>(2);
for (int i = 0; i < 8; i++)
{
Console.WriteLine("");
}
Console.WriteLine("| Deleting p3 and p4");
DbExpression eDelete = new DbExpression("id", DbOperators.GreaterThan, 2);
_Orm.DeleteMany <Person>(eDelete);
#endregion
}
catch (Exception e)
{
// Get stack trace for the exception with source file information
var st = new StackTrace(e, true);
// Get the top stack frame
var frame = st.GetFrame(0);
// Get the line number from the stack frame
var line = frame.GetFileLineNumber();
Console.WriteLine("Stack trace:" + Environment.NewLine + SerializeJson(st, true));
Console.WriteLine("Stack frame: " + Environment.NewLine + SerializeJson(st, true));
Console.WriteLine("Line number: " + line);
Console.WriteLine("Exception: " + Environment.NewLine + SerializeJson(e, true));
}
Console.WriteLine("");
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
}
/// <summary>
/// Creates the <see cref="DatabaseBlockSetting"/> instances that describe the configurationObject.
/// </summary>
/// <param name="configurationObject">The configuration object for instances that must be managed.</param>
/// <param name="wmiSettings">A collection to where the generated WMI objects are to be added.</param>
public static void GenerateWmiObjects(DatabaseSettings configurationObject,
ICollection <ConfigurationSetting> wmiSettings)
{
wmiSettings.Add(new DatabaseBlockSetting(configurationObject, configurationObject.DefaultDatabase));
}
public DatabaseBlockSetting(DatabaseSettings sourceElement, string defaultDatabase)
: base(sourceElement)
{
this.defaultDatabase = defaultDatabase;
}
public UserRepository(DatabaseSettings settings, IMapper mapper) : base(settings, mapper)
{
users = database.GetCollection <Entities.User>(settings.UsersCollectionName);
}
public void Init()
{
DatabaseSettings settings = new DatabaseSettings()
{
Integrated = true,
Type = DatabaseType.MsSql,
Server = @"(local)\SQLEXPRESS",
Name = "queue"
};
UnityContainer container = new UnityContainer();
ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(container));
sessionProvider = new SessionProvider(new string[] { "Queue.Data.Model" }, settings);
container.RegisterInstance<SessionProvider>(sessionProvider);
}
/// <summary>
/// get shard strategy object via shard config
/// </summary>
/// <param name="element"></param>
/// <param name="value"></param>
/// <returns></returns>
public IShardingStrategy GetShardingStrategy(DatabaseSetElement element, DatabaseSettings settings = null)
{
String shardingStrategy = settings == null ? element.ShardingStrategy : settings.ShardingStrategy;
if (String.IsNullOrEmpty(shardingStrategy))
{
return(null);
}
var shardconfs = shardingStrategy.Split(';');
var config = new Dictionary <String, String>();
foreach (var shardcnfg in shardconfs)
{
var param = shardcnfg.Split('=');
if (param.Length != 2)
{
throw new ArgumentException("Sharding parameters invalid.");
}
//will fix key issue(ignore case in the future)
config.Add(param[0].Trim(), param[1].Trim());
}
String classname;
if (!config.TryGetValue("class", out classname))
{
throw new ArgumentException("Strategy invalid.");
}
Type type = Type.GetType(classname);
if (type == null)
{
throw new ArgumentException("Strategy invalid.");
}
try
{
var resultStrategy = Activator.CreateInstance(type) as IShardingStrategy;
if (resultStrategy == null)
{
throw new DalException("Strategy {0} didn't implement IShardingStrategy", classname);
}
else
{
var allShardingConfig = new List <ShardingConfig>();
if (element != null)
{
foreach (DatabaseElement e in element.Databases)
{
if (!string.IsNullOrWhiteSpace(e.Sharding))
{
allShardingConfig.Add(new ShardingConfig {
Sharding = e.Sharding
});
}
}
}
if (settings != null)
{
foreach (var e in settings.ConnectionItemList)
{
if (!string.IsNullOrWhiteSpace(e.Sharding))
{
allShardingConfig.Add(new ShardingConfig {
Sharding = e.Sharding
});
}
}
}
resultStrategy.SetShardConfig(config, allShardingConfig);
return(resultStrategy);
}
}
catch (Exception ex)
{
throw new DalException("Strategy invalid.", ex);
}
}
private bool DatabaseConnect(DatabaseSettings s)
{
sessionProvider = new SessionProvider(new string[] { "Queue.Model" }, s);
schemaMenu.Enabled = dataMenu.Enabled = true;
connectButton.Enabled = false;
var model = Assembly.Load("Queue.Model");
Log(string.Format("Версия модели данных: {0}", model.GetName().Version));
return true;
}
public void Startup(IDictionary<string, string> settings)
{
m_settings = new DatabaseSettings();
m_settings.FilePath = settings["FilePath"];
if (File.Exists(m_settings.FilePath))
{
using (FileStream fs = new FileStream(m_settings.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (StreamReader sr = new StreamReader(fs))
{
Load(sr);
}
}
else
{
m_users = new List<User>();
m_roles = new List<Role>();
m_metas = new List<Meta>();
}
}
private static DbProviderMapping GetProviderMapping(string dbProviderName, DatabaseSettings databaseSettings)
{
if (databaseSettings != null)
{
DbProviderMapping dbProviderMapping = databaseSettings.ProviderMappings.Get(dbProviderName);
if (dbProviderMapping != null)
{
return dbProviderMapping;
}
}
return GetDefaultMapping(dbProviderName) ?? GetGenericMapping();
}
internal static string ConnectionString(DatabaseSettings settings)
{
return("Data Source=" + settings.Filename);
}
public ScheduledStreamService(IOptions <DatabaseSettings> dbSettings, IClock clock)
{
_dbSettings = dbSettings.Value;
_clock = clock;
}
public static void UpdateSettings(DatabaseSettings settings)
{
DataAccessInitializing.UpdateSettings(settings);
}
public DatabaseSettingsView(DatabaseSettings settings)
{
m_settings = settings;
}
public GenericRepository(DatabaseSettings settings) : base(settings)
{
}
public ExportProjectCommand(DatabaseSettings databaseSettings, IConsoleWriter consoleWriter, ICopyFile copyFile)
{
_databaseSettings = databaseSettings;
_consoleWriter = consoleWriter;
_copyFile = copyFile;
}
public void Initialize()
{
databaseSettings = DatabaseSettingsBuilder.Create();
}
