/// <summary> /// Initializes a new instance of the <see cref="Configuration"/> class. /// </summary> /// <param name="configurationWrapper"><see cref="IConfigurationFor{T}"/> <see cref="ReadModelRepositoryConfiguration"/>.</param> public Configuration(IConfigurationFor <ReadModelRepositoryConfiguration> configurationWrapper) { var config = configurationWrapper.Instance; if (string.IsNullOrEmpty(config.ConnectionString)) { var s = MongoClientSettings.FromUrl(new MongoUrl(config.Host)); if (config.UseSSL) { s.UseSsl = true; s.SslSettings = new SslSettings { EnabledSslProtocols = System.Security.Authentication.SslProtocols.Tls12, CheckCertificateRevocation = false }; } Client = new MongoClient(s); } else { Client = new MongoClient(config.ConnectionString); } Database = Client.GetDatabase(config.Database); BsonSerializer.RegisterSerializationProvider(new ConceptSerializationProvider()); }
public void SetUp() { _handHistory = new HandHistory() { ComumnityCards = BoardCards.ForFlop(new Card(5), new Card(14), new Card(40)), DateOfHandUtc = new DateTime(2012, 3, 20, 12, 30, 44), DealerButtonPosition = 5, FullHandHistoryText = "some hand text", GameDescription = new GameDescriptor(PokerFormat.CashGame, SiteName.Values.PartyPoker, GameType.NoLimitHoldem, Limit.FromSmallBlindBigBlind(10, 20, Currency.USD), TableType.FromTableTypeDescriptions(TableTypeDescription.Regular), SeatType.FromMaxPlayers(6)), HandActions = new List <HandAction>() { new HandAction("Player1", HandActionType.POSTS, 0.25m, Street.Preflop) }, HandId = 141234124, NumPlayersSeated = 2, Players = new PlayerList() { new Player("Player1", 1000, 1), new Player("Player2", 300, 5), }, TableName = "Test Table", }; _handHistory.Players[0].HoleCards = new HoleCards(CardGroup.Parse("Ac Ad")); _handHistory.Players[1].HoleCards = new HoleCards(CardGroup.Parse("Kh Qs")); BsonSerializer.RegisterSerializationProvider(new TestSerializationProvider()); }
private void InitOptions() { if (this.options != null && this.options.AnyOptionEnabled && !globalConfigurationsInitialized) { lock (locker) { if (!globalConfigurationsInitialized) { if (this.options.EnableStructSerializer) { BsonSerializer.RegisterSerializationProvider(new SerializationProvider()); } if (this.options.EnableMappingReadOnlyProperties) { ConventionRegistry.Register(nameof(MappingReadOnlyPropertiesConvention), new ConventionPack { new MappingReadOnlyPropertiesConvention() }, _ => true); } globalConfigurationsInitialized = true; } } } }
// This method gets called by the runtime. Use this method to add services to the container. public virtual void ConfigureServices(IServiceCollection services) { services .AddControllers() .AddNewtonsoftJson(options => { options.SerializerSettings.Converters.Add(new StringEnumConverter()); options.SerializerSettings.ContractResolver = new DefaultContractResolver { NamingStrategy = new CamelCaseNamingStrategy() }; }); BsonSerializer.RegisterSerializationProvider(new DateTimeOffsetSerializationProvider()); services.AddApplication(Configuration); services.AddAutoMapper(typeof(Startup)); services.AddAuthorization(options => { options.AddPolicy("BasicAuthentication", new AuthorizationPolicyBuilder("BasicAuthentication").RequireAuthenticatedUser().Build()); }); services .AddAuthentication() .AddScheme <AuthenticationSchemeOptions, BasicAuthenticationHandler>("BasicAuthentication", options => { }); services.AddSwagger(Environment.EnvironmentName); services .AddMvcCore() .AddMetricsCore(); services.AddServiceClients(Configuration); }
/// <summary>Create a database using the given settings</summary> /// <remarks> /// Since the database is registered as a service, it is constructed by the service system. /// See <code>Startup></code> for service registration. /// </remarks> public Database(DatabaseSettings settings, ILogger <Database> logger) { this.logger = logger; BsonSerializer.RegisterSerializationProvider(new BsonSerializerProvider()); client = new MongoClient(settings.ConnectionString); morphic = client.GetDatabase(settings.DatabaseName); logger.LogInformation("Opened DB {Database}: {ConnectionSettings}", settings.DatabaseName, client.Settings.ToString()); CollectionByType[typeof(Preferences)] = morphic.GetCollection <Preferences>("Preferences"); CollectionByType[typeof(User)] = morphic.GetCollection <User>("User"); CollectionByType[typeof(UsernameCredential)] = morphic.GetCollection <UsernameCredential>("UsernameCredential"); CollectionByType[typeof(KeyCredential)] = morphic.GetCollection <KeyCredential>("KeyCredential"); CollectionByType[typeof(AuthToken)] = morphic.GetCollection <AuthToken>("AuthToken"); CollectionByType[typeof(BadPasswordLockout)] = morphic.GetCollection <BadPasswordLockout>("BadPasswordLockout"); CollectionByType[typeof(OneTimeToken)] = morphic.GetCollection <OneTimeToken>("OneTimeToken"); CollectionByType[typeof(Community)] = morphic.GetCollection <Community>("Communities"); CollectionByType[typeof(Member)] = morphic.GetCollection <Member>("CommunityMembers"); CollectionByType[typeof(Bar)] = morphic.GetCollection <Bar>("CommunityBars"); CollectionByType[typeof(Invitation)] = morphic.GetCollection <Invitation>("CommunityInvitations"); CollectionByType[typeof(BillingRecord)] = morphic.GetCollection <BillingRecord>("BillingRecord"); }
public DbAccess(IMasterPieceDatabaseSettings settings) { BsonSerializer.RegisterSerializationProvider(new BsonSerializationProvider()); var client = new MongoClient(settings.ConnectionString); MongoDatabase = client.GetServer().GetDatabase(settings.DatabaseName); }
public void Migrate() { BsonSerializer.RegisterSerializationProvider(_provider); RegisterSerializer(); OnStartup(); }
public static void Register() { DictionaryConventionRegistry.Register(new DictionaryConvention()); MappingConventionRegistry.Register(new MappingConvention()); BsonSerializer.RegisterSerializationProvider(new ValueTupleSerializationProvider()); BsonSerializer.RegisterSerializer(DateTimeSerializer.LocalInstance); }
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap) { if (!ProviderAdded) { ProviderAdded = true; BsonSerializer.RegisterSerializationProvider(TypeDiscoverySerializationProvider.Instance); } }
public void RegisterProvider_LookupSerializer_FrameworkSerializerWorks() { BsonSerializer.RegisterSerializationProvider(FrameworkSerializerProvider.Instance); IBsonSerializer <Email> emailSerializer = BsonSerializer.LookupSerializer <Email>(); Assert.NotNull(emailSerializer); }
public void ApplyMapping(Type entityType, BsonClassMap classMap) { if (!ProviderAdded && entityType.GetCustomAttribute <RuntimeTypeDiscoveryAttribute>() != null) { ProviderAdded = true; BsonSerializer.RegisterSerializationProvider(TypeDiscoverySerializationProvider.Instance); } }
public void RegisterProvider_LookupSerializerTwice_ReturnsCachedSerializer() { BsonSerializer.RegisterSerializationProvider(FrameworkSerializerProvider.Instance); IBsonSerializer <Email> firstSerializer = BsonSerializer.LookupSerializer <Email>(); IBsonSerializer <Email> secondSerializer = BsonSerializer.LookupSerializer <Email>(); Assert.Equal(firstSerializer, secondSerializer); }
public void Connect(ConnectionInfo info) { BsonSerializer.RegisterSerializationProvider(new UnityResolver()); m_info = info; m_client = new MongoClient(info.DatabaseAddress); m_database = m_client.GetDatabase(info.DatabaseName); m_collection = m_database.GetCollection <T>(info.CollectionName); }
public EntityContextConnection(EntityContextConfiguration configuration) { ConnectionString = configuration.Url; DatabaseName = configuration.DefaultDatabase; Server = MongoServer.Create(ConnectionString); Database = Server.GetDatabase(DatabaseName); BsonSerializer.RegisterSerializationProvider(new ConceptSerializationProvider()); }
/// <summary> /// Add mongoDb implementation of IEventStore /// </summary> /// <param name="services"></param> /// <param name="mongoConfig"></param> /// <param name="eventStoreConfig"></param> /// <returns></returns> public static IServiceCollection AddMongoDbEventStore(this IServiceCollection services, MongoConfig mongoConfig, EventStoreConfig eventStoreConfig) { BsonSerializer.RegisterSerializationProvider(new CustomSerializationProvider()); services.AddSingleton(mongoConfig) .AddSingleton(eventStoreConfig) .AddSingleton <IMongoConnectionWrapper, MongoConnectionWrapper>() .RegisterStores(false); return(services); }
static MongoDatabase() { BsonSerializer.RegisterSerializationProvider(new StructSerializationProvider()); BsonSerializer.RegisterSerializationProvider(new DictionarySerializerProvider()); var conventionPack = new ConventionPack { new ClassMapConvention() }; ConventionRegistry.Register("AI4E default convention pack", conventionPack, _ => true); }
/// <summary> /// BSON serialization setup is static and leads to error if the same serializer or serialization providers /// have already been set up, so we make sure to set it up only once /// </summary> public static void Setup() { lock (StaticLock) { if (!_bsonSerializationInitialized) { BsonSerializer.RegisterSerializationProvider(new LanguageExtCollectionSerializationProvider()); _bsonSerializationInitialized = true; } } }
public void SetUp() { var identityConverter = new IdentityManager(new InMemoryCounterService()); MongoFlatIdSerializerHelper.IdentityConverter = identityConverter; identityConverter.RegisterIdentitiesFromAssembly(typeof(SampleId).Assembly); BsonSerializer.RegisterSerializationProvider(new EventStoreIdentitySerializationProvider()); BsonSerializer.RegisterSerializationProvider(new StringValueSerializationProvider()); }
public static void AddDocumentStore(this IServiceCollection services, string conn, string db, int max) { services.Configure <MongoDBSettings>(options => { options.DatabaseName = db; options.ConnectionString = conn; options.MaxConnections = max; }); BsonSerializer.RegisterSerializationProvider(new BsonDecimalSerializationProvider()); services.AddSingleton <SensateContext>(); }
public ReadModule(IImplementationsOf <IReadModel> readModels, ITypeFinder typeFinder) { _readModels = readModels; BsonSerializer.RegisterSerializationProvider(new ConceptSerializationProvider()); var customClassMapTypes = typeFinder.FindMultiple(typeof(IBsonClassMapForReadModel <>)); var readModelHasCustomClassMap = GetHasCustomClassMapDictionary(customClassMapTypes.ToList()); RegisterBsonClassMaps(readModelHasCustomClassMap); }
public static IServiceCollection AddMongoDb(this IServiceCollection services, MongoConfig mongoConfig) { services.AddSingleton(mongoConfig); BsonSerializer.RegisterSerializationProvider(new CustomSerializationProvider()); var mongoClient = new MongoClient(mongoConfig.ConnectionString); services.AddSingleton <IMongoClient>(mongoClient); return(services); }
public DatabaseConfiguration(IConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } this.ConnectionString = configuration["Mongo:ConnectionString"]; this.Database = configuration["Mongo:Database"]; BsonSerializer.RegisterSerializationProvider(new ObjectIdentifierSerializer()); }
internal static void Initialize() { if (_initialized) { return; } // Register custom serialization provider. BsonSerializer.RegisterSerializationProvider(new SerializationProvider()); _initialized = true; }
protected void Application_Start() { ModelBinders.Binders.DefaultBinder = new ObjectIdModelBinder(); AreaRegistration.RegisterAllAreas(); // IdentityConfig.ConfigureIdentity(); GlobalConfiguration.Configure(WebApiConfig.Register); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); BsonSerializer.RegisterSerializationProvider(new CustomDecimalSerializer()); }
public static void RegisterProvider() { if (!BsonSerializer.zIsSerializationProviderRegistered(typeof(PBSerializationProvider_v1))) { if (_trace) { pb.Trace.WriteLine("PBSerializationProvider_v1 : register provider"); } BsonSerializer.RegisterSerializationProvider(new PBSerializationProvider_v1()); //BsonSerializer.RegisterGenericSerializerDefinition(typeof(Dictionary<,>), typeof(DictionarySerializer<,>)); } }
/// <summary> /// Injects given entity types as IMongoCollection<Type> to <paramref name="services"/>. /// You should call this method as an extention to your <see cref="IServiceCollection"/> instance on your startup code. /// </summary> /// <param name="services"></param> /// <param name="entityTypes">Your entity types that represents a mongodb collection. These types must implement <see cref="EasyMongoNet.IMongoEntity"/></param> /// <param name="defaultConnection">Default mongodb connection settings</param> /// <param name="customConnections">Alternative mongodb connection settings for specific types.</param> public static void FindModelsAndAddMongoCollections(this IServiceCollection services, IEnumerable <Type> entityTypes, MongoConnectionSettings defaultConnection, MongoConnectionSettings[] customConnections = null) { var customConnectionsDic = new Dictionary <string, MongoConnectionSettings>(); if (customConnections != null) { foreach (var con in customConnections) { if (con.ConnectionString == null) { con.ConnectionString = defaultConnection.ConnectionString; } } customConnectionsDic = customConnections.ToDictionary(k => k.Type); } var databasesDic = new Dictionary <MongoConnectionSettings, IMongoDatabase>(); foreach (var type in entityTypes) { MongoConnectionSettings connSettings; if (customConnectionsDic.ContainsKey(type.Name)) { connSettings = customConnectionsDic[type.Name]; } else { connSettings = defaultConnection; } IMongoDatabase db; if (databasesDic.ContainsKey(connSettings)) { db = databasesDic[connSettings]; } else { var client = new MongoClient(connSettings.ConnectionSettings); db = client.GetDatabase(connSettings.DBName); databasesDic.Add(connSettings, db); } var col = GetCollecion(db, type); if (col == null) { continue; } SetIndexes(col, type); AddCollectionToServices(services, col, type); } services.AddSingleton(databasesDic.Values.ToList()); BsonSerializer.RegisterSerializationProvider(new CustomSerializationProvider()); }
public MongoBaseProvider(string conUrl) { BsonSerializer.RegisterSerializationProvider(new MDBsonSerializationProvider()); var mongoConnectionUrl = new MongoUrl(conUrl); if (!string.IsNullOrEmpty(mongoConnectionUrl.DatabaseName)) { DatabaseName = mongoConnectionUrl.DatabaseName; } var setting = MongoClientSettings.FromUrl(mongoConnectionUrl); client = new MongoClient(setting); }
public JobRepository(IConfiguration configuration, ILogger <AgentRepository> logger) { context = new MongoContext(configuration); buildCollection = context.MongoDatabase.GetCollection <JobBuildEntity>("Jobs"); deployCollection = context.MongoDatabase.GetCollection <JobDeployEntity>("Jobs"); var pack = new ConventionPack { new EnumRepresentationConvention(BsonType.String) }; ConventionRegistry.Register("EnumStringConvention", pack, t => true); BsonSerializer.RegisterSerializationProvider(new EnumAsStringSerializationProvider()); }
public static void Configure(Func <Type, bool> domainConventionFilter) { BsonDefaults.GuidRepresentation = GuidRepresentation.Standard; var pack = new ConventionPack { new CamelCaseElementNameConvention(), new NamedIdMemberConvention("Id", "id") }; ConventionRegistry.Register( "Domain convention", pack, domainConventionFilter); BsonSerializer.RegisterSerializationProvider(new CustomSerializationProvider()); }
public static void EnableFlatMapping(Boolean enableForAllId) { if (_enabled) { return; } if (enableForAllId) { BsonSerializer.RegisterSerializationProvider(new EventStoreIdentitySerializationProvider()); BsonSerializer.RegisterSerializationProvider(new StringValueSerializationProvider()); } _enabled = true; }