public BuildingInfoValuesCollectionDefinition(IMongoConnectionHandler connectionHandler) : base(connectionHandler) { if (!BsonClassMap.IsClassMapRegistered(typeof(BuildingInfoValues))) { try { BsonClassMap.RegisterClassMap <BuildingInfoValues>( cm => { cm.AutoMap(); }); } catch (ArgumentException) { // this fails with an argument exception at startup, but otherwise works fine. Probably should try to figure out why, but ignoring it is easier :( } } }
public void Initialize() { var mappings = new HashSet <Type>(); CreateMapping(typeof(Envelope), mappings); CreateMapping(typeof(Subscriber), mappings); foreach (var type in mappings) { if (BsonClassMap.IsClassMapRegistered(type)) { continue; } var map = new DocumentClassMap(type); map.AutoMap(); map.SetIgnoreExtraElements(true); BsonClassMap.RegisterClassMap(map); } }
public void ShouldInvokeConfigureForAllRegisteredProfiles() { //Arrange var containerExtension = A.Fake <IBootstrapperContainerExtension>(); var profiles = new List <BsonClassMap> { new TestMongoClassMap() }; A.CallTo(() => containerExtension.ResolveAll <BsonClassMap>()).Returns(profiles); Bootstrapper.With.Extension(containerExtension); var mapperExtension = new MongoExtension(registrationHelper); //Act mapperExtension.Run(); //Assert A.CallTo(() => containerExtension.ResolveAll <BsonClassMap>()).MustHaveHappened(); Assert.IsTrue(BsonClassMap.IsClassMapRegistered(typeof(TestMongo))); }
public static void RegisterClass <T>() { if (BsonClassMap.IsClassMapRegistered(typeof(T))) { return; } BsonClassMap.RegisterClassMap <T>(x => { x.AutoMap(); x.SetDiscriminatorIsRequired(true); var typeName = typeof(T).Name; if (typeName.EndsWith("Document")) { x.SetDiscriminator(typeName.Substring(0, typeName.Length - "Document".Length)); } }); }
internal static void ConfigureClassMaps() { if (BsonClassMap.IsClassMapRegistered(typeof(TimeoutEntity))) { return; } BsonClassMap.RegisterClassMap <TimeoutEntity>( cm => { cm.AutoMap(); cm.MapMember(mm => mm.Time) .SetSerializer(new DateTimeSerializer(DateTimeKind.Utc, BsonType.Document)); cm.MapMember(mm => mm.Headers) .SetSerializer( new DictionaryInterfaceImplementerSerializer <Dictionary <string, string> >( DictionaryRepresentation.ArrayOfDocuments)); }); }
protected override void ConfigureClassMap(BsonClassMap <Organization> cm) { base.ConfigureClassMap(cm); cm.GetMemberMap(c => c.Name).SetElementName(FieldNames.Name); cm.GetMemberMap(c => c.StripeCustomerId).SetElementName(FieldNames.StripeCustomerId).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.PlanId).SetElementName(FieldNames.PlanId).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.CardLast4).SetElementName(FieldNames.CardLast4).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.SubscribeDate).SetElementName(FieldNames.SubscribeDate).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.BillingChangeDate).SetElementName(FieldNames.BillingChangeDate).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.BillingChangedByUserId).SetElementName(FieldNames.BillingChangedByUserId).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.BillingStatus).SetElementName(FieldNames.BillingStatus); cm.GetMemberMap(c => c.BillingPrice).SetElementName(FieldNames.BillingPrice); cm.GetMemberMap(c => c.RetentionDays).SetElementName(FieldNames.RetentionDays); cm.GetMemberMap(c => c.HasPremiumFeatures).SetElementName(FieldNames.HasPremiumFeatures); cm.GetMemberMap(c => c.MaxUsers).SetElementName(FieldNames.MaxUsers); cm.GetMemberMap(c => c.MaxProjects).SetElementName(FieldNames.MaxProjects); cm.GetMemberMap(c => c.MaxEventsPerMonth).SetElementName(FieldNames.MaxEventsPerMonth); cm.GetMemberMap(c => c.TotalEventCount).SetElementName(FieldNames.TotalEventCount); cm.GetMemberMap(c => c.LastEventDate).SetElementName(FieldNames.LastEventDate).SetIgnoreIfDefault(true); cm.GetMemberMap(c => c.IsSuspended).SetElementName(FieldNames.IsSuspended); cm.GetMemberMap(c => c.SuspensionCode).SetElementName(FieldNames.SuspensionCode).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.SuspensionNotes).SetElementName(FieldNames.SuspensionNotes).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.SuspensionDate).SetElementName(FieldNames.SuspensionDate).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.SuspendedByUserId).SetElementName(FieldNames.SuspendedByUserId).SetIgnoreIfNull(true); cm.GetMemberMap(c => c.Invites).SetElementName(FieldNames.Invites).SetIgnoreIfNull(true).SetShouldSerializeMethod(obj => ((Organization)obj).Invites.Any()); cm.GetMemberMap(c => c.Usage).SetElementName(FieldNames.Usage).SetIgnoreIfNull(true).SetShouldSerializeMethod(obj => ((Organization)obj).Usage.Any()); cm.GetMemberMap(c => c.OverageHours).SetElementName(FieldNames.OverageHours).SetIgnoreIfNull(true).SetShouldSerializeMethod(obj => ((Organization)obj).OverageHours.Any()); if (!BsonClassMap.IsClassMapRegistered(typeof(UsageInfo))) { BsonClassMap.RegisterClassMap <UsageInfo>(cmm => { cmm.AutoMap(); cmm.SetIgnoreExtraElements(true); cmm.GetMemberMap(c => c.Date).SetIgnoreIfDefault(true); cmm.GetMemberMap(c => c.Total).SetIgnoreIfDefault(true); cmm.GetMemberMap(c => c.Blocked).SetIgnoreIfDefault(true); cmm.GetMemberMap(c => c.Limit).SetIgnoreIfDefault(true); }); } }
private void MapClasses() { var conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, t => true); if (!BsonClassMap.IsClassMapRegistered(typeof(User))) { BsonClassMap.RegisterClassMap <User>(i => { i.AutoMap(); i.SetIgnoreExtraElements(true); } ); } }
public static IEntityDefinition RegisterType(Type entityType) { if (IsRegistered(entityType)) { throw new ArgumentException("Type is already registered", nameof(entityType)); } var definition = new EntityDefinition { EntityType = entityType }; MappingLock.EnterUpgradeableReadLock(); try { if (!BsonClassMap.IsClassMapRegistered(entityType)) { MappingLock.EnterWriteLock(); try { var classMap = new BsonClassMap(entityType); BsonClassMap.RegisterClassMap(classMap); foreach (var processor in MappingProcessors) { processor.ApplyMapping(definition, classMap); } } finally { MappingLock.ExitWriteLock(); } } } finally { MappingLock.ExitUpgradeableReadLock(); } return(SetEntityDefinition(definition)); }
private void Map() { if (!BsonClassMap.IsClassMapRegistered(typeof(ArticleEntity))) { BsonClassMap.RegisterClassMap <ArticleEntity>(cm => { cm.AutoMap(); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(TranslationEntity))) { BsonClassMap.RegisterClassMap <TranslationEntity>(cm => { cm.AutoMap(); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(PublicationEntity))) { BsonClassMap.RegisterClassMap <PublicationEntity>(cm => { cm.AutoMap(); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(UserEntity))) { BsonClassMap.RegisterClassMap <UserEntity>(cm => { cm.AutoMap(); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(AuthRenewEntity))) { BsonClassMap.RegisterClassMap <AuthRenewEntity>(cm => { cm.AutoMap(); }); } }
public Mongo2GoTest(MongoDBFixture mongoDBFixture) { this.mongoDBFixture = mongoDBFixture; if (!BsonClassMap.IsClassMapRegistered(typeof(TestDocument))) { try { BsonClassMap.RegisterClassMap <TestDocument>( map => { map.AutoMap(); map.MapIdMember(c => c.TestDocumentId) .SetIdGenerator(StringObjectIdGenerator.Instance); }); } catch { } } }
public static void CustomerMap() { if (!BsonClassMap.IsClassMapRegistered(typeof(Customer))) { BsonClassMap.RegisterClassMap <Customer>(map => { map.MapProperty(x => x.CustomerId); map.MapProperty(x => x.CompanyName); map.MapProperty(x => x.ContactName); map.MapProperty(x => x.ContactTitle); map.MapProperty(x => x.Address); map.MapProperty(x => x.City); map.MapProperty(x => x.Region); map.MapProperty(x => x.PostalCode); map.MapProperty(x => x.Country); map.MapProperty(x => x.Phone); map.MapProperty(x => x.Fax); }); } }
private void MapClasses() { var conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, t => true); if (!BsonClassMap.IsClassMapRegistered(typeof(Produtos))) { BsonClassMap.RegisterClassMap <Produtos>(i => { i.AutoMap(); // Mapeia todas as propriedades automáticamente poderia fazer uma a uma // i.MapProperty(f => f.DataNascimento); // i.MapProperty(f => f.Localizacao); // i.MapProperty(f => f.Sexo); i.SetIgnoreExtraElements(true); }); } }
protected MongoDataService() { lock (this) { if (!BsonClassMap.IsClassMapRegistered(typeof(DataObject))) { BsonClassMap.RegisterClassMap <DataObject>(t => t.MapIdMember(m => m.Id)); } if (!BsonClassMap.IsClassMapRegistered(typeof(T))) { BsonClassMap.RegisterClassMap <T>(t => { t.AutoMap(); t.SetIgnoreExtraElements(true); }); } } }
public ProductsRepositoryMongoDB() { _runner = MongoDbRunner.Start(); _client = new MongoClient(_runner.ConnectionString); _database = _client.GetDatabase(DbName); if (!BsonClassMap.IsClassMapRegistered(typeof(Product))) { BsonSerializer.UseZeroIdChecker = true; BsonClassMap.RegisterClassMap <Product>(cm => { cm.AutoMap(); cm.SetIdMember(cm.GetMemberMap(p => p.CatalogNumber)); cm.GetMemberMap(p => p.Category).SetIgnoreIfNull(true); cm.GetMemberMap(p => p.Vendor).SetIgnoreIfNull(true); }); } _collection = _database.GetCollection <Product>(CollectionName); }
public UserRepository(IMongoDatabase mongoDatabase, IRoleRepository roleRepository) : base(mongoDatabase) { _roleRepository = roleRepository ?? throw new ArgumentNullException(nameof(IRoleRepository)); if (!BsonClassMap.IsClassMapRegistered(typeof(Claim))) { BsonClassMap.RegisterClassMap <Claim>(cm => { cm.SetIgnoreExtraElements(true); cm.MapMember(c => c.Issuer); cm.MapMember(c => c.OriginalIssuer); cm.MapMember(c => c.Properties); cm.MapMember(c => c.Subject); cm.MapMember(c => c.Type); cm.MapMember(c => c.Value); cm.MapMember(c => c.ValueType); cm.MapCreator(c => new Claim(c.Type, c.Value, c.ValueType, c.Issuer, c.OriginalIssuer, c.Subject)); }); } }
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, object value) { BsonDocument doc; if (BsonClassMap.IsClassMapRegistered(value.GetType())) { doc = value.ToBsonDocument(); doc.Remove("_t"); doc.InsertAt(0, new BsonElement("_t", value.GetType().AssemblyQualifiedName)); AddTypeInformation(doc.Elements, value, string.Empty); } else { var str = JsonConvert.SerializeObject(value, SerializerSettings); doc = BsonDocument.Parse(str); ConvertMetaFormat(doc); } BsonSerializer.Serialize(context.Writer, doc); }
public MongoTriggerLogger(string connectionString, string tablePrefix) { if (!BsonClassMap.IsClassMapRegistered(typeof(TriggerLogEntry))) { BsonClassMap.RegisterClassMap <TriggerLogEntry>(cm => { cm.AutoMap(); cm.MapField(x => x.Timestamp); cm.MapField(x => x.Name); cm.MapField(x => x.Kind); cm.MapField(x => x.Group); }); } var urlBuilder = new MongoUrlBuilder(connectionString); var client = new MongoClient(urlBuilder.ToMongoUrl()); this.tablePrefix = tablePrefix; this.database = client.GetServer().GetDatabase(urlBuilder.DatabaseName); }
public static void RegisterTypes(IEnumerable <Type> types, bool useAlias = true) { if (useAlias) { foreach (var t in types) { if (!BsonClassMap.IsClassMapRegistered(t)) { BsonClassMap.RegisterClassMap(new AliasClassMap(t)); } } } else { foreach (var t in types) { BsonClassMap.LookupClassMap(t); } } }
private void MapearClasses() { var conventionPack = new ConventionPack() { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, t => true); // t => true -> aplica globalmente esta convenção // t => t.FullName.StartsWith("Your.Name.Space.")); if (!BsonClassMap.IsClassMapRegistered(typeof(Infectado))) { BsonClassMap.RegisterClassMap <Infectado>(classMap => { classMap.AutoMap(); classMap.SetIgnoreExtraElements(true); }); } }
internal static void MapStatsClasses() { if (!BsonClassMap.IsClassMapRegistered(typeof(EventStatsWithStackIds))) { BsonClassMap.RegisterClassMap <EventStatsWithStackIds>(cm2 => { cm2.AutoMap(); cm2.GetMemberMap(c => c.StackIds).SetElementName("ids"); cm2.GetMemberMap(c => c.NewStackIds).SetElementName("newids").SetSerializationOptions(new ArraySerializationOptions(new RepresentationSerializationOptions(BsonType.ObjectId))); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(EventStats))) { BsonClassMap.RegisterClassMap <EventStats>(cm2 => { cm2.AutoMap(); cm2.GetMemberMap(c => c.Total).SetElementName("tot"); cm2.GetMemberMap(c => c.NewTotal).SetElementName("new"); }); } }
public static IUnitOfWorkFactory BuildMongoDb(string url, bool reload = true) { var mongoUrl = new MongoUrl(url); var db = new MongoClient(mongoUrl).GetServer(); if (reload) { if (db.DatabaseExists(mongoUrl.DatabaseName)) { db.DropDatabase(mongoUrl.DatabaseName); } } if (!BsonClassMap.IsClassMapRegistered(typeof(IncEntityBase))) { BsonClassMap.RegisterClassMap <IncEntityBase>(map => map.UnmapProperty(r => r.Id)); } return(new MongoDbUnitOfWorkFactory(new MongoDbSessionFactory(url))); }
private void MapClasses() { //Entity: // Duas formas: uma com data annotation e outra com automaps var conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, t => true); if (!BsonClassMap.IsClassMapRegistered(typeof(Infectado))) { BsonClassMap.RegisterClassMap <Infectado>(i => { i.AutoMap(); i.SetIgnoreExtraElements(true); }); } }
public override void Startup() { if (!BsonClassMap.IsClassMapRegistered(typeof(Error))) { BsonClassMap.RegisterClassMap <Error>(cmm => { cmm.AutoMap(); cmm.SetIgnoreExtraElements(true); cmm.GetMemberMap(c => c.Modules).SetElementName(FieldNames.Modules).SetIgnoreIfDefault(true); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(InnerError))) { BsonClassMap.RegisterClassMap <InnerError>(cmm => { cmm.AutoMap(); cmm.SetIgnoreExtraElements(true); cmm.GetMemberMap(c => c.Message).SetElementName(FieldNames.Message).SetIgnoreIfNull(true); cmm.GetMemberMap(c => c.Type).SetElementName(FieldNames.Type); cmm.GetMemberMap(c => c.Code).SetElementName(FieldNames.Code); cmm.GetMemberMap(c => c.Data).SetElementName(FieldNames.Data).SetShouldSerializeMethod(obj => ((InnerError)obj).Data.Any()); cmm.GetMemberMap(c => c.Inner).SetElementName(FieldNames.Inner); cmm.GetMemberMap(c => c.StackTrace).SetElementName(FieldNames.StackTrace).SetShouldSerializeMethod(obj => ((InnerError)obj).StackTrace.Any()); cmm.GetMemberMap(c => c.TargetMethod).SetElementName(FieldNames.TargetMethod).SetIgnoreIfNull(true); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(Module))) { BsonClassMap.RegisterClassMap <Module>(cmm => { cmm.AutoMap(); cmm.SetIgnoreExtraElements(true); cmm.GetMemberMap(c => c.ModuleId).SetElementName(FieldNames.ModuleId).SetIgnoreIfDefault(true); cmm.GetMemberMap(c => c.Name).SetElementName(FieldNames.Name); cmm.GetMemberMap(c => c.Version).SetElementName(FieldNames.Version).SetIgnoreIfNull(true); cmm.GetMemberMap(c => c.IsEntry).SetElementName(FieldNames.IsEntry).SetIgnoreIfDefault(true); cmm.GetMemberMap(c => c.CreatedDate).SetElementName(FieldNames.CreatedDate); cmm.GetMemberMap(c => c.ModifiedDate).SetElementName(FieldNames.ModifiedDate); cmm.GetMemberMap(c => c.Data).SetElementName(FieldNames.Data).SetShouldSerializeMethod(obj => ((Module)obj).Data.Any()); }); } }
void RegisterClassMaps() { lock (ClassMapRegistrationLock) { if (BsonClassMap.IsClassMapRegistered(typeof(IdempotencyData))) { _log.Debug("BSON class map for {type} already registered - not doing anything", typeof(IdempotencyData)); return; } _log.Debug("Registering BSON class maps for {type} and accompanying types", typeof(IdempotencyData)); BsonClassMap.RegisterClassMap <IdempotencyData>(map => { map.MapCreator(obj => new IdempotencyData(obj.OutgoingMessages, obj.HandledMessageIds)); map.MapMember(obj => obj.HandledMessageIds); map.MapMember(obj => obj.OutgoingMessages); }); BsonClassMap.RegisterClassMap <OutgoingMessage>(map => { map.MapCreator(obj => new OutgoingMessage(obj.DestinationAddresses, obj.TransportMessage)); map.MapMember(obj => obj.DestinationAddresses); map.MapMember(obj => obj.TransportMessage); }); BsonClassMap.RegisterClassMap <OutgoingMessages>(map => { map.MapCreator(obj => new OutgoingMessages(obj.MessageId, obj.MessagesToSend)); map.MapMember(obj => obj.MessageId); map.MapMember(obj => obj.MessagesToSend); }); BsonClassMap.RegisterClassMap <TransportMessage>(map => { map.MapCreator(obj => new TransportMessage(obj.Headers, obj.Body)); map.MapMember(obj => obj.Headers); map.MapMember(obj => obj.Body); }); } }
public static void Initialize() { var conventionPack = new ConventionPack { new CamelCaseElementNameConvention(), new NamedIdMemberConvention("Id"), new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("My Convention", conventionPack, type => type.FullName.StartsWith("DocumentSchemaMigration.Models")); if (!BsonClassMap.IsClassMapRegistered(typeof(Models.v2.Musician))) { BsonClassMap.RegisterClassMap <Models.v2.Musician>(cm => { cm.AutoMap(); cm.MapMember(m => m.Bands).SetDefaultValue(Enumerable.Empty <string>); cm.MapMember(m => m.Birthdate).SetDefaultValue(DateTime.MinValue); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(Models.v3.Musician))) { BsonClassMap.RegisterClassMap <Models.v3.Musician>(cm => { cm.AutoMap(); cm.MapMember(m => m.Bands).SetDefaultValue(Enumerable.Empty <string>); }); } if (!BsonClassMap.IsClassMapRegistered(typeof(Models.v4.Musician))) { BsonClassMap.RegisterClassMap <Models.v4.Musician>(cm => { cm.AutoMap(); cm.MapMember(m => m.Instruments).SetDefaultValue(Enumerable.Empty <Instrument>()); cm.MapExtraElementsMember(musician => musician.ExtraElements); }); } }
static MongoPatientTaskRepository() { #region Register ClassMap try { if (BsonClassMap.IsClassMapRegistered(typeof(GoalBase)) == false) { BsonClassMap.RegisterClassMap <GoalBase>(); } } catch { } try { if (BsonClassMap.IsClassMapRegistered(typeof(MEPatientTask)) == false) { BsonClassMap.RegisterClassMap <MEPatientTask>(); } } catch { } #endregion }
protected EntityCollectionDefinition(IMongoConnectionHandler connectionHandler) { if (connectionHandler == null) { throw new ArgumentNullException("connectionHandler"); } Collection = connectionHandler.Database.GetCollection <T>(typeof(T).Name.ToLower() + "s"); // setup serialization if (!BsonClassMap.IsClassMapRegistered(typeof(Entity))) { BsonClassMap.RegisterClassMap <Entity>( cm => { cm.AutoMap(); cm.SetIdMember(cm.GetMemberMap(c => c.Id)); cm.IdMemberMap.SetIdGenerator(StringObjectIdGenerator.Instance); }); } }
static MongoProgramRepository() { #region Register ClassMap try { if (BsonClassMap.IsClassMapRegistered(typeof(ProgramBase)) == false) { BsonClassMap.RegisterClassMap <ProgramBase>(); } } catch { } try { if (BsonClassMap.IsClassMapRegistered(typeof(MEProgram)) == false) { BsonClassMap.RegisterClassMap <MEProgram>(); } } catch { } #endregion }
private void MapClasses() { // Define que o mapping utilizara o padrão CamelCase. var conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, t => true); // Se não tivermos nenhuma classe mapeada, para esse tipo, iremos mapear. if (!BsonClassMap.IsClassMapRegistered(typeof(Infected))) { BsonClassMap.RegisterClassMap <Infected>(i => { // Aqui podemos utilizar o MapField para definir configurações especificas // o AutoMap efetua o mapeamento por convenção automaticamente. i.AutoMap(); i.SetIgnoreExtraElements(true); }); } }
static MongoDbAuditStore() { if (BsonClassMap.IsClassMapRegistered(typeof(AuditDocument))) { return; } // easiest way to metadata since keys wont become element names, therefore subject to validation // will allow keys like $correlationId to be kept var headersSerializer = new DictionaryInterfaceImplementerSerializer <AuditHeaders, string, string>( DictionaryRepresentation.ArrayOfDocuments ); BsonClassMap.RegisterClassMap <AuditDocument>(x => { x.AutoMap(); x.MapIdMember(doc => doc.AuditId); x.MapMember(doc => doc.Headers).SetSerializer(headersSerializer); x.MapMember(doc => doc.Custom).SetSerializer(headersSerializer); }); }