private static ElementMetadata AssembleElementMetatata( ElementMetadata parentMetadata, ElementFactory elementChild, HashSet <Type> visitedTypes, ICollection <ElementMetadata> elementMetadataCollection, IDictionary <OpenXmlQualifiedName, FieldInfo> fieldInfos) { OpenXmlElement element = elementChild.Create(); var elementMetadata = element.Metadata; elementMetadataCollection.Add(elementMetadata); if (!fieldInfos.TryGetValue(elementMetadata.QName, out FieldInfo? fieldInfo)) { fieldInfo = new FieldInfo(elementMetadata.QName); fieldInfos[elementMetadata.QName] = fieldInfo; } fieldInfo.AddParentElementMetadata(parentMetadata); fieldInfo.AddElementMetadata(elementMetadata); if (visitedTypes.Add(element.GetType())) { foreach (var child in elementMetadata.Children.Elements) { fieldInfo.AddChildElementMetadata( AssembleElementMetatata(elementMetadata, child, visitedTypes, elementMetadataCollection, fieldInfos)); } } return(elementMetadata); }
private Iterator CreateIterator( string elementId, Dictionary <string, Iterator> existingIterators, ServiceMetadata serviceMetadata, List <char> reservedIndexNames) { ElementMetadata elementMetadata = serviceMetadata.Elements[elementId]; string variableName = elementId; foreach (Iterator i in existingIterators.Values) { // Property -> Property[a] etc. when there are parent iterators variableName = variableName.Replace(i.ElementNameLastPart + '.', i.ElementNameWithIndexLastPart + '.'); } string indexName = GetFirstAvailableIndexName(reservedIndexNames).ToString(); var iterator = new Iterator { IndexName = indexName, ElementName = variableName, }; return(iterator); }
private void ProcessSimpleContent( XElement actualElement, XElement simpleContent, Dictionary <string, ElementMetadata> allElements, string parentTrail, string parentName) { var elementMetadata = new ElementMetadata { Restrictions = new Dictionary <string, Restriction>(), }; string newTrail = $"{parentTrail}/Value"; elementMetadata.IsTagContent = true; elementMetadata.Name = "Value"; elementMetadata.XPath = newTrail; elementMetadata.ID = newTrail.Replace("/", ".").Substring(1); elementMetadata.ParentElement = parentTrail.Replace("/", ".").Substring(1); elementMetadata.MinOccurs = 1; elementMetadata.MaxOccurs = 1; elementMetadata.DataBindingName = GetDataBindingName(elementMetadata.ID); if (simpleContent.Element(XDocName.Extension) != null) { WriteRestrictions(elementMetadata.Restrictions, simpleContent.Element(XDocName.Extension), elementMetadata); AddAttributeElements(simpleContent.Element(XDocName.Extension), allElements, parentTrail); } allElements.Add(elementMetadata.ID, elementMetadata); AddSchemaReferenceInformation(actualElement, elementMetadata); }
public void GetModelMetadata_RepeatingGroupHasCorrectDataBinding() { // Arrange JsonSchema testData = LoadTestData("Designer.Tests._TestData.Model.JsonSchema.melding-1603-12392.json"); JsonSchemaToInstanceModelGenerator target = new JsonSchemaToInstanceModelGenerator("parse", "test", testData); // Act ModelMetadata actual = target.GetModelMetadata(); // Assert Assert.NotNull(actual); ElementMetadata repeatingGroup = actual.Elements["Skjema.Endringsmeldinggrp9786.OversiktOverEndringenegrp9788"]; Assert.NotNull(repeatingGroup); Assert.Equal(999, repeatingGroup.MaxOccurs); Assert.Equal("Endringsmelding-grp-9786.OversiktOverEndringene-grp-9788", repeatingGroup.DataBindingName); ElementMetadata nonRepeatingGroup = actual.Elements["Skjema.Endringsmeldinggrp9786.Avgivergrp9787"]; Assert.NotNull(nonRepeatingGroup); Assert.Equal(1, nonRepeatingGroup.MaxOccurs); Assert.Null(nonRepeatingGroup.DataBindingName); }
private Dictionary <string, Iterator> CreateIterator( int containerId, string elementId, ServiceMetadata serviceMetadata, List <char> reservedIndexNames, Dictionary <string, Iterator> iterators) { List <string> idParts = elementId.Split('.').ToList(); string currentId = idParts[0]; for (int i = 0; i < idParts.Count; i++) { ElementMetadata currentElement = serviceMetadata.Elements[currentId]; if (currentElement.MaxOccurs > 1) { // Need iterator if (!iterators.ContainsKey($"{currentId}_{containerId}")) { iterators.Add($"{currentId}_{containerId}", CreateIterator(currentId, iterators, serviceMetadata, reservedIndexNames)); } } if ((i + 1) < idParts.Count) { currentId += '.' + idParts[i + 1]; } } return(iterators); }
private static void AddXsdDataType(ElementMetadata elementMetadata, string xsdDataType) { elementMetadata.XsdValueType = (BaseValueType)Enum.Parse( typeof(BaseValueType), xsdDataType.Split(':')[1].First().ToString().ToUpper() + string.Join(string.Empty, xsdDataType.Split(':')[1].Skip(1))); }
public void NoValidators() { var attributes = ElementMetadata.Create <NoValidatorsElement>(); var attribute = Assert.Single(attributes.Attributes); var single = Assert.Single(attribute.Validators); Assert.IsType <StringValidator>(single); }
public void RequiredValidation() { var attributes = ElementMetadata.Create <ContainsRequiredValidator>(); var attribute = Assert.Single(attributes.Attributes); Assert.Collection( attribute.Validators, t => Assert.IsType <RequiredValidator>(t), t => Assert.IsType <StringValidator>(t)); }
internal ElementClipboardDataItem(IElementFactory elementFactory, ElementMetadata elementMetadata) { if (elementMetadata == null && elementFactory == null) { throw new ArgumentException("Both arguments cannot not be null."); } _elementFactory = elementFactory; _elementMetadata = elementMetadata; }
private void WriteRestrictions(ElementMetadata elementMetadata, XElement element, XElement currentElement) { var restrictions = new Dictionary <string, Restriction>(); var minOccurs = currentElement.AttributeValue("minOccurs"); if (!string.IsNullOrEmpty(minOccurs)) { elementMetadata.MinOccurs = int.Parse(minOccurs); } else { elementMetadata.MinOccurs = 1; } var maxOccurs = currentElement.AttributeValue("maxOccurs"); if (!string.IsNullOrEmpty(maxOccurs)) { if (maxOccurs == "unbounded") { elementMetadata.MaxOccurs = 999; // TEMP } else { elementMetadata.MaxOccurs = int.Parse(maxOccurs); } } else { elementMetadata.MaxOccurs = 1; } XElement restriction = null; if (element != null) { restriction = element.Element(XDocName.Restriction); } if (restriction == null) { if ((element.AttributeValue("type") != null) && element.AttributeValue("type").Contains(":")) { elementMetadata.XsdValueType = (BaseValueType)Enum.Parse(typeof(BaseValueType), element.AttributeValue("type").Split(':')[1].First().ToString().ToUpper() + string.Join(string.Empty, element.AttributeValue("type").Split(':')[1].Skip(1))); } } else { WriteRestrictions(restrictions, restriction, elementMetadata); } elementMetadata.Restrictions = restrictions; }
private static string GetSubXPathToProperty(ElementMetadata elementMetadata) { if (elementMetadata.Type.Equals("Attribute")) { return("//xsd:attribute[@name='" + elementMetadata.XName + "']"); } else { return("//xsd:element[@name='" + elementMetadata.XName + "']"); } }
private void WriteRestrictions(ElementMetadata elementMetadata, XElement element, XElement currentElement) { var restrictions = new Dictionary <string, Restriction>(); var minOccurs = currentElement.AttributeValue("minOccurs"); if (!string.IsNullOrEmpty(minOccurs)) { elementMetadata.MinOccurs = int.Parse(minOccurs); } else { elementMetadata.MinOccurs = 1; } var maxOccurs = currentElement.AttributeValue("maxOccurs"); if (!string.IsNullOrEmpty(maxOccurs)) { if (maxOccurs == "unbounded") { elementMetadata.MaxOccurs = MaxOccursMagicNumber; // TEMP } else { elementMetadata.MaxOccurs = int.Parse(maxOccurs); } } else { elementMetadata.MaxOccurs = 1; } XElement restriction = null; if (element != null) { restriction = element.Element(XDocName.Restriction); } if (restriction == null) { if ((element.AttributeValue("type") != null) && element.AttributeValue("type").Contains(":")) { AddXsdDataType(elementMetadata, element.AttributeValue("type")); } } else { WriteRestrictions(restrictions, restriction, elementMetadata); } elementMetadata.Restrictions = restrictions; }
private static void LoadAssembly(Assembly assembly) { try { STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0}", assembly.FullName)); var tps = assembly.GetTypes(); //STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0} Part#{1}", assembly.FullName, 0)); foreach (var type in tps) { //STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0} Part#{1}", assembly.FullName, 1)); var frameworkElementAttribute = Attribute.GetCustomAttribute(type, typeof(FrameworkElementAttribute)) as FrameworkElementAttribute; //STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0} Part#{1}", assembly.FullName, 2)); if (frameworkElementAttribute != null) { //STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0} Part#{1}", assembly.FullName, 3)); var elementMetadata = new ElementMetadata(frameworkElementAttribute, type); if (Elements.Exists(element => element.XName == frameworkElementAttribute.XName && element.XNamespace == frameworkElementAttribute.XNamespace)) { throw new ElementException(ElementErrorCodes.UnspecifiedException, elementMetadata.XName); } //STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0} Part#{1}", assembly.FullName, 4)); //STrace.Debug(typeof(MetadataDirectory).FullName, "Loaded tag - {0} (namespace: {1})", frameworkElementAttribute.XName, frameworkElementAttribute.XNamespace); Elements.Add(elementMetadata); } //STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0} Part#{1}", assembly.FullName, 5)); var customMarkupExtensionAttribute = Attribute.GetCustomAttribute(type, typeof(CustomMarkupExtensionAttribute)) as CustomMarkupExtensionAttribute; if (customMarkupExtensionAttribute == null) { continue; } var constructor = type.GetConstructor(Type.EmptyTypes); var customMarkupExtension = constructor.Invoke(null) as ICustomMarkupExtension; //STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0} Part#{1}", assembly.FullName, 6)); if (customMarkupExtension == null) { throw new ElementException(ElementErrorCodes.UnableToCreateFrameworkElement, type.Name); } //STrace.Debug(typeof(MetadataDirectory).FullName, String.Format("Loading Assembly: {0} Part#{1}", assembly.FullName, 7)); CustomMarkupExtensions.Add(customMarkupExtensionAttribute.Keyword, customMarkupExtension); } } catch (ReflectionTypeLoadException e) { STrace.Exception(typeof(MetadataDirectory).FullName, e, String.Format("Exception loading Assembly: {0}", assembly.FullName)); } }
private static void AssembleAttributeMetadata( ElementMetadata elementMetadata, IDictionary <OpenXmlQualifiedName, FieldInfo> fieldInfos) { foreach (AttributeMetadata attributeMetadata in elementMetadata.Attributes) { if (!fieldInfos.TryGetValue(attributeMetadata.QName, out FieldInfo? fieldInfo)) { fieldInfo = new FieldInfo(attributeMetadata.QName); fieldInfos[attributeMetadata.QName] = fieldInfo; } fieldInfo.AddAttributeMetadata(elementMetadata, attributeMetadata); } }
public IElement CreateElement(IElementOwner owner, ElementMetadata elementMetadata) { if (owner == null) { throw new ArgumentNullException(nameof(owner)); } if (elementMetadata == null) { throw new ArgumentNullException(nameof(elementMetadata)); } //Find the factory var factory = _factoryManager.GetFactory(elementMetadata.ElementTypeId); //Create the context var context = new ElementCreationContext(owner, elementMetadata.Data, factory); //Create the element var element = factory.Create(context); SetElementProperties(element, elementMetadata); //Blocks if (elementMetadata.Blocks != null) { foreach (var blockMetadata in elementMetadata.Blocks) { var block = element.Blocks.FirstOrDefault(b => b.Id == blockMetadata.Id); if (block == null) { Console.WriteLine("Whoa - didn't find a block"); } else { SetElementProperties(block, blockMetadata); if (blockMetadata.Elements != null) { //Add the block children block.Elements.AddRange(blockMetadata.Elements.Select(e => CreateElement(owner, e)).ToArray()); } } } } return(element); }
/// <summary> /// Populates the metadata tables /// </summary> static HTMLElementTable() { // Allocate space for the first level of our tables TABLE = new ElementMetadata[Meta.Length]; KEYWORD = new Dictionary <AtomicString, ElementMetadata>(Meta.Length); // Loop through all meta-enums and populate both of their tables for (int index = 0; index < Meta.Length; index++) { // Find all the meta-values for this item (Type, MetaElementAttribute)metaInfo = Meta[index]; // Initialize the tables for this item ElementMetadata data = new ElementMetadata(metaInfo.Item2.Name, metaInfo.Item1); TABLE[index] = data; KEYWORD.Add(new AtomicString(data.LocalName), data); } }
/// <inheritdoc /> /// <remarks>Does nothing if <see cref="For"/> is <c>null</c>.</remarks> public override void Process(TagHelperContext context, TagHelperOutput output) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (output == null) { throw new ArgumentNullException(nameof(output)); } var tagBuilder = Generator.GenerateTextArea( ViewContext, For.ModelExplorer, For.Name, rows: 0, columns: 0, htmlAttributes: null); if (tagBuilder != null) { ServiceContext serviceContext = ViewContext.ViewBag.ServiceContext; string modelPath = serviceContext.RootName + "." + ModelHelper.GetMetadataModelPath(For.Name); ElementMetadata elementData = null; if (serviceContext?.ServiceMetaData.Elements.ContainsKey(modelPath) == true) { elementData = serviceContext.ServiceMetaData.Elements[modelPath]; } if (elementData.IsReadOnly) { output.Attributes.Add("disabled", null); } output.MergeAttributes(tagBuilder); if (tagBuilder.HasInnerHtml) { // Overwrite current Content to ensure expression result round-trips correctly. output.Content.SetHtmlContent(tagBuilder.InnerHtml); } ReplaceAttributeTextKeysWithText(output, serviceContext); } }
public static ElementMetadata ToMetadata(this IElement element) { if (element == null) { return(null); } var elementMetadata = new ElementMetadata() { Data = element.GetData(), Parameters = element.Parameters.ToMetadata(), Blocks = element.Blocks.ToMetadata(), ElementTypeId = element.ElementTypeId }; return(elementMetadata); }
private static void IsEquivalentTo(ElementMetadata expectedElement, ElementMetadata actualElement) { Assert.Equal(expectedElement.ID, actualElement.ID); Assert.Equal(expectedElement.ParentElement, expectedElement.ParentElement); Assert.Equal(expectedElement.Name, actualElement.Name); // Commented out for now. Needs to be verified with frontend as // it might be a bug in the old code causing expected to be wrong. // Assert.Equal(expectedElement.TypeName, actualElement.TypeName); Assert.Equal(expectedElement.Type, actualElement.Type); Assert.Equal(expectedElement.XName, actualElement.XName); Assert.Equal(expectedElement.XPath, actualElement.XPath); Assert.Equal(expectedElement.XsdValueType, actualElement.XsdValueType); Assert.Equal(expectedElement.MinOccurs, actualElement.MinOccurs); Assert.Equal(expectedElement.MaxOccurs, actualElement.MaxOccurs); Assert.Equal(expectedElement.DataBindingName, actualElement.DataBindingName); Assert.Equal(expectedElement.FixedValue, actualElement.FixedValue); }
public static IElementClipboardData CreateFunctionCallClipboardData(Guid functionId) { var data = new CommonFunctionBehavior.CallFunctionData() { FunctionId = functionId }; var elementMetadata = new ElementMetadata() { Data = JsonConvert.SerializeObject(data), ElementTypeId = PluginElementIds.CallFunction }; return(new ElementClipboardData(new ElementMetadata[] { elementMetadata })); }
public void JustUnion() { var attributes = ElementMetadata.Create <JustUnionValidator>(); var attribute = Assert.Single(attributes.Attributes); Assert.Collection( attribute.Validators, t => { var union = Assert.IsType <UnionValidator>(t); Assert.Collection( union.Validators, v => Assert.IsType <StringValidator>(v), v => Assert.IsType <StringValidator>(v)); }, t => Assert.IsType <StringValidator>(t)); }
public void GetModelMetadata_RootNameCorrectlyTransferedToModelMetadata() { // Arrange JsonSchema testData = TestDataHelper.LoadDataFromEmbeddedResourceAsJsonSchema("Designer.Tests._TestData.Model.JsonSchema.RA-0678_M.schema.json"); JsonSchemaToInstanceModelGenerator target = new JsonSchemaToInstanceModelGenerator("parse", "test", testData); // Act ModelMetadata actual = target.GetModelMetadata(); // Assert Assert.NotNull(actual); ElementMetadata rootElement = actual.Elements["melding"]; Assert.NotNull(rootElement); Assert.Equal("melding", rootElement.ID); Assert.Equal("melding", rootElement.Name); Assert.Equal("RA0678_M", rootElement.TypeName); }
private bool RequiresConversion(ElementMetadata elementMetadata) { if (elementMetadata == null) { throw new ArgumentNullException(nameof(elementMetadata)); } if (elementMetadata.Next != null) { return(true); } if (elementMetadata.Blocks != null) { if (elementMetadata.Blocks.Any(b => b.Next != null)) { return(true); } } return(false); }
public ElementChild2(ElementMetadata metadata) : base(typeof(T), metadata.Schema.NamespaceId, metadata.Schema.Tag) { }
public ElementLookup.ElementChild Build() => new ElementChild2(ElementMetadata.Create <T>());
#pragma warning disable CS0618 private static IEnumerable <ElementMetadata> EnumerateElementsWhileFixingBlocks(ElementMetadata first) { var current = first; while (current != null) { if (current.Blocks != null) { foreach (var block in current.Blocks) { FixBlock(block); } } yield return(current); current = current.Next; } }
private void AddAttributeElements(XElement currentComplexType, Dictionary <string, ElementMetadata> allElements, string parentTrail) { if (currentComplexType == null) { return; } var attributeElements = currentComplexType.Elements(XDocName.Attribute).ToList(); foreach (var attribute in attributeElements) { var attributeElementMetadata = new ElementMetadata(); var attributeName = attribute.AttributeValue("name"); if ((attribute.AttributeValue("type") != null) && attribute.AttributeValue("type").Contains(":")) { AddXsdDataType(attributeElementMetadata, attribute.AttributeValue("type")); } else { if (attribute.AttributeValue("ref") != null) { var attributeType = GetAttributeByNameAttribute(attribute.AttributeValue("ref")); if ((attributeType.AttributeValue("type") != null) && attributeType.AttributeValue("type").Contains(":")) { AddXsdDataType(attributeElementMetadata, attributeType.AttributeValue("type")); if (string.IsNullOrEmpty(attributeName)) { attributeName = attribute.AttributeValue("ref"); } } } } if (!string.IsNullOrEmpty(attribute.AttributeValue("fixed"))) { attributeElementMetadata.FixedValue = attribute.AttributeValue("fixed"); } string newTrail = $"{parentTrail}/{attributeName}"; attributeElementMetadata.XName = attributeName; attributeElementMetadata.Name = attributeName; attributeElementMetadata.XPath = newTrail; attributeElementMetadata.ID = newTrail.Replace("/", ".").Substring(1); attributeElementMetadata.ParentElement = parentTrail.Replace("/", ".").Substring(1); attributeElementMetadata.MaxOccurs = 1; if (attribute.AttributeValue("optional") != null) { attributeElementMetadata.MinOccurs = 0; } else { attributeElementMetadata.MinOccurs = 1; } attributeElementMetadata.Type = ElementType.Attribute; if (allElements.ContainsKey(attributeElementMetadata.ID)) { attributeElementMetadata.ID += _randomGen.Next(); } allElements.Add(attributeElementMetadata.ID, attributeElementMetadata); AddSchemaReferenceInformation(currentComplexType, attributeElementMetadata); } }
/// <summary> /// Recursive handling of all class /// </summary> /// <param name="classes">The classes</param> /// <param name="parentElement">The parent Element</param> private void CreateModelFromMetadataRecursive(Dictionary <string, string> classes, ElementMetadata parentElement) { List <ElementMetadata> referredTypes = new List <ElementMetadata>(); if (classes.ContainsKey(parentElement.TypeName)) { return; } StringBuilder classBuilder = new StringBuilder(); classBuilder.AppendLine("public class " + parentElement.TypeName + "{"); foreach (KeyValuePair <string, ElementMetadata> element in _serviceMetadata.Elements.Where(ele => ele.Value.ParentElement == parentElement.ID)) { string nullableString = element.Value.MinOccurs == 0 ? "?" : string.Empty; if (element.Value.Type == ElementType.Field) { string dataType = GetPropertyTypeFromXsdType(element.Value.XsdValueType.Value); WriteRestrictionAnnotations(classBuilder, element.Value); if (element.Value.IsTagContent) { classBuilder.AppendLine(" [XmlText()]"); } else { classBuilder.AppendLine(" [XmlElement(\"" + element.Value.XName + "\")]"); } if (element.Value.MaxOccurs > 1) { classBuilder.AppendLine("public List<" + dataType + "> " + element.Value.Name + " { get; set; }"); } else { classBuilder.AppendLine("public " + dataType + (dataType == "string" ? string.Empty : nullableString) + " " + element.Value.Name + " { get; set; }"); } } else if (element.Value.Type == ElementType.Group) { WriteRestrictionAnnotations(classBuilder, element.Value); classBuilder.AppendLine(" [XmlElement(\"" + element.Value.XName + "\")]"); if (element.Value.MaxOccurs > 1) { classBuilder.AppendLine("public List<" + element.Value.TypeName + "> " + element.Value.Name + " { get; set; }"); } else { classBuilder.AppendLine("public " + element.Value.TypeName + " " + element.Value.Name + " { get; set; }"); } referredTypes.Add(element.Value); } else if (element.Value.Type == ElementType.Attribute) { string dataType = "string"; if (element.Value.XsdValueType != null) { dataType = GetPropertyTypeFromXsdType(element.Value.XsdValueType.Value); } WriteRestrictionAnnotations(classBuilder, element.Value); classBuilder.AppendLine(" [XmlAttribute(\"" + element.Value.XName + "\")]"); if (element.Value.FixedValue != null) { // This value is fixed so model will ignore any values posted from use. Bind Never prevents MVC Binding classBuilder.AppendLine(" [BindNever]"); if (dataType.Equals("string")) { classBuilder.AppendLine("public " + dataType + " " + element.Value.Name + " {get; set; } = \"" + element.Value.FixedValue + "\";"); } else { classBuilder.AppendLine("public " + dataType + " " + element.Value.Name + " {get; set;} = " + element.Value.FixedValue + ";"); } } else { classBuilder.AppendLine("public " + dataType + " " + element.Value.Name + " { get; set; }"); } } } classBuilder.AppendLine("}"); if (!classes.ContainsKey(parentElement.TypeName)) { classes.Add(parentElement.TypeName, classBuilder.ToString()); } foreach (ElementMetadata refType in referredTypes) { CreateModelFromMetadataRecursive(classes, refType); } }
private void WriteRestrictionAnnotations(StringBuilder classBuilder, ElementMetadata element) { string errorMessage = string.Empty; if (element.Texts.ContainsKey(TextCategoryType.Error.ToString())) { errorMessage = ", ErrorMessage = \"" + element.Texts[TextCategoryType.Error.ToString()] + "\""; } bool hasRange = false; if (element.Restrictions.Count > 0) { if (element.Restrictions.ContainsKey("minLength")) { classBuilder.AppendLine("[MinLength(" + element.Restrictions["minLength"].Value + errorMessage + ")]"); } if (element.Restrictions.ContainsKey("maxLength")) { classBuilder.AppendLine("[MaxLength(" + element.Restrictions["maxLength"].Value + errorMessage + ")]"); } if (element.Restrictions.ContainsKey("minInclusive") && element.Restrictions.ContainsKey("maxInclusive")) { classBuilder.AppendLine("[Range(" + element.Restrictions["minInclusive"].Value + ", " + element.Restrictions["maxInclusive"].Value + errorMessage + ")]"); hasRange = true; } if (element.Restrictions.ContainsKey("pattern")) { classBuilder.AppendLine("[RegularExpression(@\"" + element.Restrictions["pattern"].Value + "\"" + errorMessage + ")]"); } } if (element.IsReadOnly) { classBuilder.AppendLine(" [BindNever]"); } if (!element.XsdValueType.HasValue || hasRange) { return; } switch (element.XsdValueType.Value) { // case BaseValueType.Decimal: // classBuilder.AppendLine("[Range(Decimal.MinValue,Decimal.MaxValue)]"); // break; case BaseValueType.Double: classBuilder.AppendLine("[Range(Double.MinValue,Double.MaxValue" + errorMessage + ")]"); break; case BaseValueType.Int: case BaseValueType.Integer: classBuilder.AppendLine("[Range(Int32.MinValue,Int32.MaxValue" + errorMessage + ")]"); break; case BaseValueType.NegativeInteger: classBuilder.AppendLine("[Range(Int32.MinValue,-1" + errorMessage + ")]"); break; case BaseValueType.NonPositiveInteger: classBuilder.AppendLine("[Range(Int32.MinValue,0" + errorMessage + ")]"); break; case BaseValueType.PositiveInteger: classBuilder.AppendLine("[Range(1,Int32.MaxValue" + errorMessage + ")]"); break; } }
private void WriteRestrictions(Dictionary <string, Restriction> restrictions, XElement restriction, ElementMetadata elementMetadata) { if (restriction == null) { return; } var xsdDataType = restriction.AttributeValue("base"); if (!xsdDataType.StartsWith("xsd:") && !xsdDataType.StartsWith("xs:")) { var baseType = GetSimpleTypeByNameAttribute(xsdDataType); var baseRestriction = baseType.Element(XDocName.Restriction); WriteRestrictions(restrictions, baseRestriction, elementMetadata); // handle xs:list if (baseType.Element(XDocName.List) != null) { var listItem = baseType.Element(XDocName.List); string itemType = listItem.AttributeValue("itemType"); baseType = GetSimpleTypeByNameAttribute(itemType); baseRestriction = baseType.Element(XDocName.Restriction); WriteRestrictions(restrictions, baseRestriction, elementMetadata); } } else { if ((xsdDataType != null) && xsdDataType.Contains(":")) { AddXsdDataType(elementMetadata, xsdDataType); } } var length = restriction.Element(XDocName.Length).AttributeValue("value"); if (!string.IsNullOrEmpty(length)) { CreateOrUpdateRestriction(restrictions, "length", length); } var minLength = restriction.Element(XDocName.MinLength).AttributeValue("value"); if (!string.IsNullOrEmpty(minLength)) { CreateOrUpdateRestriction(restrictions, "minLength", minLength); } var maxLength = restriction.Element(XDocName.MaxLength).AttributeValue("value"); if (!string.IsNullOrEmpty(maxLength)) { CreateOrUpdateRestriction(restrictions, "maxLength", maxLength); } var minInclusive = restriction.Element(XDocName.MinInclusive).AttributeValue("value"); if (!string.IsNullOrEmpty(minInclusive)) { CreateOrUpdateRestriction(restrictions, "minInclusive", minInclusive); } var maxInclusive = restriction.Element(XDocName.MaxInclusive).AttributeValue("value"); if (!string.IsNullOrEmpty(maxInclusive)) { CreateOrUpdateRestriction(restrictions, "maxInclusive", maxInclusive); } var totalDigits = restriction.Element(XDocName.TotalDigits).AttributeValue("value"); if (!string.IsNullOrEmpty(totalDigits)) { restrictions.Add("totalDigits", new Restriction { Value = totalDigits }); } var pattern = restriction.Element(XDocName.Pattern).AttributeValue("value"); if (!string.IsNullOrEmpty(pattern)) { CreateOrUpdateRestriction(restrictions, "pattern", pattern); } var enumerations = restriction.Elements(XDocName.Enumeration); if ((enumerations != null) && (enumerations.Count() > 0)) { var enums = string.Empty; foreach (var enumeration in enumerations) { enums += enumeration.AttributeValue("value") + ";"; } restrictions.Add("enumeration", new Restriction { Value = enums }); } }