public MongoSnapshotStore(IMongoDatabase database, JsonSerializer jsonSerializer)
: base(database)
{
Guard.NotNull(jsonSerializer);
BsonJsonConvention.Register(jsonSerializer);
}
public TextIndexerTests_Mongo()
{
BsonJsonConvention.Register(JsonSerializer.Create(TestUtils.CreateSerializerSettings()));
SupportsQuerySyntax = false;
SupportsGeo = true;
}
static SerializationServices()
{
ConfigureJson(DefaultJsonSettings, TypeNameHandling.Auto);
DefaultJsonSerializer = JsonSerializer.Create(DefaultJsonSettings);
BsonJsonConvention.Register(DefaultJsonSerializer);
}
private static bool Register(JsonSerializer jsonSerializer)
{
Guard.NotNull(jsonSerializer, nameof(jsonSerializer));
BsonJsonConvention.Register(jsonSerializer);
return(true);
}
public Task InitializeAsync(CancellationToken ct = default)
{
BsonJsonConvention.Register(jsonSerializer);
RuleActionConverter.Mapping = ruleRegistry.Actions.ToDictionary(x => x.Key, x => x.Value.Type);
return(TaskHelper.Done);
}
protected MongoEventStoreFixture(string connectionString)
{
mongoClient = new MongoClient(connectionString);
mongoDatabase = mongoClient.GetDatabase(TestConfig.Configuration["mongodb:database"]);
BsonJsonConvention.Register(JsonSerializer.Create(TestUtils.DefaultSettings()));
EventStore = new MongoEventStore(mongoDatabase, notifier);
EventStore.InitializeAsync(default).Wait();
public MongoEventStoreFixture()
{
mongoDatabase = mongoClient.GetDatabase("EventStoreTest");
BsonJsonConvention.Register(JsonSerializer.Create(JsonHelper.DefaultSettings()));
EventStore = new MongoEventStore(mongoDatabase, notifier);
EventStore.InitializeAsync().Wait();
}
protected MongoEventStoreFixture(string connectionString)
{
mongoClient = new MongoClient(connectionString);
mongoDatabase = mongoClient.GetDatabase("Squidex_Testing");
BsonJsonConvention.Register(JsonSerializer.Create(TestUtils.DefaultSettings()));
EventStore = new MongoEventStore(mongoDatabase, notifier);
EventStore.InitializeAsync().Wait();
}
static SerializationServices()
{
TypeNameRegistry.MapUnmapped(typeof(SquidexCoreModel).Assembly);
TypeNameRegistry.MapUnmapped(typeof(SquidexEvents).Assembly);
TypeNameRegistry.MapUnmapped(typeof(SquidexInfrastructure).Assembly);
ConfigureJson(SerializerSettings, TypeNameHandling.Auto);
BsonJsonConvention.Register(JsonSerializer.Create(SerializerSettings));
}
public MongoTextIndexFixture()
{
BsonJsonConvention.Register(JsonSerializer.Create(TestUtils.CreateSerializerSettings()));
DomainIdSerializer.Register();
var mongoClient = new MongoClient(TestConfig.Configuration["mongodb:configuration"]);
var mongoDatabase = mongoClient.GetDatabase(TestConfig.Configuration["mongodb:database"]);
Index = new MongoTextIndex(mongoDatabase, false);
Index.InitializeAsync(default).Wait();
public AtlasTextIndexFixture()
{
BsonJsonConvention.Register(JsonSerializer.Create(TestUtils.CreateSerializerSettings()));
DomainIdSerializer.Register();
var mongoClient = new MongoClient(TestConfig.Configuration["atlas:configuration"]);
var mongoDatabase = mongoClient.GetDatabase(TestConfig.Configuration["atlas:database"]);
var options = TestConfig.Configuration.GetSection("atlas").Get <AtlasOptions>();
Index = new AtlasTextIndex(mongoDatabase, Options.Create(options), false);
Index.InitializeAsync(default).Wait();
public static IServiceCollection AddMySerializers(this IServiceCollection services)
{
var serializerSettings = ConfigureJson(new JsonSerializerSettings(), TypeNameHandling.Auto);
var serializerInstance = JsonSerializer.Create(serializerSettings);
services.AddSingletonAs(t => FieldRegistry);
services.AddSingletonAs(t => serializerSettings);
services.AddSingletonAs(t => serializerInstance);
services.AddSingletonAs(t => TypeNameRegistry);
BsonJsonConvention.Register(serializerInstance);
return(services);
}
private static JsonSerializerSettings CreateJsonSerializerSettings(TypeNameRegistry typeNameRegistry, FieldRegistry fieldRegistry)
{
var settings = new JsonSerializerSettings();
settings.SerializationBinder = new TypeNameSerializationBinder(typeNameRegistry);
settings.ContractResolver = new ConverterContractResolver(
new AppClientsConverter(),
new AppContributorsConverter(),
new ClaimsPrincipalConverter(),
new InstantConverter(),
new LanguageConverter(),
new LanguagesConfigConverter(),
new NamedGuidIdConverter(),
new NamedLongIdConverter(),
new NamedStringIdConverter(),
new PropertiesBagConverter <EnvelopeHeaders>(),
new PropertiesBagConverter <PropertiesBag>(),
new RefTokenConverter(),
new RuleConverter(),
new SchemaConverter(fieldRegistry),
new StringEnumConverter());
settings.NullValueHandling = NullValueHandling.Ignore;
settings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
settings.DateParseHandling = DateParseHandling.None;
settings.TypeNameHandling = TypeNameHandling.Auto;
settings.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
BsonJsonConvention.Register(JsonSerializer.Create(settings));
return(settings);
}
private static void SetupJson()
{
var jsonSerializer = JsonSerializer.Create(TestUtils.DefaultSerializerSettings);
BsonJsonConvention.Register(jsonSerializer);
}
public static void AddMyStoreServices(this IServiceCollection services, IConfiguration config)
{
config.ConfigureByOption("store:type", new Options
{
["MongoDB"] = () =>
{
BsonJsonConvention.Register(SerializationServices.DefaultJsonSerializer);
var mongoConfiguration = config.GetRequiredValue("store:mongoDb:configuration");
var mongoDatabaseName = config.GetRequiredValue("store:mongoDb:database");
var mongoContentDatabaseName = config.GetOptionalValue("store:mongoDb:contentDatabase", mongoDatabaseName);
var mongoClient = Singletons <IMongoClient> .GetOrAdd(mongoConfiguration, s => new MongoClient(s));
var mongoDatabase = mongoClient.GetDatabase(mongoDatabaseName);
var mongoContentDatabase = mongoClient.GetDatabase(mongoContentDatabaseName);
services.AddSingleton(typeof(ISnapshotStore <,>), typeof(MongoSnapshotStore <,>));
services.AddSingletonAs(mongoDatabase)
.As <IMongoDatabase>();
services.AddSingletonAs <MongoXmlRepository>()
.As <IXmlRepository>()
.As <IInitializable>();
services.AddSingletonAs <MongoMigrationStatus>()
.As <IMigrationStatus>()
.As <IInitializable>();
services.AddSingletonAs <MongoPersistedGrantStore>()
.As <IPersistedGrantStore>()
.As <IInitializable>();
services.AddSingletonAs <MongoUsageStore>()
.As <IUsageStore>()
.As <IInitializable>();
services.AddSingletonAs <MongoRuleEventRepository>()
.As <IRuleEventRepository>()
.As <IInitializable>();
services.AddSingletonAs <MongoUserStore>()
.As <IUserStore <IUser> >()
.As <IUserFactory>()
.As <IUserResolver>()
.As <IInitializable>();
services.AddSingletonAs <MongoRoleStore>()
.As <IRoleStore <IRole> >()
.As <IRoleFactory>()
.As <IInitializable>();
services.AddSingletonAs <MongoHistoryEventRepository>()
.As <IHistoryEventRepository>()
.As <IEventConsumer>()
.As <IInitializable>();
services.AddSingletonAs <MongoAssetStatsRepository>()
.As <IAssetStatsRepository>()
.As <IEventConsumer>()
.As <IInitializable>();
services.AddSingletonAs <MongoAssetRepository>()
.As <IAssetRepository>()
.As <ISnapshotStore <AssetState, Guid> >()
.As <IInitializable>();
services.AddSingletonAs(c => new MongoContentRepository(mongoContentDatabase, c.GetService <IAppProvider>()))
.As <IContentRepository>()
.As <ISnapshotStore <ContentState, Guid> >()
.As <IEventConsumer>()
.As <IInitializable>();
services.AddTransientAs <ConvertOldSnapshotStores>()
.As <IMigration>();
services.AddTransientAs(c => new DeleteContentCollections(mongoContentDatabase))
.As <IMigration>();
}
});
services.AddSingleton(typeof(IStore <>), typeof(Store <>));
}
private static void SetupJson()
{
var jsonSerializer = JsonSerializer.Create(JsonHelper.DefaultSettings());
BsonJsonConvention.Register(jsonSerializer);
}
private void SetupBson()
{
BsonJsonConvention.Register(jsonNetSerializer);
}
