public SagaStore(ISqlServerConnection con, IDateTimeProvider dateTimeProvider, SqlServerOptions sqlServerOptions) { _con = con; _dateTimeProvider = dateTimeProvider; _sqlServerOptions = sqlServerOptions; _serializerSettings = new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore, TypeNameHandling = TypeNameHandling.All, DateFormatHandling = DateFormatHandling.IsoDateFormat }; }
public static void AddInfrastructure(this IServiceCollection services, IConfiguration configuration) { services.AddTransient <IDbSeed, DbSeed>(); services.AddTransient <ICurrentUser, CurrentUser>(); services.AddDbContext <IDbContext, TodoDbContext>(options => { var sqlServerOptions = new SqlServerOptions(); configuration.Bind("SqlServer", sqlServerOptions); options.UseSqlServer(sqlServerOptions.ConnectionString); }); }
protected DatabaseTestHost() { Logger = new Mock <ILogger <SqlServerStorage> >().Object; CapOptions = new Mock <CapOptions>().Object; SqlSeverOptions = new SqlServerOptions() { ConnectionString = ConnectionUtil.GetConnectionString() }; DiagnosticProcessorObserver = new DiagnosticProcessorObserver(new Mock <IDispatcher>().Object); InitializeDatabase(); }
public static void UseSqlServer(this ITheSagaConfig config, SqlServerOptions options) { if (string.IsNullOrEmpty(options?.ConnectionString)) { throw new Exception($"ConnectionString for TheSaga.Persistance.SqlServer cannot be empty"); } config.Services.AddSingleton <SqlServerOptions>(ctx => options); config.Services.AddTransient <ISagaPersistance, SqlServerSagaPersistance>(); config.Services.AddTransient <ISqlServerConnection>(ctx => { return(new SqlServerConnection(options.ConnectionString)); }); }
public CapPublisher(IServiceProvider provider, ILogger <CapPublisher> logger, SqlServerOptions options) { ServiceProvider = provider; _logger = logger; _options = options; if (_options.DbContextType != null) { IsUsingEF = true; _dbContext = (DbContext)ServiceProvider.GetService(_options.DbContextType); } }
private static void MigrateToLatest <TKey>(string connectionString, IdentityOptionsExtended identityOptions, SqlServerOptions options) where TKey : IEquatable <TKey> { var runner = new MigrationRunner(connectionString, options); if (identityOptions.Stores.CreateIfNotExists) { runner.CreateDatabaseIfNotExistsAsync(CancellationToken.None).Wait(); } if (identityOptions.Stores.MigrateOnStartup) { runner.MigrateUp(CancellationToken.None); } }
public CapPublisher(ILogger <CapPublisher> logger, IDispatcher dispatcher, IServiceProvider provider, SqlServerOptions options) : base(logger, dispatcher) { ServiceProvider = provider; _options = options; if (_options.DbContextType == null) { return; } IsUsingEF = true; _dbContext = (DbContext)ServiceProvider.GetService(_options.DbContextType); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddDbContextPool <AuthenticationDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"), SqlServerOptions => { SqlServerOptions.MigrationsAssembly("Auth.DATA"); })); services.AddIdentity <ApplicationUser, IdentityRole>().AddEntityFrameworkStores <AuthenticationDbContext>().AddDefaultTokenProviders(); services.Configure <IdentityOptions>(options => { options.Password.RequireDigit = false; options.Password.RequiredLength = 6; options.Password.RequireLowercase = false; options.Password.RequireNonAlphanumeric = false; options.Password.RequireUppercase = false; }); services.AddControllers(); services.AddTransient <IAuthService, AuthService>(); }
protected internal override void AddInternal(IDistributedCacheBuilder builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } base.AddInternal(builder); var sqlServerOptions = new SqlServerOptions { ConnectionStringName = this.ConnectionStringName, MigrationsAssembly = this.MigrationsAssembly, Options = this.Options }; var sqlServerCacheOptions = new SqlServerCacheOptions(); sqlServerOptions.BindSqlServerCacheOptions(builder.Configuration, sqlServerCacheOptions); builder.Services.AddDbContextFactory <SqlServerCacheContext>(optionsBuilder => { optionsBuilder.UseSqlServer(sqlServerCacheOptions.ConnectionString, options => { if (this.MigrationsAssembly != null) { options.MigrationsAssembly(this.MigrationsAssembly); } }); }); builder.Services.AddSingleton <IDistributedCache, DateTimeOffsetCacheMock>(); builder.Services.Configure <DateTimeOffsetCacheOptionsMock>(options => { this.Options?.Bind(options); }); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddDbContextPool <ApplicationDbContext>( options => options.UseSqlServer(Configuration.GetConnectionString("ApplicationConnection"), SqlServerOptions => { SqlServerOptions.MigrationsAssembly("DretBlog.Data"); } ) ); services.AddDbContextPool <AuthenticationDbContext>( options => options.UseSqlServer(Configuration.GetConnectionString("AuthenticationConnection"), SqlServerOptions => { SqlServerOptions.MigrationsAssembly("DretBlog.Data"); }) ); services.AddIdentity <ApplicationUser, IdentityRole>() .AddEntityFrameworkStores <AuthenticationDbContext>() .AddDefaultTokenProviders(); //delibrate password weakening services.Configure <IdentityOptions>(options => { options.SignIn.RequireConfirmedAccount = false; options.SignIn.RequireConfirmedEmail = false; options.SignIn.RequireConfirmedPhoneNumber = false; options.Password.RequireDigit = false; options.Password.RequireNonAlphanumeric = false; options.Password.RequireUppercase = false; }); services.AddTransient <IAccountsServices, AccountsServices>(); services.AddScoped <IDashboardServices, DashboardServices>(); services.AddScoped <IPostsServices, PostsServices>(); services.AddScoped <IBlogContentServices, BlogContentServices>(); services.AddControllersWithViews(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers(); //用户需要配置的路由 services.AddSingleton <IVirtualRoute <LogMessage>, LogMessageRoute>(); var options = new SqlServerOptions() { }; services.AddSingleton(options); services.AddScoped <IRepository, DefaultRepository>(); services.AddSingleton <IShardingDbContextProvider, ShardingDbContextProvider>(); services.AddSingleton <IVirtualTableManager, OneDbVirtualTableManager>(); services.AddSingleton(typeof(IVirtualTable <>), typeof(OneDbVirtualTable <>)); services.AddSingleton <ShardingBootstrapper>(); var dbContextOptions = new DbContextOptionsBuilder() .UseSqlServer(options.ConnectionString) .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking) .ReplaceService <IModelCacheKeyFactory, ShardingModelCacheKeyFactory>() .Options; services.AddSingleton(dbContextOptions); }
public static string GetConnectionString(this SqlServerOptions sqlServerOptions) { var builder = new SqlConnectionStringBuilder { ConnectTimeout = sqlServerOptions.ConnectTimeout, DataSource = sqlServerOptions.DataSource, Encrypt = sqlServerOptions.Encrypt, InitialCatalog = sqlServerOptions.InitialCatalog, IntegratedSecurity = sqlServerOptions.IntegratedSecurity, MultipleActiveResultSets = sqlServerOptions.MultipleActiveResultSets, PersistSecurityInfo = sqlServerOptions.PersistSecurityInfo, TrustServerCertificate = sqlServerOptions.TrustServerCertificate, }; if (builder.IntegratedSecurity) { return(builder.ConnectionString); } builder.Password = sqlServerOptions.Password; builder.UserID = sqlServerOptions.UserId; return(builder.ConnectionString); }
public TextRepository(IOptions <SqlServerOptions> options) { _configuration = options.Value; }
public JobsDbContext(DbContextOptions <JobsDbContext> options, SqlServerOptions sqlServerOptions) : base(options) { _sqlServerOptions = sqlServerOptions; }
public PersonRepository(IOptions <SqlServerOptions> sqlServerOptions) { _sqlServerOptions = sqlServerOptions.Value; }
public SqlServerMonitoringApi(IStorage storage, SqlServerOptions options) { _options = options ?? throw new ArgumentNullException(nameof(options)); _storage = storage as SqlServerStorage ?? throw new ArgumentNullException(nameof(storage)); }
public SqlServerStorageConnection(SqlServerOptions options, CapOptions capOptions) { _capOptions = capOptions; Options = options; }
public ProductRepository(IOptions <SqlServerOptions> sqlServerOptions) : base(sqlServerOptions.Value.SqlServerConnection, sqlServerOptions.Value.ProductsTableName) { _sqlServerOptions = sqlServerOptions.Value; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Esta línea configura AutoMapper services.AddAutoMapper(typeof(Startup)); // Configuración servicio para subir archivos a StorageAzure /* * Si se van a subir a AzureStorage se debe descomentar la línea siguiente * services.AddTransient<IAlmacenadorArchivos, AlmacenadorArchivosAzure>(); * * */ // Configuración servicio para subir archivos al servidor services.AddTransient <IAlmacenadorArchivos, AlmacenadorArchivosLocal>(); services.AddHttpContextAccessor(); services.AddSingleton(NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326)); services.AddSingleton(provider => new MapperConfiguration(config => { var geometryFactory = provider.GetRequiredService <GeometryFactory>(); config.AddProfile(new AutoMapperProfiles(geometryFactory)); }).CreateMapper() ); // Configuración de la cadena de conexión services.AddDbContext <ApplicationDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"), SqlServerOptions => SqlServerOptions.UseNetTopologySuite())); services.AddControllers() .AddNewtonsoftJson(); /*Configuración para la autenticación */ services.AddIdentity <IdentityUser, IdentityRole>() .AddEntityFrameworkStores <ApplicationDbContext>() .AddDefaultTokenProviders(); services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddJwtBearer(options => options.TokenValidationParameters = new TokenValidationParameters { ValidateIssuer = false, ValidateAudience = false, ValidateLifetime = true, ValidateIssuerSigningKey = true, IssuerSigningKey = new SymmetricSecurityKey( Encoding.UTF8.GetBytes(Configuration["jwt:key"])), ClockSkew = TimeSpan.Zero } ); }
public MigrationRunner(string connectionString, SqlServerOptions options) { _connectionString = connectionString; _options = options; }
public DefaultAdditionalProcessor(ILogger <DefaultAdditionalProcessor> logger, SqlServerOptions sqlServerOptions) { _logger = logger; _options = sqlServerOptions; }
public SqlServerMonitoringApi(IOptions <SqlServerOptions> options, IStorageInitializer initializer) { _options = options.Value ?? throw new ArgumentNullException(nameof(options)); _pubName = initializer.GetPublishedTableName(); _recName = initializer.GetReceivedTableName(); }
public SqlServerPublisher(IServiceProvider provider) : base(provider) { _options = ServiceProvider.GetService <SqlServerOptions>(); }
public SqlServerStorageConnection(SqlServerOptions options) { _options = options; }
public SqlServerCollectProcessor(ILogger <SqlServerCollectProcessor> logger, SqlServerOptions sqlServerOptions) { _logger = logger; _options = sqlServerOptions; }
public SqlServerStorage(ILogger <SqlServerStorage> logger, SqlServerOptions options) { _options = options; _logger = logger; }
public SqlServerPublisher(IServiceProvider provider) : base(provider) { _options = ServiceProvider.GetService <IOptions <SqlServerOptions> >().Value; }
public SqlServerSagaPersistance(ISqlServerConnection sqlServerConnection, IDateTimeProvider dateTimeProvider, SqlServerOptions sqlServerOptions, IMessageBus messageBus) { this.instances = new Dictionary <Guid, string>(); this.sqlServerConnection = sqlServerConnection; this.dateTimeProvider = dateTimeProvider; this.sqlServerOptions = sqlServerOptions; this.weakInMemorySagaPersistance = new WeakInMemorySagaPersistance( TimeSpan.FromSeconds(15)); this.messageBus = messageBus; }
public static IdentityBuilder AddSqlServerIdentityStore <TKey, TUser, TRole, TTenant>( this IdentityBuilder identityBuilder, string connectionString, ConnectionScope scope = ConnectionScope.ByRequest, Action <SqlServerOptions> configureDatabase = null) where TKey : IEquatable <TKey> where TUser : IdentityUserExtended <TKey> where TRole : IdentityRoleExtended <TKey> where TTenant : IdentityTenant <TKey> { var services = identityBuilder.Services; services.AddSingleton <ITypeRegistry, TypeRegistry>(); var serviceProvider = services.BuildServiceProvider(); var builder = new SqlConnectionStringBuilder(connectionString); void ConfigureAction(SqlServerOptions o) { configureDatabase?.Invoke(o); } identityBuilder.Services.Configure <SqlServerOptions>(ConfigureAction); var dialect = new SqlServerDialect(); identityBuilder.AddSqlStores <SqlServerConnectionFactory, TKey, TUser, TRole, TTenant>(connectionString, scope, OnCommand <TKey>(), OnConnection); SqlBuilder.Dialect = dialect; SimpleDataDescriptor.TableNameConvention = s => { switch (s) { case nameof(IdentityRoleExtended): return("AspNetRoles"); case nameof(IdentityUserExtended): return("AspNetUsers"); case nameof(IdentityTenant): return("AspNetTenants"); default: return(s); } }; DescriptorColumnMapper.AddTypeMap <TUser>(StringComparer.Ordinal); DescriptorColumnMapper.AddTypeMap <TRole>(StringComparer.Ordinal); DescriptorColumnMapper.AddTypeMap <TTenant>(StringComparer.Ordinal); services.AddMetrics(); services.AddSingleton(dialect); identityBuilder.Services.AddSingleton <IQueryableProvider <TUser>, NoQueryableProvider <TUser> >(); identityBuilder.Services.AddSingleton <IQueryableProvider <TRole>, NoQueryableProvider <TRole> >(); identityBuilder.Services.AddSingleton <IQueryableProvider <TTenant>, NoQueryableProvider <TTenant> >(); var options = new SqlServerOptions(); ConfigureAction(options); var identityOptions = serviceProvider.GetRequiredService <IOptions <IdentityOptionsExtended> >().Value; MigrateToLatest <TKey>(connectionString, identityOptions, options); return(identityBuilder); }