public void PrefixShoulWork()
{
string prefix = DateTime.Now.ToString();
var options = new DatabaseConfigurationOptions
{
ConnectionResolver = GetOpenedConnection,
KeyColumn = "key",
ValueColumn = "value",
Table = $"config_{DateTime.Now.ToString("yyyyMMddHHmmss")}",
Prefix = prefix
};
string key = Guid.NewGuid().ToString();
string value = Guid.NewGuid().ToString();
InitConfigurationTable(options, key, value);
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
.AddEnvironmentVariables()
.AddJsonFile("notExist.json", true)
.AddDatabase(options);
IConfigurationRoot configuration = configurationBuilder.Build();
string configurationValue = configuration[$"{prefix}:{key}"];
Assert.AreEqual(configurationValue, value);
}
public static DatabaseConfigurationOptions ReadDatabaseOptionsFromAppSettings(this IConfiguration configuration)
{
DatabaseConfigurationOptions databaseOptions = new DatabaseConfigurationOptions();
configuration.GetSection("DatabaseConfigurationOptions").Bind(databaseOptions);
return(databaseOptions);
}
public SqlServerInstanceProvider(ILogger <SqlServerInstanceProvider> logger, DatabaseConfigurationOptions highAvailabilityOptions, IAmsLicenseManager licenseManager, IWindowsServiceProvider windowsServiceProvider)
{
this.logger = logger;
this.highAvailabilityOptions = highAvailabilityOptions;
this.licenseManager = licenseManager;
this.windowsServiceProvider = windowsServiceProvider;
}
public HighAvailabilityViewModel(IDialogCoordinator dialogCoordinator, IShellExecuteProvider shellExecuteProvider, IAmsLicenseManager licenseManager, ILogger <HighAvailabilityViewModel> logger, INotifyModelChangedEventPublisher eventPublisher, DatabaseConfigurationOptions highAvailabilityOptions, DataProtectionOptions dataProtectionOptions, ICertificateSynchronizationProvider certSyncProvider, ISecretRekeyProvider rekeyProvider, SqlServerInstanceProvider sqlInstanceProvider, IScriptTemplateProvider scriptTemplateProvider, IWindowsServiceProvider windowsServiceProvider)
{
this.shellExecuteProvider = shellExecuteProvider;
this.licenseManager = licenseManager;
this.logger = logger;
this.dbOptions = highAvailabilityOptions;
this.dataProtectionOptions = dataProtectionOptions;
this.certSyncProvider = certSyncProvider;
this.dialogCoordinator = dialogCoordinator;
this.rekeyProvider = rekeyProvider;
this.sqlInstanceProvider = sqlInstanceProvider;
this.scriptTemplateProvider = scriptTemplateProvider;
this.windowsServiceProvider = windowsServiceProvider;
this.licenseManager.OnLicenseDataChanged += delegate
{
this.NotifyOfPropertyChange(nameof(this.IsEnterpriseEdition));
this.NotifyOfPropertyChange(nameof(this.ShowEnterpriseEditionBanner));
};
this.DisplayName = "High availability";
eventPublisher.Register(this);
this.isClusterCompatibleSecretEncryptionEnabled = this.dataProtectionOptions.EnableClusterCompatibleSecretEncryption;
}
public IServiceCollection Register(IServiceCollection services, IConfiguration configuration)
{
DatabaseConfigurationOptions databaseOptions = configuration.ReadDatabaseOptionsFromAppSettings();
switch (databaseOptions.DatabaseAccessObjectStrategy)
{
case DatabaseAccessObjectStrategy.EntityFramework:
switch (databaseOptions.DatabaseStrategy)
{
case DatabaseStrategy.InMemoryDB:
case DatabaseStrategy.SqlServer:
case DatabaseStrategy.SQLite:
new EntityFrameworkStrategy().Register(services, configuration, databaseOptions);
break;
default:
throw new ArgumentException("Não foi possível recuperar a estratégia de qual banco de dados utilizar!");
}
break;
case DatabaseAccessObjectStrategy.Dapper:
switch (databaseOptions.DatabaseStrategy)
{
case DatabaseStrategy.SqlServer:
case DatabaseStrategy.SQLite:
//new DapperStrategy().Register(services, configuration, databaseOptions);
break;
default:
throw new ArgumentException("Não foi possível recuperar a estratégia de qual banco de dados utilizar!");
}
break;
case DatabaseAccessObjectStrategy.MongoDriver:
switch (databaseOptions.DatabaseStrategy)
{
case DatabaseStrategy.MongoDB:
//new MongoDriverStrategy().Register(services, configuration, databaseOptions);
break;
default:
throw new ArgumentException("Não foi possível recuperar a estratégia de qual banco de dados utilizar!");
}
break;
default:
throw new ArgumentException("Não foi possível recuperar a estratégia de qual banco de dados utilizar!");
}
return(services);
}
public SqlDbProvider(IAmsLicenseManager licenseManager, IOptions <DatabaseConfigurationOptions> highAvailabilityOptions, ILogger <SqlDbProvider> logger, IUpgradeLog upgradeLogger, SqlLocalDbInstanceProvider localDbInstanceProvider, SqlServerInstanceProvider sqlServerInstanceProvider)
{
this.licenseManager = licenseManager;
this.highAvailabilityOptions = highAvailabilityOptions.Value;
this.logger = logger;
this.upgradeLogger = upgradeLogger;
this.localDbInstanceProvider = localDbInstanceProvider;
this.sqlServerInstanceProvider = sqlServerInstanceProvider;
this.InitializeDb();
}
// [Fact] public void Test() { }
// [Theory] public void Test(int param) { }
public StoreManagerTests()
{
// Get the connection string
string filepath = @"C:/Users/Khypr/Desktop/store_manager_configuration.json";
string json = File.ReadAllText(filepath);
string connString = JsonSerializer.Deserialize <string>(json);
// Set up storage
IStorageRepository storage = new DatabaseStorageRepository();
// Set up the configuration options
IConfigurationOptions configurationOptions = new DatabaseConfigurationOptions(new FileLogger("C:/Users/Khypr/Desktop/StoreManager/store_manager.tests.log"), connString);
// Initialize the App
StoreManagerApplication.Initialize(storage, null, configurationOptions);
}
private void InitConfigurationTable(DatabaseConfigurationOptions options, string key, string value)
{
using (SqliteConnection conn = GetOpenedConnection())
{
string sql = string.Format($@"
create table if not exists [{options.Table}]
(
[{options.KeyColumn}] nvarchar(100) not null primary key,
[{options.ValueColumn}] nvarchar(100)
);
delete from [{options.Table}];
insert into [{options.Table}]({options.KeyColumn}, {options.ValueColumn}) values ('{key}', '{value}');
");
using (IDbCommand cmd = conn.CreateCommand())
{
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
}
}
}
public void LoadDataShouldWork()
{
var options = new DatabaseConfigurationOptions
{
ConnectionResolver = GetOpenedConnection,
KeyColumn = "key",
ValueColumn = "value",
Table = $"config_{DateTime.Now.ToString("yyyyMMddHHmmss")}"
};
string key = Guid.NewGuid().ToString();
string value = Guid.NewGuid().ToString();
InitConfigurationTable(options, key, value);
var provider = new DatabaseConfigurationProvider(options);
provider.Load();
string configurationValue;
Assert.IsTrue(provider.TryGet(key, out configurationValue));
Assert.AreEqual(configurationValue, value);
}
static void Main(string[] _)
{
ApplicationInterfaceBase applicationInterface;
string filepath = @"C:/Users/Khypr/Desktop/store_manager_configuration.json";
string json = File.ReadAllText(filepath);
string connString = JsonSerializer.Deserialize <string>(json);
ISerializer serializer = null;
IConfigurationOptions configurationOptions = new DatabaseConfigurationOptions(new FileLogger("C:/Users/Khypr/Desktop/store_manager.log"), connString);
bool verbose = false; // CUI.PromptForBool("Do you wish to run the application verbosely?", "yes", "no");
if (verbose)
{
applicationInterface = new VerboseApplicationInterface(null, serializer, configurationOptions);
}
else
{
applicationInterface = new BaselineApplicationInterface(null, serializer, configurationOptions);
}
applicationInterface.Run();
}
/// <summary>
/// Add database source
/// </summary>
/// <param name="builder"></param>
/// <param name="options"></param>
public static IConfigurationBuilder AddDatabase(this IConfigurationBuilder builder, DatabaseConfigurationOptions options)
{
return(builder.Add(new DatabaseConfigurationSource(options)));
}
private void _BuildDatabase(string league, DatabaseConfigurationOptions options)
{
int shortDelay = 2000; //ms
bool success = true;
// Create League Information
if (options == DatabaseConfigurationOptions.COMPLETE || (options & DatabaseConfigurationOptions.LEAGUE) == DatabaseConfigurationOptions.LEAGUE)
{
if (league == "")
{
league = Constants.BLASEBALL_LEAGUE_ID;
}
string leagueInformation = Download($"{Constants.URL_BLASEBALL}database/league?id={league}");
if (leagueInformation == "")
{
OnDatabaseFailed?.Invoke();
return;
}
Logger.Log("League Information Downloaded");
Database.SetLeague(JsonUtility.FromJson <BBLeague>(leagueInformation));
Logger.Log("League Information Entered");
Thread.Sleep(shortDelay);
}
// Create Subleague Information
if (options == DatabaseConfigurationOptions.COMPLETE || (options & DatabaseConfigurationOptions.SUBLEAGUES) == DatabaseConfigurationOptions.SUBLEAGUES)
{
foreach (string subleague in Database.GetLeague().subleagues)
{
success = UpdateSubleague(subleague);
if (!success)
{
OnDatabaseFailed?.Invoke();
return;
}
Thread.Sleep(shortDelay);
}
}
// Division Information
if (options == DatabaseConfigurationOptions.COMPLETE || (options & DatabaseConfigurationOptions.DIVISIONS) == DatabaseConfigurationOptions.DIVISIONS)
{
foreach (string subleagueID in Database.GetSubleagueIDs())
{
BBSubleague subleague = Database.GetSubleague(subleagueID);
foreach (string division in subleague.divisions)
{
success = UpdateDivision(division);
if (!success)
{
OnDatabaseFailed?.Invoke();
return;
}
Thread.Sleep(shortDelay);
}
}
}
// Teams Information
if (options == DatabaseConfigurationOptions.COMPLETE || (options & DatabaseConfigurationOptions.TEAMS) == DatabaseConfigurationOptions.TEAMS)
{
foreach (string divisionID in Database.GetDivisionIDs())
{
BBDivision division = Database.GetDivision(divisionID);
foreach (string teamID in division.teams)
{
success = UpdateTeam(teamID);
if (!success)
{
OnDatabaseFailed?.Invoke();
return;
}
Thread.Sleep(shortDelay);
}
}
}
// Players Information
if (options == DatabaseConfigurationOptions.COMPLETE || (options & DatabaseConfigurationOptions.PLAYERS) == DatabaseConfigurationOptions.PLAYERS)
{
List <string> players = new List <string>();
foreach (string teamID in Database.GetTeamIDs())
{
BBTeam team = Database.GetTeam(teamID);
foreach (string playerID in team.lineup)
{
players.Add(playerID);
}
foreach (string playerID in team.rotation)
{
players.Add(playerID);
}
}
List <string> shortList = new List <string>();
while (players.Count > 0)
{
shortList.Add(players[0]);
players.RemoveAt(0);
if (shortList.Count >= 32 || players.Count == 0)
{
success = UpdatePlayers(shortList.ToArray(), Database);
if (!success)
{
OnDatabaseFailed?.Invoke();
return;
}
Thread.Sleep(shortDelay);
shortList = new List <string>();
}
}
}
if (options == DatabaseConfigurationOptions.COMPLETE)
{
Database.lastUpdated = Helper.GetUnixTime();
}
Logger.Log("Live Database Downloaded. Saving Local Datablase");
Database.Save();
FileLoader.SetupStreamingAssets();
OnDatabaseCreated?.Invoke();
}
public void BuildDatabase(string league, DatabaseConfigurationOptions options)
{
Thread DatabaseBuilder = new Thread(() => _BuildDatabase(league, options));
DatabaseBuilder.Start();
}
public IServiceCollection Register(IServiceCollection services, IConfiguration configuration, DatabaseConfigurationOptions databaseOptions)
{
return(services.AddDbContextPool <ApplicationContext>(options =>
{
if (databaseOptions.DatabaseStrategy == DatabaseStrategy.InMemoryDB)
{
options.UseInMemoryDatabase(databaseOptions.DatabaseName);
}
else
{
options.UseSqlServer(configuration.GetConnectionString(databaseOptions.SqlServerConnectionStringName),
sqlConfig => sqlConfig.MaxBatchSize(5));
}
}));
}
