private XmlSchemaElement CityName() { var cityNameElement = new XmlSchemaElement(); cityNameElement.Name = "CityName"; var cityNameType = new XmlSchemaSimpleType(); var cityNameRestriction = new XmlSchemaSimpleTypeRestriction(); cityNameRestriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); var maxLength = new XmlSchemaMaxLengthFacet(); maxLength.Value = "15"; var minLenght = new XmlSchemaMinLengthFacet(); minLenght.Value = "4"; cityNameRestriction.Facets.Add(maxLength); cityNameRestriction.Facets.Add(minLenght); cityNameType.Content = cityNameRestriction; cityNameElement.SchemaType = cityNameType; return(cityNameElement); }
public static XmlSchemaType MapNumber <T>(T e) where T : IElement, IRestrictable { XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(); simpleType.Name = e.Name; XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new System.Xml.XmlQualifiedName("decimal", DefaultSchemaNamespace); var min = e.Restrictions.FirstOrDefault(r => r.Key == "min"); var max = e.Restrictions.FirstOrDefault(r => r.Key == "max"); XmlSchemaMinLengthFacet mMin = new XmlSchemaMinLengthFacet(); mMin.Value = min is null ? "1" : min.Value; restriction.Facets.Add(mMin); XmlSchemaMaxLengthFacet mMax = new XmlSchemaMaxLengthFacet(); mMax.Value = max is null ? "100" : max.Value; restriction.Facets.Add(mMax); simpleType.Content = restriction; return(simpleType); }
internal XSMaxLengthFacet(XmlSchemaMaxLengthFacet maxLengthFacet) { _facet = maxLengthFacet; if (_facet.Annotation is XmlSchemaAnnotation annotation) { _annotation = XMLSchemaSerializer.CreateXSAnnotation(annotation); _annotation.BindToContainer(RootContainer, this); } }
private static XmlSchema CreateCustomerSchema2() { var firstNameElement = new XmlSchemaElement(); firstNameElement.Name = "FirstName"; var lastNameElement = new XmlSchemaElement(); lastNameElement.Name = "LastName"; var idAttribute = new XmlSchemaAttribute(); idAttribute.Name = "CustomerId"; idAttribute.Use = XmlSchemaUse.Required; // Create the simple type for LastName element XmlSchemaSimpleType lastNameType = new XmlSchemaSimpleType(); lastNameType.Name = "LastNameType"; var lastNameRestriction = new XmlSchemaSimpleTypeRestriction(); lastNameRestriction.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); var maxLength = new XmlSchemaMaxLengthFacet(); maxLength.Value = "20"; lastNameRestriction.Facets.Add(maxLength); lastNameType.Content = lastNameRestriction; firstNameElement.SchemaTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); // user defined lastNameElement.SchemaTypeName = new XmlQualifiedName("LastNameType", "http://www.tempuri.org"); idAttribute.SchemaTypeName = new XmlQualifiedName("positiveInteger", XmlSchema.Namespace); // customer top level element XmlSchemaElement customerElement = new XmlSchemaElement { Name = "Customer" }; var customerType = new XmlSchemaComplexType(); var sequence = new XmlSchemaSequence(); sequence.Items.Add(firstNameElement); sequence.Items.Add(lastNameElement); customerType.Particle = sequence; customerType.Attributes.Add(idAttribute); customerElement.SchemaType = customerType; XmlSchema customerSchema = new XmlSchema(); customerSchema.TargetNamespace = "http://www.tempuri.org"; customerSchema.Items.Add(customerElement); customerSchema.Items.Add(lastNameType); return(customerSchema); }
public bool AddMaxLengthConstraint(int maxLen) { if (maxLen < 0) { return(false); } XmlSchemaMaxLengthFacet maxLenFacet = new XmlSchemaMaxLengthFacet(); maxLenFacet.Value = maxLen.ToString(); Common.addFacet(maxLenFacet, Common.getElementFromSchema(baseSchema)); return(true); }
static string deref_simple(XmlSchemaSimpleType simp) { XmlSchemaSimpleTypeRestriction xsstr = (XmlSchemaSimpleTypeRestriction)simp.Content; foreach (object o in xsstr.Facets) { if (o.GetType() == typeof(XmlSchemaMaxLengthFacet)) { XmlSchemaMaxLengthFacet fac = (XmlSchemaMaxLengthFacet)o; return(fac.Value); } } return(""); }
public bool AddMaxLengthConstraint(string max_length) { int maxLen; if (!int.TryParse(max_length, out maxLen) || maxLen < 0) { return(false); } XmlSchemaMaxLengthFacet maxLenFacet = new XmlSchemaMaxLengthFacet(); maxLenFacet.Value = max_length; Common.addFacet(maxLenFacet, Common.getElementFromSchema(baseSchema)); return(true); }
public static XmlSchemaType MapDecimal <T>(T e) where T : IElement, INamable, IRestrictable { var simpleType = new XmlSchemaSimpleType(); simpleType.Name = e.Name; var restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new System.Xml.XmlQualifiedName("decimal", DefaultSchemaNamespace); var min = e.Restrictions.FirstOrDefault(r => r.Key == "min"); var max = e.Restrictions.FirstOrDefault(r => r.Key == "max"); var decimals = e.Restrictions.FirstOrDefault(r => r.Key == "decimals"); if (min != null) { var mMin = new XmlSchemaMinLengthFacet(); mMin.Value = min is null ? "1" : min.Value; restriction.Facets.Add(mMin); } if (max != null) { var mMax = new XmlSchemaMaxLengthFacet(); mMax.Value = max is null ? "100" : max.Value; restriction.Facets.Add(mMax); } if (decimals != null) { var mFractionDigits = new XmlSchemaFractionDigitsFacet { Value = decimals is null ? "2" : decimals.Value }; restriction.Facets.Add(mFractionDigits); } simpleType.Content = restriction; return(simpleType); } }
private void CreateSimpletypeLength(string length, string minLength, string maxLength, bool expected) { passed = true; XmlSchema schema = new XmlSchema(); XmlSchemaSimpleType testType = new XmlSchemaSimpleType(); testType.Name = "TestType"; XmlSchemaSimpleTypeRestriction testTypeRestriction = new XmlSchemaSimpleTypeRestriction(); testTypeRestriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); if (length != "-") { XmlSchemaLengthFacet _length = new XmlSchemaLengthFacet(); _length.Value = length; testTypeRestriction.Facets.Add(_length); } if (minLength != "-") { XmlSchemaMinLengthFacet _minLength = new XmlSchemaMinLengthFacet(); _minLength.Value = minLength; testTypeRestriction.Facets.Add(_minLength); } if (maxLength != "-") { XmlSchemaMaxLengthFacet _maxLength = new XmlSchemaMaxLengthFacet(); _maxLength.Value = maxLength; testTypeRestriction.Facets.Add(_maxLength); } testType.Content = testTypeRestriction; schema.Items.Add(testType); schema.Compile(new ValidationEventHandler(ValidationCallbackOne)); Assert( (passed ? "Test passed, should have failed" : "Test failed, should have passed") + ": " + length + " " + minLength + " " + maxLength, expected == passed); }
public bool AddRangeLengthConstraint(string sMinLen, string sMaxLen) { int minLen, maxLen; if (!int.TryParse(sMinLen, out minLen) || !int.TryParse(sMaxLen, out maxLen) || maxLen < 0 || minLen < 0 || minLen > maxLen) // FIXME { return(false); } XmlSchemaMaxLengthFacet maxLenFacet = new XmlSchemaMaxLengthFacet(); maxLenFacet.Value = maxLen.ToString(); Common.addFacet(maxLenFacet, Common.getElementFromSchema(baseSchema)); XmlSchemaMinLengthFacet minLenFacet = new XmlSchemaMinLengthFacet(); minLenFacet.Value = minLen.ToString(); Common.addFacet(minLenFacet, Common.getElementFromSchema(baseSchema)); return(true); }
/// <summary> /// Returns a simple type which extends the basic datatype and /// restricts is using the string validator /// </summary> public override XmlSchemaSimpleType GetSimpleType(string attributeDataType) { var retVal = base.GetSimpleType(attributeDataType); var restriction = (XmlSchemaSimpleTypeRestriction)retVal.Content; var sva = (StringValidatorAttribute)Attribute; if (!string.IsNullOrEmpty(sva.InvalidCharacters)) { var pFacet = new XmlSchemaPatternFacet { Value = sva.InvalidCharacters }; // TODO: convert this to a regex that excludes the characters pFacet.Value = string.Format( "[^{0}]*", pFacet.Value .Replace(@"\", @"\\") .Replace(@"[", @"\[") .Replace(@"]", @"\]")); restriction.Facets.Add(pFacet); } var minFacet = new XmlSchemaMinLengthFacet { Value = sva.MinLength.ToString() }; restriction.Facets.Add(minFacet); var maxFacet = new XmlSchemaMaxLengthFacet { Value = sva.MaxLength.ToString() }; restriction.Facets.Add(maxFacet); return(retVal); }
public static XmlSchemaType MapString <T>(T e) where T : IElement, INamable, IRestrictable { var simpleType = new XmlSchemaSimpleType(); simpleType.Name = e.Name; var restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new System.Xml.XmlQualifiedName("string", DefaultSchemaNamespace); var min = e.Restrictions.FirstOrDefault(r => r.Key == "min"); var max = e.Restrictions.FirstOrDefault(r => r.Key == "max"); var pattern = e.Restrictions.FirstOrDefault(r => r.Key == "pattern"); var mMin = new XmlSchemaMinLengthFacet(); mMin.Value = min is null ? "1" : min.Value; restriction.Facets.Add(mMin); var mMax = new XmlSchemaMaxLengthFacet(); mMax.Value = max is null ? "100" : max.Value; restriction.Facets.Add(mMax); if (pattern != null) { var mPattern = new XmlSchemaMaxLengthFacet(); mPattern.Value = mPattern?.Value ?? ""; restriction.Facets.Add(mPattern); } simpleType.Content = restriction; return(simpleType); }
protected override void Visit(XmlSchemaMaxLengthFacet facet) { AddLeaf(SimpleTypeStructureNodeType.FacetMaxLength, facet); }
internal string GenerateSimpleType( XmlSchemaSimpleType type, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) { CodeTypeDeclaration codeClass = CodeDomHelper.CreateClassDeclaration(type); mainNamespace.Types.Add(codeClass); CodeDomHelper.GenerateXmlTypeAttribute(codeClass, type.QualifiedName.Name, type.QualifiedName.Namespace); XmlSchemaSimpleTypeRestriction restriction = type.Content as XmlSchemaSimpleTypeRestriction; Type baseType = XsdToClrPrimitive(restriction.BaseTypeName); CodeMemberField field = CodeDomHelper.AddField(codeClass, "value", baseType); CodeMemberProperty prop = CodeDomHelper.AddPropertyDeclaration(codeClass, field, "Value", baseType); CodeDomHelper.AddTextAttribute(prop.CustomAttributes); CodeDomHelper.AddCtor(codeClass); CodeDomHelper.AddCtor(codeClass, prop); // for each facet we support, add validation to the setter foreach (object facet in restriction.Facets) { XmlSchemaLengthFacet length = facet as XmlSchemaLengthFacet; if (length != null) { int?value = ToInt32(length.Value); if (value.HasValue) { CodeExpression valueLength = CodeDomHelper.Property(CodeDomHelper.Value(), "Length"); CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(valueLength, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(value)); prop.SetStatements.Add(new CodeConditionStatement(condition, new CodeStatement[] { CodeDomHelper.ThrowFacetViolation("length", value) }, new CodeStatement[0])); } continue; } XmlSchemaPatternFacet pattern = facet as XmlSchemaPatternFacet; if (pattern != null) { // TODO: might want ot validate the pattern value here to make sure that it is a valid Regex. if (!string.IsNullOrEmpty(pattern.Value)) { CodeExpression patternMatch = CodeDomHelper.MethodCall( CodeDomHelper.TypeExpr(typeof(Regex)), "IsMatch", new CodeExpression[] { CodeDomHelper.Value(), CodeDomHelper.Primitive(pattern.Value) }); CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(patternMatch, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(true)); prop.SetStatements.Add(new CodeConditionStatement(condition, new CodeStatement[] { CodeDomHelper.ThrowFacetViolation("pattern", pattern.Value) }, new CodeStatement[0])); } continue; } XmlSchemaMinLengthFacet minLength = facet as XmlSchemaMinLengthFacet; if (minLength != null) { int?value = ToInt32(minLength.Value); if (value.HasValue) { CodeExpression valueLength = CodeDomHelper.Property(CodeDomHelper.Value(), "Length"); CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(valueLength, CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(value)); prop.SetStatements.Add(new CodeConditionStatement(condition, new CodeStatement[] { CodeDomHelper.ThrowFacetViolation("minLength", value) }, new CodeStatement[0])); } continue; } XmlSchemaMaxLengthFacet maxLength = facet as XmlSchemaMaxLengthFacet; if (maxLength != null) { int?value = ToInt32(maxLength.Value); if (value.HasValue) { CodeExpression valueLength = CodeDomHelper.Property(CodeDomHelper.Value(), "Length"); CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(valueLength, CodeBinaryOperatorType.GreaterThan, new CodePrimitiveExpression(value)); prop.SetStatements.Add(new CodeConditionStatement(condition, new CodeStatement[] { CodeDomHelper.ThrowFacetViolation("maxLength", value) }, new CodeStatement[0])); } continue; } } //add ToSrting() Overload and implicit and explicit Cast operators for compatibilty woth previously generated code CodeMemberMethod toString = CodeDomHelper.MethodDecl(typeof(string), "ToString", MemberAttributes.Public | MemberAttributes.Override); toString.Statements.Add(CodeDomHelper.Return(CodeDomHelper.Property("value"))); codeClass.Members.Add(toString); // Unfortunately CodeDom does not support operators, so we have to use CodeSnippet to generate the Cast operators // CodeSnippet is not language aware, so we have to use different snippets for different providers // this version only support c# syntax if (codeProvider is Microsoft.CSharp.CSharpCodeProvider) { string implicitCast = string.Format(" public static implicit operator {0}({1} x) {{ return new {0}(x); }}", codeClass.Name, baseType.FullName); CodeSnippetTypeMember implicitOp = new CodeSnippetTypeMember(implicitCast); codeClass.Members.Add(implicitOp); string explicitCast = string.Format(" public static explicit operator {1}({0} x) {{ return x.Value; }}", codeClass.Name, baseType.FullName); CodeSnippetTypeMember explicitOp = new CodeSnippetTypeMember(explicitCast); codeClass.Members.Add(explicitOp); } return(codeClass.Name); }
public static void Main() { XmlSchema schema = new XmlSchema(); // <xs:simpleType name="ZipCodeType"> XmlSchemaSimpleType ZipCodeType = new XmlSchemaSimpleType(); ZipCodeType.Name = "ZipCodeType"; // <xs:restriction base="xs:string"> XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // <xs:maxLength value="10"/> XmlSchemaMaxLengthFacet maxLength = new XmlSchemaMaxLengthFacet(); maxLength.Value = "10"; restriction.Facets.Add(maxLength); ZipCodeType.Content = restriction; schema.Items.Add(ZipCodeType); // <xs:element name="Address"> XmlSchemaElement element = new XmlSchemaElement(); element.Name = "Address"; // <xs:complexType> XmlSchemaComplexType complexType = new XmlSchemaComplexType(); // <xs:attribute name="ZipCode" type="ZipCodeType"/> XmlSchemaAttribute ZipCodeAttribute = new XmlSchemaAttribute(); ZipCodeAttribute.Name = "ZipCode"; ZipCodeAttribute.SchemaTypeName = new XmlQualifiedName("ZipCodeType", ""); complexType.Attributes.Add(ZipCodeAttribute); element.SchemaType = complexType; schema.Items.Add(element); XmlSchemaSet schemaSet = new XmlSchemaSet(); schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne); schemaSet.Add(schema); schemaSet.Compile(); XmlSchema compiledSchema = null; foreach (XmlSchema schema1 in schemaSet.Schemas()) { compiledSchema = schema1; } XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable()); nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema"); compiledSchema.Write(Console.Out, nsmgr); }
/// <summary> /// Render field-criteria such as max length and patterns. /// </summary> /// <param name="restrictions">XSD restriction object to receive the facets.</param> /// <param name="fieldEntity">The field being described.</param> /// <param name="fieldTypeAlias">The XSD type string for the field type. E.g. 'string'.</param> private void AddFieldRestrictions(XmlSchemaSimpleTypeRestriction restrictions, Entity fieldEntity, string fieldTypeAlias) { switch (fieldTypeAlias) { // Int constraints case "intField": int?minValue = _schemaManager.GetIntFieldValue(fieldEntity, Aliases2.MinInt); if (minValue != null) { var minFacet = new XmlSchemaMinInclusiveFacet() { Value = minValue.ToString() }; restrictions.Facets.Add(minFacet); } int?maxValue = _schemaManager.GetIntFieldValue(fieldEntity, Aliases2.MaxInt); if (maxValue != null) { var maxFacet = new XmlSchemaMaxInclusiveFacet() { Value = maxValue.ToString() }; restrictions.Facets.Add(maxFacet); } break; // String constraints case "stringField": int?minLength = _schemaManager.GetIntFieldValue(fieldEntity, Aliases2.MinLength); if (minLength != null) { var minFacet = new XmlSchemaMinLengthFacet() { Value = minLength.ToString() }; restrictions.Facets.Add(minFacet); } int?maxLength = _schemaManager.GetIntFieldValue(fieldEntity, Aliases2.MaxLength); if (maxLength != null) { var maxFacet = new XmlSchemaMaxLengthFacet() { Value = maxLength.ToString() }; restrictions.Facets.Add(maxFacet); } var stringPattern = _schemaManager.GetRelationshipsFromEntity(fieldEntity, A(Aliases2.Pattern)).FirstOrDefault(); if (stringPattern != null) { string sRegex = _schemaManager.GetStringFieldValue(stringPattern, Aliases2.Regex); if (sRegex != null) { var regexFacet = new XmlSchemaPatternFacet() { Value = sRegex }; restrictions.Facets.Add(regexFacet); } } break; // String constraints case "aliasField": // optional namespace prefix, followed by lower-case alpha, alphanumeric string aliasRegex = @"([_a-zA-Z][_a-zA-Z0-9]*\:)?[_a-zA-Z][_a-zA-Z0-9]{0,99}"; var aliasRegexFacet = new XmlSchemaPatternFacet() { Value = aliasRegex }; restrictions.Facets.Add(aliasRegexFacet); break; } }
private void button1_Click(object sender, EventArgs e) { XmlSchema schema = new XmlSchema(); //define NameSimpleType XmlSchemaSimpleType nametype = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeRestriction nameRes = new XmlSchemaSimpleTypeRestriction(); nameRes.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); XmlSchemaMinLengthFacet nameFacet1 = new XmlSchemaMinLengthFacet(); nameFacet1.Value = "3"; XmlSchemaMaxLengthFacet nameFacet2 = new XmlSchemaMaxLengthFacet(); nameFacet2.Value = "255"; nameRes.Facets.Add(nameFacet1); nameRes.Facets.Add(nameFacet2); nametype.Content = nameRes; //define PhoneSimpleType XmlSchemaSimpleType phonetype = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeRestriction phoneRes = new XmlSchemaSimpleTypeRestriction(); phoneRes.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); XmlSchemaMaxLengthFacet phoneFacet1 = new XmlSchemaMaxLengthFacet(); phoneFacet1.Value = "20"; phoneRes.Facets.Add(phoneFacet1); phonetype.Content = phoneRes; //define NotesSimpleType XmlSchemaSimpleType notestype = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeRestriction notesRes = new XmlSchemaSimpleTypeRestriction(); notesRes.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); XmlSchemaMaxLengthFacet notesFacet1 = new XmlSchemaMaxLengthFacet(); notesFacet1.Value = "500"; notesRes.Facets.Add(notesFacet1); notestype.Content = notesRes; //define EmployeeType complex type XmlSchemaComplexType employeetype = new XmlSchemaComplexType(); XmlSchemaSequence sequence = new XmlSchemaSequence(); XmlSchemaElement firstname = new XmlSchemaElement(); firstname.Name = "firstname"; firstname.SchemaType = nametype; XmlSchemaElement lastname = new XmlSchemaElement(); lastname.Name = "lastname"; lastname.SchemaType = nametype; XmlSchemaElement homephone = new XmlSchemaElement(); homephone.Name = "homephone"; homephone.SchemaType = phonetype; XmlSchemaElement notes = new XmlSchemaElement(); notes.Name = "notes"; notes.SchemaType = notestype; sequence.Items.Add(firstname); sequence.Items.Add(lastname); sequence.Items.Add(homephone); sequence.Items.Add(notes); employeetype.Particle = sequence; //define employeeid attribute XmlSchemaAttribute employeeid = new XmlSchemaAttribute(); employeeid.Name = "employeeid"; employeeid.SchemaTypeName = new XmlQualifiedName("int", "http://www.w3.org/2001/XMLSchema"); employeeid.Use = XmlSchemaUse.Required; employeetype.Attributes.Add(employeeid); //define top complex type XmlSchemaComplexType complextype = new XmlSchemaComplexType(); XmlSchemaSequence sq = new XmlSchemaSequence(); XmlSchemaElement employee = new XmlSchemaElement(); employee.Name = "employee"; employee.SchemaType = employeetype; employee.MinOccurs = 0; employee.MaxOccursString = "unbounded"; sq.Items.Add(employee); complextype.Particle = sq; //define <employees> element XmlSchemaElement employees = new XmlSchemaElement(); employees.Name = "employees"; employees.SchemaType = complextype; schema.Items.Add(employees); //compile the schema try { XmlSchemaSet set = new XmlSchemaSet(); set.Add(schema); set.Compile(); } catch (Exception ex) { MessageBox.Show("Schema compilation failed"); return; } //save the schema XmlTextWriter writer = new XmlTextWriter(textBox1.Text, null); schema.Write(writer); writer.Close(); MessageBox.Show("Schema Created Successfully!"); }
private XmlSchemaSimpleTypeRestriction ExtractStringFacets(JsonSchema jSchema) { XmlSchemaSimpleTypeRestriction content = new XmlSchemaSimpleTypeRestriction { BaseTypeName = new XmlQualifiedName("string", XML_SCHEMA_NS), }; EnumKeyword enumKeyword = jSchema.Get<EnumKeyword>(); if (enumKeyword != null) { foreach (JsonValue enumValue in GetterExtensions.Enum(jSchema)) { XmlSchemaEnumerationFacet enumFacet = new XmlSchemaEnumerationFacet { Value = enumValue.String, }; content.Facets.Add(enumFacet); } } MinLengthKeyword minLength = jSchema.Get<MinLengthKeyword>(); MaxLengthKeyword maxLength = jSchema.Get<MaxLengthKeyword>(); if (minLength != null && maxLength != null && minLength.Value == maxLength.Value) { // special rule that maps equal min and max lengths to xsd length facet XmlSchemaLengthFacet lengthFacet = new XmlSchemaLengthFacet { Value = minLength.Value.ToString(), }; content.Facets.Add(lengthFacet); } else { if (minLength != null) { XmlSchemaMinLengthFacet minLengthFacet = new XmlSchemaMinLengthFacet { Value = minLength.Value.ToString(), }; content.Facets.Add(minLengthFacet); } if (maxLength != null) { XmlSchemaMaxLengthFacet maxLengthFacet = new XmlSchemaMaxLengthFacet { Value = maxLength.Value.ToString(), }; content.Facets.Add(maxLengthFacet); } } PatternKeyword pattern = jSchema.Get<PatternKeyword>(); if (pattern != null) { XmlSchemaPatternFacet patternFacet = new XmlSchemaPatternFacet { Value = pattern.Value.ToString(), }; content.Facets.Add(patternFacet); } FormatKeyword format = jSchema.Get<FormatKeyword>(); if (format != null && format.Value != null && !string.IsNullOrEmpty(format.Value.Key)) { content.BaseTypeName = ExtractBaseTypeNameFromFormat(format.Value.Key); } return content; }
public static IEnumerable <XmlSchemaFacet> createXmlFacets(IEnumerable <ICctsFacet> facets) { var xmlFacets = new List <XmlSchemaFacet>(); foreach (var facet in facets) { XmlSchemaFacet xmlFacet = null; switch (facet.name) { case "fractionDigit": xmlFacet = new XmlSchemaFractionDigitsFacet(); break; case "length": xmlFacet = new XmlSchemaLengthFacet(); break; case "maxExclusive": xmlFacet = new XmlSchemaMaxExclusiveFacet(); break; case "maxInclusive": xmlFacet = new XmlSchemaMaxInclusiveFacet(); break; case "maxLength": xmlFacet = new XmlSchemaMaxLengthFacet(); break; case "minExclusive": xmlFacet = new XmlSchemaMinExclusiveFacet(); break; case "minInclusive": xmlFacet = new XmlSchemaMinInclusiveFacet(); break; case "minLength": xmlFacet = new XmlSchemaMinLengthFacet(); break; case "pattern": xmlFacet = new XmlSchemaPatternFacet(); break; case "totalDigits": xmlFacet = new XmlSchemaTotalDigitsFacet(); break; case "whiteSpace": xmlFacet = new XmlSchemaWhiteSpaceFacet(); break; case "enumeration": foreach (var enumValue in facet.content.Split('|')) { var enumerationFacet = new XmlSchemaEnumerationFacet(); enumerationFacet.Value = enumValue; xmlFacets.Add(enumerationFacet); } break; } if (xmlFacet != null) { xmlFacet.Value = facet.content; xmlFacets.Add(xmlFacet); } } return(xmlFacets); }
/// <summary> /// Запись в новый XSD файл содержимого класса SeSchemaItem /// </summary> /// <param name="newXSDElement">Новый элемент в схеме</param> /// <param name="xs">Новый экземпляр схемы</param> public void SaveXSD(XmlSchemaElement newXSDElement, XmlSchema xs) { SetProperties(newXSDElement); if (Type == "") { XmlSchemaComplexType newSchemaType = new XmlSchemaComplexType(); newXSDElement.SchemaType = newSchemaType; XmlSchemaAll newAll = new XmlSchemaAll(); if (Properties != null) { Properties.SetPropAll(newAll); } newSchemaType.Particle = newAll; foreach (SeSchemaItem ssi in SchemaItemsChildren) { XmlSchemaElement newElement = new XmlSchemaElement(); newElement.Name = ssi.Name; ssi.SetProperties(newElement); if (ssi.Description != null && ssi.Description != "") { newElement.Annotation = SetAnnotation(ssi); } if (ssi.SchemaItemsChildren != null && ssi.SchemaItemsChildren.Count != 0) { if (ssi.SchemaItemsChildren[0].Name == "SimpleType") { XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(); newElement.SchemaType = simpleType; XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); simpleType.Content = restriction; restriction.BaseTypeName = new XmlQualifiedName(ssi.Type, "http://www.w3.org/2001/XMLSchema"); foreach (SeSchemaItem sstc in ssi.SchemaItemsChildren) { string facetName = sstc.Description.Split('-')[0]; string facetValue = sstc.Description.Split('-')[1]; if (facetName == "XmlSchemaMaxLengthFacet") { XmlSchemaMaxLengthFacet ml = new XmlSchemaMaxLengthFacet(); restriction.Facets.Add(ml); ml.Value = facetValue; } if (facetName == "XmlSchemaTotalDigitsFacet") { XmlSchemaTotalDigitsFacet ml = new XmlSchemaTotalDigitsFacet(); restriction.Facets.Add(ml); ml.Value = facetValue; } if (facetName == "XmlSchemaFractionDigitsFacet") { XmlSchemaFractionDigitsFacet ml = new XmlSchemaFractionDigitsFacet(); restriction.Facets.Add(ml); ml.Value = facetValue; } } } else { if (ssi.CheckToCommonTypes() == true) { newElement.SchemaTypeName = new XmlQualifiedName(ssi.Type, "http://www.w3.org/2001/XMLSchema"); } else { newElement.SchemaTypeName = new XmlQualifiedName(ssi.Type); }; } } else { if (ssi.CheckToCommonTypes() == true) { newElement.SchemaTypeName = new XmlQualifiedName(ssi.Type, "http://www.w3.org/2001/XMLSchema"); } else { newElement.SchemaTypeName = new XmlQualifiedName(ssi.Type); } } newAll.Items.Add(newElement); } } else { if (CheckToCommonTypes() == true) { newXSDElement.SchemaTypeName = new XmlQualifiedName(Type, "http://www.w3.org/2001/XMLSchema"); } else { newXSDElement.SchemaTypeName = new XmlQualifiedName(Type); }; } }
static void Main(string[] args) { //<snippet2> // Create the FirstName and LastName elements. XmlSchemaElement firstNameElement = new XmlSchemaElement(); firstNameElement.Name = "FirstName"; XmlSchemaElement lastNameElement = new XmlSchemaElement(); lastNameElement.Name = "LastName"; // Create CustomerId attribute. XmlSchemaAttribute idAttribute = new XmlSchemaAttribute(); idAttribute.Name = "CustomerId"; idAttribute.Use = XmlSchemaUse.Required; //</snippet2> //<snippet3> // Create the simple type for the LastName element. XmlSchemaSimpleType lastNameType = new XmlSchemaSimpleType(); lastNameType.Name = "LastNameType"; XmlSchemaSimpleTypeRestriction lastNameRestriction = new XmlSchemaSimpleTypeRestriction(); lastNameRestriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); XmlSchemaMaxLengthFacet maxLength = new XmlSchemaMaxLengthFacet(); maxLength.Value = "20"; lastNameRestriction.Facets.Add(maxLength); lastNameType.Content = lastNameRestriction; // Associate the elements and attributes with their types. // Built-in type. firstNameElement.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // User-defined type. lastNameElement.SchemaTypeName = new XmlQualifiedName("LastNameType", "http://www.tempuri.org"); // Built-in type. idAttribute.SchemaTypeName = new XmlQualifiedName("positiveInteger", "http://www.w3.org/2001/XMLSchema"); // Create the top-level Customer element. XmlSchemaElement customerElement = new XmlSchemaElement(); customerElement.Name = "Customer"; // Create an anonymous complex type for the Customer element. XmlSchemaComplexType customerType = new XmlSchemaComplexType(); XmlSchemaSequence sequence = new XmlSchemaSequence(); sequence.Items.Add(firstNameElement); sequence.Items.Add(lastNameElement); customerType.Particle = sequence; // Add the CustomerId attribute to the complex type. customerType.Attributes.Add(idAttribute); // Set the SchemaType of the Customer element to // the anonymous complex type created above. customerElement.SchemaType = customerType; //</snippet3> //<snippet4> // Create an empty schema. XmlSchema customerSchema = new XmlSchema(); customerSchema.TargetNamespace = "http://www.tempuri.org"; // Add all top-level element and types to the schema customerSchema.Items.Add(customerElement); customerSchema.Items.Add(lastNameType); // Create an XmlSchemaSet to compile the customer schema. XmlSchemaSet schemaSet = new XmlSchemaSet(); schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback); schemaSet.Add(customerSchema); schemaSet.Compile(); foreach (XmlSchema schema in schemaSet.Schemas()) { customerSchema = schema; } // Write the complete schema to the Console. customerSchema.Write(Console.Out); //</snippet4> }
/// <summary> /// Initializes the column from an XmlSchemaElement or XmlSchemaAttribute. /// </summary> /// <param name="xmlSchemaAnnotated">An XmlSchema object containing the attributes of the column.</param> private void Initialize(XmlSchemaAnnotated xmlSchemaAnnotated) { // Extract the column properties from an XmlSchemaElement. if (xmlSchemaAnnotated is XmlSchemaElement) { // This element is used to describe the column. XmlSchemaElement xmlSchemaElement = xmlSchemaAnnotated as XmlSchemaElement; // This information is taken directly from the known XmlSchema attributes. The rest of the information about the // column needs to be extracted using unhandled attributes and element facets. this.name = xmlSchemaElement.Name; this.isNullable = xmlSchemaElement.MinOccurs == 0.0m; // Extract the string that contains the type information from the 'DataType' custom attribute. This is a // Microsoft extension to the XML Schema definition. XmlAttribute dataTypeAttribute = ObjectSchema.GetUnhandledAttribute(xmlSchemaElement, QualifiedName.DataType); if (dataTypeAttribute != null) { // The type information is stored as a string. This will rip apart the string to get the type, // assembly, version, etc. information that can be used to access the type through reflection. string typeName = dataTypeAttribute.Value; string[] parts = typeName.Split(','); // There's no a lot of fancy parsing going on here. If it doesn't match the expected format, then // reject the type. if (parts.Length != 5) { throw new Exception(String.Format("Can't analyze the data type found on line {0}, {1}", xmlSchemaElement.LineNumber, typeName)); } // This will load the assembly into memory and use reflection to get the data type that was specified // in the XML file as a string. string assemblyFullName = String.Format("{0},{1},{2},{3}", parts[1], parts[2], parts[3], parts[4]); Assembly assembly = Assembly.Load(assemblyFullName); if (assembly == null) { throw new Exception(String.Format("Unable to load the type {0} from assembly {1}", parts[0], assemblyFullName)); } this.dataType = assembly.GetType(parts[0]); if (this.dataType == null) { throw new Exception(String.Format("Unable to load the type {0} from assembly {1}", parts[0], assemblyFullName)); } } else { // This will extract the simple data type and the maximum field length from the facets associated with the element. if (xmlSchemaElement.ElementSchemaType is XmlSchemaSimpleType) { XmlSchemaSimpleType xmlSchemaSimpleType = xmlSchemaElement.ElementSchemaType as XmlSchemaSimpleType; this.dataType = xmlSchemaSimpleType.Datatype.ValueType; if (xmlSchemaSimpleType.Content is XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction xmlSchemaSimpleTypeRestriction = xmlSchemaSimpleType.Content as XmlSchemaSimpleTypeRestriction; foreach (XmlSchemaFacet xmlSchemaFacet in xmlSchemaSimpleTypeRestriction.Facets) { if (xmlSchemaFacet is XmlSchemaMaxLengthFacet) { XmlSchemaMaxLengthFacet xmlSchemaMaxLengthFacet = xmlSchemaFacet as XmlSchemaMaxLengthFacet; this.maximumLength = Convert.ToInt32(xmlSchemaMaxLengthFacet.Value); } } } } } // The defalt value can only be evaluated after the data type has been determined. Otherwise, there's no way to // know to which data type the default value is converted. this.defaultValue = DataModelSchema.ConvertValue(this.dataType, xmlSchemaElement.DefaultValue); } // Extract the column properties from an Attribute. if (xmlSchemaAnnotated is XmlSchemaAttribute) { // This attribute describes the column. XmlSchemaAttribute xmlSchemaAttribute = xmlSchemaAnnotated as XmlSchemaAttribute; // This information is taken directly from the known XmlSchema attributes. The rest of the information about the // column needs to be extracted using unhandled attributes and element facets. this.name = xmlSchemaAttribute.Name; this.dataType = xmlSchemaAttribute.AttributeSchemaType.Datatype.ValueType; this.defaultValue = DataModelSchema.ConvertValue(this.dataType, xmlSchemaAttribute.DefaultValue); } // Determine the IsEncryptedColumn property. XmlAttribute isColumnEncrytedAttribute = ObjectSchema.GetUnhandledAttribute(xmlSchemaAnnotated, QualifiedName.IsEncrypted); this.isEncrypted = isColumnEncrytedAttribute == null ? false : Convert.ToBoolean(isColumnEncrytedAttribute.Value); // Determine the IsIdentityColumn property. XmlAttribute autoIncrementAttribute = ObjectSchema.GetUnhandledAttribute(xmlSchemaAnnotated, QualifiedName.AutoIncrement); this.isAutoIncrement = autoIncrementAttribute == null ? false : Convert.ToBoolean(autoIncrementAttribute.Value); // Determine the IsPersistent property. XmlAttribute isColumnPersistentAttribute = ObjectSchema.GetUnhandledAttribute(xmlSchemaAnnotated, QualifiedName.IsPersistent); this.isPersistent = isColumnPersistentAttribute == null ? true : Convert.ToBoolean(isColumnPersistentAttribute.Value); // Determine the AutoIncrementSeed property. XmlAttribute autoIncrementSeedAttribute = ObjectSchema.GetUnhandledAttribute(xmlSchemaAnnotated, QualifiedName.AutoIncrementSeed); this.autoIncrementSeed = autoIncrementSeedAttribute == null ? 0 : Convert.ToInt32(autoIncrementSeedAttribute.Value); // Determine the AutoIncrementStop property XmlAttribute autoIncrementStepAttribute = ObjectSchema.GetUnhandledAttribute(xmlSchemaAnnotated, QualifiedName.AutoIncrementStep); this.autoIncrementStep = autoIncrementStepAttribute == null ? 0 : Convert.ToInt32(autoIncrementStepAttribute.Value); }
public XsdSimpleRestrictionType(RelaxngDatatype primitive, RelaxngParamList parameters) { type = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeRestriction r = new XmlSchemaSimpleTypeRestriction(); type.Content = r; string ns = primitive.NamespaceURI; // Remap XML Schema datatypes namespace -> XML Schema namespace. if (ns == "http://www.w3.org/2001/XMLSchema-datatypes") { ns = XSchema.Namespace; } r.BaseTypeName = new XmlQualifiedName(primitive.Name, ns); foreach (RelaxngParam p in parameters) { XmlSchemaFacet f = null; string value = p.Value; switch (p.Name) { case "maxExclusive": f = new XmlSchemaMaxExclusiveFacet(); break; case "maxInclusive": f = new XmlSchemaMaxInclusiveFacet(); break; case "minExclusive": f = new XmlSchemaMinExclusiveFacet(); break; case "minInclusive": f = new XmlSchemaMinInclusiveFacet(); break; case "pattern": f = new XmlSchemaPatternFacet(); // .NET/Mono Regex has a bug that it does not support "IsLatin-1Supplement" // (it somehow breaks at '-'). value = value.Replace("\\p{IsLatin-1Supplement}", "[\\x80-\\xFF]"); break; case "whiteSpace": f = new XmlSchemaWhiteSpaceFacet(); break; case "length": f = new XmlSchemaLengthFacet(); break; case "maxLength": f = new XmlSchemaMaxLengthFacet(); break; case "minLength": f = new XmlSchemaMinLengthFacet(); break; case "fractionDigits": f = new XmlSchemaFractionDigitsFacet(); break; case "totalDigits": f = new XmlSchemaTotalDigitsFacet(); break; default: throw new RelaxngException(String.Format("XML Schema facet {0} is not recognized or not supported.", p.Name)); } f.Value = value; r.Facets.Add(f); } // Now we create XmlSchema to handle simple-type // based validation (since there is no other way, // because of sucky XmlSchemaSimpleType design). schema = new XSchema(); XmlSchemaElement el = new XmlSchemaElement(); el.Name = "root"; el.SchemaType = type; schema.Items.Add(el); schema.Compile(null); }
private XmlSchemaSimpleType SetSchemaFacets(XmlSchemaSimpleType simpleType, List <MessagePart> MessageParts) { Debug.Assert(!(simpleType.Content is XmlSchemaSimpleTypeUnion), "Cannot apply restrictions to unions."); Debug.Assert(!(simpleType.Content is XmlSchemaSimpleTypeList), "Cannot apply restrictions to lists."); XmlSchemaSimpleTypeRestriction oldRestriction = simpleType.Content as XmlSchemaSimpleTypeRestriction; XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); //preserve existing facets if (oldRestriction != null) { foreach (XmlSchemaObject restrictionFacet in oldRestriction.Facets) { if (!(restrictionFacet is XmlSchemaMaxLengthFacet) && !(restrictionFacet is XmlSchemaMinLengthFacet)) { restriction.Facets.Add(restrictionFacet); } } } foreach (MessagePart messagePart in MessageParts) { StringLengthMessagePart stringLengthMessagePart = messagePart as StringLengthMessagePart; RegexMessagePart regexMessagePart = messagePart as RegexMessagePart; RangeMessagePart rangeMessagePart = messagePart as RangeMessagePart; if (stringLengthMessagePart != null) { if (stringLengthMessagePart.MaxLength > 0) { XmlSchemaMaxLengthFacet maxLengthFacet = new XmlSchemaMaxLengthFacet(); maxLengthFacet.Value = stringLengthMessagePart.MaxLength.ToString(); restriction.Facets.Add(maxLengthFacet); } if (stringLengthMessagePart.MinLength > 0) { XmlSchemaMinLengthFacet minLengthFacet = new XmlSchemaMinLengthFacet(); minLengthFacet.Value = stringLengthMessagePart.MinLength.ToString(); restriction.Facets.Add(minLengthFacet); } } if (regexMessagePart != null) { XmlSchemaPatternFacet patternFacet = new XmlSchemaPatternFacet(); patternFacet.Value = regexMessagePart.Regex; restriction.Facets.Add(patternFacet); } if (rangeMessagePart != null) { XmlSchemaMinInclusiveFacet minInclusiveFacet = new XmlSchemaMinInclusiveFacet(); minInclusiveFacet.Value = rangeMessagePart.Min.ToString(); restriction.Facets.Add(minInclusiveFacet); XmlSchemaMaxInclusiveFacet maxInclusiveFacet = new XmlSchemaMaxInclusiveFacet(); maxInclusiveFacet.Value = rangeMessagePart.Max.ToString(); restriction.Facets.Add(maxInclusiveFacet); } } restriction.BaseTypeName = simpleType.QualifiedName; XmlSchemaSimpleType newType = new XmlSchemaSimpleType(); newType.Content = restriction; return(newType); }
/// <summary> /// Gets the Aggregate Schema associated with the GML objects served by the WMS/WFS Servers /// </summary> /// <param name="WmsLayer"></param> /// <returns></returns> public static XmlSchema GetFeatureSchema(ViewContext context, bool includeGMLBaseReference) { XmlSchema schema = new XmlSchema(); schema.Version = "1.0.0"; schema.Namespaces.Add(Declarations.Wfs100DefaultPrefix, Declarations.Wfs100DefaultNameSpace); schema.Namespaces.Add(Declarations.DefaultPrefix, Declarations.DefaultNameSpace); schema.Namespaces.Add(Declarations.GmlPrefix, Declarations.GmlNameSpace); schema.Namespaces.Add(Declarations.GmlSfPrefix, Declarations.GmlSfNameSpace); schema.Namespaces.Add(Declarations.XlinkPrefix, Declarations.XlinkNameSpace); schema.TargetNamespace = Declarations.DefaultNameSpace; schema.ElementFormDefault = XmlSchemaForm.Qualified; XmlSchemaImport schemaImport = new XmlSchemaImport(); schema.Includes.Add(schemaImport); schemaImport.Namespace = Declarations.GmlNameSpace; schemaImport.SchemaLocation = Declarations.GmlSchemaLocation; schemaImport = new XmlSchemaImport(); schema.Includes.Add(schemaImport); schemaImport.Namespace = Declarations.GmlSfNameSpace; schemaImport.SchemaLocation = Declarations.GmlSfLevelsSchemaLocation; XmlSchemaElement schemaElement = null; XmlSchemaComplexType schemaComplexType = null; XmlSchemaComplexContent schemaComplexContent = null; XmlSchemaComplexContentExtension schemaComplexContentExtension = null; XmlSchemaSequence schemaSequence = null; XmlDocument document = null; if (includeGMLBaseReference) { XmlSchemaAnnotation schemaAnnotation = new XmlSchemaAnnotation(); schema.Items.Add(schemaAnnotation); XmlSchemaAppInfo appInfo = new XmlSchemaAppInfo(); schemaAnnotation.Items.Add(appInfo); appInfo.Source = Declarations.GmlSfLevelsSchemaLocation; XmlNode[] markupNodes = new XmlNode[2]; appInfo.Markup = markupNodes; document = new XmlDocument(); markupNodes[0] = document.CreateNode(XmlNodeType.Element, "ComplianceLevel", Declarations.DefaultNameSpace); markupNodes[0].InnerText = "0"; markupNodes[1] = document.CreateNode(XmlNodeType.Element, "GMLProfileSchema", Declarations.DefaultNameSpace); markupNodes[1].InnerText = Declarations.GmlSfProfileSchemaLocation; schemaElement = new XmlSchemaElement(); schema.Items.Add(schemaElement); schemaElement.Name = "FeatureCollection"; schemaElement.SchemaTypeName = new XmlQualifiedName("FeatureCollectionType", Declarations.DefaultNameSpace); schemaElement.SubstitutionGroup = new XmlQualifiedName("_GML", Declarations.GmlNameSpace); schemaComplexType = new XmlSchemaComplexType(); schema.Items.Add(schemaComplexType); schemaComplexType.Name = "FeatureCollectionType"; schemaComplexContent = new XmlSchemaComplexContent(); schemaComplexType.ContentModel = schemaComplexContent; schemaComplexContentExtension = new XmlSchemaComplexContentExtension(); schemaComplexContent.Content = schemaComplexContentExtension; schemaComplexContentExtension.BaseTypeName = new XmlQualifiedName("AbstractFeatureType", Declarations.GmlNameSpace); schemaSequence = new XmlSchemaSequence(); schemaComplexContentExtension.Particle = schemaSequence; schemaSequence.MinOccurs = 0; schemaSequence.MaxOccursString = "unbounded"; schemaElement = new XmlSchemaElement(); schemaSequence.Items.Add(schemaElement); schemaElement.Name = "featureMember"; schemaComplexType = new XmlSchemaComplexType(); schemaElement.SchemaType = schemaComplexType; schemaSequence = new XmlSchemaSequence(); schemaComplexType.Particle = schemaSequence; schemaElement = new XmlSchemaElement(); schemaSequence.Items.Add(schemaElement); schemaElement.RefName = new XmlQualifiedName("_Feature", Declarations.GmlNameSpace); } string geometryPropertyType = string.Empty; string featureTypeName = string.Empty; FeatureDataRow thisFeature = null; foreach (GeospatialServices.Ogc.Wmc.Layer wmcLayer in context.Layers) { thisFeature = wmcLayer.GetFeatureDataRow(0); if (thisFeature != null) { schemaElement = new XmlSchemaElement(); schema.Items.Add(schemaElement); schemaElement.Name = wmcLayer.Name; featureTypeName = wmcLayer.Name + "Type"; schemaElement.SchemaTypeName = new XmlQualifiedName(featureTypeName, Declarations.DefaultNameSpace); schemaElement.SubstitutionGroup = new XmlQualifiedName("_Feature", Declarations.GmlNameSpace); schemaComplexType = new XmlSchemaComplexType(); schema.Items.Add(schemaComplexType); schemaComplexType.Name = featureTypeName; schemaComplexContent = new XmlSchemaComplexContent(); schemaComplexType.ContentModel = schemaComplexContent; schemaComplexContentExtension = new XmlSchemaComplexContentExtension(); schemaComplexContent.Content = schemaComplexContentExtension; schemaComplexContentExtension.BaseTypeName = new XmlQualifiedName("AbstractFeatureType", Declarations.GmlNameSpace); schemaSequence = new XmlSchemaSequence(); schemaComplexContentExtension.Particle = schemaSequence; XmlSchemaSimpleType schemaSimpleType = null; XmlSchemaMaxLengthFacet maxLengthFacet = null; foreach (DataColumn thisColumn in thisFeature.Table.Columns) { schemaElement = new XmlSchemaElement(); schemaSequence.Items.Add(schemaElement); schemaElement.Name = thisColumn.ColumnName; schemaElement.MinOccurs = thisColumn.AllowDBNull ? 0 : 1; schemaSimpleType = new XmlSchemaSimpleType(); schemaElement.SchemaType = schemaSimpleType; XmlSchemaSimpleTypeRestriction schemaSimpleTypeRestriction = new XmlSchemaSimpleTypeRestriction(); schemaSimpleType.Content = schemaSimpleTypeRestriction; schemaSimpleTypeRestriction.BaseTypeName = new XmlQualifiedName(OgcUtilities.GetGmlSfType(thisColumn), Declarations.XsNameSpace); if (thisColumn.MaxLength > -1) { maxLengthFacet = new XmlSchemaMaxLengthFacet(); maxLengthFacet.Value = thisColumn.MaxLength.ToString(); schemaSimpleTypeRestriction.Facets.Add(maxLengthFacet); } } // Geometry schemaElement = new XmlSchemaElement(); schemaSequence.Items.Add(schemaElement); schemaElement.Name = GMLDeclarations.GeometryFeatureElementName; geometryPropertyType = OgcUtilities.GetGmlSfGeometricPropertyType(thisFeature.Geometry); schemaElement.SchemaTypeName = new XmlQualifiedName(geometryPropertyType, Declarations.GmlNameSpace); schemaElement.MinOccurs = 0; } } return(schema); }
private XmlAttributeType GetAttributeType(XmlSchemaSimpleType simpleType) { XmlAttributeType attributeType; if (!m_attributeTypes.TryGetValue(simpleType.QualifiedName.ToString(), out attributeType)) { bool simpleList = simpleType.Content is XmlSchemaSimpleTypeList; int length = 1; if (simpleList) { length = Int32.MaxValue; // unbounded, until restricted } List <AttributeRule> rules = null; XmlSchemaSimpleTypeRestriction restriction = simpleType.Content as XmlSchemaSimpleTypeRestriction; if (restriction != null) { if (restriction.BaseTypeName != null) { XmlAttributeType baseType; m_attributeTypes.TryGetValue(restriction.BaseTypeName.ToString(), out baseType); if (baseType != null) { length = baseType.Length; } } foreach (XmlSchemaFacet facet in restriction.Facets) { XmlSchemaLengthFacet lengthFacet = facet as XmlSchemaLengthFacet; if (lengthFacet != null) { Int32.TryParse(lengthFacet.Value, out length); continue; } // also handle minLength, maxLength facets in a limited fashion, ie. either one // will specify the array length XmlSchemaMinLengthFacet minLengthFacet = facet as XmlSchemaMinLengthFacet; if (minLengthFacet != null) { int minLength; if (Int32.TryParse(minLengthFacet.Value, out minLength)) { length = Math.Max(length, minLength); } continue; } XmlSchemaMaxLengthFacet maxLengthFacet = facet as XmlSchemaMaxLengthFacet; if (maxLengthFacet != null) { int maxLength; if (Int32.TryParse(maxLengthFacet.Value, out maxLength)) { length = Math.Max(length, maxLength); } continue; } } rules = GetRules(restriction); } string typeName = simpleType.QualifiedName.ToString(); // if xs:IDREF, then the attribute type should be DomNode as this is a reference Type valueType = simpleType.Datatype.ValueType; XmlTypeCode xmlTypeCode = simpleType.Datatype.TypeCode; if (xmlTypeCode == XmlTypeCode.Idref) { if (valueType.IsArray) { valueType = typeof(string[]); } else { valueType = typeof(DomNode); } } // map xs:integer to xs:int (ATGI schema uses xs:integer, which we don't want to map to System.Decimal) if (xmlTypeCode == XmlTypeCode.Integer) { if (valueType.IsArray) { valueType = typeof(Int32[]); } else { valueType = typeof(Int32); } xmlTypeCode = XmlTypeCode.Int; } else if (xmlTypeCode == XmlTypeCode.NonNegativeInteger) { if (valueType.IsArray) { valueType = typeof(UInt32[]); } else { valueType = typeof(UInt32); } xmlTypeCode = XmlTypeCode.UnsignedInt; } // create our extended attribute type attributeType = new XmlAttributeType(typeName, valueType, length, xmlTypeCode); m_annotations.Add(attributeType, GetAnnotation(simpleType)); if (rules != null) { foreach (AttributeRule rule in rules) { attributeType.AddRule(rule); } } if (!string.IsNullOrEmpty(typeName)) { m_attributeTypes.Add(typeName, attributeType); } } return(attributeType); }
protected virtual void Visit(XmlSchemaMaxLengthFacet facet) { }