public FieldBuilder CreateField(SchemaBuilder schemaBuilder,
                                        PropertyInfo propertyInfo)
        {
            FieldBuilder fieldBuilder;

            var genericKeyType   = propertyInfo.PropertyType.GetGenericArguments()[0];
            var genericValueType = propertyInfo.PropertyType.GetGenericArguments()[1];

            if (genericValueType.GetInterface("IRevitEntity") != null)
            {
                fieldBuilder =
                    schemaBuilder.AddMapField(propertyInfo.Name,
                                              genericKeyType, typeof(Entity));

                AttributeExtractor <SchemaAttribute> schemaAttributeExtractor =
                    new AttributeExtractor <SchemaAttribute>();
                var subSchemaAttribute =
                    schemaAttributeExtractor
                    .GetAttribute(genericValueType);
                fieldBuilder
                .SetSubSchemaGUID(subSchemaAttribute.GUID);
            }
            else
            {
                fieldBuilder =
                    schemaBuilder.AddMapField(propertyInfo.Name,
                                              genericKeyType, genericValueType);
            }

            var needSubschemaId = fieldBuilder.NeedsSubSchemaGUID();

            return(fieldBuilder);
        }
        public FieldBuilder CreateField(SchemaBuilder schemaBuilder, PropertyInfo propertyInfo)
        {
            FieldBuilder fieldBuilder;

            var iRevitEntity = propertyInfo.PropertyType.GetInterface("IRevitEntity");

            if (iRevitEntity != null)
            {
                AttributeExtractor <SchemaAttribute> schemaAttributeExtractor =
                    new AttributeExtractor <SchemaAttribute>();

                fieldBuilder = schemaBuilder
                               .AddSimpleField(propertyInfo.Name, typeof(Entity));
                var subSchemaAttribute =
                    schemaAttributeExtractor
                    .GetAttribute(propertyInfo.PropertyType);
                fieldBuilder
                .SetSubSchemaGUID(subSchemaAttribute.GUID);
            }
            else
            {
                fieldBuilder =
                    schemaBuilder.AddSimpleField(propertyInfo.Name, propertyInfo.PropertyType);
            }

            return(fieldBuilder);
        }
        public FieldBuilder CreateField(SchemaBuilder schemaBuilder,
                                        PropertyInfo propertyInfo)
        {
            FieldBuilder fieldBuilder;

            // Check whether generic type is subentity or not
            var genericType = propertyInfo.PropertyType.GetGenericArguments()[0];

            var iRevitEntity = genericType.GetInterface("IRevitEntity");

            if (iRevitEntity != null)
            {
                fieldBuilder =
                    schemaBuilder.AddArrayField(propertyInfo.Name, typeof(Entity));

                AttributeExtractor <SchemaAttribute> schemaAttributeExtractor =
                    new AttributeExtractor <SchemaAttribute>();
                var subSchemaAttribute =
                    schemaAttributeExtractor
                    .GetAttribute(genericType);
                fieldBuilder
                .SetSubSchemaGUID(subSchemaAttribute.GUID);
            }
            else
            {
                fieldBuilder =
                    schemaBuilder.AddArrayField(propertyInfo.Name, genericType);
            }
            return(fieldBuilder);
        }
        public Schema CreateSchema(Type type)
        {
            SchemaAttribute schemaAttribute =
                _schemaAttributeExtractor.GetAttribute(type);

            // Create a new Schema using SchemaAttribute Properties
            SchemaBuilder schemaBuilder = new SchemaBuilder(schemaAttribute.GUID);

            schemaBuilder.SetSchemaName(schemaAttribute.SchemaName);

            // Set up other schema properties if they exists
            if (schemaAttribute.ApplicationGUID != Guid.Empty)
            {
                schemaBuilder.SetApplicationGUID(schemaAttribute.ApplicationGUID);
            }

            if (!string.IsNullOrEmpty(schemaAttribute.Documentation))
            {
                schemaBuilder.SetDocumentation(schemaAttribute.Documentation);
            }

            if (schemaAttribute.ReadAccessLevel != default(AccessLevel))
            {
                schemaBuilder.SetReadAccessLevel(schemaAttribute.ReadAccessLevel);
            }

            if (schemaAttribute.WriteAccessLevel != default(AccessLevel))
            {
                schemaBuilder.SetReadAccessLevel(schemaAttribute.WriteAccessLevel);
            }

            if (!string.IsNullOrEmpty(schemaAttribute.VendorId))
            {
                schemaAttribute.VendorId = schemaAttribute.VendorId;
            }

            var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);

            // Iterate all of the RevitEntity Properties
            foreach (var pi in properties)
            {
                //get the field attribute of public properties
                var propertyAttributes =
                    pi.GetCustomAttributes(typeof(FieldAttribute), true);

                // if property does not have a FieldAttribute
                // skip this property
                if (propertyAttributes.Length == 0)
                {
                    continue;
                }

                FieldAttribute fieldAttribute =
                    _fieldAttributeExtractor.GetAttribute(pi);

                FieldBuilder fieldBuilder =
                    _fieldFactory.CreateField(schemaBuilder, pi);

                /*
                 * //If entity contains field of IRevitEntity
                 * //also create a schema and add subSchemaId
                 * var iRevitEntity = pi.PropertyType.GetInterface("IRevitEntity");
                 * if (iRevitEntity != null)
                 * {
                 *  fieldBuilder = schemaBuilder.AddSimpleField(pi.Name, typeof(Entity));
                 *  var subSchemaAttribute = _schemaAttributeExtractor.GetAttribute(pi.PropertyType);
                 *  fieldBuilder.SetSubSchemaGUID(subSchemaAttribute.GUID);
                 * }
                 * else
                 * {
                 *  fieldBuilder = schemaBuilder.AddSimpleField(pi.Name, pi.PropertyType);
                 * }
                 */

                if (!string.IsNullOrEmpty(fieldAttribute.Documentation))
                {
                    fieldBuilder.SetDocumentation(fieldAttribute.Documentation);
                }
                if (fieldBuilder.NeedsUnits())
                {
                    fieldBuilder.SetUnitType(fieldAttribute.UnitType);
                }
            }

            return(schemaBuilder.Finish());
        }