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
});
}
}
