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