/// <exception cref="Ca.Infoway.Messagebuilder.Marshalling.HL7.XmlToModelTransformationException"></exception> private void HandlePersonName(XmlToModelResult xmlToModelResult, PersonName result, XmlNodeList childNodes) { foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { if (childNode is XmlElement) { XmlElement element = (XmlElement)childNode; string name = NodeUtil.GetLocalOrTagName(element); string value = GetTextValue(element, xmlToModelResult); string qualifierString = GetAttributeValue(element, NAME_PART_TYPE_QUALIFIER); EntityNamePartQualifier qualifier = CodeResolverRegistry.Lookup <EntityNamePartQualifier>(qualifierString); if (StringUtils.IsNotBlank(value)) { result.AddNamePart(new EntityNamePart(value, GetPersonalNamePartType(name), qualifier)); } } else { //GN: Added in fix similar to what was done for AD.BASIC. Issue with XML containing mixture of elements and untyped text nodes. if (IsNonBlankTextNode(childNode)) { // validation will catch if this type does not allow for a free-form name result.AddNamePart(new EntityNamePart(childNode.Value.Trim(), null)); } } } }
private Hl7Error CreateInvalidCodeError(XmlNode node, Type type, string code) { string message = "The code, \"" + code + "\", in element <" + NodeUtil.GetLocalOrTagName(node) + "> is not a valid value for domain type \"" + ClassUtils.GetShortClassName(type) + "\""; return(new Hl7Error(Hl7ErrorCode.VALUE_NOT_IN_CODE_SYSTEM, message, (XmlElement)node)); }
private PostalAddress ParseAddressPartTypes(XmlNode node, XmlToModelResult xmlToModelResult) { PostalAddress result = new PostalAddress(); XmlNodeList childNodes = node.ChildNodes; foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { if (IsNonBlankTextNode(childNode)) { string value = childNode.Value; result.AddPostalAddressPart(new PostalAddressPart(value)); } else { if (childNode is XmlElement) { XmlElement element = (XmlElement)childNode; string name = NodeUtil.GetLocalOrTagName(element); if (!"useablePeriod".Equals(name)) { PostalAddressPartType postalAddressPartType = GetPostalAddressPartType(name, element, xmlToModelResult); string value = GetTextValue(name, element, xmlToModelResult); if (postalAddressPartType != null) { result.AddPostalAddressPart(new PostalAddressPart(postalAddressPartType, value)); } } } } } return(result); }
private void ParseUseablePeriods(XmlNode node, XmlToModelResult xmlToModelResult, TelecommunicationAddress result, ParseContext context) { XmlNodeList childNodes = node.ChildNodes; foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { if (childNode is XmlElement) { XmlElement useablePeriodElement = (XmlElement)childNode; string name = NodeUtil.GetLocalOrTagName(useablePeriodElement); if ("useablePeriod".Equals(name)) { BareANY tsAny = tsR2ElementParser.Parse(TsContext(context), useablePeriodElement, xmlToModelResult); MbDate mbDate = (MbDate)tsAny.BareValue; result.AddUseablePeriod(mbDate == null ? null : mbDate.Value, ((ANYMetaData)tsAny).Operator); } else { xmlToModelResult.AddHl7Error(new Hl7Error(Hl7ErrorCode.DATA_TYPE_ERROR, "Unexpected TEL child element: \"" + useablePeriodElement .Name + "\"", useablePeriodElement)); } } } }
private IList <XmlElement> FindComponents(XmlElement element, XmlToModelResult xmlToModelResult) { IList <XmlElement> result = new List <XmlElement>(); XmlNodeList list = element.ChildNodes; if (list != null) { foreach (XmlNode node in new XmlNodeListIterable(list)) { if (node.NodeType != System.Xml.XmlNodeType.Element) { } else { // skip it if (StringUtils.Equals("comp", NodeUtil.GetLocalOrTagName((XmlElement)node))) { result.Add((XmlElement)node); } else { xmlToModelResult.AddHl7Error(new Hl7Error(Hl7ErrorCode.DATA_TYPE_ERROR, System.String.Format("Unexpected tag {0} in GTS.BOUNDEDPIVL" , XmlDescriber.DescribeSingleElement((XmlElement)node)), (XmlElement)node)); } } } } return(result); }
protected override EntityName ParseNode(XmlNode node, XmlToModelResult xmlToModelResult) { OrganizationName result = new OrganizationName(); XmlNodeList childNodes = node.ChildNodes; foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { if (childNode.NodeType == System.Xml.XmlNodeType.Text) { string value = childNode.Value; result.AddNamePart(new EntityNamePart(value)); } else { if (childNode is XmlElement) { XmlElement element = (XmlElement)childNode; string name = NodeUtil.GetLocalOrTagName(element); string value = GetTextValue(element, xmlToModelResult); result.AddNamePart(new EntityNamePart(value, GetOrganizationNamePartType(name))); } } } return(result); }
private Interval <PlatformDate> ParseValidTime(XmlElement node, ParseContext context, XmlToModelResult xmlToModelResult) { Interval <PlatformDate> validTime = null; bool foundValidTime = false; bool loggedValidTimeError = false; XmlNodeList childNodes = node.ChildNodes; foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { string childElementName = NodeUtil.GetLocalOrTagName(childNode); bool isValidTime = AbstractNameR2ElementParser <V> .VALID_TIME_ELEMENT.Equals(childElementName); if (!loggedValidTimeError && foundValidTime) { loggedValidTimeError = true; RecordError("Only one validTime is allowed, and it must come after all name parts", (XmlElement)node, xmlToModelResult); } if (childNode is XmlElement) { if (isValidTime) { foundValidTime = true; ParseContext newContext = ParseContextImpl.Create("IVL<TS>", context); BareANY ivlTsAny = this.ivlTsParser.Parse(newContext, Arrays.AsList(childNode), xmlToModelResult); if (ivlTsAny != null && ivlTsAny.BareValue != null) { DateInterval dateInterval = (DateInterval)ivlTsAny.BareValue; validTime = dateInterval == null ? null : dateInterval.Interval; } } } } return(validTime); }
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); }
protected virtual XmlNode GetNamedChildNode(XmlNode node, string childNodeName) { XmlNode result = null; XmlNodeList childNodes = node.ChildNodes; foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { if (childNodeName.Equals(NodeUtil.GetLocalOrTagName(childNode))) { result = childNode; } } return(result); }
public virtual IList <XmlElement> GetElements(Relationship relationship) { IList <XmlElement> result = new List <XmlElement>(); ICollection <string> name = GetElementNames(relationship); foreach (XmlElement element in NodeUtil.ToElementList(this.@base)) { string elementName = NodeUtil.GetLocalOrTagName(element); if (name.Contains(elementName)) { result.Add(element); } } return(result); }
protected override Ratio <N, D> ParseNonNullNode(ParseContext context, XmlNode node, BareANY parseResult, Type expectedReturnType , XmlToModelResult xmlToModelResult) { Ratio <N, D> result = new Ratio <N, D>(); IList <Hl7DataTypeName> innerTypes = Hl7DataTypeName.Create(context.Type).GetInnerTypes(); if (innerTypes.Count != 2) { // this should never happen unless a message set is incorrect; ok to abort with exception (parsing will continue after this datatype) throw new XmlToModelTransformationException("RTO data type must have two inner types. Type " + context.Type + " has " + innerTypes .Count + "."); } bool numeratorFound = false; bool denominatorFound = false; XmlNodeList childNodes = node.ChildNodes; foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { if (childNode is XmlElement) { XmlElement element = (XmlElement)childNode; string name = NodeUtil.GetLocalOrTagName(element); if ("numerator".Equals(name)) { numeratorFound = true; result.Numerator = GetNumeratorValue(element, innerTypes[0].ToString(), context, xmlToModelResult); } else { if ("denominator".Equals(name)) { denominatorFound = true; result.Denominator = GetDenominatorValue(element, innerTypes[1].ToString(), context, xmlToModelResult); } } } } if (!numeratorFound) { RecordMissingElementError("Numerator", context, node, xmlToModelResult); } if (!denominatorFound) { RecordMissingElementError("Denominator", context, node, xmlToModelResult); } return(result); }
public virtual ICollection <string> GetNames() { ICollection <string> names = new HashSet <string>(); if (IsStructuralAttribute()) { names.Add(this.relationship.Name); } else { foreach (XmlElement element in GetElements()) { names.Add(NodeUtil.GetLocalOrTagName(element)); } } return(names); }
private IList <EntityNamePart> ParseNameParts(ParseContext context, XmlNodeList childNodes, XmlToModelResult xmlToModelResult ) { IList <EntityNamePart> parts = new List <EntityNamePart>(); foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { if (childNode is XmlElement) { XmlElement element = (XmlElement)childNode; string name = NodeUtil.GetLocalOrTagName(element); if (!StringUtils.Equals(AbstractNameR2ElementParser <V> .VALID_TIME_ELEMENT, name)) { if (StringUtils.Equals("TN", context.Type)) { RecordError("TN fields only support text and a single (optional) validTime element. Found element: " + name, element, xmlToModelResult ); } else { NullFlavor nullFlavor = GetNullFlavor(element, xmlToModelResult); string value = GetTextValue(element, xmlToModelResult); EntityNamePartQualifier qualifier = GetQualifier(context, element, xmlToModelResult); if (StringUtils.IsNotBlank(value) || nullFlavor != null) { NamePartType namePartType = GetNamePartType(name, context.Type, element, xmlToModelResult); if (namePartType != null) { parts.Add(new EntityNamePart(value, namePartType, qualifier, nullFlavor)); } } } } } else { if (IsNonBlankTextNode(childNode)) { parts.Add(new EntityNamePart(childNode.Value.Trim(), null)); } } } return(parts); }
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 IList <string> CreateListOfXmlNamesInOrderProvided(XmlElement element, IList <string> properlyOrderedProvidedRelationshipNames ) { IList <string> xmlElementNamesInOrderProvided = new List <string>(); foreach (XmlElement currentXmlElement in NodeUtil.ToElementList(element)) { string elementName = NodeUtil.GetLocalOrTagName(currentXmlElement); if (properlyOrderedProvidedRelationshipNames.Contains(elementName)) { // remove consecutive dups (ignore garbage/extra in between; they will be caught later) if (xmlElementNamesInOrderProvided.IsEmpty() || !xmlElementNamesInOrderProvided[xmlElementNamesInOrderProvided.Count - 1] .Equals(elementName)) { xmlElementNamesInOrderProvided.Add(elementName); } } } return(xmlElementNamesInOrderProvided); }
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); } } } }
private PostalAddress ParseNode(XmlNode node, XmlToModelResult xmlToModelResult) { PostalAddress result = new PostalAddress(); XmlNodeList childNodes = node.ChildNodes; foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { if (IsNonBlankTextNode(childNode)) { string value = childNode.Value; result.AddPostalAddressPart(new PostalAddressPart(value)); } else { if (childNode is XmlElement) { XmlElement element = (XmlElement)childNode; string name = NodeUtil.GetLocalOrTagName(element); PostalAddressPartType postalAddressPartType = GetPostalAddressPartType(name); string value = GetTextValue(name, element, xmlToModelResult); string codeAsString = GetAttributeValue(childNode, "code"); // only for state/country string codeSystem = GetAttributeValue(childNode, "codeSystem"); // only for state/country Code code = CodeUtil.ConvertToCode(codeAsString, codeSystem); if (postalAddressPartType == null) { // error if part type not found RecordError("Address part type not valid: " + name, element, xmlToModelResult); } else { result.AddPostalAddressPart(new PostalAddressPart(postalAddressPartType, code, value)); } } } } return(result); }
protected virtual string GetOriginalText(XmlElement element) { XmlNodeList children = element.ChildNodes; string result = null; if (children != null) { foreach (XmlNode node in new XmlNodeListIterable(children)) { if (node.NodeType != System.Xml.XmlNodeType.Element) { } else { if ("originalText".Equals(NodeUtil.GetLocalOrTagName(node))) { result = NodeUtil.GetTextValue(node); } } } } return(result); }
private IDictionary <PlatformDate, SetOperator> ParseUseablePeriods(XmlElement node, ParseContext context, XmlToModelResult xmlToModelResult) { IDictionary <PlatformDate, SetOperator> useablePeriods = new Dictionary <PlatformDate, SetOperator>(); XmlNodeList childNodes = node.ChildNodes; bool foundUseablePeriod = false; bool loggedUseablePeriodError = false; foreach (XmlNode childNode in new XmlNodeListIterable(childNodes)) { string childElementName = NodeUtil.GetLocalOrTagName(childNode); bool isUseablePeriod = "useablePeriod".Equals(childElementName); if (foundUseablePeriod && !isUseablePeriod && !loggedUseablePeriodError) { loggedUseablePeriodError = true; RecordError("Useable periods must come after all address part types.", (XmlElement)node, xmlToModelResult); } if (childNode is XmlElement) { XmlElement childElement = (XmlElement)childNode; if (isUseablePeriod) { foundUseablePeriod = true; ParseContext newContext = ParseContextImpl.Create("SXCM<TS>", context); BareANY tsAny = this.tsParser.Parse(newContext, childElement, xmlToModelResult); if (tsAny != null && tsAny.BareValue != null) { SetOperator @operator = ((ANYMetaData)tsAny).Operator; MbDate ts = (MbDate)tsAny.BareValue; useablePeriods[ts.Value] = @operator; } } } } return(useablePeriods); }
private string ResolveTopmostType(Relationship relationship, XmlElement currentElement) { return(this.hl7InteractionSource.GetConversionContext().ResolveTopmostType(relationship, NodeUtil.GetLocalOrTagName(currentElement ))); }
private string GetInteractionId(XmlDocument message) { return(NodeUtil.GetLocalOrTagName(message.DocumentElement)); }
public virtual NullFlavor ParseNullNode() { string attributeValue = GetAttributeValue(node, NULL_FLAVOR_ATTRIBUTE_NAME); NullFlavor nullFlavor = CodeResolverRegistry.Lookup <NullFlavor>(attributeValue); if (ConformanceLevelUtil.IsMandatory(this.conformanceLevel, null)) { xmlToModelResult.AddHl7Error(Hl7Error.CreateMandatoryAttributeIsNullError(NodeUtil.GetLocalOrTagName((XmlElement)node), GetAttributeValue (node, NULL_FLAVOR_ATTRIBUTE_NAME), (XmlElement)node)); } else { // RM #15431 - strictly speaking, nullFlavors are not allowed for REQUIRED fields. However, jurisdictions often ignore this restriction. // FIXME: TM (see RM18424) - once MB has error levels implemented, this can be reinstated as a warning // } else if (this.conformanceLevel != null && this.conformanceLevel == ConformanceLevel.REQUIRED) { // xmlToModelResult.addHl7Error(Hl7Error.createRequiredAttributeIsNullError( // NodeUtil.getLocalOrTagName((Element) node), // getAttributeValue(node, NULL_FLAVOR_ATTRIBUTE_NAME), // (Element) node)); if (this.isAssociation && !StringUtils.Equals(GetAttributeValue(node, NULL_FLAVOR_XSI_NIL_ATTRIBUTE_NAME), "true")) { if (!Ca.Infoway.Messagebuilder.BooleanUtils.ValueOf(Runtime.GetProperty(Ca.Infoway.Messagebuilder.Marshalling.HL7.Parser.NullFlavorHelper .MB_SUPPRESS_XSI_NIL_ON_NULLFLAVOR))) { xmlToModelResult.AddHl7Error(Hl7Error.CreateNullFlavorMissingXsiNilError(NodeUtil.GetLocalOrTagName((XmlElement)node), (XmlElement )node)); } } } return(nullFlavor); }
/// <summary>Obtains the message's interaction id.</summary> /// <remarks>Obtains the message's interaction id.</remarks> /// <returns>the message's interaction id</returns> /// <exception cref="TransportLayerException">if the message's interaction id could not be determined</exception> /// <exception cref="Ca.Infoway.Messagebuilder.Transport.TransportLayerException"></exception> public virtual string GetInteractionId() { return(NodeUtil.GetLocalOrTagName(this.document.DocumentElement)); }
public virtual Hl7PartSource CreatePartSourceForSpecificType(Relationship relationship, XmlElement currentElement, string type) { string resolvedType = (type == null ? this.context.ResolveType(relationship, NodeUtil.GetLocalOrTagName(currentElement)) : type); return(new Hl7PartSource(this, resolvedType, currentElement, relationship.Type)); }
private string GetMessageIdFromDocument() { return(NodeUtil.GetLocalOrTagName(this.document.DocumentElement)); }
private bool IsSameElementName(XmlElement element, XmlElement nextElement) { return(StringUtils.Equals(element.NamespaceURI, nextElement.NamespaceURI) && StringUtils.Equals(NodeUtil.GetLocalOrTagName (element), NodeUtil.GetLocalOrTagName(nextElement))); }
private void ProcessEachRelationshipValue(Interaction interaction, RelationshipBridge relationshipBridge, MessageVisitor visitor) { foreach (XmlElement child in relationshipBridge.GetElements()) { Relationship relationship = relationshipBridge.GetRelationship(); IList <MessagePart> messageParts = GetMessageParts(relationship, interaction, NodeUtil.GetLocalOrTagName(child)); if (!messageParts.IsEmpty() && !IsNull(child)) { ProcessAllRelationships(child, interaction, messageParts, visitor); } } }
public static Ca.Infoway.Messagebuilder.Error.Hl7Error CreateUnknownChildElementError(XmlElement element) { return(new Ca.Infoway.Messagebuilder.Error.Hl7Error(Hl7ErrorCode.SYNTAX_ERROR, System.String.Format("Unknown child element \"{0}\" will be ignored." , NodeUtil.GetLocalOrTagName(element)), element)); }