/// <summary>
/// Initializes a new object from the the <see cref="RatingBox"/> class.
/// </summary>
/// <param name="typeName">The name of the <see cref="RatingBox"/> instance in the workflow.</param>
/// <param name="elementName">The name of the element in the workflow.</param>
/// <param name="schema">The schema xml that describe the IntBox type.</param>
public RatingBox(String typeName, String elementName, XmlSchemaSet schema)
{
this.TypeName = typeName;
this.FieldName = elementName;
this.Schema = schema;
List <String> values = new List <string>();
//Instatiate all the possible values
XmlSchemaComplexType myType = schema.GlobalTypes[new XmlQualifiedName(typeName)] as XmlSchemaComplexType;
XmlSchemaComplexContentExtension ext = myType.ContentModel.Content as XmlSchemaComplexContentExtension;
XmlSchemaSequence seq = ext.Particle as XmlSchemaSequence;
foreach (XmlSchemaObject subf in seq.Items)
{
XmlSchemaElement element = subf as XmlSchemaElement;
XmlSchemaSimpleType type = element.SchemaType as XmlSchemaSimpleType;
XmlSchemaSimpleTypeRestriction restriction = type.Content as XmlSchemaSimpleTypeRestriction;
XmlSchemaMinInclusiveFacet min = restriction.Facets[0] as XmlSchemaMinInclusiveFacet;
XmlSchemaMaxInclusiveFacet max = restriction.Facets[1] as XmlSchemaMaxInclusiveFacet;
int minValue = Int32.Parse(min.Value);
int maxValue = Int32.Parse(max.Value);
for (int i = minValue; i <= maxValue; i++)
{
values.Add(i.ToString());
}
Values = values.ToArray();
selectedIndex = 0;
}
}
internal XSMinInclusiveFacet(XmlSchemaMinInclusiveFacet minInclusiveFacet)
{
_facet = minInclusiveFacet;
_value = ValueFactory.Create(_facet.Value);
if (_facet.Annotation is XmlSchemaAnnotation annotation)
{
_annotation = XMLSchemaSerializer.CreateXSAnnotation(annotation);
_annotation.BindToContainer(RootContainer, this);
}
}
public override XmlSchemaSimpleType GetSimpleType(string attributeDataType)
{
var retVal = base.GetSimpleType(attributeDataType);
var restriction = (XmlSchemaSimpleTypeRestriction)retVal.Content;
var minFacet = new XmlSchemaMinInclusiveFacet {
Value = TimeSpan.Zero.ToString()
};
restriction.Facets.Add(minFacet);
return(retVal);
}
public bool MinimumDateConstraint(string minDate)
{
DateTime min;
if (!DateTime.TryParse(minDate, out min))
{
return(false);
}
else
{
XmlSchemaMinInclusiveFacet facet = new XmlSchemaMinInclusiveFacet();
facet.Value = min.ToString("u").Substring(0, 10);
Common.addFacet(facet, Common.getElementFromSchema(baseSchema));
return(true);
}
}
public bool AddGreaterThanConstraint(string minVal)
{
int min;
if (int.TryParse(minVal, out min))
{
XmlSchemaMinInclusiveFacet facet = new XmlSchemaMinInclusiveFacet();
facet.Value = min.ToString();
Common.addFacet(facet, Common.getElementFromSchema(baseSchema));
return(true);
}
else
{
return(false);
}
}
public Rating()
{
baseSchema = new XmlSchema();
//<xs:complexType name="RatingN"> first time is empty
XmlSchemaComplexType newType = new XmlSchemaComplexType();
newType.Name = "";
baseSchema.Items.Add(newType);
//<xs:complexContent>
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
newType.ContentModel = complexContent;
//<xs:extension base="Rating">
XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension();
complexContent.Content = complexContentExtension;
complexContentExtension.BaseTypeName = new XmlQualifiedName("Rating");
//<xs:sequence>
XmlSchemaSequence seq = new XmlSchemaSequence();
complexContentExtension.Particle = seq;
//<xs:element name="Value" type="xs:integer"/>
XmlSchemaElement elem = new XmlSchemaElement();
seq.Items.Add(elem);
elem.Name = "Value";
elem.SchemaTypeName = new XmlQualifiedName("integer", "http://www.w3.org/2001/XMLSchema");
//to Check
XmlSchemaMinInclusiveFacet minFacet = new XmlSchemaMinInclusiveFacet();
minFacet.Value = "0";
Common.addFacet(minFacet, Common.getElementFromSchema(baseSchema));
maxRateFacet.Value = "5";
Common.addFacet(maxRateFacet, Common.getElementFromSchema(baseSchema));
}
public override XmlSchemaSimpleType GetSimpleType(string attributeDataType)
{
var retVal = base.GetSimpleType(attributeDataType);
var restriction = (XmlSchemaSimpleTypeRestriction)retVal.Content;
var iva = (IntegerValidatorAttribute)Attribute;
var minFacet = new XmlSchemaMinInclusiveFacet {
Value = iva.MinValue.ToString()
};
restriction.Facets.Add(minFacet);
var maxFacet = new XmlSchemaMaxInclusiveFacet {
Value = iva.MaxValue.ToString()
};
restriction.Facets.Add(maxFacet);
return(retVal);
}
public bool RangeDateConstraint(string minDate, string maxDate)
{
DateTime max, min;
if (!DateTime.TryParse(maxDate, out max) || !DateTime.TryParse(minDate, out min))
{
return(false);
}
if (min.CompareTo(max) > 0)
{
return(false);
}
XmlSchemaMinInclusiveFacet facmin = new XmlSchemaMinInclusiveFacet();
facmin.Value = min.ToString("u").Substring(0, 10);
XmlSchemaMaxInclusiveFacet facmax = new XmlSchemaMaxInclusiveFacet();
facmax.Value = max.ToString("u").Substring(0, 10);
Common.addFacet(facmax, Common.getElementFromSchema(baseSchema));
Common.addFacet(facmin, Common.getElementFromSchema(baseSchema));
return(true);
}
public bool AddIntervalConstraint(string minVal, string maxVal)
{
int min, max;
if (!int.TryParse(minVal, out min) ||
!int.TryParse(maxVal, out max) ||
min > max)
{
return(false);
}
//max facet
XmlSchemaMaxInclusiveFacet maxFacet = new XmlSchemaMaxInclusiveFacet();
maxFacet.Value = max.ToString();
Common.addFacet(maxFacet, Common.getElementFromSchema(baseSchema));
//min facet
XmlSchemaMinInclusiveFacet minFacet = new XmlSchemaMinInclusiveFacet();
minFacet.Value = min.ToString();
Common.addFacet(minFacet, Common.getElementFromSchema(baseSchema));
return(true);
}
public static void Main()
{
XmlSchema schema = new XmlSchema();
// <xs:simpleType name="LotteryNumber">
XmlSchemaSimpleType LotteryNumberType = new XmlSchemaSimpleType();
LotteryNumberType.Name = "LotteryNumber";
// <xs:restriction base="xs:int">
XmlSchemaSimpleTypeRestriction LotteryNumberRestriction = new XmlSchemaSimpleTypeRestriction();
LotteryNumberRestriction.BaseTypeName = new XmlQualifiedName("int", "http://www.w3.org/2001/XMLSchema");
// <xs:minInclusive value="1"/>
XmlSchemaMinInclusiveFacet minInclusive = new XmlSchemaMinInclusiveFacet();
minInclusive.Value = "1";
LotteryNumberRestriction.Facets.Add(minInclusive);
// <xs:maxInclusive value="99"/>
XmlSchemaMaxInclusiveFacet maxInclusive = new XmlSchemaMaxInclusiveFacet();
maxInclusive.Value = "99";
LotteryNumberRestriction.Facets.Add(maxInclusive);
LotteryNumberType.Content = LotteryNumberRestriction;
schema.Items.Add(LotteryNumberType);
// <xs:simpleType name="LotteryNumberList">
XmlSchemaSimpleType LotteryNumberListType = new XmlSchemaSimpleType();
LotteryNumberListType.Name = "LotteryNumberList";
// <xs:list itemType="LotteryNumber"/>
XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList();
list.ItemTypeName = new XmlQualifiedName("LotteryNumber", "");
LotteryNumberListType.Content = list;
schema.Items.Add(LotteryNumberListType);
// <xs:simpleType name="LotteryNumbers">
XmlSchemaSimpleType LotteryNumbersType = new XmlSchemaSimpleType();
LotteryNumbersType.Name = "LotteryNumbers";
// <xs:restriction base="LotteryNumberList">
XmlSchemaSimpleTypeRestriction LotteryNumbersRestriction = new XmlSchemaSimpleTypeRestriction();
LotteryNumbersRestriction.BaseTypeName = new XmlQualifiedName("LotteryNumberList", "");
// <xs:length value="5"/>
XmlSchemaLengthFacet length = new XmlSchemaLengthFacet();
length.Value = "5";
LotteryNumbersRestriction.Facets.Add(length);
LotteryNumbersType.Content = LotteryNumbersRestriction;
schema.Items.Add(LotteryNumbersType);
// <xs:element name="TodaysLottery" type="LotteryNumbers">
XmlSchemaElement TodaysLottery = new XmlSchemaElement();
TodaysLottery.Name = "TodaysLottery";
TodaysLottery.SchemaTypeName = new XmlQualifiedName("LotteryNumbers", "");
schema.Items.Add(TodaysLottery);
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);
}
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);
}
private static XmlSchemaSimpleTypeRestriction ExtractNumberAndIntegerFacets(JsonSchema jSchema, TypeKeyword type)
{
XmlSchemaSimpleTypeRestriction content = new XmlSchemaSimpleTypeRestriction();
double? minValue = GetterExtensions.Minimum(jSchema);
double? minExclusiveValue = GetterExtensions.ExclusiveMinimum(jSchema);
if (type.Value == JsonSchemaType.Number)
{
content.BaseTypeName = new XmlQualifiedName("decimal", XML_SCHEMA_NS);
}
else if (type.Value == JsonSchemaType.Integer)
{
if (minValue != null && minValue == 0.0)
{
content.BaseTypeName = new XmlQualifiedName("positiveInteger", XML_SCHEMA_NS);
}
else
{
content.BaseTypeName = new XmlQualifiedName("integer", XML_SCHEMA_NS);
}
}
if (minValue != null || minExclusiveValue != null)
{
if (minValue != null)
{
XmlSchemaMinInclusiveFacet facet = new XmlSchemaMinInclusiveFacet
{
Value = FormatDouble((double)minValue),
};
content.Facets.Add(facet);
}
else
{
XmlSchemaMinExclusiveFacet facet = new XmlSchemaMinExclusiveFacet
{
Value = FormatDouble((double)minExclusiveValue),
};
content.Facets.Add(facet);
}
}
double? maxValue = GetterExtensions.Maximum(jSchema);
double? maxExclusiveValue = GetterExtensions.ExclusiveMaximum(jSchema);
if (maxValue != null || maxExclusiveValue != null)
{
if (maxValue != null)
{
XmlSchemaMaxInclusiveFacet maxInclusiveFacet = new XmlSchemaMaxInclusiveFacet
{
Value = FormatDouble((double)maxValue),
};
content.Facets.Add(maxInclusiveFacet);
}
else
{
XmlSchemaMaxExclusiveFacet maxExclusiveFacet = new XmlSchemaMaxExclusiveFacet
{
Value = FormatDouble((double)maxExclusiveValue),
};
content.Facets.Add(maxExclusiveFacet);
}
}
return content;
}
static XmlQualifiedName AddAttributeTypeToXmlSchema(SchemaInfo schemaInfo, UxmlAttributeDescription description, IUxmlFactory factory, FactoryProcessingHelper processingData)
{
if (description.name == null)
{
return(null);
}
string attrTypeName = factory.uxmlQualifiedName + "_" + description.name + "_" + k_TypeSuffix;
string attrTypeNameInBaseElement = factory.substituteForTypeQualifiedName + "_" + description.name + "_" + k_TypeSuffix;
FactoryProcessingHelper.AttributeRecord attrRecord;
if (processingData.attributeTypeNames.TryGetValue(attrTypeNameInBaseElement, out attrRecord))
{
// If restriction != baseElement.restriction, we need to declare a new type.
// Note: we do not support attributes having a less restrictive restriction than its base type.
if ((description.restriction == null && attrRecord.desc.restriction == null) ||
(description.restriction != null && description.restriction.Equals(attrRecord.desc.restriction)))
{
// Register attrTypeName -> attrRecord for potential future derived elements.
processingData.attributeTypeNames.Add(attrTypeName, attrRecord);
return(attrRecord.name);
}
}
XmlQualifiedName xqn;
FactoryProcessingHelper.AttributeRecord attributeRecord;
if (description.restriction == null)
{
// Type is a built-in type.
xqn = new XmlQualifiedName(description.type, description.typeNamespace);
attributeRecord = new FactoryProcessingHelper.AttributeRecord {
name = xqn, desc = description
};
processingData.attributeTypeNames.Add(attrTypeName, attributeRecord);
return(xqn);
}
string attrTypeNameForSchema = factory.uxmlName + "_" + description.name + "_" + k_TypeSuffix;
xqn = new XmlQualifiedName(attrTypeNameForSchema, schemaInfo.schema.TargetNamespace);
XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType();
simpleType.Name = attrTypeNameForSchema;
UxmlEnumeration enumRestriction = description.restriction as UxmlEnumeration;
if (enumRestriction != null)
{
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
simpleType.Content = restriction;
restriction.BaseTypeName = new XmlQualifiedName(description.type, description.typeNamespace);
foreach (var v in enumRestriction.values)
{
XmlSchemaEnumerationFacet enumValue = new XmlSchemaEnumerationFacet();
enumValue.Value = v;
restriction.Facets.Add(enumValue);
}
}
else
{
UxmlValueMatches regexRestriction = description.restriction as UxmlValueMatches;
if (regexRestriction != null)
{
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
simpleType.Content = restriction;
restriction.BaseTypeName = new XmlQualifiedName(description.type, description.typeNamespace);
XmlSchemaPatternFacet pattern = new XmlSchemaPatternFacet();
pattern.Value = regexRestriction.regex;
restriction.Facets.Add(pattern);
}
else
{
UxmlValueBounds bounds = description.restriction as UxmlValueBounds;
if (bounds != null)
{
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
simpleType.Content = restriction;
restriction.BaseTypeName = new XmlQualifiedName(description.type, description.typeNamespace);
XmlSchemaFacet facet;
if (bounds.excludeMin)
{
facet = new XmlSchemaMinExclusiveFacet();
}
else
{
facet = new XmlSchemaMinInclusiveFacet();
}
facet.Value = bounds.min;
restriction.Facets.Add(facet);
if (bounds.excludeMax)
{
facet = new XmlSchemaMaxExclusiveFacet();
}
else
{
facet = new XmlSchemaMaxInclusiveFacet();
}
facet.Value = bounds.max;
restriction.Facets.Add(facet);
}
else
{
Debug.Log("Unsupported restriction type.");
}
}
}
schemaInfo.schema.Items.Add(simpleType);
attributeRecord = new FactoryProcessingHelper.AttributeRecord {
name = xqn, desc = description
};
processingData.attributeTypeNames.Add(attrTypeName, attributeRecord);
return(xqn);
}
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);
}
public static void Main()
{
XmlSchema schema = new XmlSchema();
// <xs:simpleType name="OrderQuantityType">
XmlSchemaSimpleType OrderQuantityType = new XmlSchemaSimpleType();
OrderQuantityType.Name = "OrderQuantityType";
// <xs:restriction base="xs:int">
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
restriction.BaseTypeName = new XmlQualifiedName("int", "http://www.w3.org/2001/XMLSchema");
// <xs:minInclusive value="5"/>
XmlSchemaMinInclusiveFacet minInclusive = new XmlSchemaMinInclusiveFacet();
minInclusive.Value = "5";
restriction.Facets.Add(minInclusive);
OrderQuantityType.Content = restriction;
schema.Items.Add(OrderQuantityType);
// <xs:element name="item">
XmlSchemaElement element = new XmlSchemaElement();
element.Name = "item";
// <xs:complexType>
XmlSchemaComplexType complexType = new XmlSchemaComplexType();
// <xs:attribute name="OrderQuantity" type="OrderQuantityType"/>
XmlSchemaAttribute OrderQuantityAttribute = new XmlSchemaAttribute();
OrderQuantityAttribute.Name = "OrderQuantity";
OrderQuantityAttribute.SchemaTypeName = new XmlQualifiedName("OrderQuantityType", "");
complexType.Attributes.Add(OrderQuantityAttribute);
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);
}
protected override void Visit(XmlSchemaMinInclusiveFacet facet)
{
AddLeaf(SimpleTypeStructureNodeType.FacetMinInclusive, facet);
}
protected virtual void Visit(XmlSchemaMinInclusiveFacet facet)
{
}
private List <AttributeRule> GetRules(XmlSchemaSimpleTypeRestriction restriction)
{
List <AttributeRule> rules = new List <AttributeRule>();
List <string> enumValues = null;
foreach (XmlSchemaFacet facet in restriction.Facets)
{
XmlSchemaEnumerationFacet enumFacet = facet as XmlSchemaEnumerationFacet;
if (enumFacet != null)
{
if (enumValues == null)
{
enumValues = new List <string>();
}
enumValues.Add(enumFacet.Value);
continue;
}
XmlSchemaMinExclusiveFacet minExclusiveFacet = facet as XmlSchemaMinExclusiveFacet;
if (minExclusiveFacet != null)
{
double minExclusive;
if (Double.TryParse(minExclusiveFacet.Value, out minExclusive))
{
rules.Add(new NumericMinRule(minExclusive, false));
}
continue;
}
XmlSchemaMinInclusiveFacet minInclusiveFacet = facet as XmlSchemaMinInclusiveFacet;
if (minInclusiveFacet != null)
{
double minInclusive;
if (Double.TryParse(minInclusiveFacet.Value, out minInclusive))
{
rules.Add(new NumericMinRule(minInclusive, true));
}
continue;
}
XmlSchemaMaxExclusiveFacet maxExclusiveFacet = facet as XmlSchemaMaxExclusiveFacet;
if (maxExclusiveFacet != null)
{
double maxExclusive;
if (Double.TryParse(maxExclusiveFacet.Value, out maxExclusive))
{
rules.Add(new NumericMaxRule(maxExclusive, false));
}
continue;
}
XmlSchemaMaxInclusiveFacet maxInclusiveFacet = facet as XmlSchemaMaxInclusiveFacet;
if (maxInclusiveFacet != null)
{
double maxInclusive;
if (Double.TryParse(maxInclusiveFacet.Value, out maxInclusive))
{
rules.Add(new NumericMaxRule(maxInclusive, true));
}
continue;
}
}
if (enumValues != null && enumValues.Count > 0)
{
rules.Add(new StringEnumRule(enumValues.ToArray()));
}
return(rules);
}
private static XmlSchemaSimpleTypeRestriction ExtractNumberAndIntegerFacets(JsonSchema jSchema, TypeKeyword type)
{
XmlSchemaSimpleTypeRestriction content = new XmlSchemaSimpleTypeRestriction();
double?minValue = GetterExtensions.Minimum(jSchema);
double?minExclusiveValue = GetterExtensions.ExclusiveMinimum(jSchema);
if (type.Value == JsonSchemaType.Number)
{
content.BaseTypeName = new XmlQualifiedName("decimal", XML_SCHEMA_NS);
}
else if (type.Value == JsonSchemaType.Integer)
{
if (minValue != null && minValue == 1)
{
content.BaseTypeName = new XmlQualifiedName("positiveInteger", XML_SCHEMA_NS);
}
else
{
content.BaseTypeName = new XmlQualifiedName("integer", XML_SCHEMA_NS);
}
}
double?maxValue = GetterExtensions.Maximum(jSchema);
double?maxExclusiveValue = GetterExtensions.ExclusiveMaximum(jSchema);
Regex regex = new Regex("^[9]+$");
if ((minValue != null && maxValue != null) && Math.Abs((double)minValue).Equals(maxValue) && regex.IsMatch(maxValue.ToString()))
{
XmlSchemaTotalDigitsFacet facet = new XmlSchemaTotalDigitsFacet
{
Value = FormatDouble(maxValue.ToString().Length),
};
content.Facets.Add(facet);
}
else
{
if (minValue != null || minExclusiveValue != null)
{
if (minValue != null)
{
XmlSchemaMinInclusiveFacet facet = new XmlSchemaMinInclusiveFacet
{
Value = FormatDouble((double)minValue),
};
content.Facets.Add(facet);
}
else
{
XmlSchemaMinExclusiveFacet facet = new XmlSchemaMinExclusiveFacet
{
Value = FormatDouble((double)minExclusiveValue),
};
content.Facets.Add(facet);
}
}
if (maxValue != null || maxExclusiveValue != null)
{
if (maxValue != null)
{
XmlSchemaMaxInclusiveFacet maxInclusiveFacet = new XmlSchemaMaxInclusiveFacet
{
Value = FormatDouble((double)maxValue),
};
content.Facets.Add(maxInclusiveFacet);
}
else
{
XmlSchemaMaxExclusiveFacet maxExclusiveFacet = new XmlSchemaMaxExclusiveFacet
{
Value = FormatDouble((double)maxExclusiveValue),
};
content.Facets.Add(maxExclusiveFacet);
}
}
}
return(content);
}
/// <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;
}
}
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);
}
