public static IServiceCollection AddMongoDataAccess(this IServiceCollection services,
IConfiguration configuration)
{
IConfigurationSection dataAccessConfig = configuration.GetSection("DataAccess");
string connectionString = dataAccessConfig.GetValue <string>("ConnectionString");
services.AddHangfire(x => x.UseMongoStorage(connectionString, DbNames.Jobs));
BsonSerializer.RegisterDiscriminatorConvention(typeof(Project),
new HierarchicalDiscriminatorConvention("appName"));
var pack = new ConventionPack
{
new CamelCaseElementNameConvention(),
new ObjectRefConvention()
};
ConventionRegistry.Register("Custom", pack, t => true);
services.AddSingleton <IMongoClient>(sp => new MongoClient(connectionString));
services.AddMongoRepository <SendReceiveJob>("send_receive");
services.AddMongoRepository <User>("users", cm =>
{
cm.MapMember(u => u.SiteRole).SetSerializer(
new DictionaryInterfaceImplementerSerializer <Dictionary <string, string> >(
DictionaryRepresentation.Document, new SiteDomainSerializer(), new StringSerializer()));
});
services.AddMongoRepository <Project>("projects");
services.AddMongoRepository <LexProject>("projects", cm =>
{
cm.SetDiscriminator("lexicon");
}, true);
return(services);
}
/*******************************************/
private static void RegisterSerializers()
{
try
{
BsonSerializer.RegisterSerializer(typeof(object), new BH_ObjectSerializer());
BsonSerializer.RegisterSerializer(typeof(System.Drawing.Color), new ColourSerializer());
BsonSerializer.RegisterSerializer(typeof(MethodBase), new MethodBaseSerializer());
BsonSerializer.RegisterSerializer(typeof(Guid), new GuidSerializer(BsonType.String));
BsonSerializer.RegisterSerializer(typeof(CustomObject), new CustomObjectSerializer());
BsonSerializer.RegisterSerializer(typeof(Enum), new EnumSerializer());
BsonSerializer.RegisterSerializer(typeof(IDeprecated), new DeprecatedSerializer());
BsonSerializer.RegisterSerializer(typeof(DataTable), new DataTableSerialiser());
BsonSerializer.RegisterSerializer(typeof(Bitmap), new BitmapSerializer());
BsonSerializer.RegisterSerializer(typeof(IntPtr), new IntPtrSerializer());
BsonSerializer.RegisterSerializer(typeof(Regex), new RegexSerializer());
var typeSerializer = new TypeSerializer();
BsonSerializer.RegisterSerializer(typeof(Type), typeSerializer);
BsonSerializer.RegisterSerializer(Type.GetType("System.RuntimeType"), typeSerializer);
BsonDefaults.DynamicDocumentSerializer = new CustomObjectSerializer();
BsonSerializer.RegisterDiscriminatorConvention(typeof(IBHoMObject), new BHoMObjectDiscriminatorConvention());
BsonSerializer.RegisterDiscriminatorConvention(typeof(IObject), new BHoMObjectDiscriminatorConvention());
}
catch (Exception)
{
Debug.WriteLine("Problem with initialisation of the Bson Serializer");
}
}
protected void SetUp()
{
var f = new FileStream("config.json", FileMode.Open);
var sr = new StreamReader(f);
try
{
var settings = JsonConvert
.DeserializeObject <MongoSettings>(sr.ReadToEnd());
var client = new MongoClient(new MongoUrl(settings.Url));
_database = client.GetDatabase(settings.DatabaseName);
}
catch (FileNotFoundException)
{
throw new Exception("Talk to John about why this one fails");
}
finally
{
f.Dispose();
sr.Dispose();
}
_collectionName = Guid.NewGuid().ToString();
_collection = _database.GetCollection <Container>(_collectionName);
var mapper = new StringMapper <BasePaymentModel>(x => x.PaymentType)
.Register <AchInputModel>("ach")
.Register <CreditCardInputModel>("cc")
.Register <PayPalInputModel>("paypal");
BsonSerializer.RegisterDiscriminatorConvention(
typeof(BasePaymentModel),
new DiscriminatorConvention <string, BasePaymentModel>(mapper));
}
/*******************************************/
/**** Public Methods ****/
/*******************************************/
public static void RegisterClassMap(Type type)
{
if (!BsonClassMap.IsClassMapRegistered(type))
{
try
{
if (type.IsEnum)
{
MethodInfo generic = m_CreateEnumSerializer.MakeGenericMethod(type);
generic.Invoke(null, null);
}
else if (!type.IsGenericTypeDefinition)
{
BsonClassMap cm = new BsonClassMap(type);
cm.AutoMap();
cm.SetDiscriminator(type.FullName);
cm.SetDiscriminatorIsRequired(true);
cm.SetIgnoreExtraElements(true); // It would have been nice to use cm.MapExtraElementsProperty("CustomData") but it doesn't work for inherited properties
cm.SetIdMember(null);
BsonClassMap.RegisterClassMap(cm);
BsonSerializer.RegisterDiscriminatorConvention(type, new GenericDiscriminatorConvention());
}
else
{
BsonSerializer.RegisterDiscriminatorConvention(type, new GenericDiscriminatorConvention());
}
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
}
}
private void RegisterConventions()
{
var pack = new ConventionPack {
new IgnoreIfNullConvention(true), /*new MongoRefConvention(),*/ new IgnoreExtraElementsConvention(true)
};
ConventionRegistry.Register("Custom Conventions", pack, t => true);
try
{
BsonSerializer.RegisterGenericSerializerDefinition(typeof(MongoRef <>), typeof(MongoRefSerializer <>));
}
catch (BsonSerializationException bsex) when(bsex.Message == "There is already a serializer mapping registered for type MongoRef<T>.")
{
}
try
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(FileAction), new ContentTypeDiscriminatorConvention());
}
catch (Exception e) { }
if (!BsonClassMap.IsClassMapRegistered(typeof(MongoEntity)))
{
BsonClassMap.RegisterClassMap <MongoEntity>(delegate(BsonClassMap <MongoEntity> map)
{
map.AutoMap();
//map.MapProperty(f => f.ParentId).SetSerializer(new StringSerializer().WithRepresentation(BsonType.ObjectId));
map.IdMemberMap.SetSerializer(new StringSerializer().WithRepresentation(BsonType.ObjectId)).SetIdGenerator(StringObjectIdGenerator.Instance);;
});
}
}
/*******************************************/
private static void RegisterClassMaps()
{
MethodInfo method = typeof(BH.Engine.Serialiser.Convert).GetMethod("CreateEnumSerializer", BindingFlags.NonPublic | BindingFlags.Static);
foreach (Type type in BH.Engine.Reflection.Query.BHoMTypeList())
{
if (!BsonClassMap.IsClassMapRegistered(type))
{
if (type.IsEnum)
{
MethodInfo generic = method.MakeGenericMethod(type);
generic.Invoke(null, null);
}
else if (!type.IsGenericType)
{
Compute.RegisterClassMap(type);
}
else
{
BsonSerializer.RegisterDiscriminatorConvention(type, new GenericDiscriminatorConvention());
}
}
}
Compute.RegisterClassMap(typeof(System.Drawing.Color));
Compute.RegisterClassMap(typeof(MethodInfo));
Compute.RegisterClassMap(typeof(ConstructorInfo));
Compute.RegisterClassMap(typeof(Bitmap));
Compute.RegisterClassMap(typeof(IntPtr));
Compute.RegisterClassMap(typeof(Regex));
}
//--- CONSTRUCTORS
/// <summary>
/// Use static constructor to set discriminator convention.
///
/// This call is in static constructor because MongoDB driver
/// complains if it is called more than once.
/// </summary>
static MongoDataSource()
{
// Set discriminator convention to hierarchical. For this convention,
// BSON element _t is either an array of GetType().Name values for ell
// types in the inheritance chain, or a single string value for a chain
// of length 1.
//
// Choosing root type to be Record ensures that _t is always an array.
BsonSerializer.RegisterDiscriminatorConvention(typeof(Data), new HierarchicalDiscriminatorConvention("_t"));
}
private void ProcessTypeToRegisterForBson(
TypeToRegisterForBson typeToRegisterForBson,
SerializationConfigurationType registeringSerializationConfigurationType)
{
var type = typeToRegisterForBson.Type;
var bsonSerializerBuilder = typeToRegisterForBson.BsonSerializerBuilder;
var propertyNameWhitelist = typeToRegisterForBson.PropertyNameWhitelist;
if (registeringSerializationConfigurationType == this.SerializationConfigurationType)
{
if (bsonSerializerBuilder == null)
{
try
{
if (type.IsClass)
{
var bsonClassMap = AutomaticallyBuildBsonClassMap(type, propertyNameWhitelist);
BsonClassMap.RegisterClassMap(bsonClassMap);
}
// we are not 100% sure whether interface types or abstract types need to be registered
// but there doesn't seem to be any harm in doing so.
BsonSerializer.RegisterDiscriminatorConvention(type, ObcBsonDiscriminatorConvention.Instance);
}
catch (Exception ex)
{
throw new BsonSerializationConfigurationException(Invariant($"Failed to run {nameof(BsonClassMap.RegisterClassMap)} on {type.FullName}"), ex);
}
}
else
{
// see comments in RegisteredTypeBsonSerializer<T> for why we are wrapping the serializer
var registeredTypeBsonSerializer = RegisteredTypeBsonSerializer.Build(type, bsonSerializerBuilder.BsonSerializerBuilderFunc());
BsonSerializer.RegisterSerializer(type, registeredTypeBsonSerializer);
}
}
if (bsonSerializerBuilder != null)
{
this.typesWithCustomSerializerOrPropertyNamesWhitelist.Add(type, null);
if (bsonSerializerBuilder.OutputKind == BsonSerializerOutputKind.String)
{
this.typesWithCustomStringSerializers.Add(type, null);
}
}
if (propertyNameWhitelist != null)
{
this.typesWithCustomSerializerOrPropertyNamesWhitelist.Add(type, null);
}
}
public static void Init()
{
var dis = new TypeDiscriminator(typeof(AbstractDownloadState), AbstractDownloadState.NameToType,
AbstractDownloadState.TypeToName);
BsonSerializer.RegisterDiscriminatorConvention(typeof(AbstractDownloadState), dis);
BsonClassMap.RegisterClassMap <AbstractDownloadState>(cm => cm.SetIsRootClass(true));
dis = new TypeDiscriminator(typeof(AJobPayload), AJobPayload.NameToType, AJobPayload.TypeToName);
BsonSerializer.RegisterDiscriminatorConvention(typeof(AJobPayload), dis);
BsonClassMap.RegisterClassMap <AJobPayload>(cm => cm.SetIsRootClass(true));
}
private IMongoDatabase InitializeDatabase()
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(BaseProperty), new BasePropertyDiscriminator());
BsonSerializer.RegisterDiscriminatorConvention(typeof(Entity), new EntityDiscriminator());
MapEntities();
// Mongo client
var client = new MongoClient("mongodb+srv://m001-student:m001-mongodb-basics@" +
"sandbox.aidnp.mongodb.net/temp?retryWrites=true&w=majority");
return(client.GetDatabase("Live2K"));
}
public void RegisterClassMapsForDerivedClassesOf(Type baseClass)
{
// TODO: If derived types need extra registration steps, figure out how to discover that here.
// Current idea is to have an ExtraRegistrationSteps function that does extra steps based on
// what the type is, and derived classes like MongoRegistrarForLfConfig can override that function.
BsonSerializer.RegisterDiscriminatorConvention(baseClass, new ScalarDiscriminatorConvention("type"));
foreach (Type type in
Assembly.GetAssembly(baseClass).GetTypes()
.Where(thisType => thisType.IsClass && !thisType.IsAbstract && thisType.IsSubclassOf(baseClass)))
{
RegisterClassWithDiscriminator(type);
}
}
protected BsonClassMap Create <T>(Definitions.ItemDefinition definition, IEnumerable <Definitions.ItemDefinition> allDefinitions)
where T : ContentItem
{
return(new BsonClassMap <T>(cm =>
{
cm.SetDiscriminator(definition.Discriminator);
BsonSerializer.RegisterDiscriminatorConvention(definition.ItemType, new IgnoreProxyTypeDiscriminatorConvention());
foreach (var type in allDefinitions.Select(d => d.ItemType).Where(t => definition.ItemType.IsAssignableFrom(t)))
{
cm.AddKnownType(type);
}
cm.AutoMap();
cm.SetCreator(() =>
{
try
{
return database.IdentityMap.Current
?? CreateItem <T>(definition, proxies, database);
}
finally
{
database.IdentityMap.Current = null;
}
});
foreach (var p in definition.Properties.Values
.Where(p => p.Info != null)
.Where(p => typeof(ContentItem).IsAssignableFrom(p.Info.PropertyType))
.Where(p => p.Info.DeclaringType == definition.ItemType))
{
if (p.Info.CanRead && p.Info.CanWrite)
{
cm.GetMemberMap(p.Name).SetSerializer(new ContentItemReferenceSerializer(database));
}
else
{
cm.UnmapProperty(p.Name);
}
}
cm.SetIgnoreExtraElements(true);
}));
}
/*******************************************/
private static void RegisterClassMap(Type type)
{
try
{
BsonClassMap cm = new BsonClassMap(type);
cm.AutoMap();
cm.SetDiscriminator(type.FullName);
cm.SetDiscriminatorIsRequired(true);
cm.SetIgnoreExtraElements(false); // It would have been nice to use cm.MapExtraElementsProperty("CustomData") but it doesn't work for inherited properties
BsonClassMap.RegisterClassMap(cm);
BsonSerializer.RegisterDiscriminatorConvention(type, new GenericDiscriminatorConvention());
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
}
/// <summary>
/// If the type is not registered, attach it to our discriminator
/// </summary>
/// <param name="actualType">the type to examine</param>
protected void RegisterNewTypesToDiscriminator(Type actualType)
{
// we've detected a new concrete type that isn't registered in MongoDB's serializer
if (actualType != typeof(object) && !actualType.GetTypeInfo().IsInterface&& !BsonSerializer.IsTypeDiscriminated(actualType))
{
try
{
BsonSerializer.RegisterDiscriminatorConvention(actualType, DiscriminatorConvention);
BsonSerializer.RegisterDiscriminator(actualType, DiscriminatorConvention.GetDiscriminator(typeof(object), actualType));
}
catch (BsonSerializationException)
{
// the MongoDB driver library has no nice mechanism for checking if a discriminator convention is registerd.
// The "Lookup" logic tends to define a default if it doesn't exist.
// So we're forced to eat the "duplicate registration" exception.
}
}
}
public MongoResponseCache(string connectionString)
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(Response), new TypeDiscriminatorConvention());
BsonClassMap.RegisterClassMap <Response>(cm =>
{
cm.AutoMap();
cm.MapProperty(x => x.Type).SetRepresentation(BsonType.String);
});
BsonClassMap.RegisterClassMap <Error>();
BsonClassMap.RegisterClassMap <Link>();
BsonClassMap.RegisterClassMap <Photo>();
BsonClassMap.RegisterClassMap <Rich>();
BsonClassMap.RegisterClassMap <Video>();
var url = MongoUrl.Create(connectionString);
var client = new MongoClient(url);
var server = client.GetServer();
var database = server.GetDatabase(url.DatabaseName);
_collection = database.GetCollection <MongoCacheItem>("embedly");
}
public void Register(TinyIoCContainer container)
{
container.Register <ISettingService, SettingService>();
container.Register(typeof(IConfigurationProvider <>), typeof(ConfigurationProvider <>));
container.Register((context, p) => GetSettingsDatabase(context));
container.Register((context, p) => GetSettingsDatabase(context).GetCollection <Setting>("Settings"));
container.ResolveUnregisteredType += (sender, e) =>
{
if (typeof(ISettings).IsAssignableFrom(e.Request.Type))
{
var buildMethod = BuildSettingsMethod.MakeGenericMethod(e.Request.Type);
e.Result = buildMethod.Invoke(null, new object[] { container });
}
};
try
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(Setting), new SettingsDiscriminatorConvention());
}catch (BsonSerializationException ex)
{
// ensure that we can call this multiple times in same app domain for unit tests
}
}
/*******************************************/
private static void RegisterTypes()
{
// Define the conventions
var pack = new ConventionPack();
pack.Add(new ImmutableBHoMClassMapConvention());
pack.Add(new ImmutableBHoMCreatorMapConvention());
pack.Add(new BHoMDictionaryConvention());
ConventionRegistry.Register("BHoM Conventions", pack, x => x is object);
var pack2 = new ConventionPack();
pack2.Add(new BHoMEnumConvention());
ConventionRegistry.Register("Enum Conventions", pack2, x => x.GetType().IsEnum);
// Register additional serialisers
try
{
BsonSerializer.RegisterSerializer(typeof(object), new BH_ObjectSerializer());
BsonSerializer.RegisterSerializer(typeof(System.Drawing.Color), new ColourSerializer());
BsonSerializer.RegisterSerializer(typeof(MethodBase), new MethodBaseSerializer());
BsonSerializer.RegisterSerializer(typeof(Guid), new GuidSerializer(BsonType.String));
BsonSerializer.RegisterSerializer(typeof(CustomObject), new CustomObjectSerializer());
BsonSerializer.RegisterSerializer(typeof(Enum), new EnumSerializer());
BsonSerializer.RegisterSerializer(typeof(IDeprecated), new DeprecatedSerializer());
BsonSerializer.RegisterSerializer(typeof(DataTable), new DataTableSerialiser());
var typeSerializer = new TypeSerializer();
BsonSerializer.RegisterSerializer(typeof(Type), typeSerializer);
BsonSerializer.RegisterSerializer(Type.GetType("System.RuntimeType"), typeSerializer);
BsonDefaults.DynamicDocumentSerializer = new CustomObjectSerializer();
BsonSerializer.RegisterDiscriminatorConvention(typeof(object), new GenericDiscriminatorConvention());
}
catch (Exception)
{
Debug.WriteLine("Problem with initialisation of the Bson Serializer");
}
// Register class maps
MethodInfo method = typeof(BH.Engine.Serialiser.Convert).GetMethod("CreateEnumSerializer", BindingFlags.NonPublic | BindingFlags.Static);
foreach (Type type in BH.Engine.Reflection.Query.BHoMTypeList())
{
if (!BsonClassMap.IsClassMapRegistered(type))
{
if (type.IsEnum)
{
MethodInfo generic = method.MakeGenericMethod(type);
generic.Invoke(null, null);
}
else if (!type.IsGenericType)
{
RegisterClassMap(type);
}
}
}
RegisterClassMap(typeof(System.Drawing.Color));
RegisterClassMap(typeof(MethodInfo));
RegisterClassMap(typeof(ConstructorInfo));
m_TypesRegistered = true;
}
public MongoDatabaseService(MongoDBSettings mongoDBSettings)
{
Database = new MongoClient(mongoDBSettings.ConnectionString).GetDatabase(mongoDBSettings.DatabaseName);
BsonSerializer.RegisterDiscriminatorConvention(typeof(Item), new DiscriminatorConvention());
}
static A()
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(A), new MagicDiscriminatorConvention());
}
private void RegisterDiscriminators()
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(OrderModel), new OrderModelDiscriminator());
BsonSerializer.RegisterDiscriminatorConvention(typeof(JobTask), new JobTaskDiscriminator());
}
public static void RegisterDiscriminatorConvention(Type type)
{
BsonSerializer.RegisterDiscriminatorConvention(type, NoDiscriminatorConventionInstance);
}
public static IEventSourcingBuilder AddMongo(this IServiceCollection services)
{
services.AddSingleton <IConfigureOptions <MongoOptions> >(s => new MongoOptionsConfigure(
s.GetRequiredService <IConfiguration>()
));
services.AddSingleton <IMongoClient>(s => {
var options = s.GetRequiredService <IOptions <MongoOptions> >().Value;
var mappers = s.GetServices <Action <IMapState> >().ToList();
foreach (var mapper in mappers)
{
mapper(new MongoStateMapper(s));
}
if (!Initialized)
{
Initialized = true;
BsonSerializer.RegisterDiscriminatorConvention(
typeof(object),
new ScalarDiscriminatorConvention("_t")
);
BsonClassMap.RegisterClassMap <Envelope>(map => {
map.AutoMap();
map.MapIdProperty(x => x.MessageId)
.SetIdGenerator(StringObjectIdGenerator.Instance)
.SetSerializer(new StringSerializer(BsonType.String));
});
BsonClassMap.RegisterClassMap <Snapshot>(map => {
map.AutoMap();
map.MapIdProperty(p => p.SnapshotId);
});
}
return(new MongoClient(options.ConnectionString));
});
services.AddSingleton <IMongoDatabase>(s => s
.GetRequiredService <IMongoClient>()
.GetDatabase(
s.GetRequiredService <IOptions <MongoOptions> >().Value.Database
));
services.AddSingleton(s => new List <IMapState>());
services.AddSingleton(s => new MongoStore(
s.GetRequiredService <ILoggerFactory>().CreateLogger <MongoStore>(),
s.GetRequiredService <IClientSessionHandle>(),
s.GetRequiredService <IMongoCollection <Envelope> >(),
s.GetRequiredService <IMongoCollection <Snapshot> >()
));
services.AddSingleton(s => s
.GetRequiredService <IMongoDatabase>()
.GetCollection <Envelope>(
s.GetService <IOptions <MongoOptions> >().Value.EventCollection
));
services.AddSingleton(s => s
.GetRequiredService <IMongoDatabase>()
.GetCollection <Snapshot>(
s.GetService <IOptions <MongoOptions> >().Value.SnapshotCollection
)
);
services.AddSingleton <IStoreEvents>(s => s.GetRequiredService <MongoStore>());
services.AddSingleton <IStoreSnapshots>(s => s.GetRequiredService <MongoStore>());
services.AddTransient <IClientSessionHandle>(s => s.GetService <IMongoClient>().StartSession());
services.AddTransient <IHostedService>(s => new MongoInitializationService(
s.GetRequiredService <IMongoCollection <Envelope> >(),
s.GetRequiredService <IMongoCollection <Snapshot> >()
));
return(new MongoServiceBuilder(services));
}
public static IServiceCollection AddMongoDataAccess(this IServiceCollection services,
IConfiguration configuration)
{
IConfigurationSection dataAccessConfig = configuration.GetSection("DataAccess");
string connectionString = dataAccessConfig.GetValue <string>("ConnectionString",
"mongodb://localhost:27017");
string jobDatabase = dataAccessConfig.GetValue <string>("JobDatabase", "jobs");
services.AddHangfire(x => x.UseMongoStorage(connectionString, jobDatabase,
new MongoStorageOptions
{
MigrationOptions = new MongoMigrationOptions
{
Strategy = MongoMigrationStrategy.Migrate
}
}));
BsonSerializer.RegisterDiscriminatorConvention(typeof(Project),
new HierarchicalDiscriminatorConvention("appName"));
BsonSerializer.RegisterDiscriminatorConvention(typeof(LexConfig),
new HierarchicalDiscriminatorConvention("type"));
BsonSerializer.RegisterDiscriminatorConvention(typeof(LexViewFieldConfig),
new HierarchicalDiscriminatorConvention("type"));
BsonSerializer.RegisterDiscriminatorConvention(typeof(LexTask),
new HierarchicalDiscriminatorConvention("type"));
var globalPack = new ConventionPack
{
new CamelCaseElementNameConvention(),
new ObjectRefConvention()
};
ConventionRegistry.Register("Global", globalPack, t => true);
var paratextProjectPack = new ConventionPack {
new NoIdMemberConvention()
};
ConventionRegistry.Register("ParatextProject", paratextProjectPack, t => t == typeof(ParatextProject));
RegisterClass <EntityBase>(cm =>
{
cm.MapIdProperty(e => e.Id)
.SetIdGenerator(StringObjectIdGenerator.Instance)
.SetSerializer(new StringSerializer(BsonType.ObjectId));
});
RegisterClass <LexConfig>(cm =>
{
cm.MapMember(lc => lc.HideIfEmpty).SetSerializer(new EmptyStringBooleanSerializer());
});
RegisterClass <LexConfigFieldList>(cm => cm.SetDiscriminator(LexConfig.FieldList));
RegisterClass <LexConfigOptionList>(cm => cm.SetDiscriminator(LexConfig.OptionList));
RegisterClass <LexConfigMultiOptionList>(cm => cm.SetDiscriminator(LexConfig.MultiOptionList));
RegisterClass <LexConfigMultiText>(cm => cm.SetDiscriminator(LexConfig.MultiText));
RegisterClass <LexConfigPictures>(cm => cm.SetDiscriminator(LexConfig.Pictures));
RegisterClass <LexConfigMultiParagraph>(cm => cm.SetDiscriminator(LexConfig.MultiParagraph));
RegisterClass <LexViewFieldConfig>(cm => cm.SetDiscriminator("basic"));
RegisterClass <LexViewMultiTextFieldConfig>(cm => cm.SetDiscriminator("multitext"));
RegisterClass <LexTask>(cm => cm.SetDiscriminator(""));
RegisterClass <LexTaskDashboard>(cm => cm.SetDiscriminator(LexTask.Dashboard));
RegisterClass <LexTaskSemdom>(cm => cm.SetDiscriminator(LexTask.Semdom));
RegisterClass <LexAuthorInfo>(cm =>
{
cm.MapMember(a => a.ModifiedByUserRef)
.SetSerializer(new StringSerializer(BsonType.ObjectId));
cm.MapMember(a => a.CreatedByUserRef)
.SetSerializer(new StringSerializer(BsonType.ObjectId));
});
RegisterClass <LexSense>(cm =>
{
cm.UnmapMember(s => s.CustomFields);
cm.UnmapMember(s => s.AuthorInfo);
cm.UnmapMember(s => s.ReversalEntries);
});
services.AddSingleton <IMongoClient>(sp => new MongoClient(connectionString));
services.AddMongoRepository <SendReceiveJob>("send_receive");
services.AddMongoRepository <User>("users", cm =>
{
cm.MapMember(u => u.SiteRole).SetSerializer(
new DictionaryInterfaceImplementerSerializer <Dictionary <string, string> >(
DictionaryRepresentation.Document, new SiteDomainSerializer(), new StringSerializer()));
cm.MapMember(u => u.Projects)
.SetSerializer(new EnumerableInterfaceImplementerSerializer <List <string>, string>(
new StringSerializer(BsonType.ObjectId)));
});
services.AddMongoRepository <Project>("projects");
services.AddMongoRepository <LexProject>("projects", cm => cm.SetDiscriminator("lexicon"));
services.AddMongoRepository <TranslateProject>("projects", cm => cm.SetDiscriminator("translate"));
services.AddMongoProjectRepositoryFactory <TranslateDocumentSet>("translate");
services.AddMongoProjectRepositoryFactory <LexEntry>("lexicon", cm =>
{
cm.UnmapMember(e => e.Environments);
cm.UnmapMember(e => e.MorphologyType);
});
return(services);
}
/// <summary>
/// Sets our custom <see cref="IDiscriminatorConvention"/>'s.
/// </summary>
/// <remarks>
/// DiscriminatorConvetions need to be registered before everything else is done with MongoDB, otherwise the classes
/// will get assiged a BsonClassMapSerializer implicitly. We can also only register them once, multiple registrations
/// result in errors.
/// https://stackoverflow.com/a/30292486/5806412 .
/// </remarks>
static void RegisterCustomDiscriminators()
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(AbstractStreamProcessorState), new StreamProcessorStateDiscriminatorConvention());
BsonSerializer.RegisterDiscriminatorConvention(typeof(AbstractFilterDefinition), new FilterDefinitionDiscriminatorConvention());
}
public static void RegisterConcreteClass <TBase, TConcrete>()
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(TBase),
new SingleDiscriminatorConvention(typeof(TConcrete)));
BsonClassMap.RegisterClassMap <TConcrete>();
}
public static void Configure()
{
BsonSerializer.RegisterDiscriminatorConvention(typeof(OrderModel), new OrderModelDiscriminator());
BsonSerializer.RegisterDiscriminatorConvention(typeof(JobTask), new JobTaskDiscriminator());
}
