public SimplifiedSchemaObject(SimplifiedSchemaObject parent, XmlSchemaElement element)
{
this.Name = element.Name;
this.Type = Shared.SimplifiedSchemaObjectType.Element;
this.Parent = parent;
string minOccurs = element.MinOccurs.ToString();
string maxOccurs = element.MaxOccurs.ToString();
this.Cardinality = string.Format("{0}..{1}",
minOccurs != "79228162514264337593543950335" ? minOccurs : "*",
maxOccurs != "79228162514264337593543950335" ? maxOccurs : "*");
if (this.Cardinality == "0..0")
{
this.Conformance = "SHALL NOT";
}
else if (this.Cardinality.StartsWith("0.."))
{
this.Conformance = "MAY";
}
else if (this.Cardinality.StartsWith("1.."))
{
this.Conformance = "SHALL";
}
if (element.ElementSchemaType != null && !string.IsNullOrEmpty(element.ElementSchemaType.Name))
{
this.DataType = Helper.GetDataTypeName(element.ElementSchemaType.Name);
this.Mixed = element.ElementSchemaType.IsMixed;
}
}
/// <summary>
/// Because of the performance hit involved in recursively checking each parent node to determine if it
/// is a recursively recurring element, IsRecurring is used to determine if the type in question is
/// actually a recurring type. When building complex types, the types that recursively occur
/// are added to a list, and the list is checked first when the actual document's elements are being built.
/// This reduces the number of times we have to recursively check parent nodes for re-occurance.
/// </summary>
public bool IsRecurring(SimplifiedSchemaObject parent, string compareName, string compareDataType)
{
if (this.recurringTypes.Contains(compareDataType))
{
compareName = !string.IsNullOrEmpty(compareName) ? compareName : null;
compareDataType = !string.IsNullOrEmpty(compareDataType) ? compareDataType : null;
return(CheckRecursivelyRecurring(parent, compareName, compareDataType));
}
return(false);
}
private SimplifiedSchemaObject FindOrAddComplexType(XmlQualifiedName complexTypeName)
{
string simpleComplexTypeName = Helper.GetDataTypeName(complexTypeName.Name);
SimplifiedSchemaObject foundComplexType = this.ComplexTypes.SingleOrDefault(y => y.Name == simpleComplexTypeName);
if (foundComplexType == null)
{
XmlSchemaComplexType schemaComplexType = this.schema.SchemaTypes[complexTypeName] as XmlSchemaComplexType;
foundComplexType = new SimplifiedSchemaObject(schemaComplexType);
this.ComplexTypes.Add(foundComplexType);
InitializeChildren(schemaComplexType, foundComplexType, true);
return(foundComplexType);
}
return(foundComplexType);
}
public SimplifiedSchemaObject GetObjectFromString(string uniqueString)
{
string[] contextSplit = uniqueString.Split('/');
SimplifiedSchemaObject lastFoundObject = null;
foreach (string cContext in contextSplit)
{
if (string.IsNullOrEmpty(cContext))
{
continue;
}
string cActualContext = cContext;
string cActualDataType = string.Empty;
if (this.uniqueStringContextRegex.IsMatch(cContext))
{
Match uniqueStringMatch = this.uniqueStringContextRegex.Match(cContext);
cActualContext = uniqueStringMatch.Groups[1].Value;
cActualDataType = uniqueStringMatch.Groups[2].Value;
}
List <SimplifiedSchemaObject> searchChildren = this.Children;
if (lastFoundObject != null)
{
searchChildren = lastFoundObject.Children;
}
if (cActualContext.StartsWith("@"))
{
lastFoundObject = searchChildren.SingleOrDefault(y => y.Name == cActualContext.Substring(1) && y.IsAttribute);
}
else
{
lastFoundObject = searchChildren.SingleOrDefault(y => y.Name == cActualContext);
}
if (lastFoundObject == null)
{
return(null);
}
}
return(lastFoundObject);
}
private void InitializeLevel(SimplifiedSchemaObject parent, XmlSchemaElement currentSchemaElement, bool initializingComplexType)
{
string currentName = currentSchemaElement.Name;
string currentDataType = currentSchemaElement.ElementSchemaType != null?Helper.GetDataTypeName(currentSchemaElement.ElementSchemaType.Name) : string.Empty;
// If we are initializing a complex type, we should check the complex type to se if it is recursively used. If so, add it to the recurring types.
// Otherwise, use the IsRecurring method to improve performance by only checking for known recurring types
if (initializingComplexType)
{
if (CheckRecursivelyRecurring(parent, currentName, currentDataType))
{
this.recurringTypes.Add(currentDataType);
return;
}
}
else
{
if (IsRecurring(parent, currentName, currentDataType))
{
return;
}
}
SimplifiedSchemaObject newElement = new SimplifiedSchemaObject(parent, currentSchemaElement);
if (currentSchemaElement.SchemaTypeName != null)
{
newElement.BaseComplexType = FindOrAddComplexType(currentSchemaElement.SchemaTypeName);
}
if (parent == null)
{
Children.Add(newElement);
}
else
{
parent.Children.Add(newElement);
}
if (newElement.BaseComplexType == null)
{
InitializeChildren(currentSchemaElement.ElementSchemaType as XmlSchemaComplexType, newElement, initializingComplexType);
}
}
private bool CheckRecursivelyRecurring(SimplifiedSchemaObject parent, string compareName, string compareDataType)
{
if (parent == null)
{
return(false);
}
string currentName = !string.IsNullOrEmpty(parent.Name) ? parent.Name : null;
string currentDataType = !string.IsNullOrEmpty(parent.DataType) ? parent.DataType : null;
if (currentName == compareName && currentDataType == compareDataType)
{
return(true);
}
if (CheckRecursivelyRecurring(parent.Parent, compareName, compareDataType))
{
return(true);
}
return(false);
}
public SimplifiedSchema GetSchemaFromContext(ContextTypes contextType, string context)
{
SimplifiedSchemaObject foundObject = null;
if (contextType == ContextTypes.ComplexType)
{
foundObject = GetFromComplexType(context);
}
else if (contextType == ContextTypes.XPath)
{
foundObject = GetFromXpath(context);
}
if (foundObject != null)
{
SimplifiedSchema schema = new SimplifiedSchema();
schema.Children.Add(foundObject);
return(schema);
}
return(null);
}
public SimplifiedSchemaObject(SimplifiedSchemaObject parent, XmlSchemaAttribute attribute)
{
this.Name = attribute.Name;
this.Type = SimplifiedSchemaObjectType.Attribute;
this.Parent = parent;
this.Value = attribute.DefaultValue;
this.FixedValue = attribute.FixedValue;
if (attribute.Use == XmlSchemaUse.Prohibited)
{
this.Conformance = "SHALL NOT";
this.Cardinality = "0..0";
}
else if (attribute.Use == XmlSchemaUse.Required || !string.IsNullOrEmpty(FixedValue))
{
this.Conformance = "SHALL";
this.Cardinality = "1..1";
}
else
{
this.Conformance = "MAY";
this.Cardinality = "0..1";
}
if (attribute.SchemaTypeName != null && !string.IsNullOrEmpty(attribute.SchemaTypeName.Name))
{
if (attribute.SchemaTypeName.Name.Contains("."))
{
this.DataType = attribute.SchemaTypeName.Name.Substring(attribute.SchemaTypeName.Name.LastIndexOf(".") + 1);
}
else
{
this.DataType = attribute.SchemaTypeName.Name;
}
}
}
private SimplifiedSchemaObject GetFromXpath(string xpath)
{
string[] xpathParts = xpath.Split('/');
SimplifiedSchemaObject current = null;
foreach (string cXpathPart in xpathParts)
{
if (current == null)
{
current = this.Children.SingleOrDefault(y => y.Name.ToLower() == cXpathPart);
}
else
{
current = current.Children.SingleOrDefault(y => y.Name.ToLower() == cXpathPart);
}
if (current == null)
{
return(null);
}
}
return(null);
}
private void InitializeChildren(XmlSchemaComplexType complexType, SimplifiedSchemaObject element, bool initializingComplexType)
{
if (complexType == null)
{
return;
}
XmlSchemaComplexContentRestriction restriction = complexType.ContentModel != null ? complexType.ContentModel.Content as XmlSchemaComplexContentRestriction : null;
XmlSchemaComplexContentExtension extension = complexType.ContentModel != null ? complexType.ContentModel.Content as XmlSchemaComplexContentExtension : null;
XmlSchemaObjectCollection baseAttributes = null;
if (restriction != null)
{
baseAttributes = restriction.Attributes;
}
else if (extension != null)
{
baseAttributes = extension.Attributes;
}
if (baseAttributes != null)
{
foreach (XmlSchemaObject cObject in baseAttributes)
{
XmlSchemaAttribute cAttribute = cObject as XmlSchemaAttribute;
if (cAttribute != null)
{
element.Children.Add(
new SimplifiedSchemaObject(element, cAttribute));
}
}
}
foreach (XmlSchemaObject cObject in complexType.Attributes)
{
XmlSchemaAttribute cAttribute = cObject as XmlSchemaAttribute;
if (cAttribute != null)
{
element.Children.Add(
new SimplifiedSchemaObject(element, cAttribute));
}
}
//if (element.ToString() == "ClinicalDocument/recordTarget/patientRole")
// Console.WriteLine("Test");
if (complexType.ContentTypeParticle is XmlSchemaSequence)
{
XmlSchemaSequence sequence = complexType.ContentTypeParticle as XmlSchemaSequence;
foreach (XmlSchemaObject cObject in sequence.Items)
{
// Check here if this element's name is the same as it's parent or grand-parents
XmlSchemaElement cElement = cObject as XmlSchemaElement;
XmlSchemaChoice cChoice = cObject as XmlSchemaChoice;
if (cElement != null)
{
InitializeLevel(element, cElement, initializingComplexType);
}
else if (cChoice != null)
{
foreach (XmlSchemaObject cChoiceObject in cChoice.Items)
{
XmlSchemaElement cChoiceElement = cChoiceObject as XmlSchemaElement;
if (cChoiceElement != null)
{
InitializeLevel(element, cChoiceElement, initializingComplexType);
}
}
}
}
}
}