Beispiel #1
0
        private void ParseSchema(string fileName, string baseUrl, XMLSchema.schema schemaDOM)
        {
            string basePath = Path.GetDirectoryName(fileName);

            if (schemaDOM.Items != null)
            {
                foreach (XMLSchema.openAttrs openAttrs in schemaDOM.Items)
                {
                    string loadedFileName = "";
                    string schemaLocation = "";

                    if (openAttrs is XMLSchema.include)
                    {
                        XMLSchema.include include = openAttrs as XMLSchema.include;
                        if (include.schemaLocation != null)
                        {
                            schemaLocation = include.schemaLocation;
                        }
                    }
                    else if (openAttrs is XMLSchema.import)
                    {
                        XMLSchema.import import = openAttrs as XMLSchema.import;
                        if (import.schemaLocation != null)
                        {
                            schemaLocation = import.schemaLocation;
                        }
                    }

                    if (!string.IsNullOrEmpty(schemaLocation))
                    {
                        schemaLocation = Uri.UnescapeDataString(schemaLocation);

                        loadedFileName = basePath + Path.DirectorySeparatorChar + schemaLocation.Replace('/', Path.DirectorySeparatorChar);

                        string url = schemaLocation.Trim();
                        if (url.IndexOf("http://") == 0 || url.IndexOf("https://") == 0)
                        {
                            string lf, bu;
                            if (LoadSchemaFromUrl(basePath, url, out lf, out bu))
                            {
                                loadedFileName = lf;
                                baseUrl        = bu; // The baseUrl change for this file
                            }
                        }
                        else if (!File.Exists(loadedFileName))
                        {
                            // The relative file does not exist, so try to download it from the web with the baseUrl
                            url = baseUrl + "/" + schemaLocation;

                            string lf, bu;
                            if (LoadSchemaFromUrl(basePath, url, out lf, out bu))
                            {
                                loadedFileName = lf;
                                baseUrl        = bu; // The baseUrl change for this file
                            }
                        }
                    }

                    if (!string.IsNullOrEmpty(loadedFileName))
                    {
                        ImportSchema(loadedFileName, baseUrl);
                    }
                }
            }

            string nameSpace = schemaDOM.targetNamespace;

            if (schemaDOM.Items1 != null)
            {
                foreach (XMLSchema.openAttrs openAttrs in schemaDOM.Items1)
                {
                    if (openAttrs is XMLSchema.element)
                    {
                        XMLSchema.element element   = openAttrs as XMLSchema.element;
                        XSDObject         xsdObject = new XSDObject(fileName, element.name, nameSpace, "element", element);
                        this.hashtableElementsByName[xsdObject.FullName] = xsdObject;

                        if (this.firstElement == null)
                        {
                            this.firstElement = xsdObject;
                        }

                        elements.Add(xsdObject);
                    }
                    else if (openAttrs is XMLSchema.group)
                    {
                        XMLSchema.group group     = openAttrs as XMLSchema.group;
                        XSDObject       xsdObject = new XSDObject(fileName, group.name, nameSpace, "group", group);
                        this.hashtableElementsByName[xsdObject.FullName] = xsdObject;

                        elements.Add(xsdObject);
                    }
                    else if (openAttrs is XMLSchema.simpleType)
                    {
                        XMLSchema.simpleType simpleType = openAttrs as XMLSchema.simpleType;
                        XSDObject            xsdObject  = new XSDObject(fileName, simpleType.name, nameSpace, "simpleType", simpleType);
                        this.hashtableElementsByName[xsdObject.FullName] = xsdObject;

                        elements.Add(xsdObject);
                    }
                    else if (openAttrs is XMLSchema.complexType)
                    {
                        XMLSchema.complexType complexType = openAttrs as XMLSchema.complexType;
                        XSDObject             xsdObject   = new XSDObject(fileName, complexType.name, nameSpace, "complexType", complexType);
                        this.hashtableElementsByName[xsdObject.FullName] = xsdObject;

                        elements.Add(xsdObject);
                    }
                    else if (openAttrs is XMLSchema.attribute)
                    {
                        XMLSchema.attribute attribute    = openAttrs as XMLSchema.attribute;
                        XSDAttribute        xsdAttribute = new XSDAttribute(fileName, attribute.name, nameSpace, "attribute", attribute.@ref != null, attribute.@default, attribute.use.ToString(), attribute);
                        this.hashtableAttributesByName[xsdAttribute.FullName] = xsdAttribute;
                    }
                    else if (openAttrs is XMLSchema.attributeGroup)
                    {
                        XMLSchema.attributeGroup attributeGroup    = openAttrs as XMLSchema.attributeGroup;
                        XSDAttributeGroup        xsdAttributeGroup = new XSDAttributeGroup(fileName, attributeGroup.name, nameSpace, "attributeGroup", attributeGroup is XMLSchema.attributeGroupRef, attributeGroup);
                        this.hashtableAttributesByName[xsdAttributeGroup.FullName] = xsdAttributeGroup;
                    }
                }
            }
        }
Beispiel #2
0
        private static XSDAttribute ParseAttribute(Schema schema, string nameSpace, List <XSDAttribute> listAttributes, XMLSchema.attribute attribute, bool isRestriction)
        {
            bool   isReference = false;
            string filename    = "";
            string name        = attribute.name;
            string type        = "";

            if (attribute.@ref != null)
            {
                object o = null;
                schema.AttributesByName.TryGetValue(QualifiedNameToFullName("attribute", attribute.@ref), out o);
                if (o is XSDAttribute)
                {
                    XSDAttribute xsdAttributeInstance = o as XSDAttribute;
                    XSDAttribute refXSDAttribute      = ParseAttribute(schema, nameSpace, listAttributes, xsdAttributeInstance.Tag, isRestriction);
                    if (refXSDAttribute != null)
                    {
                        // Override the "use" field with
                        refXSDAttribute.Use = attribute.use.ToString();
                    }
                    return(null);
                }
                else // Reference not found!
                {
                    type        = QualifiedNameToAttributeTypeName(attribute.@ref);
                    name        = [email protected];
                    nameSpace   = [email protected];
                    isReference = true;
                }
            }
            else if (attribute.type != null)
            {
                type      = QualifiedNameToAttributeTypeName(attribute.type);
                nameSpace = attribute.type.Namespace;
            }
            else if (attribute.simpleType != null)
            {
                XMLSchema.simpleType simpleType = attribute.simpleType as XMLSchema.simpleType;
                if (simpleType.Item is XMLSchema.restriction)
                {
                    XMLSchema.restriction restriction = simpleType.Item as XMLSchema.restriction;
                    type      = QualifiedNameToAttributeTypeName(restriction.@base);
                    nameSpace = [email protected];
                }
                else if (simpleType.Item is XMLSchema.list)
                {
                    XMLSchema.list list = simpleType.Item as XMLSchema.list;
                    type      = QualifiedNameToAttributeTypeName(list.itemType);
                    nameSpace = list.itemType.Namespace;
                }
                else
                {
                }
            }
            else
            {
            }
            if (string.IsNullOrEmpty(attribute.name) && string.IsNullOrEmpty(name))
            {
            }
            if (isRestriction)
            {
                if (attribute.use == XMLSchema.attributeUse.prohibited)
                {
                    foreach (XSDAttribute xsdAttribute in listAttributes)
                    {
                        if (xsdAttribute.Name == name)
                        {
                            //listAttributes.Remove(xsdAttribute);
                            xsdAttribute.Use = attribute.use.ToString();
                            break;
                        }
                    }
                }
            }
            else
            {
                XSDAttribute xsdAttribute = new XSDAttribute(filename, name, nameSpace, type, isReference, attribute.@default, attribute.use.ToString(), attribute);
                listAttributes.Insert(0, xsdAttribute);
                return(xsdAttribute);
            }
            return(null);
        }