private static List <XSDAttribute> GetComplexTypeAttributes(Schema schema, XMLSchema.complexType complexType, string nameSpace) { List <XSDAttribute> listAttributes = new List <XSDAttribute>(); DiagramHelpers.ParseComplexTypeAttributes(schema, nameSpace, listAttributes, complexType, false); return(listAttributes); }
/// <summary> /// Gets the annotated attributes. /// </summary> /// <param name="schema">The schema.</param> /// <param name="annotated">The annotated.</param> /// <param name="nameSpace">The name space.</param> /// <returns>The list of all the attributes.</returns> public static List <XSDAttribute> GetAnnotatedAttributes(Schema schema, XMLSchema.annotated annotated, string nameSpace) { // Attributes enumeration List <XSDAttribute> listAttributes = new List <XSDAttribute>(); if (annotated is XMLSchema.element) { XMLSchema.element element = annotated as XMLSchema.element; if (element.Item is XMLSchema.complexType) { XMLSchema.complexType complexType = element.Item as XMLSchema.complexType; listAttributes.AddRange(GetComplexTypeAttributes(schema, complexType, nameSpace)); } else if (element.type != null) { //XSDObject xsdObject = this.schema.ElementsByName[DiagramHelpers.QualifiedNameToFullName("type", element.type)] as XSDObject; //if (xsdObject != null) XSDObject xsdObject; if (schema.ElementsByName.TryGetValue(DiagramHelpers.QualifiedNameToFullName("type", element.type), out xsdObject) && xsdObject != null) { XMLSchema.annotated annotatedElement = xsdObject.Tag as XMLSchema.annotated; if (annotatedElement is XMLSchema.complexType) { XMLSchema.complexType complexType = annotatedElement as XMLSchema.complexType; listAttributes.AddRange(GetComplexTypeAttributes(schema, complexType, nameSpace)); } else { } } else { } } else { } } else if (annotated is XMLSchema.complexType) { XMLSchema.complexType complexType = annotated as XMLSchema.complexType; listAttributes.AddRange(GetComplexTypeAttributes(schema, complexType, nameSpace)); } else if (annotated is XMLSchema.simpleType) { XMLSchema.attribute attr = new XMLSchema.attribute(); XMLSchema.localSimpleType def = new XMLSchema.localSimpleType(); def.Item = (annotated as XMLSchema.simpleType).Item; attr.simpleType = def; string type = ""; if (def.Item is XMLSchema.restriction) { type = (def.Item as XMLSchema.restriction)[email protected]; } XSDAttribute XSDattr = new XSDAttribute("filename", (annotated as XMLSchema.simpleType).name, "namespace", type, false, "", "", attr); listAttributes.Add(XSDattr); } return(listAttributes); }
private void GetChildrenInfo(XMLSchema.complexType complexTypeElement, out bool hasChildren, out bool isSimpleType) { bool hasSimpleContent = false; if (complexTypeElement.Items != null) { for (int i = 0; i < complexTypeElement.Items.Length; i++) { if (complexTypeElement.Items[i] is XMLSchema.group || complexTypeElement.Items[i] is XMLSchema.complexType || complexTypeElement.Items[i] is XMLSchema.complexContent) { hasChildren = true; isSimpleType = complexTypeElement.mixed; if (complexTypeElement.Items[i] is XMLSchema.complexContent) { //hasChildren = false; XMLSchema.complexContent complexContent = complexTypeElement.Items[i] as XMLSchema.complexContent; if (complexContent.Item is XMLSchema.extensionType) { hasChildren = false; XMLSchema.extensionType extensionType = complexContent.Item as XMLSchema.extensionType; if (extensionType.all != null || extensionType.group != null || extensionType.choice != null || extensionType.sequence != null) { hasChildren = true; } else if (extensionType.@base != null) { XSDObject xsdObject = null; if (_elementsByName.TryGetValue([email protected] + ":type:" + [email protected], out xsdObject) && xsdObject != null) { XMLSchema.complexType baseComplexType = xsdObject.Tag as XMLSchema.complexType; if (baseComplexType != null) { GetChildrenInfo(baseComplexType, out hasChildren, out isSimpleType); } } } } //else if (complexContent.Item is XMLSchema.complexRestrictionType) //{ // XMLSchema.complexRestrictionType complexRestrictionType = complexContent.Item as XMLSchema.complexRestrictionType; //} } return; } else if (complexTypeElement.Items[i] is XMLSchema.simpleContent) { hasSimpleContent = true; } } } hasChildren = false; isSimpleType = (hasSimpleContent ? true : complexTypeElement.mixed); }
public DiagramItem AddComplexType(DiagramItem parentDiagramElement, XMLSchema.complexType childElement, bool isReference, string nameSpace) { ClearSearch(); if (childElement != null) { DiagramItem childDiagramElement = new DiagramItem(); childDiagramElement.Diagram = this; childDiagramElement.TabSchema = childElement; childDiagramElement.Name = childElement.name != null ? childElement.name : ""; childDiagramElement.NameSpace = nameSpace; childDiagramElement.ItemType = DiagramItemType.type; childDiagramElement.MinOccurrence = 1; childDiagramElement.MaxOccurrence = 1; childDiagramElement.IsReference = isReference; childDiagramElement.IsSimpleContent = false; childDiagramElement.HasChildElements = false; if (childElement.Items != null) { for (int i = 0; i < childElement.Items.Length; i++) { if (childElement.Items[i] is XMLSchema.group || childElement.Items[i] is XMLSchema.complexType || childElement.Items[i] is XMLSchema.complexContent) { childDiagramElement.HasChildElements = true; break; } } } if (parentDiagramElement == null) { _rootElements.Add(childDiagramElement); } else { childDiagramElement.Parent = parentDiagramElement; parentDiagramElement.ChildElements.Add(childDiagramElement); } return(childDiagramElement); } return(null); }
private void GetChildrenInfo(XMLSchema.element childElement, out bool hasChildren, out bool isSimpleType) { if (childElement.Item is XMLSchema.complexType) { XMLSchema.complexType complexTypeElement = childElement.Item as XMLSchema.complexType; GetChildrenInfo(complexTypeElement, out hasChildren, out isSimpleType); return; //if (complexTypeElement.Items != null) //{ // for (int i = 0; i < complexTypeElement.Items.Length; i++) // { // if (complexTypeElement.Items[i] is XMLSchema.group || // complexTypeElement.Items[i] is XMLSchema.complexType || // complexTypeElement.Items[i] is XMLSchema.complexContent) // { // return true; // } // } //} } else if (childElement.type != null) { XSDObject xsdObject = null; if (_elementsByName.TryGetValue(childElement.type.Namespace + ":type:" + childElement.type.Name, out xsdObject) && xsdObject != null) //if (_elementsByName.ContainsKey(childElement.type.Namespace + ":type:" + childElement.type.Name)) { XMLSchema.annotated annotated = xsdObject.Tag as XMLSchema.annotated; if (annotated is XMLSchema.simpleType) { hasChildren = false; isSimpleType = true; } else { GetChildrenInfo(annotated as XMLSchema.complexType, out hasChildren, out isSimpleType); } return; } } hasChildren = false; isSimpleType = true; }
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; } } } }
private static void ParseComplexTypeAttributes(Schema schema, string nameSpace, List <XSDAttribute> listAttributes, XMLSchema.complexType complexType, bool isRestriction) { if (complexType.ItemsElementName != null) { for (int i = 0; i < complexType.ItemsElementName.Length; i++) { switch (complexType.ItemsElementName[i]) { case XMLSchema.ItemsChoiceType4.attribute: { XMLSchema.attribute attribute = complexType.Items[i] as XMLSchema.attribute; ParseAttribute(schema, nameSpace, listAttributes, attribute, false); } break; case XMLSchema.ItemsChoiceType4.attributeGroup: { XMLSchema.attributeGroup attributeGroup = complexType.Items[i] as XMLSchema.attributeGroup; ParseAttributeGroup(schema, nameSpace, listAttributes, attributeGroup, false); } break; case XMLSchema.ItemsChoiceType4.anyAttribute: XMLSchema.wildcard wildcard = complexType.Items[i] as XMLSchema.wildcard; XSDAttribute xsdAttribute = new XSDAttribute("", "*", wildcard.@namespace, "", false, null, null, null); listAttributes.Add(xsdAttribute); break; case XMLSchema.ItemsChoiceType4.simpleContent: case XMLSchema.ItemsChoiceType4.complexContent: XMLSchema.annotated annotatedContent = null; if (complexType.Items[i] is XMLSchema.complexContent) { XMLSchema.complexContent complexContent = complexType.Items[i] as XMLSchema.complexContent; annotatedContent = complexContent.Item; } else if (complexType.Items[i] is XMLSchema.simpleContent) { XMLSchema.simpleContent simpleContent = complexType.Items[i] as XMLSchema.simpleContent; annotatedContent = simpleContent.Item; } if (annotatedContent is XMLSchema.extensionType) { XMLSchema.extensionType extensionType = annotatedContent as XMLSchema.extensionType; //XSDObject xsdExtensionType = this.schema.ElementsByName[QualifiedNameToFullName("type", extensionType.@base)] as XSDObject; //if (xsdExtensionType != null) XSDObject xsdExtensionType; if (schema.ElementsByName.TryGetValue(QualifiedNameToFullName("type", extensionType.@base), out xsdExtensionType) && xsdExtensionType != null) { XMLSchema.annotated annotatedExtension = xsdExtensionType.Tag as XMLSchema.annotated; if (annotatedExtension != null) { if (annotatedExtension is XMLSchema.complexType) { ParseComplexTypeAttributes(schema, [email protected], listAttributes, annotatedExtension as XMLSchema.complexType, false); } } } if (extensionType.Items != null) { foreach (XMLSchema.annotated annotated in extensionType.Items) { if (annotated is XMLSchema.attribute) { ParseAttribute(schema, nameSpace, listAttributes, annotated as XMLSchema.attribute, false); } else if (annotated is XMLSchema.attributeGroup) { ParseAttributeGroup(schema, nameSpace, listAttributes, annotated as XMLSchema.attributeGroup, false); } } } } else if (annotatedContent is XMLSchema.restrictionType) { XMLSchema.restrictionType restrictionType = annotatedContent as XMLSchema.restrictionType; //XSDObject xsdRestrictionType = this.schema.ElementsByName[QualifiedNameToFullName("type", restrictionType.@base)] as XSDObject; //if (xsdRestrictionType != null) XSDObject xsdRestrictionType; if (schema.ElementsByName.TryGetValue(QualifiedNameToFullName("type", restrictionType.@base), out xsdRestrictionType) && xsdRestrictionType != null) { XMLSchema.annotated annotatedRestriction = xsdRestrictionType.Tag as XMLSchema.annotated; if (annotatedRestriction != null) { if (annotatedRestriction is XMLSchema.complexType) { ParseComplexTypeAttributes(schema, [email protected], listAttributes, annotatedRestriction as XMLSchema.complexType, false); } } } if (restrictionType.Items1 != null) { foreach (XMLSchema.annotated annotated in restrictionType.Items1) { if (annotated is XMLSchema.attribute) { ParseAttribute(schema, nameSpace, listAttributes, annotated as XMLSchema.attribute, true); } else if (annotated is XMLSchema.attributeGroup) { ParseAttributeGroup(schema, nameSpace, listAttributes, annotated as XMLSchema.attributeGroup, true); } } } } break; } } } else { } }
private void ExpandComplexType(DiagramItem parentDiagramElement, XMLSchema.complexType complexTypeElement) { if (complexTypeElement.Items != null) { XMLSchema.annotated[] items = complexTypeElement.Items; XMLSchema.ItemsChoiceType4[] itemsChoiceType = complexTypeElement.ItemsElementName; for (int i = 0; i < items.Length; i++) { if (items[i] is XMLSchema.group) { XMLSchema.group group = items[i] as XMLSchema.group; DiagramItem diagramCompositors = AddCompositors(parentDiagramElement, group, (DiagramItemGroupType)Enum.Parse(typeof(DiagramItemGroupType), itemsChoiceType[i].ToString(), true), parentDiagramElement.NameSpace); parentDiagramElement.ShowChildElements = true; if (diagramCompositors != null) { ExpandChildren(diagramCompositors); } } else if (items[i] is XMLSchema.complexContent) { XMLSchema.complexContent complexContent = items[i] as XMLSchema.complexContent; if (complexContent.Item is XMLSchema.extensionType) { XMLSchema.extensionType extensionType = complexContent.Item as XMLSchema.extensionType; XSDObject xsdObject = null; if (_elementsByName.TryGetValue([email protected] + ":type:" + [email protected], out xsdObject) && xsdObject != null) { XMLSchema.annotated annotated = xsdObject.Tag as XMLSchema.annotated; ExpandAnnotated(parentDiagramElement, annotated, [email protected]); } XMLSchema.group group = extensionType.group as XMLSchema.group; if (group != null) { DiagramItem diagramCompositors = AddCompositors(parentDiagramElement, group, DiagramItemGroupType.Group, [email protected]); parentDiagramElement.ShowChildElements = true; if (diagramCompositors != null) { ExpandChildren(diagramCompositors); } } XMLSchema.group groupSequence = extensionType.sequence as XMLSchema.group; if (groupSequence != null) { DiagramItem diagramCompositors = AddCompositors(parentDiagramElement, groupSequence, DiagramItemGroupType.Sequence, [email protected]); parentDiagramElement.ShowChildElements = true; if (diagramCompositors != null) { ExpandChildren(diagramCompositors); } } XMLSchema.group groupChoice = extensionType.choice as XMLSchema.group; if (groupChoice != null) { DiagramItem diagramCompositors = AddCompositors(parentDiagramElement, groupChoice, DiagramItemGroupType.Choice, [email protected]); parentDiagramElement.ShowChildElements = true; if (diagramCompositors != null) { ExpandChildren(diagramCompositors); } } XMLSchema.group groupAll = extensionType.all as XMLSchema.group; if (groupAll != null) { DiagramItem diagramCompositors = AddCompositors(parentDiagramElement, groupAll, DiagramItemGroupType.All, [email protected]); parentDiagramElement.ShowChildElements = true; if (diagramCompositors != null) { ExpandChildren(diagramCompositors); } } } else if (complexContent.Item is XMLSchema.restrictionType) { XMLSchema.restrictionType restrictionType = complexContent.Item as XMLSchema.restrictionType; XSDObject xsdObject = null; if (_elementsByName.TryGetValue([email protected] + ":type:" + [email protected], out xsdObject) && xsdObject != null) { XMLSchema.annotated annotated = xsdObject.Tag as XMLSchema.annotated; ExpandAnnotated(parentDiagramElement, annotated, [email protected]); } else { //dgis fix github issue 2 if (restrictionType.Items != null) { //for (int j = 0; j < items.Length; j++) for (int j = 0; j < restrictionType.Items.Length; j++) { if (restrictionType.Items[j] is XMLSchema.group) { XMLSchema.group group = restrictionType.Items[j] as XMLSchema.group; DiagramItem diagramCompositors = AddCompositors(parentDiagramElement, group, (DiagramItemGroupType)Enum.Parse(typeof(DiagramItemGroupType), restrictionType.ItemsElementName[j].ToString(), true), parentDiagramElement.NameSpace); parentDiagramElement.ShowChildElements = true; if (diagramCompositors != null) { ExpandChildren(diagramCompositors); } } } } } } } } } }
public bool ExpandChildren(DiagramItem parentDiagramElement) { bool result = false; ClearSearch(); if (parentDiagramElement.ItemType == DiagramItemType.element || parentDiagramElement.ItemType == DiagramItemType.type) { result = true; DiagramItem diagramElement = parentDiagramElement; if (diagramElement.TabSchema is XMLSchema.element) { XMLSchema.element element = diagramElement.TabSchema as XMLSchema.element; if (element.Item is XMLSchema.complexType) { XMLSchema.complexType complexTypeElement = element.Item as XMLSchema.complexType; ExpandComplexType(diagramElement, complexTypeElement); } else if (element.type != null) { XSDObject objectAnnotated = null; if (_elementsByName.TryGetValue(element.type.Namespace + ":type:" + element.type.Name, out objectAnnotated) && objectAnnotated != null) { XMLSchema.annotated annotated = objectAnnotated.Tag as XMLSchema.annotated; ExpandAnnotated(diagramElement, annotated, element.type.Namespace); } } } else if (diagramElement.TabSchema is XMLSchema.any) { //XMLSchema.any any = diagramElement.TabSchema as XMLSchema.any; if (RequestAnyElement != null) { XMLSchema.element requestElement; string requestNameSpace; RequestAnyElement(diagramElement, out requestElement, out requestNameSpace); if (requestElement != null) { AddElement(diagramElement, requestElement, requestNameSpace); diagramElement.ShowChildElements = true; } } } else if (diagramElement.TabSchema is XMLSchema.complexType) { XMLSchema.complexType complexTypeElement = diagramElement.TabSchema as XMLSchema.complexType; ExpandComplexType(diagramElement, complexTypeElement); } } else if (parentDiagramElement.ItemType == DiagramItemType.group) { result = true; DiagramItem diagramCompositors = parentDiagramElement; XMLSchema.group group = diagramCompositors.TabSchema as XMLSchema.group; if (group.Items != null) { for (int i = 0; i < group.Items.Length; i++) { switch (group.ItemsElementName[i]) { case XMLSchema.ItemsChoiceType2.element: if (group.Items[i] is XMLSchema.element) { AddElement(diagramCompositors, group.Items[i] as XMLSchema.element, diagramCompositors.NameSpace); } break; case XMLSchema.ItemsChoiceType2.any: if (group.Items[i] is XMLSchema.any) { AddAny(diagramCompositors, group.Items[i] as XMLSchema.any, diagramCompositors.NameSpace); } break; case XMLSchema.ItemsChoiceType2.group: if (group.Items[i] is XMLSchema.group) { AddCompositors(diagramCompositors, group.Items[i] as XMLSchema.group, DiagramItemGroupType.Group, diagramCompositors.NameSpace); } break; case XMLSchema.ItemsChoiceType2.all: if (group.Items[i] is XMLSchema.group) { AddCompositors(diagramCompositors, group.Items[i] as XMLSchema.group, DiagramItemGroupType.All, diagramCompositors.NameSpace); } break; case XMLSchema.ItemsChoiceType2.choice: if (group.Items[i] is XMLSchema.group) { AddCompositors(diagramCompositors, group.Items[i] as XMLSchema.group, DiagramItemGroupType.Choice, diagramCompositors.NameSpace); } break; case XMLSchema.ItemsChoiceType2.sequence: if (group.Items[i] is XMLSchema.group) { AddCompositors(diagramCompositors, group.Items[i] as XMLSchema.group, DiagramItemGroupType.Sequence, diagramCompositors.NameSpace); } break; } } parentDiagramElement.ShowChildElements = true; } else { AddAny(diagramCompositors, null, diagramCompositors.NameSpace); } } return(result); }
public DiagramItem AddComplexType(DiagramItem parentDiagramElement, XMLSchema.complexType childElement, string nameSpace) { return(AddComplexType(parentDiagramElement, childElement, false, nameSpace)); }
public DiagramItem AddComplexType(XMLSchema.complexType childElement, string nameSpace) { return(AddComplexType(null, childElement, false, nameSpace)); }