public PostgresDatabaseCleaner(
IOptions <DatabaseOptions> databaseOptions,
IOptions <DatabaseCleanerOptions> databaseCleanerOptions)
{
_databaseCleanerOptions = databaseCleanerOptions.Value;
_databaseOptions = databaseOptions.Value;
}
public ManualEntryViewModel()
{
if (DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
return;
}
ObjectTypeOptions = new List <SqlServerObjectType>
{
new SqlServerObjectType("U", "Table"),
new SqlServerObjectType("P", "Stored Procedure"),
new SqlServerObjectType("V", "View"),
new SqlServerObjectType("TF", "Table Function"),
new SqlServerObjectType("FN", "Scalar Function")
};
Labels = new ObservableCollection <ProjectLabel>();
Labels.AddRange(_rogueProjectRepository.GetProjectLabels().Select(x => new ProjectLabel(x)));
Labels.Insert(0, new ProjectLabel {
Name = "Select a Label"
});
SelectedLabel = Labels.FirstOrDefault();
SelectedSqlServerObjectType = ObjectTypeOptions.Single(x => x.TypeCode == "P");
SelectedDatabase = DatabaseOptions.SingleOrDefault(x => x.DatabaseName.Equals("StoneEdgeRogue") && x.Environment == "NA");
ObjectSchemaOptions = _utilityRepository.GetDatabaseSchemaNames(SelectedDatabase?.DatabaseName);
SelectedObjectSchema = ObjectSchemaOptions.SingleOrDefault(x => x == "dbo");
SelectedDeveloper = DeveloperOptions.SingleOrDefault(x => x.DomainUserName.Equals(Environment.UserName));
ReleaseDate = DateHelper.GetNextWeekday(DateTime.Now, DayOfWeek.Thursday);
if (SelectedDatabase != null && SelectedObjectSchema != null)
{
ObjectNameOptions = _utilityRepository.GetObjectNames(SelectedDatabase.DatabaseName, SelectedObjectSchema, SelectedSqlServerObjectType.TypeCode);
}
SelectedObjectName = ObjectNameOptions.FirstOrDefault();
}
public Migrator(
ILogger <Migrator> logger,
IOptions <DatabaseOptions> databaseOptions)
{
_logger = logger;
_databaseOptions = databaseOptions.Value;
}
/// <summary>
/// 添加SQLServer数据库服务。
/// </summary>
/// <param name="builder">构建服务实例。</param>
/// <param name="options">数据源选项。</param>
/// <returns>返回服务集合实例。</returns>
public static IMozliteBuilder AddSqlServer(this IMozliteBuilder builder, Action <DatabaseOptions> options)
{
Check.NotNull(builder, nameof(builder));
Check.NotNull(options, nameof(options));
var source = new DatabaseOptions();
options(source);
return(builder.AddServices(services => services
.AddSingleton <IDatabase, SqlServerDatabase>()
.Configure <DatabaseOptions>(o =>
{
o.ConnectionString = source.ConnectionString;
o.Prefix = source.Prefix?.Trim();
o.Provider = "SqlServer";
})
.AddSingleton(typeof(IDbContext <>), typeof(DbContext <>))
.AddTransient <IDataMigrator, DataMigrator>()
.AddTransient <IMigrationRepository, SqlServerMigrationRepository>()
.AddTransient <IMigrationsSqlGenerator, SqlServerMigrationsSqlGenerator>()
.AddSingleton <IQuerySqlGenerator, SqlServerQuerySqlGenerator>()
.AddSingleton <ITypeMapper, SqlServerTypeMapper>()
.AddSingleton <ISqlHelper, SqlServerHelper>()
.AddSingleton <IMemberTranslator, SqlServerCompositeMemberTranslator>()
.AddSingleton <IMethodCallTranslator, SqlServerCompositeMethodCallTranslator>()
.AddSingleton <IExpressionFragmentTranslator, SqlServerCompositeExpressionFragmentTranslator>()
.AddSingleton <IExpressionVisitorFactory, SqlServerExpressionVisitorFactory>()));
}
public void Test()
{
DatabaseOptions option = new DatabaseOptions()
{
Location = "c:\\d",
AccessNumberPattern = "ddd",
ContaminationNamePattern = "ccc",
DecoyPattern = "eee",
RemovePeptideFromDecoyDB = true
};
XElement root = new XElement("Root");
option.Save(root);
DatabaseOptions target = new DatabaseOptions();
target.Load(root);
root.RemoveAll();
target.Save(root);
Assert.AreEqual(option.Location, target.Location);
Assert.AreEqual(option.AccessNumberPattern, target.AccessNumberPattern);
Assert.AreEqual(option.ContaminationNamePattern, target.ContaminationNamePattern);
Assert.AreEqual(option.DecoyPattern, target.DecoyPattern);
Assert.AreEqual(option.RemovePeptideFromDecoyDB, target.RemovePeptideFromDecoyDB);
}
public ServerBasedConnectionStringProvider(
ITenantProvider tenantProvider,
IOptions <DatabaseOptions> options)
{
this.tenantProvider = tenantProvider;
this.options = options.Value;
}
public IntegrationTestsContext()
{
bool lockTaken = false;
Monitor.Enter(_lockObject, ref lockTaken);
try
{
if (!isRegistered)
{
ConventionPackDefault.Register();
isRegistered = true;
}
}
finally
{
if (lockTaken)
{
Monitor.Exit(_lockObject);
}
}
MongoDatabaseOptions = new DatabaseOptions
{
ConnectionString = "mongodb://localhost:27017",
ConnectionType = ConnectionType.MongoDB,
Datasource = GenerateUniqueDatasourceName()
};
CreateSomeDummyData();
}
static async Task Main(string[] args)
{
Console.WriteLine("Enter the user name:");
var user = Console.ReadLine();
EmbeddedServer.Instance.StartServer(new ServerOptions
{
DataDirectory = "D:\\RavenData",
ServerUrl = "http://127.0.0.1:8080"
});
var databaseOptions = new DatabaseOptions(new DatabaseRecord
{
DatabaseName = "Embedded"
});
using (var store = await EmbeddedServer.Instance.GetDocumentStoreAsync(databaseOptions))
{
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = user });
await session.SaveChangesAsync();
}
}
EmbeddedServer.Instance.OpenStudioInBrowser();
Console.WriteLine("Press ENTER to quit this program (and close RavenDB)");
Console.ReadLine();
}
public AccountController(IJwtTokenGenerator tokenGenerator,
IOptions <DatabaseOptions> databaseOptions,
IUserHelper userHelper)
{
this.tokenGenerator = tokenGenerator;
this._userHelper = userHelper;
this._databaseOptions = databaseOptions.Value;
}
private UserMongoRepository GetUserMongoRepository()
{
DatabaseOptions databaseOptions = MongoDatabaseOptions;
IOptionsMonitor <DatabaseOptions> databaseOptionsMock = Mock.Of <IOptionsMonitor <DatabaseOptions> >(_ => _.CurrentValue == databaseOptions);
UserMongoRepository userMongoRepository = new UserMongoRepository(new MongoConnection(databaseOptionsMock.CurrentValue));
return(userMongoRepository);
}
private void OnClientChanged(MongoClient client)
{
DatabaseOptions options = this._databaseOptions.CurrentValue;
this._collection = this._databaseConnection.Client
.GetDatabase(options.DatabaseName)
.GetCollection <StellarisMod>(options.StellarisModsCollectionName);
}
public ConfigurationOptions()
{
Data = new DatabaseOptions();
Redis = new RedisOptions();
AppSettings = new AppSettingsOptions();
KeyVault = new KeyVaultOptions();
AzureAd = new AzureAdOptions();
}
private RoleMongoRepository GetRoleMongoRepository()
{
DatabaseOptions databaseOptions = MongoDatabaseOptions;
IOptionsMonitor <DatabaseOptions> databaseOptionsMock = Mock.Of <IOptionsMonitor <DatabaseOptions> >(_ => _.CurrentValue == databaseOptions);
RoleMongoRepository roleMongoRepository = new RoleMongoRepository(new MongoConnection(databaseOptionsMock.CurrentValue));
return(roleMongoRepository);
}
public async Task InitializeAsync()
{
DatabaseOptions databaseOptions;
if (!this.useServiceDatabase)
{
await this.databaseContainer.StartAsync();
this.migrationsContainer = new ContainerBuilder <MigrationsContainer>()
.ConfigureContainer((context, container) =>
{
var connectionString =
$"Server=localhost;Port={this.databaseContainer.GetMappedPort(MySqlContainer.DefaultPort)};database={this.databaseContainer.DatabaseName};uid={this.databaseContainer.Username};password={this.databaseContainer.Password};SslMode=None;";
container.Command = new List <string>
{
"-cs", connectionString,
};
})
.ConfigureNetwork((hostContext, builderContext) =>
{
return(new NetworkBuilder <UserDefinedNetwork>()
.ConfigureNetwork((context, network) => { network.NetworkName = "host"; })
.Build());
})
.Build();
await this.migrationsContainer.StartAsync();
var exitCode = await this.migrationsContainer.GetExitCodeAsync();
if (exitCode > 0)
{
throw new Exception($"Database migrations failed");
}
databaseOptions = new DatabaseOptions
{
Server = this.databaseContainer.GetDockerHostIpAddress(),
Port = this.databaseContainer.GetMappedPort(MySqlContainer.DefaultPort),
Database = ServiceDatabaseName,
Username = this.databaseContainer.Username,
Password = this.databaseContainer.Password,
};
}
else
{
databaseOptions = new DatabaseOptions
{
Server = "localhost",
Port = 10286,
Database = ServiceDatabaseName,
Username = "******",
Password = "******",
};
}
this.ConnectionStringProvider = new ConnectionStringProvider(databaseOptions);
}
private UserManager <User> GetUserManager()
{
DatabaseOptions databaseOptions = _context.MongoDatabaseOptions;
IOptionsMonitor <DatabaseOptions> databaseOptionsMock = Mock.Of <IOptionsMonitor <DatabaseOptions> >(_ => _.CurrentValue == databaseOptions);
#pragma warning disable CA2000 // Dispose objects before losing scope
UserMongoRepository userRepository = new UserMongoRepository(new MongoConnection(databaseOptionsMock.CurrentValue));
RoleMongoRepository roleRepository = new RoleMongoRepository(new MongoConnection(databaseOptionsMock.CurrentValue));
UserStore userStore = new UserStore(userRepository, roleRepository);
#pragma warning restore CA2000 // Dispose objects before losing scope
Mock <IOptions <IdentityOptions> > identityOptionsMock = new Mock <IOptions <IdentityOptions> >();
IdentityOptions identityOptions = new IdentityOptions
{
SignIn = new SignInOptions
{
RequireConfirmedEmail = false,
RequireConfirmedPhoneNumber = false
},
User = new UserOptions
{
RequireUniqueEmail = true
},
Lockout = new LockoutOptions
{
AllowedForNewUsers = true
}
};
identityOptionsMock.Setup(a => a.Value).Returns(identityOptions);
List <IUserValidator <User> > userValidators = new List <IUserValidator <User> >();
List <PasswordValidator <User> > pwdValidators = new List <PasswordValidator <User> >();
Mock <IServiceProvider> serviceProviders = new Mock <IServiceProvider>();
Mock <IUserTwoFactorTokenProvider <User> > mockUserFactorTokenProvider = new Mock <IUserTwoFactorTokenProvider <User> >();
mockUserFactorTokenProvider
.Setup(a => a.CanGenerateTwoFactorTokenAsync(It.IsAny <UserManager <User> >(), It.IsAny <User>()))
.Returns(Task.FromResult(true));
mockUserFactorTokenProvider
.Setup(a => a.GenerateAsync(It.IsAny <string>(), It.IsAny <UserManager <User> >(), It.IsAny <User>()))
.Returns(Task.FromResult(Guid.NewGuid().ToString()));
mockUserFactorTokenProvider
.Setup(a => a.ValidateAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <UserManager <User> >(), It.IsAny <User>()))
.Returns(Task.FromResult(true));
UserManager <User> userManager = new UserManager <User>(
userStore,
identityOptionsMock.Object,
new PasswordHasher <User>(),
userValidators,
pwdValidators,
new UpperInvariantLookupNormalizer(),
new IdentityErrorDescriber(),
serviceProviders.Object,
new Mock <ILogger <UserManager <User> > >().Object);
return(userManager);
}
private void MangeDatabaseAndSecrets(DatabaseOptions databaseOption)
{
var database = LocateDatabase(databaseOption.Id, $"The database with id {databaseOption.Id} was not created");
foreach (var databaseSecretKeyValuePair in databaseOption.Secrets)
{
AddSecret(databaseOption, database, databaseSecretKeyValuePair);
}
}
/// <summary>
/// Called when Augurk starts up.
/// </summary>
/// <param name="cancellationToken">A <see cref="CancellationToken" /> that is triggered when startup is cancelled.</param>
public async Task StartAsync(CancellationToken cancellationToken)
{
// Build the options for the server
var dotNetVersion = Environment.Version.ToString();
_logger.LogInformation("Configuring embedded RavenDb server to use version {DotNetVersion} of .NET.", dotNetVersion);
var serverOptions = new ServerOptions
{
AcceptEula = true,
DataDirectory = Path.Combine(Environment.CurrentDirectory, "data"),
FrameworkVersion = dotNetVersion,
};
// Setup logging for RavenDB during development
if (_environment.IsDevelopment())
{
// Enable diagnostic logging
serverOptions.LogsPath = Path.Combine(Environment.CurrentDirectory, "logs");
serverOptions.CommandLineArgs.Add("--Logs.Mode=Information");
}
// Build the options for the database
var databaseOptions = new DatabaseOptions("AugurkStore")
{
Conventions = new DocumentConventions
{
IdentityPartsSeparator = '-'
}
};
// Start the mebedded RavenDB server
EmbeddedServer.Instance.ServerProcessExited += RavenDbServerProcessesExited;
EmbeddedServer.Instance.StartServer(serverOptions);
Store = await EmbeddedServer.Instance.GetDocumentStoreAsync(databaseOptions, cancellationToken);
// Make sure that indexes are created
IndexCreation.CreateIndexes(Assembly.GetExecutingAssembly(), Store);
// Enable the expiration option, even if it is already enabled
// This runs async, there is no need to wait on it
await Store.Maintenance.SendAsync(new ConfigureExpirationOperation(new ExpirationConfiguration
{
Disabled = false,
DeleteFrequencyInSec = 60
}), cancellationToken);
// Start asynchronous migration
// Note: We're instantiating the MigrationManager here directly, rather than having it injected
// This is because of a chicken-egg problem, since the MigrationManager also needs a
// IDocumentStoreProvider
await new MigrationManager(this, _migrationLogger).StartMigrating();
// Write the RavenDB Studio URL to the log
var ravenUrl = await EmbeddedServer.Instance.GetServerUriAsync(cancellationToken);
_logger.LogInformation("RavenDB has started successfully and is available on {RavenDbURL}", ravenUrl);
}
private MySqlDataContext CreateContext(DatabaseOptions options)
{
if (options.Provider != DatabaseProviders.MySql)
{
throw new InvalidOperationException("This project is only for MySql use MsSqlContext Project for an MsSql Connection");
}
return(new MySqlDataContext(options.BuildOptions()));
}
public UserRepository(DatabaseOptions databaseOptions, SharedOptions sharedOptions,
IDataRepository dataRepository, IUserLogger userAuditLog, IMapper autoMapper)
{
DatabaseOptions = databaseOptions ?? throw new ArgumentNullException(nameof(databaseOptions));
SharedOptions = sharedOptions ?? throw new ArgumentNullException(nameof(sharedOptions));
DataRepository = dataRepository ?? throw new ArgumentNullException(nameof(dataRepository));
UserAuditLog = userAuditLog ?? throw new ArgumentNullException(nameof(userAuditLog));
AutoMapper = autoMapper ?? throw new ArgumentNullException(nameof(autoMapper));
}
public async Task <Database> CreateDatabaseAsync(int serverId, DatabaseOptions options, CancellationToken token = default)
{
var request = new RestRequest($"/api/application/servers/{serverId}/databases", Method.POST)
.AddJsonBody(options);
var response = await HandleRequest <Database>(request, token);
return(response);
}
public CouchbaseManager(string dbDir)
{
VFS.SetCurrent(new FileSystem());
manager = new Manager(new System.IO.DirectoryInfo(dbDir),
ManagerOptions.Default);
options = new DatabaseOptions();
Options.Create = true;
Databases = new List <IStorage> ();
}
public MongoVersionContext(DatabaseOptions databaseOptions)
{
if (mongoClient == null)
{
mongoClient = new MongoClient(databaseOptions.ConnectionString);
}
mongoDatabase = mongoClient.GetDatabase(databaseOptions.Datasource);
}
public ArtistsService(
IOptionsMonitor <DatabaseOptions> optionsAccessor,
IArtistSlugsService artistSlugsService,
BbContext context)
{
_databaseOptions = optionsAccessor.CurrentValue;
_artistSlugsService = artistSlugsService;
_context = context;
}
/// <summary>
/// Creates a new instance of AsteriskProvider.
///
/// Exceptions
/// ArgumentNullException: when any parameter is null.
/// </summary>
public AsteriskProvider(
ILogger <AsteriskProvider> logger,
DatabaseOptions options
)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_options = options ?? throw new ArgumentNullException(nameof(options));
_connection = new NpgsqlConnection(_options.ConnectionString);
}
private MsSqlDataContext CreateContext(DatabaseOptions options)
{
if (options.Provider != DatabaseProviders.MsSql)
{
throw new InvalidOperationException("This Project can only handly MsSql Connections");
}
return(new MsSqlDataContext(options.BuildOptions()));
}
public ReleaseManagement(IdentityDbContext context, IWebHostEnvironment hostingEnvironment, ILogger <ReleaseManagement> logger,
IOptionsSnapshot <DatabaseOptions> databaseOptions)
#endif
{
_context = context;
_hostingEnvironment = hostingEnvironment;
_logger = logger;
_databaseOptions = databaseOptions.Value;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="configureOptions"></param>
/// <param name="dbConfigurations"></param>
/// <param name="logger"></param>
public OracleEFContextFactory(
IOptions <DatabaseOptions> configureOptions,
Lazy <IEnumerable <IDbObjConfiguration> > dbConfigurations,
ILogger <OracleEFContext> logger)
{
_configure = configureOptions.Value;
_dbConfigurations = dbConfigurations;
_logger = logger;
}
private void RegisterServicesForIdentity(IServiceCollection services, DatabaseOptions databaseOptions)
{
if (databaseOptions.ConnectionType == ConnectionType.MongoDB)
{
services.AddTransient(a => new MongoConnection(databaseOptions));
}
IdentityExtensions.RegisterRepos(services, databaseOptions, true);
}
private void OnClientChanged(MongoClient client)
{
DatabaseOptions options = base.DatabaseOptions.CurrentValue;
this._collection = base.MongoConnection.Client
.GetDatabase(options.DatabaseName)
.GetCollection <CommunityGoal>(options.EliteCommunityGoalsCollectionName);
base.RecreateBatchInserter(_cachingOptions.Get(CacheOptionName).Lifetime, this._collection);
}
public Startup(IConfiguration configuration, IWebHostEnvironment environment)
{
IdentityModelEventSource.ShowPII = true;
_configuration = configuration;
_environment = environment;
_databaseOptions = new DatabaseOptions();
_configuration.GetSection("ConnectionStrings").Bind(_databaseOptions);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="options">Options to configure database.</param>
/// <param name="compare">Key comparison function.</param>
public DatabaseConfiguration(DatabaseOptions options, SpanComparison <byte> compare = null)
{
this.Options = options;
this.Compare = compare;
if (compare != null)
{
this.LibCompare = CompareWrapper;
}
}
public DatabaseHolder(Database p_db, DatabaseOptions p_options)
{
DB = p_db;
Options = p_options;
}
private static DatabaseHolder InitDatabase(string p_sDataBaseName)
{
Database db = DatabaseFactory.CreateDatabase(p_sDataBaseName);
DatabaseOptions opt = new DatabaseOptions(p_sDataBaseName);
return new DatabaseHolder(db, opt);
}
