/// <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; }