private void ProcessUnknownStructuralAttributes(ICollection <string> knownItems, XmlElement element, MessageVisitor visitor
)
{
XmlAttributeCollection attrs = element.Attributes;
if (attrs != null)
{
foreach (XmlNode node in new XmlNamedNodeMapIterable(attrs))
{
XmlAttribute item = (XmlAttribute)node;
if (IsIgnorable(item))
{
}
else
{
// skip it
if (!NamespaceUtil.IsHl7Node(item))
{
}
else
{
// skip it
if (!knownItems.Contains(item.Name))
{
knownItems.Add(item.Name);
// this call will intentionally fail fast with an error (since relationship is null)
visitor.VisitStructuralAttribute(element, item, null);
}
}
}
}
}
}
private void MapToTeal(Hl7Source source, BeanWrapper wrapper, Relationship relationship)
{
bool hasNullFlavor = MapNodeAttributesToTeal(source, wrapper, relationship);
IList <XmlElement> elements = NodeUtil.ToElementList(source.GetCurrentElement());
if (hasNullFlavor && elements.IsEmpty())
{
// don't bother processing/validating any further
// however, if there are elements and the association has a nullFlavor, something weird is going on so keep processing
return;
}
// 1) "elements" contains the xml-order of the current part's relationships - note that this can have duplicates at this point
// 2) "source" contains the message part being processed - this is not exposed
// 3) "source" contains the result bean where errors can be stored - this *is* exposed
// 4) need to watch choice/template cases (including choices with supertypes)
// relationship.getType() is
// - choice type (if choice)
// - null (if template)
// - or the actual type
// source.getMessagePartName() is
// - the choice option (if above was a choice)
// - the actual template type (if above was null)
// - or the actual type (which it is in all cases, really)
IList <string> xmlElementNamesInProvidedOrder = new List <string>();
List <Relationship> sortedRelationshipsMatchingUpToXmlElementNames = new List <Relationship>();
IDictionary <string, string> resolvedRelationshipNames = new Dictionary <string, string>();
int length = elements.Count;
for (int j = 0; j < length; j++)
{
XmlElement element = elements[j];
string nodeName = NodeUtil.GetLocalOrTagName(element);
IList <XmlNode> nodes = new List <XmlNode>();
nodes.Add(element);
while (j + 1 < length && IsSameElementName(element, elements[j + 1]))
{
nodes.Add(elements[++j]);
}
if (NamespaceUtil.IsHl7Node(element))
{
Relationship xmlRelationship = source.GetRelationship(nodeName);
if (xmlRelationship != null)
{
ValidateNamespace(element, xmlRelationship, source);
// since we have a match we know that the xml name is correct; all we need the xmlRelationship for is sorting purposes
// however, for choice and template relationships, there will be an apparent mismatch between relationship names
xmlElementNamesInProvidedOrder.Add(nodeName);
sortedRelationshipsMatchingUpToXmlElementNames.Add(xmlRelationship);
resolvedRelationshipNames[GenerateRelationshipKey(xmlRelationship)] = nodeName;
}
Process(wrapper, source, nodes, nodeName);
}
}
ValidateElementOrder(source, xmlElementNamesInProvidedOrder, sortedRelationshipsMatchingUpToXmlElementNames, resolvedRelationshipNames
);
// only do this if relationship not null and relationship not a null flavor???
ValidateMissingMandatoryNonStructuralRelationships(source, resolvedRelationshipNames);
}
private void ValidateNamespace(XmlNode node, Relationship xmlRelationship, Hl7Source source)
{
if (!NamespaceUtil.IsNamespaceCorrect(node, xmlRelationship))
{
string message = System.String.Format("Expected relationship {0}.{1} to have namespace {2} but was {3}", xmlRelationship.
ParentType, xmlRelationship.Name, NamespaceUtil.GetExpectedNamespace(xmlRelationship), NamespaceUtil.GetActualNamespace(
node));
Hl7Error hl7Error = new Hl7Error(Hl7ErrorCode.UNEXPECTED_NAMESPACE, ErrorLevel.ERROR, message, node);
source.GetResult().AddHl7Error(hl7Error);
}
}
public ModelType(string typeName)
{
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
CodeType = null;
TypeName = typeName;
DisplayName = typeName;
ShortTypeName = NamespaceUtil.GetFullTypeNameShortTypeName(typeName);
}
private bool MapNodeAttributesToTeal(Hl7Source source, BeanWrapper wrapper, Relationship relationship)
{
XmlElement currentElement = source.GetCurrentElement();
NullFlavorHelper nullFlavorHelper = new NullFlavorHelper(relationship != null ? relationship.Conformance : Ca.Infoway.Messagebuilder.Xml.ConformanceLevel
.OPTIONAL, currentElement, source.GetResult(), true);
bool hasValidNullFlavorAttribute = nullFlavorHelper.HasValidNullFlavorAttribute();
if (hasValidNullFlavorAttribute)
{
wrapper.WriteNullFlavor(source, relationship, nullFlavorHelper.ParseNullNode());
}
else
{
XmlAttributeCollection map = currentElement.Attributes;
foreach (XmlNode attributeNode in new XmlNamedNodeMapIterable(map))
{
Relationship attributeRelationship = source.GetRelationship(NodeUtil.GetLocalOrTagName(attributeNode));
if (!NamespaceUtil.IsHl7Node(attributeNode))
{
}
else
{
// quietly ignore it
if (attributeRelationship == null)
{
this.log.Info("Can't find NodeAttribute relationship named: " + attributeNode.Name);
}
else
{
ValidateNamespace(attributeNode, attributeRelationship, source);
if (attributeRelationship.HasFixedValue())
{
ValidateFixedValue(source, currentElement, (XmlAttribute)attributeNode, attributeRelationship);
}
wrapper.WriteNodeAttribute(attributeRelationship, attributeNode.Value, source.GetVersion(), source.IsR2());
}
}
ValidateMandatoryAttributesExist(source, currentElement);
}
}
return(hasValidNullFlavorAttribute);
}
private void ProcessUnknownChildElements(ICollection <string> knownItems, XmlElement element, MessageVisitor visitor)
{
IList <XmlElement> children = NodeUtil.ToElementList(element);
foreach (XmlElement child in children)
{
if (!NamespaceUtil.IsHl7Node(child))
{
}
else
{
// ignore it
string localOrTagName = NodeUtil.GetLocalOrTagName(child);
if (!knownItems.Contains(localOrTagName))
{
knownItems.Add(localOrTagName);
// this call will intentionally fail fast with an error (since relationship is null)
visitor.VisitNonStructuralAttribute(element, Arrays.AsList(child), null);
}
}
}
}
