internal bool IsXDRField(XmlElement node, XmlElement typeNode) { int minOccurs = 1; int maxOccurs = 1; if (!this.IsTextOnlyContent(typeNode)) { return(false); } for (XmlNode node2 = typeNode.FirstChild; node2 != null; node2 = node2.NextSibling) { if (XMLSchema.FEqualIdentity(node2, "element", "urn:schemas-microsoft-com:xml-data") || XMLSchema.FEqualIdentity(node2, "attribute", "urn:schemas-microsoft-com:xml-data")) { return(false); } } if (XMLSchema.FEqualIdentity(node, "element", "urn:schemas-microsoft-com:xml-data")) { this.GetMinMax(node, ref minOccurs, ref maxOccurs); if ((maxOccurs == -1) || (maxOccurs > 1)) { return(false); } } return(true); }
internal void LoadSchema(XmlElement schemaRoot, DataSet ds) { if (schemaRoot != null) { this._schemaRoot = schemaRoot; this._ds = ds; this._schemaName = schemaRoot.GetAttribute("name"); this._schemaUri = ""; if ((this._schemaName == null) || (this._schemaName.Length == 0)) { this._schemaName = "NewDataSet"; } ds.Namespace = this._schemaUri; for (XmlNode node = schemaRoot.FirstChild; node != null; node = node.NextSibling) { if (node is XmlElement) { XmlElement element = (XmlElement)node; if (XMLSchema.FEqualIdentity(element, "ElementType", "urn:schemas-microsoft-com:xml-data")) { this.HandleTable(element); } } } this._schemaName = XmlConvert.DecodeName(this._schemaName); if (ds.Tables[this._schemaName] == null) { ds.DataSetName = this._schemaName; } } }
internal DataTable InstantiateSimpleTable(DataSet dataSet, XmlElement node) { XmlAttributeCollection attrs = node.Attributes; int minOccurs = 1; int maxOccurs = 1; string instanceName = this.GetInstanceName(node); if (dataSet.Tables.GetTable(instanceName, this._schemaUri) != null) { throw ExceptionBuilder.DuplicateDeclaration(instanceName); } string tableName = XmlConvert.DecodeName(instanceName); DataTable instance = new DataTable(tableName) { Namespace = this._schemaUri }; this.GetMinMax(node, ref minOccurs, ref maxOccurs); instance.MinOccurs = minOccurs; instance.MaxOccurs = maxOccurs; XMLSchema.SetProperties(instance, attrs); instance.repeatableElement = true; this.HandleColumn(node, instance); instance.Columns[0].ColumnName = tableName + "_Column"; this._ds.Tables.Add(instance); return(instance); }
internal XmlElement FindTypeNode(XmlElement node) { if (XMLSchema.FEqualIdentity(node, "ElementType", "urn:schemas-microsoft-com:xml-data")) { return(node); } string attribute = node.GetAttribute("type"); if (XMLSchema.FEqualIdentity(node, "element", "urn:schemas-microsoft-com:xml-data") || XMLSchema.FEqualIdentity(node, "attribute", "urn:schemas-microsoft-com:xml-data")) { if ((attribute == null) || (attribute.Length == 0)) { return(null); } XmlNode firstChild = node.OwnerDocument.FirstChild; XmlNode ownerDocument = node.OwnerDocument; while (firstChild != ownerDocument) { if (((XMLSchema.FEqualIdentity(firstChild, "ElementType", "urn:schemas-microsoft-com:xml-data") && XMLSchema.FEqualIdentity(node, "element", "urn:schemas-microsoft-com:xml-data")) || (XMLSchema.FEqualIdentity(firstChild, "AttributeType", "urn:schemas-microsoft-com:xml-data") && XMLSchema.FEqualIdentity(node, "attribute", "urn:schemas-microsoft-com:xml-data"))) && ((firstChild is XmlElement) && (((XmlElement)firstChild).GetAttribute("name") == attribute))) { return((XmlElement)firstChild); } if (firstChild.FirstChild != null) { firstChild = firstChild.FirstChild; } else { if (firstChild.NextSibling == null) { goto Label_0115; } firstChild = firstChild.NextSibling; } continue; Label_00FD: firstChild = firstChild.ParentNode; if (firstChild.NextSibling != null) { firstChild = firstChild.NextSibling; continue; } Label_0115: if (firstChild != ownerDocument) { goto Label_00FD; } } } return(null); }
internal string GetInstanceName(XmlElement node) { string attribute; if (XMLSchema.FEqualIdentity(node, "ElementType", "urn:schemas-microsoft-com:xml-data") || XMLSchema.FEqualIdentity(node, "AttributeType", "urn:schemas-microsoft-com:xml-data")) { attribute = node.GetAttribute("name"); if ((attribute == null) || (attribute.Length == 0)) { throw ExceptionBuilder.MissingAttribute("Element", "name"); } return(attribute); } attribute = node.GetAttribute("type"); if ((attribute == null) || (attribute.Length == 0)) { throw ExceptionBuilder.MissingAttribute("Element", "type"); } return(attribute); }
internal void HandleTypeNode(XmlElement typeNode, DataTable table, ArrayList tableChildren) { for (XmlNode node = typeNode.FirstChild; node != null; node = node.NextSibling) { if (node is XmlElement) { if (XMLSchema.FEqualIdentity(node, "element", "urn:schemas-microsoft-com:xml-data")) { DataTable table2 = this.HandleTable((XmlElement)node); if (table2 != null) { tableChildren.Add(table2); continue; } } if (XMLSchema.FEqualIdentity(node, "attribute", "urn:schemas-microsoft-com:xml-data") || XMLSchema.FEqualIdentity(node, "element", "urn:schemas-microsoft-com:xml-data")) { this.HandleColumn((XmlElement)node, table); } } } }
internal DataTable InstantiateTable(DataSet dataSet, XmlElement node, XmlElement typeNode) { DataTable table; string name = ""; XmlAttributeCollection attrs = node.Attributes; int minOccurs = 1; int maxOccurs = 1; string str2 = null; ArrayList tableChildren = new ArrayList(); if (attrs.Count > 0) { name = this.GetInstanceName(node); table = dataSet.Tables.GetTable(name, this._schemaUri); if (table != null) { return(table); } } table = new DataTable(XmlConvert.DecodeName(name)) { Namespace = this._schemaUri }; this.GetMinMax(node, ref minOccurs, ref maxOccurs); table.MinOccurs = minOccurs; table.MaxOccurs = maxOccurs; this._ds.Tables.Add(table); this.HandleTypeNode(typeNode, table, tableChildren); XMLSchema.SetProperties(table, attrs); if (str2 != null) { string[] strArray = str2.TrimEnd(null).Split(null); int length = strArray.Length; DataColumn[] columnArray = new DataColumn[length]; for (int i = 0; i < length; i++) { DataColumn column2 = table.Columns[strArray[i], this._schemaUri]; if (column2 == null) { throw ExceptionBuilder.ElementTypeNotFound(strArray[i]); } columnArray[i] = column2; } table.PrimaryKey = columnArray; } foreach (DataTable table2 in tableChildren) { DataRelation relation = null; DataRelationCollection childRelations = table.ChildRelations; for (int j = 0; j < childRelations.Count; j++) { if (childRelations[j].Nested && (table2 == childRelations[j].ChildTable)) { relation = childRelations[j]; } } if (relation == null) { DataColumn parentKey = table.AddUniqueKey(); DataColumn childColumn = table2.AddForeignKey(parentKey); relation = new DataRelation(table.TableName + "_" + table2.TableName, parentKey, childColumn, true) { CheckMultipleNested = false, Nested = true }; table2.DataSet.Relations.Add(relation); relation.CheckMultipleNested = true; } } return(table); }
internal void HandleColumn(XmlElement node, DataTable table) { DataColumn column; Type type; string str3; string str4; int minOccurs = 0; int maxOccurs = 1; node.GetAttribute("use"); if (node.Attributes.Count > 0) { string str7 = node.GetAttribute("ref"); if ((str7 != null) && (str7.Length > 0)) { return; } str3 = str4 = this.GetInstanceName(node); column = table.Columns[str4, this._schemaUri]; if (column != null) { if (column.ColumnMapping == MappingType.Attribute) { if (XMLSchema.FEqualIdentity(node, "attribute", "urn:schemas-microsoft-com:xml-data")) { throw ExceptionBuilder.DuplicateDeclaration(str3); } } else if (XMLSchema.FEqualIdentity(node, "element", "urn:schemas-microsoft-com:xml-data")) { throw ExceptionBuilder.DuplicateDeclaration(str3); } str4 = XMLSchema.GenUniqueColumnName(str3, table); } } else { str3 = str4 = ""; } XmlElement element = this.FindTypeNode(node); SimpleType type2 = null; if (element == null) { throw ExceptionBuilder.UndefinedDatatype(node.GetAttribute("type")); } string attribute = element.GetAttribute("type", "urn:schemas-microsoft-com:datatypes"); string dtValues = element.GetAttribute("values", "urn:schemas-microsoft-com:datatypes"); if ((attribute == null) || (attribute.Length == 0)) { attribute = ""; type = typeof(string); } else { type = this.ParseDataType(attribute, dtValues); if (attribute == "float") { attribute = ""; } if (attribute == "char") { attribute = ""; type2 = SimpleType.CreateSimpleType(type); } if (attribute == "enumeration") { attribute = ""; type2 = SimpleType.CreateEnumeratedType(dtValues); } if (attribute == "bin.base64") { attribute = ""; type2 = SimpleType.CreateByteArrayType("base64"); } if (attribute == "bin.hex") { attribute = ""; type2 = SimpleType.CreateByteArrayType("hex"); } } bool isAttribute = XMLSchema.FEqualIdentity(node, "attribute", "urn:schemas-microsoft-com:xml-data"); this.GetMinMax(node, isAttribute, ref minOccurs, ref maxOccurs); string str2 = null; str2 = node.GetAttribute("default"); bool flag2 = false; column = new DataColumn(XmlConvert.DecodeName(str4), type, null, isAttribute ? MappingType.Attribute : MappingType.Element); XMLSchema.SetProperties(column, node.Attributes); column.XmlDataType = attribute; column.SimpleType = type2; column.AllowDBNull = (minOccurs == 0) || flag2; column.Namespace = isAttribute ? string.Empty : this._schemaUri; if (node.Attributes != null) { for (int i = 0; i < node.Attributes.Count; i++) { if ((node.Attributes[i].NamespaceURI == "urn:schemas-microsoft-com:xml-msdata") && (node.Attributes[i].LocalName == "Expression")) { column.Expression = node.Attributes[i].Value; break; } } } string str5 = node.GetAttribute("targetNamespace"); if ((str5 != null) && (str5.Length > 0)) { column.Namespace = str5; } table.Columns.Add(column); if ((str2 != null) && (str2.Length != 0)) { try { column.DefaultValue = SqlConvert.ChangeTypeForXML(str2, type); } catch (FormatException) { throw ExceptionBuilder.CannotConvert(str2, type.FullName); } } for (XmlNode node2 = node.FirstChild; node2 != null; node2 = node2.NextSibling) { if (XMLSchema.FEqualIdentity(node2, "description", "urn:schemas-microsoft-com:xml-data")) { column.Description(((XmlElement)node2).InnerText); } } }
private void SelectSchemaElement(XMLSchema.openAttrs openAttrs, string nameSpace) { this.propertyGridSchemaObject.SelectedObject = openAttrs; ShowDocumentation(null); XMLSchema.annotated annotated = openAttrs as XMLSchema.annotated; if (annotated != null) { // Element documentation if (annotated.annotation != null) ShowDocumentation(annotated.annotation); // Show the enumeration ShowEnumerate(annotated); // 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(ShowAttributes(complexType, nameSpace)); } else if (element.type != null) { //XSDObject xsdObject = this.schema.ElementsByName[QualifiedNameToFullName("type", element.type)] as XSDObject; //if (xsdObject != null) XSDObject xsdObject; if (this.schema.ElementsByName.TryGetValue(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(ShowAttributes(complexType, nameSpace)); } else { } } else { } } else { } } else if (annotated is XMLSchema.complexType) { XMLSchema.complexType complexType = annotated as XMLSchema.complexType; listAttributes.AddRange(ShowAttributes(complexType, nameSpace)); } //RC++ Original code //else //{ //} //this.listViewAttributes.Items.Clear(); //foreach (XSDAttribute attribute in listAttributes) // this.listViewAttributes.Items.Add(new ListViewItem(new string[] { attribute.Name, attribute.Type, attribute.Use, attribute.DefaultValue })).Tag = attribute; //RC-- //Adrian++ //This part i modify 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); } //This part i modify this.listViewAttributes.Items.Clear(); listAttributes.Reverse(); foreach (XSDAttribute attribute in listAttributes) { string s = ""; //dgis fix github issue 2 (attribute.Tag == null ???) if (attribute.Tag != null && attribute.Tag.simpleType != null && attribute.Tag.simpleType.Item is XMLSchema.restriction) { XMLSchema.restriction r = attribute.Tag.simpleType.Item as XMLSchema.restriction; if (r.Items != null) { for (int i = 0; i < r.Items.Length; i++) { s += r.ItemsElementName[i].ToString() + "(" + r.Items[i].id + " " + r.Items[i].value + ");"; } } } this.listViewAttributes.Items.Add(new ListViewItem(new string[] { attribute.Name, attribute.Type, attribute.Use, attribute.DefaultValue, s })).Tag = attribute; } //Adrian-- } }
private void ParseAttributeGroup(string nameSpace, List<XSDAttribute> listAttributes, XMLSchema.attributeGroup attributeGroup, bool isRestriction) { if (attributeGroup is XMLSchema.attributeGroupRef && attributeGroup.@ref != null) { object o = null; this.schema.AttributesByName.TryGetValue(QualifiedNameToFullName("attributeGroup", attributeGroup.@ref), out o); if (o is XSDAttributeGroup) { XSDAttributeGroup xsdAttributeGroup = o as XSDAttributeGroup; XMLSchema.attributeGroup attributeGroupInstance = xsdAttributeGroup.Tag; foreach (XMLSchema.annotated annotated in attributeGroupInstance.Items) { if (annotated is XMLSchema.attribute) { ParseAttribute(nameSpace, listAttributes, annotated as XMLSchema.attribute, isRestriction); } else if (annotated is XMLSchema.attributeGroup) { ParseAttributeGroup(nameSpace, listAttributes, annotated as XMLSchema.attributeGroup, isRestriction); } } } } else { } }
private XSDAttribute ParseAttribute(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; this.schema.AttributesByName.TryGetValue(QualifiedNameToFullName("attribute", attribute.@ref), out o); if (o is XSDAttribute) { XSDAttribute xsdAttributeInstance = o as XSDAttribute; XSDAttribute refXSDAttribute = ParseAttribute(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; }
void diagram_RequestAnyElement(DiagramItem diagramElement, out XMLSchema.element element, out string nameSpace) { element = null; nameSpace = ""; //ElementsForm elementsForm = new ElementsForm(); //elementsForm.Location = MousePosition; //diagramElement.Location //MousePosition; //elementsForm.ListBoxElements.Items.Clear(); //elementsForm.ListBoxElements.Items.Insert(0, "(Cancel)"); //foreach (XSDObject xsdObject in this.schema.ElementsByName.Values) // if (xsdObject != null && xsdObject.Type == "element") // elementsForm.ListBoxElements.Items.Add(xsdObject); //if (elementsForm.ShowDialog(this.diagramControl) == DialogResult.OK && (elementsForm.ListBoxElements.SelectedItem as XSDObject) != null) //{ // XSDObject xsdObject = elementsForm.ListBoxElements.SelectedItem as XSDObject; // element = xsdObject.Tag as XMLSchema.element; // nameSpace = xsdObject.NameSpace; //} }
private void ShowEnumerate(XMLSchema.simpleType simpleType) { if (simpleType != null) { if (simpleType.Item != null) { XMLSchema.restriction restriction = simpleType.Item as XMLSchema.restriction; if (restriction != null && restriction.ItemsElementName != null) { for (int i = 0; i < restriction.ItemsElementName.Length; i++) { if (restriction.ItemsElementName[i] == XMLSchema.ItemsChoiceType.enumeration) { XMLSchema.facet facet = restriction.Items[i] as XMLSchema.facet; if (facet != null) this.listViewEnumerate.Items.Add(facet.value).Tag = facet; } } if (this.listViewEnumerate.Items.Count != 0) this.listViewEnumerate.Columns[0].Width = -1; } } } }
private void ShowEnumerate(XMLSchema.annotated annotated) { this.listViewEnumerate.Items.Clear(); if (annotated != null) { XMLSchema.element element = annotated as XMLSchema.element; if (element != null && element.type != null) { //XSDObject xsdObject = this.schema.ElementsByName[QualifiedNameToFullName("type", element.type)] as XSDObject; //if (xsdObject != null) XSDObject xsdObject; if (this.schema.ElementsByName.TryGetValue(QualifiedNameToFullName("type", element.type), out xsdObject) && xsdObject != null) { XMLSchema.annotated annotatedElement = xsdObject.Tag as XMLSchema.annotated; if (annotatedElement is XMLSchema.simpleType) ShowEnumerate(annotatedElement as XMLSchema.simpleType); } } } }
private void ShowDocumentation(XMLSchema.annotation annotation) { if (this.textBoxAnnotation == null) { // // webBrowserDocumentation // if(webBrowserSupported) { this.webBrowserDocumentation = new System.Windows.Forms.WebBrowser(); this.webBrowserDocumentation.Dock = System.Windows.Forms.DockStyle.Fill; this.webBrowserDocumentation.Location = new System.Drawing.Point(0, 0); this.webBrowserDocumentation.MinimumSize = new System.Drawing.Size(20, 20); this.webBrowserDocumentation.Name = "webBrowserDocumentation"; this.webBrowserDocumentation.Size = new System.Drawing.Size(214, 117); this.webBrowserDocumentation.TabIndex = 1; this.splitContainerDiagramElement.Panel2.Controls.Add(this.webBrowserDocumentation); } else this.webBrowserDocumentation = null; // // textBoxAnnotation // this.textBoxAnnotation = new System.Windows.Forms.TextBox(); this.textBoxAnnotation.Dock = System.Windows.Forms.DockStyle.Fill; this.textBoxAnnotation.Location = new System.Drawing.Point(0, 0); this.textBoxAnnotation.Multiline = true; this.textBoxAnnotation.Name = "textBoxAnnotation"; this.textBoxAnnotation.ReadOnly = true; this.textBoxAnnotation.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; this.textBoxAnnotation.Size = new System.Drawing.Size(214, 117); this.textBoxAnnotation.TabIndex = 0; this.splitContainerDiagramElement.Panel2.Controls.Add(this.textBoxAnnotation); } if (annotation == null) { this.textBoxAnnotation.Text = ""; this.textBoxAnnotation.Visible = true; if (this.webBrowserDocumentation != null) this.webBrowserDocumentation.Visible = false; return; } foreach (object o in annotation.Items) { if (o is XMLSchema.documentation) { XMLSchema.documentation documentation = o as XMLSchema.documentation; if (documentation.Any != null && documentation.Any.Length > 0 && documentation.Any[0].Value != null) { string text = documentation.Any[0].Value; text = text.Replace("\n", " "); text = text.Replace("\t", " "); text = text.Replace("\r", ""); text = Regex.Replace(text, " +", " "); text = text.Trim(); //text = text.Replace(, " "); //text = text.Trim('\n', '\t', '\r', ' '); //string[] textLines = text.Split(new char[] { '\n' }); //for (int i = 0; i < textLines.Length; i++) // textLines[i] = textLines[i].Trim('\n', '\t', '\r', ' '); //text = string.Join("\r\n", textLines); this.textBoxAnnotation.Text = text; this.textBoxAnnotation.Visible = true; if (this.webBrowserDocumentation != null) this.webBrowserDocumentation.Visible = false; } else if (documentation.source != null) { if (this.webBrowserDocumentation != null) { this.textBoxAnnotation.Visible = false; this.webBrowserDocumentation.Visible = true; this.webBrowserDocumentation.Navigate(documentation.source); } else { this.textBoxAnnotation.Text = documentation.source; this.textBoxAnnotation.Visible = true; } } break; } } }
private List<XSDAttribute> ShowAttributes(XMLSchema.complexType complexType, string nameSpace) { List<XSDAttribute> listAttributes = new List<XSDAttribute>(); ParseComplexTypeAttributes(nameSpace, listAttributes, complexType, false); return listAttributes; }
private void LoadRowData(DataRow row, XmlElement rowElement) { DataTable table = row.Table; if (this.FromInference) { table.Prefix = rowElement.Prefix; } Hashtable hashtable = new Hashtable(); row.BeginEdit(); XmlNode firstChild = rowElement.FirstChild; DataColumn textOnlyColumn = this.GetTextOnlyColumn(row); if (textOnlyColumn != null) { hashtable[textOnlyColumn] = textOnlyColumn; string valueForTextOnlyColums = this.GetValueForTextOnlyColums(firstChild); if (XMLSchema.GetBooleanAttribute(rowElement, "nil", "http://www.w3.org/2001/XMLSchema-instance", false) && ADP.IsEmpty(valueForTextOnlyColums)) { row[textOnlyColumn] = DBNull.Value; } else { this.SetRowValueFromXmlText(row, textOnlyColumn, valueForTextOnlyColums); } } while ((firstChild != null) && (firstChild != rowElement)) { if (firstChild.NodeType == XmlNodeType.Element) { XmlElement node = (XmlElement)firstChild; object schemaForNode = this.nodeToSchemaMap.GetSchemaForNode(node, this.FIgnoreNamespace(node)); if ((schemaForNode is DataTable) && this.FColumnElement(node)) { schemaForNode = this.nodeToSchemaMap.GetColumnSchema(node, this.FIgnoreNamespace(node)); } if ((schemaForNode == null) || (schemaForNode is DataColumn)) { firstChild = node.FirstChild; if ((schemaForNode != null) && (schemaForNode is DataColumn)) { DataColumn col = (DataColumn)schemaForNode; if (((col.Table == row.Table) && (col.ColumnMapping != MappingType.Attribute)) && (hashtable[col] == null)) { hashtable[col] = col; string str = this.GetValueForTextOnlyColums(firstChild); if (XMLSchema.GetBooleanAttribute(node, "nil", "http://www.w3.org/2001/XMLSchema-instance", false) && ADP.IsEmpty(str)) { row[col] = DBNull.Value; } else { this.SetRowValueFromXmlText(row, col, str); } } } else if ((schemaForNode == null) && (firstChild != null)) { continue; } if (firstChild == null) { firstChild = node; } } } while ((firstChild != rowElement) && (firstChild.NextSibling == null)) { firstChild = firstChild.ParentNode; } if (firstChild != rowElement) { firstChild = firstChild.NextSibling; } } foreach (XmlAttribute attribute in rowElement.Attributes) { object columnSchema = this.nodeToSchemaMap.GetColumnSchema(attribute, this.FIgnoreNamespace(attribute)); if ((columnSchema != null) && (columnSchema is DataColumn)) { DataColumn column3 = (DataColumn)columnSchema; if ((column3.ColumnMapping == MappingType.Attribute) && (hashtable[column3] == null)) { hashtable[column3] = column3; firstChild = attribute.FirstChild; this.SetRowValueFromXmlText(row, column3, this.GetInitialTextFromNodes(ref firstChild)); } } } foreach (DataColumn column in row.Table.Columns) { if ((hashtable[column] == null) && XmlToDatasetMap.IsMappedColumn(column)) { if (!column.AutoIncrement) { if (column.AllowDBNull) { row[column] = DBNull.Value; } else { row[column] = column.DefaultValue; } } else { column.Init(row.tempRecord); } } } row.EndEdit(); }
private void ParseComplexTypeAttributes(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(nameSpace, listAttributes, attribute, false); } break; case XMLSchema.ItemsChoiceType4.attributeGroup: { XMLSchema.attributeGroup attributeGroup = complexType.Items[i] as XMLSchema.attributeGroup; ParseAttributeGroup(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 (this.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([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(nameSpace, listAttributes, annotated as XMLSchema.attribute, false); } else if (annotated is XMLSchema.attributeGroup) { ParseAttributeGroup(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 (this.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([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(nameSpace, listAttributes, annotated as XMLSchema.attribute, true); } else if (annotated is XMLSchema.attributeGroup) { ParseAttributeGroup(nameSpace, listAttributes, annotated as XMLSchema.attributeGroup, true); } } } } break; } } } else { } }