public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap)
        {
            var entityType = definition.EntityType;

            //Ignore extra elements when the "IgnoreExtraElementsAttribute" is on the Entity
            var ignoreExtraElements = entityType.GetCustomAttribute <IgnoreExtraElementsAttribute>();

            if (ignoreExtraElements != null)
            {
                classMap.SetIgnoreExtraElements(true);
                classMap.SetIgnoreExtraElementsIsInherited(ignoreExtraElements.IgnoreInherited);
            }
            else
            {
                classMap.SetIgnoreExtraElements(false);

                //If any of the Entity's properties have the "ExtraElementsAttribute", assign that against the BsonClassMap

                foreach (var property in definition.Properties)
                {
                    var extraElementsAttribute = property.PropertyInfo.GetCustomAttribute <ExtraElementsAttribute>();
                    if (extraElementsAttribute != null && typeof(IDictionary <string, object>).IsAssignableFrom(property.PropertyType))
                    {
                        foreach (var memberMap in classMap.DeclaredMemberMaps)
                        {
                            if (memberMap.ElementName == property.ElementName)
                            {
                                classMap.SetExtraElementsMember(memberMap);
                                return;
                            }
                        }
                    }
                }
            }
        }
예제 #2
0
        public static void Register(BsonClassMap <User> cm)
        {
            cm.AutoMap();
            //cm.MapIdField(a )
            //cm.MapIdMember(c => c.Username);

            //  cm.MapIdProperty(c => c.Username);
            //  cm.SetIdMember(cm.GetMemberMap(c => c.Username));
            cm.SetIgnoreExtraElements(true);
            cm.SetIgnoreExtraElements(true);
        }
예제 #3
0
        /*******************************************/
        /**** 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());
                }
            }
        }
예제 #4
0
 public override void Map(BsonClassMap <ApiResource> cm)
 {
     cm.AutoMap();
     cm.MapIdField(x => x.Id);
     //cm.GetMemberMap(x=>x.Description)
     cm.SetIgnoreExtraElements(true);
 }
        internal static void InitializeSagaDataTypes(IMongoClient client, string databaseName, Func <Type, string> collectionNamingConvention, SagaMetadataCollection sagaMetadataCollection)
        {
            var databaseSettings = new MongoDatabaseSettings
            {
                ReadConcern    = ReadConcern.Majority,
                ReadPreference = ReadPreference.Primary,
                WriteConcern   = WriteConcern.WMajority
            };
            var database = client.GetDatabase(databaseName, databaseSettings);

            foreach (var sagaMetadata in sagaMetadataCollection)
            {
                if (!BsonClassMap.IsClassMapRegistered(sagaMetadata.SagaEntityType))
                {
                    var classMap = new BsonClassMap(sagaMetadata.SagaEntityType);
                    classMap.AutoMap();
                    classMap.SetIgnoreExtraElements(true);

                    BsonClassMap.RegisterClassMap(classMap);
                }

                var collectionName = collectionNamingConvention(sagaMetadata.SagaEntityType);

                if (sagaMetadata.TryGetCorrelationProperty(out var property) && property.Name != "Id")
                {
                    var propertyElementName = sagaMetadata.SagaEntityType.GetElementName(property.Name);

                    var indexModel = new CreateIndexModel <BsonDocument>(new BsonDocumentIndexKeysDefinition <BsonDocument>(new BsonDocument(propertyElementName, 1)), new CreateIndexOptions
                    {
                        Unique = true
                    });
                    database.GetCollection <BsonDocument>(collectionName).Indexes.CreateOne(indexModel);
                }
예제 #6
0
 public static void Register(BsonClassMap <GlobalValue> sm)
 {
     sm.AutoMap();
     // sm.MapIdMember(c => c.Id);
     sm.MapMember(m => m.Name).SetIsRequired(true);
     sm.SetIgnoreExtraElements(true);
 }
예제 #7
0
        //Register type
        private void RegisterType(Type type)
        {
            if (!BsonClassMap.IsClassMapRegistered(type))
            {
                string typeName = type.Name;
                if (typeName.Contains("Extension") || typeName.Contains("Util"))
                {
                    return;
                }

                var bsonClassMap = new BsonClassMap(type);
                bsonClassMap.AutoMap();
                bsonClassMap.SetIgnoreExtraElements(true);

                //Set date time with local
                var names = TypeUtil.GetNamesWithDateTime(type);

                if (names.Count > 0)
                {
                    var dateTimeSerializer = new DateTimeSerializer(DateTimeKind.Local);
                    foreach (var name in names)
                    {
                        if (bsonClassMap.GetMemberMap(name) != null)
                        {
                            bsonClassMap.GetMemberMap(name).SetSerializer(dateTimeSerializer);
                        }
                    }
                }

                BsonClassMap.RegisterClassMap(bsonClassMap);
                _logger.LogInformation(type.ToString());
            }
        }
예제 #8
0
 public static void Register(BsonClassMap <Update> cm)
 {
     cm.AutoMap();
     //   cm.GetMemberMap(c => c.Value).SetSerializer(new ObjectSerializer());
     cm.SetIsRootClass(true);
     cm.SetIgnoreExtraElements(true);
 }
예제 #9
0
 public static void Register(BsonClassMap <BaseCommand> cm)
 {
     cm.AutoMap();
     AppDomain.CurrentDomain.GetAssemblies().SelectMany(assem => assem.GetTypes()).Where(type => type.IsSubclassOf(typeof(BaseCommand))).ToList()
     .ForEach(type => cm.AddKnownType(type));
     cm.SetIgnoreExtraElements(true);
 }
예제 #10
0
 public static void Register(BsonClassMap <JournalEntry> journal)
 {
     journal.AutoMap();
     // journal.MapMember(c => c.Updates).SetSerializer(new EnumerableInterfaceImplementerSerializer<List<Update>>());
     journal.SetIgnoreExtraElements(true);
     //cm.SetIdMember(cm.GetMemberMap(c => c.Id)).SetIdGenerator(CombGuidGenerator.Instance);
 }
        public void ApplyMapping(Type entityType, BsonClassMap classMap)
        {
            //Ignore extra elements when the "IgnoreExtraElementsAttribute" is on the Entity
            var ignoreExtraElements = entityType.GetCustomAttribute <IgnoreExtraElementsAttribute>();

            if (ignoreExtraElements != null)
            {
                classMap.SetIgnoreExtraElements(true);
                classMap.SetIgnoreExtraElementsIsInherited(ignoreExtraElements.IgnoreInherited);
            }
            else
            {
                //If any of the Entity's properties have the "ExtraElementsAttribute", assign that against the BsonClassMap
                var extraElementsProperty = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
                                            .Select(p => new
                {
                    PropertyInfo           = p,
                    ExtraElementsAttribute = p.GetCustomAttribute <ExtraElementsAttribute>()
                }).Where(p => p.ExtraElementsAttribute != null).FirstOrDefault();

                if (extraElementsProperty != null && typeof(IDictionary <string, object>).IsAssignableFrom(extraElementsProperty.PropertyInfo.PropertyType))
                {
                    classMap.SetExtraElementsMember(new BsonMemberMap(classMap, extraElementsProperty.PropertyInfo));
                }
            }
        }
예제 #12
0
        public static bool RegisterTrackablePocoMap(Type trackablePocoType)
        {
            if (BsonClassMap.IsClassMapRegistered(trackablePocoType))
            {
                return(false);
            }

            var classMap = new BsonClassMap(trackablePocoType);
            var pocoType = TrackableResolver.GetPocoType(trackablePocoType);

            // start with auto map
            classMap.AutoMap();

            // ignore extra elements for smooth schema change
            classMap.SetIgnoreExtraElements(true);

            // unmap all members which T doesn't have
            var propertyNames   = new HashSet <string>(pocoType.GetProperties().Select(p => p.Name));
            var deletingMembers = classMap.DeclaredMemberMaps.Where(m =>
            {
                var propertyInfo = m.MemberInfo as PropertyInfo;
                return(propertyInfo == null ||
                       propertyNames.Contains(propertyInfo.Name) == false);
            }).ToList();

            foreach (var m in deletingMembers)
            {
                classMap.UnmapMember(m.MemberInfo);
            }

            // set default ignore for saving spaces
            foreach (var memberMap in classMap.DeclaredMemberMaps)
            {
                var mt           = memberMap.MemberType;
                var defaultValue = mt.IsValueType ? Activator.CreateInstance(mt) : null;
                memberMap.SetDefaultValue(defaultValue);
                memberMap.SetIgnoreIfDefault(true);
            }

            // tell customized id to mongo-db
            var identityColumn = pocoType.GetProperties().FirstOrDefault(
                p => TrackablePropertyAttribute.GetParameter(p, "mongodb.identity") != null);

            if (identityColumn != null)
            {
                classMap.MapIdProperty(identityColumn.Name);
            }

            try
            {
                BsonClassMap.RegisterClassMap(classMap);
            }
            catch (ArgumentException)
            {
                // if duplicate key exists
                return(false);
            }

            return(true);
        }
예제 #13
0
 public static void Register(BsonClassMap <Journal> journal)
 {
     journal.AutoMap();
     journal.MapMember(c => c.JournalEntries).SetSerializer(new DictionaryInterfaceImplementerSerializer <SortedDictionary <int, JournalEntry> >(DictionaryRepresentation.ArrayOfDocuments));
     journal.SetIgnoreExtraElements(true);
     //cm.SetIdMember(cm.GetMemberMap(c => c.Id)).SetIdGenerator(CombGuidGenerator.Instance);
 }
예제 #14
0
 public override void Map(BsonClassMap <DiarySettingsPeriodDTO> cm)
 {
     cm.AutoMap();
     cm.MapCreator(d => new DiarySettingsPeriodDTO(d.School, d.IsGuarianAllowedToSendMessage, d.MealSettingPeriods, d.NapSettingPeriods, d.MyDayPeriods, d.MyPopInfos));
     cm.SetIgnoreExtraElements(true);
     MapNestedObjects();
 }
예제 #15
0
 /// <summary>
 /// Configure the default mapping for the model.
 /// </summary>
 protected virtual void ConfigureDetaultTableMappings <TType>(
     BsonClassMap <TType> c,
     string idColumn)
 {
     c.AutoMap();
     c.MapIdProperty(idColumn);
     c.SetIgnoreExtraElements(true);
 }
예제 #16
0
 private static void Initializer <TClass>(BsonClassMap <TClass> cm)
     where TClass : IModel
 {
     cm.AutoMap();
     cm.MapIdMember(c => c.Id).SetIdGenerator(CombGuidGenerator.Instance);
     cm.SetDiscriminator(typeof(TClass).Name);
     cm.SetDiscriminatorIsRequired(true);
     cm.SetIgnoreExtraElements(true);
 }
예제 #17
0
 protected override void ConfigureClassMap(BsonClassMap<DayStackStats> cm) {
     cm.AutoMap();
     cm.SetIgnoreExtraElements(true);
     cm.SetIdMember(cm.GetMemberMap(c => c.Id));
     cm.GetMemberMap(c => c.ProjectId).SetElementName(CommonFieldNames.ProjectId).SetRepresentation(BsonType.ObjectId).SetIdGenerator(new StringObjectIdGenerator());
     cm.GetMemberMap(c => c.StackId).SetElementName(CommonFieldNames.StackId).SetRepresentation(BsonType.ObjectId).SetIdGenerator(new StringObjectIdGenerator());
     cm.GetMemberMap(c => c.Total).SetElementName(FieldNames.Total);
     cm.GetMemberMap(c => c.MinuteStats).SetElementName(FieldNames.MinuteStats).SetSerializationOptions(DictionarySerializationOptions.Document);
 }
예제 #18
0
        public void RegisterClassIgnoreExtraFields(Type type)
        {
            BsonClassMap cm = new BsonClassMap(type);

            cm.AutoMap();
            cm.SetIgnoreExtraElements(true);
            BsonClassMap.RegisterClassMap(cm);
            //BsonSerializer.RegisterDiscriminatorConvention(type, new ScalarDiscriminatorConvention("type"));
        }
        protected override void ConfigureClassMap(BsonClassMap <MonthProjectStats> cm)
        {
            cm.AutoMap();
            cm.SetIgnoreExtraElements(true);
            cm.SetIdMember(cm.GetMemberMap(c => c.Id));
            cm.GetMemberMap(c => c.ProjectId).SetElementName(CommonFieldNames.ProjectId).SetRepresentation(BsonType.ObjectId).SetIdGenerator(new StringObjectIdGenerator());
            cm.GetMemberMap(c => c.DayStats).SetElementName(FieldNames.DayStats).SetSerializationOptions(DictionarySerializationOptions.Document);

            EventStatsHelper.MapStatsClasses();
        }
예제 #20
0
 public static void Register(BsonClassMap <BaseState> cm)
 {
     cm.AutoMap();
     cm.SetIsRootClass(true);
     cm.SetIgnoreExtraElements(true);
     cm.MapMember(s => s.Nodes).SetSerializer(new DictionaryInterfaceImplementerSerializer <ConcurrentDictionary <Guid, NodeInformation> >(DictionaryRepresentation.ArrayOfArrays));
     cm.MapMember(s => s.Indexes).SetSerializer(new DictionaryInterfaceImplementerSerializer <ConcurrentDictionary <string, Index> >(DictionaryRepresentation.ArrayOfArrays));
     cm.MapMember(s => s.ClusterTasks).SetSerializer(new DictionaryInterfaceImplementerSerializer <ConcurrentDictionary <Guid, BaseTask> >(DictionaryRepresentation.ArrayOfArrays));
     cm.MapMember(s => s.Locks).SetSerializer(new DictionaryInterfaceImplementerSerializer <ConcurrentDictionary <string, Lock> >(DictionaryRepresentation.ArrayOfArrays));
 }
        public override void Map(BsonClassMap <Campaign> config)
        {
            config.AutoMap();
            config.SetIgnoreExtraElements(true);

            config.MapField("_name").SetElementName("Name");
            config.MapField("_startsAt").SetElementName("StartsAt")
            .SetSerializer(new DateTimeSerializer(DateTimeKind.Local));
            config.MapField("_completesAt").SetElementName("CompletesAt")
            .SetSerializer(new DateTimeSerializer(DateTimeKind.Local));
        }
        public override void Map(BsonClassMap <ReceiptItem> config)
        {
            config.AutoMap();
            config.SetIgnoreExtraElements(true);

            config.MapProperty(t => t.Title).SetElementName("Title");
            config.MapProperty(t => t.Description).SetElementName("Description");
            config.MapProperty(t => t.Price).SetElementName("Price")
            .SetSerializer(new DecimalSerializer(BsonType.Decimal128));
            config.MapProperty(t => t.Quantity).SetElementName("Quantity");
        }
예제 #23
0
        public static void Register(BsonClassMap <Condition> cm)
        {
            cm.AutoMap();
            cm.SetIsRootClass(true);
            cm.SetIgnoreExtraElements(true);
            var featureType = typeof(Condition);

            featureType.Assembly.GetTypes()
            .Where(type => featureType.IsAssignableFrom(type)).ToList()
            .ForEach(type => cm.AddKnownType(type));
        }
        public override void Map(BsonClassMap <Article> cm)
        {
            cm.AutoMap();
            cm.MapIdProperty(c => c.Id);

            cm.MapProperty(c => c.Title).SetElementName("title");
            cm.MapProperty(c => c.Author).SetElementName("author");
            cm.MapProperty(c => c.Summary).SetElementName("summary");
            cm.MapProperty(c => c.Content).SetElementName("content");
            cm.SetIgnoreExtraElements(true);
        }
예제 #25
0
        public static void Register(BsonClassMap <NodeStorage <CindiClusterState> > cm)
        {
            cm.AutoMap();
            cm.SetIsRootClass(true);
            cm.MapMember(s => s.Logs).SetSerializer(new DictionaryInterfaceImplementerSerializer <SortedList <int, LogEntry> >(DictionaryRepresentation.ArrayOfArrays));

            /*AppDomain.CurrentDomain.GetAssemblies().SelectMany(assem => assem.GetTypes()).Where(type => type.IsSubclassOf(typeof(NodeStorage))).ToList()
             *  .ForEach(type => cm.AddKnownType(type));*/
            cm.UnmapMember(c => c.CommandsQueue);
            cm.SetIgnoreExtraElements(true);
        }
예제 #26
0
        public override void Map(BsonClassMap <ReceiptItem> config)
        {
            config.AutoMap();
            config.SetIgnoreExtraElements(true);

            config.MapField("_title").SetElementName("Title");
            config.MapField("_description").SetElementName("Description");
            config.MapField("_price").SetElementName("Price")
            .SetSerializer(new DecimalSerializer(BsonType.Decimal128));
            config.MapField("_quantity").SetElementName("Quantity");
        }
예제 #27
0
 /// <summary>
 /// Configure the default mapping for the model.
 /// </summary>
 protected virtual void ConfigureDetaultTableMappings <TType, TKey>(
     BsonClassMap <TType> c,
     Expression <Func <TType, TKey> > idMap)
 {
     c.AutoMap();
     if (idMap != null)
     {
         c.MapIdMember(idMap);
     }
     c.SetIgnoreExtraElements(true);
 }
        public override void Map(BsonClassMap <Receipt> config)
        {
            config.AutoMap();
            config.SetIgnoreExtraElements(true);

            config.MapProperty(t => t.Date).SetElementName("Date")
            .SetSerializer(new DateTimeSerializer(DateTimeKind.Local));
            config.MapProperty(t => t.Description).SetElementName("Description");
            config.MapProperty(t => t.CampaignId).SetElementName("CampaignId");
            config.MapProperty(t => t.ReceiptItems).SetElementName("ReceiptItems");
            config.MapProperty(t => t.Tags).SetElementName("Tags");
        }
예제 #29
0
        public override void Map(BsonClassMap <Receipt> config)
        {
            config.AutoMap();
            config.SetIgnoreExtraElements(true);

            config.MapField("_date").SetElementName("Date")
            .SetSerializer(new DateTimeSerializer(DateTimeKind.Local));
            config.MapField("_description").SetElementName("Description");
            config.MapField("_campaignId").SetElementName("CampaignId");
            config.MapField("_receiptItems").SetElementName("ReceiptItems");
            config.MapField("_tags").SetElementName("Tags");
        }
예제 #30
0
        public static void Register(BsonClassMap <Step> cm)
        {
            cm.AutoMap();
            cm.SetIgnoreExtraElements(true);
            // cm.MapIdMember(c => c.Id);
            //cm.SetIdMember(cm.GetMemberMap(c => c.Id));
            //cm.SetIgnoreExtraElements(true);

            /*cm.UnmapMember(c => c.Status);
             * cm.UnmapMember(c => c.IsComplete);
             * cm.UnmapMember(c => c.Outputs);
             * cm.UnmapMember(c => c.TestResults);
             * cm.UnmapMember(c => c.Journal);*/
        }
예제 #31
0
        public static bool RegisterClassMap(Type classType)
        {
            if (BsonClassMap.IsClassMapRegistered(classType))
                return false;

            var classMap = new BsonClassMap(classType);

            // start with auto map
            classMap.AutoMap();

            // ignore extra elements for smooth schema change
            classMap.SetIgnoreExtraElements(true);

            // unmap all members which has mongodb.ignore attribute
            var deletingMembers = classMap.DeclaredMemberMaps.Where(m =>
            {
                return TrackablePropertyAttribute.GetParameter(m.MemberInfo, "mongodb.ignore") != null;
            }).ToList();
            foreach (var m in deletingMembers)
                classMap.UnmapMember(m.MemberInfo);

            // set default ignore for saving spaces
            foreach (var memberMap in classMap.DeclaredMemberMaps)
            {
                var mt = memberMap.MemberType;
                var defaultValue = mt.IsValueType ? Activator.CreateInstance(mt) : null;
                memberMap.SetDefaultValue(defaultValue);
                memberMap.SetIgnoreIfDefault(true);
            }

            try
            {
                BsonClassMap.RegisterClassMap(classMap);
            }
            catch (ArgumentException)
            {
                // if duplicate key exists
                return false;
            }

            return true;
        }
 public void Apply(BsonClassMap classMap)
 {
     var value = _convention.IgnoreExtraElements(classMap.ClassType);
     classMap.SetIgnoreExtraElements(value);
 }
 // public methods
 /// <summary>
 /// Applies a modification to the class map.
 /// </summary>
 /// <param name="classMap">The class map.</param>
 public void Apply(BsonClassMap classMap)
 {
     classMap.SetIgnoreExtraElements(_ignoreExtraElements);
     classMap.SetIgnoreExtraElementsIsInherited(_inherited);
 }
예제 #34
0
        protected static void ConfigureErrorClassMap(BsonClassMap<OldModels.Error> cm) {
            cm.AutoMap();
            cm.SetIgnoreExtraElements(true);
            cm.SetIdMember(cm.GetMemberMap(c => c.Id).SetRepresentation(BsonType.ObjectId).SetIdGenerator(new StringObjectIdGenerator()));
            cm.GetMemberMap(p => p.OrganizationId).SetElementName(ErrorFieldNames.OrganizationId).SetRepresentation(BsonType.ObjectId);
            cm.GetMemberMap(c => c.ErrorStackId).SetElementName(ErrorFieldNames.ErrorStackId).SetRepresentation(BsonType.ObjectId);
            cm.GetMemberMap(c => c.ProjectId).SetElementName(ErrorFieldNames.ProjectId).SetRepresentation(BsonType.ObjectId);
            cm.GetMemberMap(c => c.OccurrenceDate).SetElementName(ErrorFieldNames.OccurrenceDate).SetSerializer(new UtcDateTimeOffsetSerializer());
            cm.GetMemberMap(c => c.Tags).SetElementName(ErrorFieldNames.Tags).SetIgnoreIfNull(true).SetShouldSerializeMethod(obj => ((OldModels.Error)obj).Tags.Any());
            cm.GetMemberMap(c => c.UserEmail).SetElementName(ErrorFieldNames.UserEmail).SetIgnoreIfNull(true);
            cm.GetMemberMap(c => c.UserName).SetElementName(ErrorFieldNames.UserName).SetIgnoreIfNull(true);
            cm.GetMemberMap(c => c.UserDescription).SetElementName(ErrorFieldNames.UserDescription).SetIgnoreIfNull(true);
            cm.GetMemberMap(c => c.RequestInfo).SetElementName(ErrorFieldNames.RequestInfo).SetIgnoreIfNull(true);
            cm.GetMemberMap(c => c.ExceptionlessClientInfo).SetElementName(ErrorFieldNames.ExceptionlessClientInfo).SetIgnoreIfNull(true);
            cm.GetMemberMap(c => c.Modules).SetElementName(ErrorFieldNames.Modules).SetIgnoreIfNull(true);
            cm.GetMemberMap(c => c.EnvironmentInfo).SetElementName(ErrorFieldNames.EnvironmentInfo).SetIgnoreIfNull(true);
            cm.GetMemberMap(c => c.IsFixed).SetElementName(ErrorFieldNames.IsFixed).SetIgnoreIfDefault(true);
            cm.GetMemberMap(c => c.IsHidden).SetElementName(ErrorFieldNames.IsHidden).SetIgnoreIfDefault(true);

            if (!BsonClassMap.IsClassMapRegistered(typeof(OldModels.ErrorInfo))) {
                BsonClassMap.RegisterClassMap<OldModels.ErrorInfo>(cmm => {
                    cmm.AutoMap();
                    cmm.SetIgnoreExtraElements(true);
                    cmm.GetMemberMap(c => c.Message).SetElementName(ErrorFieldNames.Message).SetIgnoreIfNull(true);
                    cmm.GetMemberMap(c => c.Type).SetElementName(ErrorFieldNames.Type);
                    cmm.GetMemberMap(c => c.Code).SetElementName(ErrorFieldNames.Code);
                    cmm.GetMemberMap(c => c.ExtendedData).SetElementName(ErrorFieldNames.ExtendedData).SetShouldSerializeMethod(obj => ((OldModels.ErrorInfo)obj).ExtendedData.Any());
                    cmm.GetMemberMap(c => c.Inner).SetElementName(ErrorFieldNames.Inner);
                    cmm.GetMemberMap(c => c.StackTrace).SetElementName(ErrorFieldNames.StackTrace).SetShouldSerializeMethod(obj => ((OldModels.ErrorInfo)obj).StackTrace.Any());
                    cmm.GetMemberMap(c => c.TargetMethod).SetElementName(ErrorFieldNames.TargetMethod).SetIgnoreIfNull(true);
                });
            }

            if (!BsonClassMap.IsClassMapRegistered(typeof(OldModels.RequestInfo))) {
                BsonClassMap.RegisterClassMap<OldModels.RequestInfo>(cmm => {
                    cmm.AutoMap();
                    cmm.SetIgnoreExtraElements(true);
                    cmm.GetMemberMap(c => c.UserAgent).SetElementName(ErrorFieldNames.UserAgent);
                    cmm.GetMemberMap(c => c.HttpMethod).SetElementName(ErrorFieldNames.HttpMethod);
                    cmm.GetMemberMap(c => c.IsSecure).SetElementName(ErrorFieldNames.IsSecure);
                    cmm.GetMemberMap(c => c.Host).SetElementName(ErrorFieldNames.Host);
                    cmm.GetMemberMap(c => c.Port).SetElementName(ErrorFieldNames.Port);
                    cmm.GetMemberMap(c => c.Path).SetElementName(ErrorFieldNames.Path);
                    cmm.GetMemberMap(c => c.Referrer).SetElementName(ErrorFieldNames.Referrer).SetIgnoreIfNull(true);
                    cmm.GetMemberMap(c => c.ClientIpAddress).SetElementName(ErrorFieldNames.ClientIpAddress);
                    cmm.GetMemberMap(c => c.Cookies).SetElementName(ErrorFieldNames.Cookies).SetShouldSerializeMethod(obj => ((RequestInfo)obj).Cookies.Any());
                    cmm.GetMemberMap(c => c.PostData).SetElementName(ErrorFieldNames.PostData).SetShouldSerializeMethod(obj => ShouldSerializePostData(obj as RequestInfo));
                    cmm.GetMemberMap(c => c.QueryString).SetElementName(ErrorFieldNames.QueryString).SetShouldSerializeMethod(obj => ((OldModels.RequestInfo)obj).QueryString.Any());
                    cmm.GetMemberMap(c => c.ExtendedData).SetElementName(ErrorFieldNames.ExtendedData).SetShouldSerializeMethod(obj => ((OldModels.RequestInfo)obj).ExtendedData.Any());
                });
            }

            if (!BsonClassMap.IsClassMapRegistered(typeof(OldModels.ExceptionlessClientInfo))) {
                BsonClassMap.RegisterClassMap<OldModels.ExceptionlessClientInfo>(cmm => {
                    cmm.AutoMap();
                    cmm.SetIgnoreExtraElements(true);
                    cmm.GetMemberMap(c => c.Version).SetElementName(ErrorFieldNames.Version);
                    cmm.GetMemberMap(c => c.InstallIdentifier).SetElementName(ErrorFieldNames.InstallIdentifier);
                    cmm.GetMemberMap(c => c.InstallDate).SetElementName(ErrorFieldNames.InstallDate);
                    cmm.GetMemberMap(c => c.StartCount).SetElementName(ErrorFieldNames.StartCount);
                    cmm.GetMemberMap(c => c.SubmitCount).SetElementName(ErrorFieldNames.SubmitCount);
                    cmm.GetMemberMap(c => c.Platform).SetElementName(ErrorFieldNames.Platform);
                    cmm.GetMemberMap(c => c.SubmissionMethod).SetElementName(ErrorFieldNames.SubmissionMethod);
                });
            }

            if (!BsonClassMap.IsClassMapRegistered(typeof(OldModels.EnvironmentInfo))) {
                BsonClassMap.RegisterClassMap<OldModels.EnvironmentInfo>(cmm => {
                    cmm.AutoMap();
                    cmm.SetIgnoreExtraElements(true);
                    cmm.GetMemberMap(c => c.ProcessorCount).SetElementName(ErrorFieldNames.ProcessorCount);
                    cmm.GetMemberMap(c => c.TotalPhysicalMemory).SetElementName(ErrorFieldNames.TotalPhysicalMemory);
                    cmm.GetMemberMap(c => c.AvailablePhysicalMemory).SetElementName(ErrorFieldNames.AvailablePhysicalMemory);
                    cmm.GetMemberMap(c => c.CommandLine).SetElementName(ErrorFieldNames.CommandLine);
                    cmm.GetMemberMap(c => c.ProcessName).SetElementName(ErrorFieldNames.ProcessName);
                    cmm.GetMemberMap(c => c.ProcessId).SetElementName(ErrorFieldNames.ProcessId);
                    cmm.GetMemberMap(c => c.ProcessMemorySize).SetElementName(ErrorFieldNames.ProcessMemorySize);
                    cmm.GetMemberMap(c => c.ThreadName).SetElementName(ErrorFieldNames.ThreadName).SetIgnoreIfNull(true);
                    cmm.GetMemberMap(c => c.ThreadId).SetElementName(ErrorFieldNames.ThreadId);
                    cmm.GetMemberMap(c => c.Architecture).SetElementName(ErrorFieldNames.Architecture);
                    cmm.GetMemberMap(c => c.OSName).SetElementName(ErrorFieldNames.OSName);
                    cmm.GetMemberMap(c => c.OSVersion).SetElementName(ErrorFieldNames.OSVersion);
                    cmm.GetMemberMap(c => c.MachineName).SetElementName(ErrorFieldNames.MachineName);
                    cmm.GetMemberMap(c => c.RuntimeVersion).SetElementName(ErrorFieldNames.RuntimeVersion);
                    cmm.GetMemberMap(c => c.IpAddress).SetElementName(ErrorFieldNames.IpAddress);
                    cmm.GetMemberMap(c => c.ExtendedData).SetElementName(ErrorFieldNames.ExtendedData).SetShouldSerializeMethod(obj => ((OldModels.EnvironmentInfo)obj).ExtendedData.Any());
                });
            }

            if (!BsonClassMap.IsClassMapRegistered(typeof(OldModels.Method))) {
                BsonClassMap.RegisterClassMap<OldModels.Method>(cmm => {
                    cmm.AutoMap();
                    cmm.SetIgnoreExtraElements(true);
                    cmm.GetMemberMap(c => c.DeclaringNamespace).SetElementName(ErrorFieldNames.DeclaringNamespace);
                    cmm.GetMemberMap(c => c.DeclaringType).SetElementName(ErrorFieldNames.DeclaringType);
                    cmm.GetMemberMap(c => c.Name).SetElementName(ErrorFieldNames.Name);
                    cmm.GetMemberMap(c => c.ModuleId).SetElementName(ErrorFieldNames.ModuleId);
                    cmm.GetMemberMap(c => c.IsSignatureTarget).SetElementName(ErrorFieldNames.IsSignatureTarget);
                    cmm.GetMemberMap(c => c.ExtendedData).SetElementName(ErrorFieldNames.ExtendedData).SetShouldSerializeMethod(obj => ((OldModels.Method)obj).ExtendedData.Any());
                    cmm.GetMemberMap(c => c.GenericArguments).SetElementName(ErrorFieldNames.GenericArguments).SetShouldSerializeMethod(obj => ((Method)obj).GenericArguments.Any());
                    cmm.GetMemberMap(c => c.Parameters).SetElementName(ErrorFieldNames.Parameters).SetShouldSerializeMethod(obj => ((OldModels.Method)obj).Parameters.Any());
                });
            }

            if (!BsonClassMap.IsClassMapRegistered(typeof(OldModels.Parameter))) {
                BsonClassMap.RegisterClassMap<OldModels.Parameter>(cmm => {
                    cmm.AutoMap();
                    cmm.SetIgnoreExtraElements(true);
                    cmm.GetMemberMap(c => c.Name).SetElementName(ErrorFieldNames.Name);
                    cmm.GetMemberMap(c => c.Type).SetElementName(ErrorFieldNames.Type);
                    cmm.GetMemberMap(c => c.TypeNamespace).SetElementName(ErrorFieldNames.TypeNamespace);
                    cmm.GetMemberMap(c => c.ExtendedData).SetElementName(ErrorFieldNames.ExtendedData).SetShouldSerializeMethod(obj => ((OldModels.Parameter)obj).ExtendedData.Any());
                    cmm.GetMemberMap(c => c.GenericArguments).SetElementName(ErrorFieldNames.GenericArguments).SetShouldSerializeMethod(obj => ((OldModels.Parameter)obj).GenericArguments.Any());
                });
            }

            if (!BsonClassMap.IsClassMapRegistered(typeof(OldModels.StackFrame))) {
                BsonClassMap.RegisterClassMap<OldModels.StackFrame>(cmm => {
                    cmm.AutoMap();
                    cmm.SetIgnoreExtraElements(true);
                    cmm.GetMemberMap(c => c.FileName).SetElementName(ErrorFieldNames.FileName).SetIgnoreIfNull(true);
                    cmm.GetMemberMap(c => c.LineNumber).SetElementName(ErrorFieldNames.LineNumber).SetIgnoreIfDefault(true);
                    cmm.GetMemberMap(c => c.Column).SetElementName(ErrorFieldNames.Column).SetIgnoreIfDefault(true);
                });
            }

            if (!BsonClassMap.IsClassMapRegistered(typeof(OldModels.Module))) {
                BsonClassMap.RegisterClassMap<OldModels.Module>(cmm => {
                    cmm.AutoMap();
                    cmm.SetIgnoreExtraElements(true);
                    cmm.GetMemberMap(c => c.ModuleId).SetElementName(ErrorFieldNames.ModuleId).SetIgnoreIfDefault(true);
                    cmm.GetMemberMap(c => c.Name).SetElementName(ErrorFieldNames.Name);
                    cmm.GetMemberMap(c => c.Version).SetElementName(ErrorFieldNames.Version).SetIgnoreIfNull(true);
                    cmm.GetMemberMap(c => c.IsEntry).SetElementName(ErrorFieldNames.IsEntry).SetIgnoreIfDefault(true);
                    cmm.GetMemberMap(c => c.CreatedDate).SetElementName(ErrorFieldNames.CreatedDate);
                    cmm.GetMemberMap(c => c.ModifiedDate).SetElementName(ErrorFieldNames.ModifiedDate);
                    cmm.GetMemberMap(c => c.ExtendedData).SetElementName(ErrorFieldNames.ExtendedData).SetShouldSerializeMethod(obj => ((OldModels.Module)obj).ExtendedData.Any());
                });
            }
        }
        private BsonClassMap BuildClassMap(Type type, ProjectionMapping mapping)
        {
            if (type == null || type == typeof(object))
            {
                return null;
            }

            var baseClassMap = BuildClassMap(type.BaseType, mapping);
            if (baseClassMap != null)
            {
                baseClassMap.Freeze();
            }
            var classMap = new BsonClassMap(type, baseClassMap);

            // Ignore extra elements, as the projection expression will likely not be complete
            classMap.SetIgnoreExtraElements(true);

            foreach (var memberMapping in mapping.Members.Where(x => x.Member.DeclaringType == type))
            {
                var serializationExpression = memberMapping.Expression as SerializationExpression;
                if (serializationExpression == null)
                {
                    var serializer = Build(memberMapping.Expression);
                    serializationExpression = new FieldExpression(
                        memberMapping.Member.Name,
                        serializer,
                        memberMapping.Expression);
                }

                var memberMap = classMap.MapMember(memberMapping.Member)
                    .SetSerializer(serializationExpression.Serializer)
                    .SetElementName(memberMapping.Member.Name);

                if (classMap.IdMemberMap == null && serializationExpression is GroupingKeyExpression)
                {
                    classMap.SetIdMember(memberMap);
                }
            }

            return classMap;
        }
예제 #36
0
 protected static void ConfigureErrorStackClassMap(BsonClassMap<Stack> cm) {
     cm.AutoMap();
     cm.SetIgnoreExtraElements(true);
     cm.SetIdMember(cm.GetMemberMap(c => c.Id).SetRepresentation(BsonType.ObjectId).SetIdGenerator(new StringObjectIdGenerator()));
     cm.GetMemberMap(p => p.OrganizationId).SetElementName(ErrorStackFieldNames.OrganizationId).SetRepresentation(BsonType.ObjectId);
     cm.GetMemberMap(c => c.ProjectId).SetRepresentation(BsonType.ObjectId).SetElementName(ErrorStackFieldNames.ProjectId);
     cm.GetMemberMap(c => c.SignatureHash).SetElementName(ErrorStackFieldNames.SignatureHash);
     cm.GetMemberMap(c => c.SignatureInfo).SetElementName(ErrorStackFieldNames.SignatureInfo);
     cm.GetMemberMap(c => c.FixedInVersion).SetElementName(ErrorStackFieldNames.FixedInVersion).SetIgnoreIfNull(true);
     cm.GetMemberMap(c => c.DateFixed).SetElementName(ErrorStackFieldNames.DateFixed).SetIgnoreIfNull(true);
     cm.GetMemberMap(c => c.Title).SetElementName(ErrorStackFieldNames.Title);
     cm.GetMemberMap(c => c.TotalOccurrences).SetElementName(ErrorStackFieldNames.TotalOccurrences);
     cm.GetMemberMap(c => c.FirstOccurrence).SetElementName(ErrorStackFieldNames.FirstOccurrence);
     cm.GetMemberMap(c => c.LastOccurrence).SetElementName(ErrorStackFieldNames.LastOccurrence);
     cm.GetMemberMap(c => c.Description).SetElementName(ErrorStackFieldNames.Description).SetIgnoreIfNull(true);
     cm.GetMemberMap(c => c.IsHidden).SetElementName(ErrorStackFieldNames.IsHidden).SetIgnoreIfDefault(true);
     cm.GetMemberMap(c => c.IsRegressed).SetElementName(ErrorStackFieldNames.IsRegressed).SetIgnoreIfDefault(true);
     cm.GetMemberMap(c => c.DisableNotifications).SetElementName(ErrorStackFieldNames.DisableNotifications).SetIgnoreIfDefault(true);
     cm.GetMemberMap(c => c.OccurrencesAreCritical).SetElementName(ErrorStackFieldNames.OccurrencesAreCritical).SetIgnoreIfDefault(true);
     cm.GetMemberMap(c => c.References).SetElementName(ErrorStackFieldNames.References).SetShouldSerializeMethod(obj => ((OldModels.ErrorStack)obj).References.Any());
     cm.GetMemberMap(c => c.Tags).SetElementName(ErrorStackFieldNames.Tags).SetShouldSerializeMethod(obj => ((OldModels.ErrorStack)obj).Tags.Any());
 }
 /// <summary>
 /// Applies a modification to the class map.
 /// </summary>
 /// <param name="classMap">The class map.</param>
 public void Apply(BsonClassMap classMap)
 {
     classMap.SetIgnoreExtraElements(_ignoreExtraElements);
 }
예제 #38
-1
        public static bool RegisterTrackablePocoMap(Type trackablePocoType)
        {
            if (BsonClassMap.IsClassMapRegistered(trackablePocoType))
                return false;

            var classMap = new BsonClassMap(trackablePocoType);
            var pocoType = TrackableResolver.GetPocoType(trackablePocoType);

            // start with auto map
            classMap.AutoMap();

            // ignore extra elements for smooth schema change
            classMap.SetIgnoreExtraElements(true);

            // unmap all members which T doesn't have
            var propertyNames = new HashSet<string>(pocoType.GetProperties().Select(p => p.Name));
            var deletingMembers = classMap.DeclaredMemberMaps.Where(m =>
            {
                var propertyInfo = m.MemberInfo as PropertyInfo;
                return propertyInfo == null ||
                       propertyNames.Contains(propertyInfo.Name) == false;
            }).ToList();
            foreach (var m in deletingMembers)
                classMap.UnmapMember(m.MemberInfo);

            // set default ignore for saving spaces
            foreach (var memberMap in classMap.DeclaredMemberMaps)
            {
                var mt = memberMap.MemberType;
                var defaultValue = mt.IsValueType ? Activator.CreateInstance(mt) : null;
                memberMap.SetDefaultValue(defaultValue);
                memberMap.SetIgnoreIfDefault(true);
            }

            // tell customized id to mongo-db
            var identityColumn = pocoType.GetProperties().FirstOrDefault(
                p => TrackablePropertyAttribute.GetParameter(p, "mongodb.identity") != null);
            if (identityColumn != null)
            {
                classMap.MapIdProperty(identityColumn.Name);
            }

            try
            {
                BsonClassMap.RegisterClassMap(classMap);
            }
            catch (ArgumentException)
            {
                // if duplicate key exists
                return false;
            }
            
            return true;
        }