/// <summary>
/// Creates a new donut runner
/// </summary>
/// <typeparam name="TDonut">The type of donut to run</typeparam>
/// <typeparam name="TContext">The donut's type of context</typeparam>
/// <typeparam name="TData">The type of data that will be consumed</typeparam>
/// <param name="harvester">The harvester that will read the data</param>
/// <param name="db">Db config</param>
/// <param name="featuresCollection">The targeted features collection that would be outputed to.</param>
/// <returns></returns>
public static IDonutRunner <TDonut, TData> Create <TDonut, TContext, TData>(
IHarvester <IntegratedDocument> harvester,
IDatabaseConfiguration db,
string featuresCollection)
where TDonut : Donutfile <TContext, TData>
where TContext : DonutContext
where TData : class, IIntegratedDocument
{
var builderType = typeof(DonutRunner <, ,>).MakeGenericType(new Type[] { typeof(TDonut), typeof(TContext), typeof(TData) });
//DataIntegration integration, RedisCacher cacher, IServiceProvider serviceProvider
var builderCtor = builderType.GetConstructor(new Type[]
{
typeof(Harvester <TData>),
typeof(IDatabaseConfiguration),
typeof(string)
});
if (builderCtor == null)
{
throw new Exception("DonutBuilder<> has invalid ctor parameters.");
}
var builder = Activator.CreateInstance(builderType, harvester, db, featuresCollection) as IDonutRunner <TDonut, TData>;
return(builder);
}
public StdIdentityDbContext(ILoggerFactory loggerFactory, IDatabaseConfiguration configuration)
{
LoggerFactory = loggerFactory;
_configuration = configuration;
//_mediator = mediator;
Logger = LoggerFactory.CreateLogger <StdIdentityDbContext <TUser, TRole, TKey, TUserClaim, TUserRole, TUserLogin, TRoleClaim, TUserToken> >();
}
public UserRepository(IDatabaseConfiguration dbConfig)
{
var client = new MongoClient(dbConfig.ConnectionString);
var database = client.GetDatabase(dbConfig.DatabaseName);
_users = database.GetCollection <User>(dbConfig.UsersCollectionName);
}
public DatabaseQueryPredicateBuilder(IObjectMapperFactory objectMappingFactory,
IDatabaseConfiguration databaseConfiguration)
{
_objectMappingFactory = objectMappingFactory.ThrowIfNull(nameof(objectMappingFactory));
_databaseConfiguration = databaseConfiguration.ThrowIfNull(nameof(databaseConfiguration));
_parameters = new List <IDbDataParameter>();
}
public DocumentRepository(IDatabaseConfiguration configuration,
ITranslatorFactory translatorFactory) : base(configuration.ToConnection())
{
_translatorFactory = translatorFactory;
//_translator = translatorFactory.CreateDocumentTranslator()
_repoCounter = new Repository <Counter>(configuration.ToConnection());
}
private readonly Dictionary <string, string> _scriptReplacements = new Dictionary <string, string>(); // Holds tokens and replacement values for scripts
public dbmgrDataMigration(IDatabaseConfiguration config, string deployDirectory, IDBScripts database, string scriptReplacementsFile, string[] replacementParameters, string netConnectionString = null)
{
// Setup data context information
_database = database;
if (netConnectionString != null)
{
_connectionString = netConnectionString;
}
else
{
_connectionString = config.ConnectionString;
_connectionString = DataContext.GetConnectionString(_connectionString, replacementParameters);
}
_providerName = config.ConnectionProviderName;
_defaultTimeout = config.DefaultCommandTimeoutSecs;
_defaultTransTimeout = config.DefaultTransactionTimeoutMins;
// Setup Directories used
_baseDeployDirectory = Path.Combine(deployDirectory, "Database");
_migrationScriptLocation = Path.Combine(_baseDeployDirectory, "Deltas");
_currentScriptLocation = Path.Combine(_baseDeployDirectory, "Current");
_postScriptLocation = Path.Combine(_baseDeployDirectory, "Post");
if (String.IsNullOrWhiteSpace(scriptReplacementsFile))
{
scriptReplacementsFile = Path.Combine(_baseDeployDirectory, "Database", DEFAULT_SCRIPT_REPLACEMENTS_FILE);
}
if (File.Exists(scriptReplacementsFile))
{
LoadScriptReplacements(scriptReplacementsFile);
}
}
public MessageRepository(IDatabaseConfiguration settings)
{
var client = new MongoClient(Environment.GetEnvironmentVariable("DATABASE_URL"));
var database = client.GetDatabase(settings.DatabaseName);
_messages = database.GetCollection <Message>(settings.MessagesCollectionName);
}
public Database(IDatabaseConfiguration config)
{
this.disposed = false;
this.config = config;
this.logins = new HashSet <ILogin>();
this.dataContextBySession = new Dictionary <Guid, Dictionary <Type, DBContextBase> >();
}
public MongoDbContext(IDatabaseConfiguration dbConfig)
{
_dbConfig = dbConfig;
var client = new MongoClient(dbConfig.Server);
db = client.GetDatabase(_dbConfig.Database);
}
public DatabaseContext(ILoggerFactory loggerFactory, IDatabaseConfiguration configuration, IMediator mediator)
{
LoggerFactory = loggerFactory;
_configuration = configuration;
_mediator = mediator;
Logger = LoggerFactory.CreateLogger <DatabaseContext>();
}
public WhereClause(IDatabaseConfiguration databaseConfiguration)
{
Contract.Ensures(this.databaseConfiguration != null);
this.databaseConfiguration = databaseConfiguration;
this.expressions = new List <Tuple <string, string, string, string> >();
}
public HeroService(IDatabaseConfiguration dbConfig)
{
var client = new MongoClient(dbConfig.ConnectionString);
var db = client.GetDatabase(dbConfig.DatabaseName);
_heros = db.GetCollection <Hero>(dbConfig.HerosCollectionName);
}
public Database(
ILogger logger,
IDatabaseConfiguration configuration,
IMetadataProvider metadataProvider)
: base(logger, configuration, metadataProvider)
{
}
// TODO
internal static IConnection ToConnection(this IDatabaseConfiguration configuration)
{
var dbConfig = configuration as DocumentDbConfiguration;
var connection = new Connection(dbConfig.Endpoint, dbConfig.AuthorizationKey, dbConfig.Database, dbConfig.Collection);
return(connection);
}
/// <summary>
/// Initializes Localization library.
/// </summary>
/// <param name="configFilePath">Path to configuration file.</param>
/// <param name="databaseConfiguration">Configure database storage, e.g. NHibernateDatabaseConfiguration</param>
/// <param name="loggerFactory">Logger factory for enabling logging</param>
public LocalizationLib(
string configFilePath,
IDatabaseConfiguration databaseConfiguration = null,
ILoggerFactory loggerFactory = null
) : this(LoadConfigurationFromFile(configFilePath, loggerFactory), databaseConfiguration, loggerFactory)
{
// Empty, only call different constructor
}
public GlobalConfiguration(IDatabaseConfiguration database,
IOCRConfiguration ocr, string apiUrl, string tokenDir)
{
APIUrl = apiUrl;
Database = database;
OCR = ocr;
TokenDir = tokenDir;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:KotoriCore.Configuration.KotoriConfiguration"/> class.
/// </summary>
/// <param name="instance">Instance.</param>
/// <param name="version">Version.</param>
/// <param name="masterKeys">Master keys.</param>
/// <param name="database">Database.</param>
/// <param name="search">Search service.</param>
public KotoriConfiguration(string instance, string version, IEnumerable <MasterKey> masterKeys, IDatabaseConfiguration database, ISearchConfiguration search)
{
Instance = instance;
Version = version;
MasterKeys = masterKeys;
Database = database;
Search = search;
}
protected SqlServerOperation(IDatabaseConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException();
}
Context = new AlgorithmContext(configuration);
}
public PagedQueryBuilderStrategy(IFieldHelper fieldHelper, IPredicateBuilder predicateBuilder,
IObjectMapperFactory objectMappingFactory, IDatabaseConfiguration databaseConfiguration)
: base(fieldHelper)
{
_predicateBuilder = predicateBuilder.ThrowIfNull(nameof(predicateBuilder));
_objectMappingFactory = objectMappingFactory.ThrowIfNull(nameof(objectMappingFactory));
_databaseConfiguration = databaseConfiguration.ThrowIfNull(nameof(databaseConfiguration));
}
/// <summary>
/// Al configurarse la base de datos
/// </summary>
/// <param name="optionsBuilder"></param>
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
base.OnConfiguring(optionsBuilder);
IDatabaseConfiguration databaseConfiguration = ConfigurationManager.Get <IDatabaseConfiguration>();
optionsBuilder.UseSqlite($"Data Source={databaseConfiguration.DBFilePath}");
}
public ConfigurationManagerConnectionStringProvider(IDatabaseConfiguration dbConfig)
{
if (dbConfig == null)
{
throw new ArgumentNullException(nameof(dbConfig));
}
this.dbConfig = dbConfig;
}
public InjectionRepository(IMongoDatabase database, IDatabaseConfiguration configuration)
{
Match = new MatchRepository(database);
PlayersResults = new PlayerResultsRepository(database);
User = new UserRepository(database, new DirectoryInfo(configuration.UserImageFolder));
UserChange = new UserChangeRepository(database);
Team = new TeamRepository(database, new DirectoryInfo(configuration.TeamImageFolder));
TeamPontuation = new TeamPontuationRepository(database);
}
protected DatabaseContext(
ILogger logger,
IDatabaseConfiguration configuration,
IMetadataProvider metadataProvider)
{
Logger = logger;
Configuration = configuration;
MetadataProvider = metadataProvider;
RetryPolicy = new ExponentialRetryPolicy(configuration, logger);
}
public static IDatabaseConfiguration Map(this IDatabaseConfiguration databaseConfiguration, IConfigurationSection configurationSection)
{
databaseConfiguration.DatabaseName = configurationSection.Key;
databaseConfiguration.ConnectionString = configurationSection.GetValue("ConnectionString", "");
databaseConfiguration.ConnectionTimeout = configurationSection.GetValue("ConnectionTimeout", 0);
databaseConfiguration.BulkInsertTimeout = configurationSection.GetValue("BulkInsertTimeout", 0);
databaseConfiguration.UpdateTimeout = configurationSection.GetValue("UpdateTimeout", 0);
return(databaseConfiguration);
}
public PrefsDb(IDatabaseConfiguration dbConfig)
{
_prefsCtx = dbConfig switch
{
SqliteConfiguration sqlite => (PreferencesDbContext) new SqlitePreferencesDbContext(
sqlite.Options),
PostgresConfiguration postgres => new PostgresPreferencesDbContext(postgres.Options),
_ => throw new NotImplementedException()
};
_prefsCtx.Database.Migrate();
}
/// <summary>
/// Load providers
/// </summary>
/// <param name="repository">provider repository</param>
/// <param name="providerXml">provider XML</param>
/// <param name="parentTypes">parent type collection</param>
/// <param name="parentCommands">parent commands</param>
private static void LoadProviders(
IDictionary <string, IDatabaseConfiguration> repository,
XmlElement providerXml,
IReadOnlyDictionary <string, IDataType> parentTypes,
IReadOnlyDictionary <string, string> parentCommands)
{
var types = LoadTypes(providerXml, parentTypes);
var commands = LoadCommands(providerXml, parentCommands);
IDatabaseConfiguration configuration = null;
if ((types != null) || (commands != null))
{
string providerName = providerXml.GetAttribute(ProviderNameAttributeName);
if (!string.IsNullOrWhiteSpace(providerName))
{
providerName = providerName.Trim();
if (repository.ContainsKey(providerName))
{
var errorMessage = string.Format(
CultureInfo.InvariantCulture,
"Provider name \"{0}\" has been defined. Duplicate names were found. XML: {1}",
providerName,
providerXml.OuterXml);
Trace.TraceError(errorMessage);
throw new ArgumentException(errorMessage);
}
configuration = new DatabaseConfiguration(types, commands);
repository.Add(providerName, configuration);
}
}
var providerNodeCollection = providerXml.SelectNodes(ProviderXmlElementName);
if (providerNodeCollection != null)
{
foreach (XmlNode providerNode in providerNodeCollection)
{
var inheritedProviderXml = providerNode as XmlElement;
if (inheritedProviderXml == null)
{
var errorMessage = string.Format(
CultureInfo.InvariantCulture,
"Expect \"{0}\" element but it is not. XML: {1}",
ProviderXmlElementName,
providerNode.OuterXml);
Trace.TraceError(errorMessage);
throw new ArgumentException(errorMessage);
}
LoadProviders(repository, inheritedProviderXml, types, commands);
}
}
}
public Repository(IDatabaseConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
var client = new MongoClient(configuration.ConnectionString);
this.Database = client.GetDatabase(configuration.Database);
}
/// <summary>
///
/// </summary>
/// <param name="donutType"></param>
/// <param name="donutContextType"></param>
/// <param name="harvester"></param>
/// <param name="db"></param>
/// <param name="featuresCollection"></param>
/// <returns></returns>
public static IDonutRunner <IntegratedDocument> CreateByType(Type donutType,
Type donutContextType,
Harvester <IntegratedDocument> harvester,
IDatabaseConfiguration db,
string featuresCollection)
{
var runnerCrMethod = typeof(DonutRunnerFactory).GetMethod(nameof(DonutRunnerFactory.Create));
var runnerCtor = runnerCrMethod.MakeGenericMethod(donutType, donutContextType, typeof(IntegratedDocument));
var runner = runnerCtor.Invoke(null, new object[] { harvester, db, featuresCollection });
return(runner as IDonutRunner <IntegratedDocument>);
}
public static IMongoCollection <BsonDocument> GetCollection(IDatabaseConfiguration dbc, string collectionName)
{
var db = GetDatabase(dbc);
IMongoCollection <BsonDocument> records;
if (null == (records = db.GetCollection <BsonDocument>(collectionName)))
{
db.CreateCollection(collectionName);
}
records = db.GetCollection <BsonDocument>(collectionName);
return(records);
}
/// <summary>
///
/// </summary>
/// <param name="harvester"></param>
/// <param name="db"></param>
/// <param name="featuresCollection"></param>
public DonutRunner(
Harvester <TData> harvester,
IDatabaseConfiguration db,
string featuresCollection)
{
if (string.IsNullOrEmpty(featuresCollection))
{
throw new ArgumentNullException(nameof(featuresCollection));
}
_harvester = harvester;
//var mlist = new MongoList(db, featuresCollection);
_featuresCollection = MongoHelper.GetCollection(db.Value);
}
public AddGraph(IDatabaseConfiguration configuration) : base(configuration)
{
}
protected SqlServerOperation(IDatabaseConfiguration configuration)
{
if (configuration == null)
throw new ArgumentNullException();
Context = new AlgorithmContext(configuration);
}
public bool CanConnectToDatabase(IDatabaseConfiguration configuration)
{
return true;
//throw new NotImplementedException();
}
public AddAlgorithm(IDatabaseConfiguration configuration) : base(configuration)
{
}
public FluentConfiguration()
{
this.CollectionConfiguration = new DefaultCollectionConfiguration();
this.DatabaseConfiguration = new DefaultDatabaseConfiguration();
}
public DatabaseElement(IDatabaseConfiguration config)
: this(config.Id + " Source", config.Name, config.ConnectionString, config.Query, config.Labels)
{
}
public DatabaseModule(IDatabaseConfiguration configuration, IEventAggregator broker)
{
this.configuration = configuration;
this.broker = broker;
}
public LocalizationOverridesRepository(IDatabaseConfiguration databaseConfiguration)
: base(databaseConfiguration)
{
}
public PluginPersister(IDatabaseConfiguration configuration, IPluginMetadata pluginMetadata)
{
_configuration = configuration;
_pluginName = pluginMetadata.PluginData.Name;
}
public LocalizationSettingsRepository(IDatabaseConfiguration databaseConfiguration)
: base(databaseConfiguration)
{
}
public ProjectTasks(IDatabaseConfiguration configuration)
{
this.configuration = configuration;
}
public ProfileStorageSqlPersister(IDatabaseConfiguration configuration)
{
_configuration = configuration;
}
public AlgorithmContext(IDatabaseConfiguration configuration) : base(configuration.ConnectionString)
{
Database.SetInitializer(new InitialConfiguration());
this.Configuration.LazyLoadingEnabled = false;
}
