private void AddMissingComplexDataTypeElements(SDTreeNode node)
{
StructureDefinition dataTypeDefinition;
ElementDefinition dataTypeRootElement;
ElementDefinition[] dataTypeChildElements;
// if is element in multi level complex type, recall context
if (multiLevelComplexTypeRevisit.ContainsKey(node))
{
dataTypeDefinition = multiLevelComplexTypeRevisit[node].ComplexDataTypeDefinition;
dataTypeRootElement = multiLevelComplexTypeRevisit[node].MultiLevelElementDefinition;
dataTypeChildElements = dataTypeDefinition.differential.element.GetChildren(dataTypeRootElement).ToArray();
}
else // else check whether is root of complex type
{
// don't expand profiles with multi choice types
if (node.GetElementDefinitionType() == null)
{
return;
}
if (node.GetElementDefinitionType().Count() != 1)
{
return;
}
ElementDefinitionType elementType = node.GetElementDefinitionType().Single();
if (elementType == null)
{
return;
}
if (!(elementType.IsComplexType() || elementType.IsReference()))
{
return;
}
// don't expand root Extension elements
if ((node.Path == "Extension") && (elementType.TypeName == "Element"))
{
return;
}
dataTypeDefinition = FhirData.Instance.FindDataTypeStructureDefinition(elementType.TypeName);
if (dataTypeDefinition == null)
{
throw new Exception("Could not find FHIR data type " + elementType.TypeName);
}
dataTypeRootElement = dataTypeDefinition.differential.element.GetRootElement();
dataTypeChildElements = dataTypeDefinition.differential.element.GetChildren(dataTypeRootElement).ToArray();
}
List <SDTreeNode> newChildren = new List <SDTreeNode>();
foreach (ElementDefinition dataTypeChildElement in dataTypeChildElements)
{
string lastPathElement = dataTypeChildElement.GetLastPathValue();
SDTreeNode[] existingChildren = node.Children.Where(t => t.LastPathElementWithoutSliceIndex == lastPathElement).ToArray();
List <SDTreeNode> currentNewChildren = new List <SDTreeNode>();
// if child or children don't exist, add the child
if (existingChildren.Length == 0)
{
SDTreeNode newChild = new SDTreeNode(dataTypeChildElement);
currentNewChildren.Add(newChild);
}
else // child or children already exists
{
foreach (SDTreeNode existingChild in existingChildren)
{
// if is a "fake" element, it needs replacing
if (existingChild.Element.IsFake)
{
SDTreeNode newChild = new SDTreeNode(dataTypeChildElement);
SDTreeNode[] childsChildren = existingChild.Children;
existingChild.RemoveAllChildren();
newChild.AddChildren(childsChildren);
currentNewChildren.Add(newChild);
}
else // keep the existing child
{
existingChild.Element.BaseElementDefinition = dataTypeChildElement;
currentNewChildren.Add(existingChild);
}
}
}
newChildren.AddRange(currentNewChildren);
// if complex data type's children have children....argh! (should only be for the Timing data type)
if (dataTypeDefinition.differential.element.GetChildren(dataTypeChildElement).Count() > 0)
{
MultiLevelComplexTypePointer multiLevelComplexTypePointer = new MultiLevelComplexTypePointer()
{
ComplexDataTypeDefinition = dataTypeDefinition,
MultiLevelElementDefinition = dataTypeChildElement
};
foreach (SDTreeNode currentChild in currentNewChildren)
{
multiLevelComplexTypeRevisit.Add(currentChild, multiLevelComplexTypePointer);
}
}
}
foreach (SDTreeNode childNode in node.Children)
{
if (newChildren.All(t => t.LastPathElement != childNode.LastPathElement))
{
newChildren.Add(childNode);
}
}
node.RemoveAllChildren();
node.AddChildren(newChildren.ToArray());
}
private object GetNonReferenceTypeName(ElementDefinitionType type)
{
return(GetDataTypeLink(type.WhenNotNull(t => t.code.value)));
}
public static bool HasExtensionProfile(this ElementDefinitionType type)
{
return(type.WhenNotNull(t => t.profile.WhenNotNull(s => s.Any())));
}
private XElement GetTypeTableCell(ElementDefinitionType[] types, SDTreeNode associatedTreeNode = null)
{
string result = string.Empty;
if (types == null)
{
if (associatedTreeNode != null)
{
ElementDefinition associatedElement = associatedTreeNode.Element;
if (associatedElement.nameReference != null)
{
if (!string.IsNullOrWhiteSpace(associatedElement.nameReference.value))
{
return(Html.Td("(see element " + associatedElement.nameReference.value + ")"));
}
}
}
return(Html.Td(string.Empty));
}
if (types.Length == 0)
{
return(Html.Td(string.Empty));
}
else if (types.Length == 1)
{
ElementDefinitionType type = types.Single();
if (type.IsReference())
{
return(Html.Td(GetReferenceTypeName(new ElementDefinitionType[] { type })));
}
else if (type.IsExtension())
{
uri profileUri = type.profile.WhenNotNull(t => t.FirstOrDefault());
if (profileUri != null)
{
StructureDefinition structureDefinition = _resourceFileSet.GetStructureDefinition(profileUri.value);
if (structureDefinition.IsComplexExtension())
{
return(Html.Td("(complex extension)"));
}
else
{
ElementDefinitionType[] elementDefinitionTypes = structureDefinition.GetSimpleExtensionType();
return(GetTypeTableCell(elementDefinitionTypes));
}
}
else
{
return(Html.Td(string.Empty));
}
}
else
{
return(Html.Td(GetNonReferenceTypeName(type)));
}
}
else
{
if (types.All(t => t.IsReference()))
{
return(Html.Td(GetReferenceTypeName(types)));
}
return(Html.Td(types.Select(t => GetNonReferenceTypeName(t)).Intersperse(" | ")));
}
}
public SDNodeType GetNodeType()
{
if (IsSetupSlice)
{
return(SDNodeType.SetupSlice);
}
ElementDefinitionType[] types = GetElementDefinitionType();
if (types != null)
{
if (types.Length == 0)
{
return(SDNodeType.Unknown);
}
else if (types.Length == 1)
{
ElementDefinitionType elementType = types.Single();
if (elementType.IsBackboneElement())
{
return(SDNodeType.Element);
}
else if (elementType.IsPrimitiveType())
{
return(SDNodeType.PrimitiveType);
}
else if (elementType.IsReference())
{
return(SDNodeType.Reference);
}
else if (elementType.IsComplexType())
{
return(SDNodeType.ComplexType);
}
else if (elementType.IsExtension())
{
if (ExtensionDefinition != null)
{
if (ExtensionDefinition.IsComplexExtension())
{
return(SDNodeType.ComplexExtension);
}
}
return(SDNodeType.SimpleExtension);
}
else if (elementType.IsResource())
{
return(SDNodeType.Resource);
}
return(SDNodeType.Unknown);
}
else
{
if (types.Any(t => t.IsReference()))
{
return(SDNodeType.Reference);
}
return(SDNodeType.Choice);
}
}
else if ((Element.PathBeforeSliceIndexing ?? string.Empty).EndsWith(".extension"))
{
// hacky but apparently only way to determine extensions within extensions
return(SDNodeType.SimpleExtension);
}
else if (Element.nameReference != null)
{
return(SDNodeType.ReferenceToAnotherElement);
}
return(SDNodeType.Unknown);
}
