Example #1
0
        /// <summary>
        /// </summary>
        public override void GenerateSchemaTypeObjects(PropertyInfo property, XmlSchemaType type, int level)
        {
            var atts = GetAttributes <ConfigurationPropertyAttribute>(property);

            if (atts.Length == 0)
            {
                return;
            }

            XmlSchemaComplexType ct;

            if (Generator.ComplexMap.ContainsKey(property.PropertyType))
            {
                //already done the work
                ct = Generator.ComplexMap[property.PropertyType];
            }
            else
            {
                //  got to generate a new one
                ct = new XmlSchemaComplexType {
                    Name = atts[0].Name + "CT"
                };
                ct.AddAnnotation(property, null);
                ct.CreateSchemaSequenceParticle();

                Generator.ComplexMap.Add(property.PropertyType, ct);
                Generator.Schema.Items.Add(ct);

                //  get all properties from the configuration object
                var propertyInfos = GetProperties <ConfigurationPropertyAttribute>(property.PropertyType);

                foreach (var pi in propertyInfos)
                {
                    var parser = TypeParserFactory.GetParser(Generator, pi);
                    parser.GenerateSchemaTypeObjects(pi, ct, level + 1);
                }
            }

            var element = new XmlSchemaElement
            {
                Name           = atts[0].Name, // property.PropertyType.Name + "CT",
                MinOccurs      = atts[0].IsRequired ? 1 : 0,
                SchemaTypeName = new XmlQualifiedName(XmlHelper.PrependNamespaceAlias(ct.Name))
            };
            var pct = (XmlSchemaComplexType)type;

            ((XmlSchemaGroupBase)pct.Particle).Items.Add(element);

            //  add the documentation
            element.AddAnnotation(property, atts[0]);
        }
Example #2
0
        /// <summary>
        ///     Convert the property into a schema object
        /// </summary>
        public override void GenerateSchemaTypeObjects(PropertyInfo property, XmlSchemaType type, int level)
        {
            Debug.IndentLevel = level;
            Debug.WriteLine("{0} {1} {2}", level, property.Name, type.Name);

            var configPropertyAtts = GetAttributes <ConfigurationPropertyAttribute>(property);

            if (configPropertyAtts.Length == 0)
            {
                return;
            }

            var configCollPropertyAtts = GetAttributes <ConfigurationCollectionAttribute>(property);

            if (configCollPropertyAtts.Length == 0)
            {
                configCollPropertyAtts = GetAttributes <ConfigurationCollectionAttribute>(property.PropertyType);
            }
            if (configCollPropertyAtts.Length == 0)
            {
                return;
            }

            var configAttribute     = configPropertyAtts[0];
            var configCollAttribute = configCollPropertyAtts[0];

            XmlSchemaComplexType ct;
            var typeAlreadyInSchema = false;

            if (Generator.ComplexMap.ContainsKey(property.PropertyType))
            {
                //already done the work
                typeAlreadyInSchema = true;
                ct = Generator.ComplexMap[property.PropertyType];
            }
            else
            {
                //  got to generate a new one for the collection
                ct = new XmlSchemaComplexType
                {
                    Name = configAttribute.Name + "CT",
                };

                var seq = new XmlSchemaChoice
                {
                    MinOccurs       = 0,
                    MaxOccursString = "unbounded"
                };
                ct.Particle = seq;
                Generator.ComplexMap.Add(property.PropertyType, ct);
                Generator.Schema.Items.Add(ct);
            }

            var element = new XmlSchemaElement
            {
                Name           = configAttribute.Name,
                MinOccurs      = configAttribute.IsRequired ? 1 : 0,
                SchemaTypeName = new XmlQualifiedName(XmlHelper.PrependNamespaceAlias(ct.Name))
            };
            var pct   = (XmlSchemaComplexType)type;
            var items = ((XmlSchemaGroupBase)pct.Particle).Items;

            if (items.OfType <XmlSchemaElement>().All(x => x.Name != element.Name))
            {
                items.Add(element);
            }

            //  get all properties from the configuration object
            foreach (var pi in GetProperties <ConfigurationPropertyAttribute>(property.PropertyType))
            {
                Debug.WriteLine("ConfigurationProperty: " + pi.Name);
                var parser = TypeParserFactory.GetParser(Generator, pi);
                parser.GenerateSchemaTypeObjects(pi, ct, level + 1);
            }

            //  add the documentation
            element.AddAnnotation(property, configPropertyAtts[0]);

            //  at this point the element has been added to the schema
            //  but we now need to add support for the child elements
            if (!typeAlreadyInSchema)
            {
                AddCollectionChildren((XmlSchemaGroupBase)ct.Particle, configCollAttribute, level);
            }
        }
Example #3
0
        /// <summary>
        ///     Adds the child elements of the collection
        /// </summary>
        protected void AddCollectionChildren(XmlSchemaGroupBase parentParticle, ConfigurationCollectionAttribute configCollAttribute, int level)
        {
            Debug.IndentLevel = level;

            XmlSchemaComplexType ct;

            if (Generator.ComplexMap.ContainsKey(configCollAttribute.ItemType))
            {
                //already done the work
                ct = Generator.ComplexMap[configCollAttribute.ItemType];
            }
            else
            {
                //  got to generate a new one for the collection
                ct = new XmlSchemaComplexType {
                    Name = configCollAttribute.ItemType.Name + "CT"
                };
                ct.CreateSchemaSequenceParticle();

                Generator.ComplexMap.Add(configCollAttribute.ItemType, ct);
                Generator.Schema.Items.Add(ct);
            }

            //  add method
            var addElement = new XmlSchemaElement
            {
                Name           = configCollAttribute.AddItemName,
                MinOccurs      = 0,
                SchemaTypeName = new XmlQualifiedName(XmlHelper.PrependNamespaceAlias(ct.Name))
            };

            //  ok we now have the child element as a complextype object
            //  but we need to add three elements to the parent complex type
            //  which support the add / remove / clear methods of the collection
            //  if we must add a clear method then it has to come first

            //  the basic map types do not include the clear and remove methods
            if (configCollAttribute.CollectionType == ConfigurationElementCollectionType.AddRemoveClearMap ||
                configCollAttribute.CollectionType == ConfigurationElementCollectionType.AddRemoveClearMapAlternate)
            {
                //  clear method (which is a simple element)
                var element = new XmlSchemaElement
                {
                    Name      = configCollAttribute.ClearItemsName,
                    MinOccurs = 0,
                    MaxOccurs = 1,
                    //SchemaType = new XmlSchemaComplexType()
                };

                parentParticle.Items.Add(element);

                //  remove method
                element = new XmlSchemaElement
                {
                    MinOccurs = 0,
                    Name      = configCollAttribute.RemoveItemName
                };

                var removeCt = new XmlSchemaComplexType();
                element.SchemaType = removeCt;

                //  get the type contained in the collection and work out
                //  what the key property is
                var childElementType = configCollAttribute.ItemType;
                var found            = false;
                foreach (var pi in childElementType.GetProperties())
                {
                    if (found)
                    {
                        break;
                    }

                    Debug.WriteLine("Child property: " + pi.Name);

                    var cpAtts = GetAttributes <ConfigurationPropertyAttribute>(pi);

                    // this should return a standardtypeparser object, if it doesnt
                    //  then it means that the key of the element was an element
                    //  itself and I don't think that is possible!

                    if (cpAtts.Any(att => att.IsKey))
                    {
                        var parser = TypeParserFactory.GetParser(Generator, pi);
                        parser.GenerateSchemaTypeObjects(pi, removeCt, level + 1);
                        found = true;
                    }
                }

                parentParticle.Items.Add(element);
                SetMaxOccurs(element, parentParticle);
            }

            SetMaxOccurs(addElement, parentParticle);

            parentParticle.Items.Add(addElement);

            //  get all properties from the configuration object
            var propertyInfos = GetProperties <ConfigurationPropertyAttribute>(configCollAttribute.ItemType);

            foreach (var pi in propertyInfos)
            {
                var parser = TypeParserFactory.GetParser(Generator, pi);
                Debug.WriteLine("\tConfigurationProperty: {0} {1}", pi.Name, parser.GetType());
                parser.GenerateSchemaTypeObjects(pi, ct, level + 1);
            }
        }