/// <summary> /// Takes a given child element (aChildElement) and parent constraint (aParentTemplateConstraint) and steps through the Children of the parent constraint /// to determine if any siblings of the child element exist. /// </summary> /// <param name="aChildElement">Target element that we need to locate siblings for</param> /// <param name="aParentTemplateConstraint">Parent Constraint of the aChildElement</param> /// <param name="aParentElement">Parent Element for the aChildElement</param> /// <param name="aAddedConstraints">Constraints that have already been added to the child collection, we don't need to parse these.</param> static private void AddSiblingElements(DocumentTemplateElement aChildElement, IConstraint aParentTemplateConstraint, DocumentTemplateElement aParentElement, Dictionary <DocumentTemplateElement, IConstraint> aConstraintMap) { //look at parent to get the siblings if (aParentTemplateConstraint.Children != null) { DocumentTemplateElement parsedElement = null; DocumentTemplateElementAttribute parsedAttribute = null; //walk through the siblings foreach (var sibling in aParentTemplateConstraint.Children) { //have we already added this constraint in a previous iteration (e.g. it's on the main path from the leaf to the root) if (sibling.IsBranchIdentifier && !aConstraintMap.ContainsValue(sibling)) { //parse the context var cp = new ContextParser(sibling.Context); cp.Parse(out parsedElement, out parsedAttribute); //is this an element or an attribute? if ((parsedElement != null) && (!string.IsNullOrEmpty(parsedElement.ElementName))) { parsedElement.IsBranchIdentifier = sibling.IsBranchIdentifier; parsedElement.IsBranch = sibling.IsBranch; //element, let's add it to the parent element's children so it becomes a sibling of aChildElement parsedElement.Value = sibling.Value; aParentElement.AddElement(parsedElement); AddBranchedAttributes(parsedElement, sibling); aConstraintMap.Add(parsedElement, sibling); } } } } }
public ContextBuilder(DocumentTemplateElement aElement, string prefix, bool aIsBranch = false, bool aIncludeLeafElement = false) { _element = aElement; _prefix = prefix; _isBranch = aIsBranch; _includeLeafElement = aIncludeLeafElement; }
public void GenerateSchematronAssertion_NestedElement_WithAttribute_ConformanceSHALL_CardinalityOneToOne() { var addrElement = new DocumentTemplateElement("addr"); var useAttr = new DocumentTemplateElementAttribute("use", "HP"); addrElement.AddAttribute(useAttr); var element = new DocumentTemplateElement("state"); var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3") .AddElement(new DocumentTemplateElement("recordTarget") .AddElement(new DocumentTemplateElement("patientRole") .AddElement(addrElement) .AddElement(element))); //need to have cardinality on both parent and child elements? //how do we tell it to generate cda: on context as in below? var cardinality = CardinalityParser.Parse("1..1"); var builder = new AssertionLineBuilder(this.tdb, element, this.igType, this.igTypeSchema).WithCardinality(cardinality).ConformsTo(Conformance.SHALL).WithinContext(@"cda:"); var assertion = builder.ToString(); var expectedAssertion = @"count(cda:state)=1"; Assert.IsTrue(assertion == expectedAssertion, "Assertion string was not correct. Expected '{0}', Actual '{1}'.", expectedAssertion, assertion); var contextBuilder = new ContextBuilder(useAttr, "cda"); var context = contextBuilder.GetRelativeContextString(); var expectedContext = "cda:addr[@use='HP']"; Assert.IsTrue(context == expectedContext, "Context is not correct. Expected '{0}', Actual '{1}'", expectedContext, context); }
private AssertionLineBuilder CreateAssertionLineBuilderForAttribute(DocumentTemplateElement aParentElement, DocumentTemplateElementAttribute aAttribute, ref string aParentContext, ref IConstraint aConstraint) { AssertionLineBuilder asb = null; if ((aParentElement != null) && (aConstraint.Parent.IsBranch)) { asb = CreateAssertionLineBuilderForElement(aParentElement, aConstraint.Parent, ref aParentContext); aConstraint = aConstraint.Parent; } else { asb = new AssertionLineBuilder(this.tdb, aAttribute, this.igType, this.igTypeSchema); if (aConstraint.Parent != null) { Cardinality cardinality = CardinalityParser.Parse(aConstraint.Parent.Cardinality); if (cardinality.Left == 0) { asb.HasOptionalParentContext(); } } } return(asb); }
public void GenerateSchematronAssertion_NestedElement_WithAttribute_NULLFlavor_ConformanceSHALL_CardinalityOneToOne() { var idElement = new DocumentTemplateElement("id"); var nullFlavorAttribute = new DocumentTemplateElementAttribute("nullFlavor", "NI"); idElement.AddAttribute(nullFlavorAttribute); var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3"); cdaDocumentTemplate.AddElement(new DocumentTemplateElement("component") .AddElement(new DocumentTemplateElement("section") .AddElement(new DocumentTemplateElement("entry") .AddElement(new DocumentTemplateElement("organizer") .AddElement(new DocumentTemplateElement("performer") .AddElement(new DocumentTemplateElement("assignedEntity") .AddElement(idElement))))))); var builder = new AssertionLineBuilder(this.tdb, nullFlavorAttribute, this.igType, this.igTypeSchema); builder.ConformsTo(ConformanceParser.Parse("SHALL")).WithCardinality(CardinalityParser.Parse("1..1")).WithinContext("cda:"); var assertion = builder.ToString(); var expectedAssertion = @"cda:id[@nullFlavor='NI']"; Assert.IsTrue(assertion == expectedAssertion, "Assertion string was not correct. Expected '{0}', Actual '{1}'.", expectedAssertion, assertion); var contextBuilder = new ContextBuilder(idElement.ParentElement, "cda"); var context = contextBuilder.GetRelativeContextString(); var expectedContext = "cda:assignedEntity"; Assert.IsTrue(context == expectedContext, "Context is not correct. Expected '{0}', Actual '{1}'", expectedContext, context); }
static public void AddElementValueAndDataType(string aPrefix, DocumentTemplateElement aElement, IConstraint aTemplateConstraint) { if (!string.IsNullOrEmpty(aTemplateConstraint.Value)) { if (!string.IsNullOrEmpty(aTemplateConstraint.ValueConformance)) { var valueConformanceType = ConformanceParser.Parse(aTemplateConstraint.ValueConformance); var conformanceType = ConformanceParser.Parse(aTemplateConstraint.Conformance); if (valueConformanceType == conformanceType) { aElement.Value = !string.IsNullOrEmpty(aTemplateConstraint.Value) ? aTemplateConstraint.Value.Trim() : aTemplateConstraint.Value; } } else { aElement.Value = !string.IsNullOrEmpty(aTemplateConstraint.Value) ? aTemplateConstraint.Value.Trim() : aTemplateConstraint.Value; } } // Add the data type attribute if one is present on the constraint if (!string.IsNullOrEmpty(aTemplateConstraint.DataType)) { if (aPrefix == "cda") { if (aElement.ElementName != "code") { DocumentTemplateElementAttribute dataTypeAttr = new DocumentTemplateElementAttribute("xsi:type"); dataTypeAttr.SingleValue = aTemplateConstraint.DataType; aElement.AddAttribute(dataTypeAttr); } } } }
static public DocumentTemplateElement CreateParentElementForAttribute(IConstraint aConstraint, DocumentTemplateElementAttribute aAttribute) { DocumentTemplateElement parentElement = null; // Is there a parent constraint that should be used as a context if (aConstraint.Parent != null && !string.IsNullOrEmpty(aConstraint.Parent.Context) && !aConstraint.Parent.IsBranch) { if ((aAttribute != null) && (aAttribute.Element == null)) //we have an attribute, but no element attached. the parent constraint would then be the element. { parentElement = new DocumentTemplateElement(aConstraint.Parent.Context); if (aConstraint.Parent.IsBranch) { parentElement.AddAttribute(aAttribute); } } else if ((aAttribute != null) && (aAttribute.Element != null) && (aConstraint.Parent.Context != aAttribute.Element.ElementName)) //we have an attribute, with an element attached, but the element does not match the parent context { parentElement = new DocumentTemplateElement(aConstraint.Parent.Context); parentElement.AddElement(aAttribute.Element); } else if (aAttribute != null && aAttribute.Element != null) { parentElement = aAttribute.Element; } } return(parentElement); }
public void GenerateSchematronAssertion_Element_With_Value_And_AttributeOverride_ConformanceSHALL_CardinalityOneToOne() { //create cda doc var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3"); //create code element var element = new DocumentTemplateElement("statusCode", "Test"); element.ElementToAttributeOverrideMapping.Add("statusCode", "code"); element.ElementToAttributeOverrideMapping.Add("code", "code"); //add element to doc cdaDocumentTemplate.AddElement(element); //create schematron assertion line builder var builder = new AssertionLineBuilder(this.tdb, element, this.igType, this.igTypeSchema); //define cardinality and conformance var cardinality = CardinalityParser.Parse("1..1"); var conformance = ConformanceParser.Parse("SHALL"); //add element (context comes from doc), conformance, cardinality through fluent interface builder.ConformsTo(conformance).WithCardinality(cardinality); //generate string string assertion = builder.ToString(); //did we generate the correct string? Assert.IsTrue(assertion == @"count(cda:statusCode[@code='Test'])=1", "The generated assertion was not correct. Expected 'count(cda:statusCode[@code='Test'])=1', Actual '{0}'.", assertion); }
/// <summary> /// If the template constraint is a branch then add the appropriate attributes to the element passed in. /// </summary> /// <param name="aElement"> /// Element to create the attributes on /// </param> /// <param name="aTemplateConstraint"> /// Constraint to evaluate /// </param> static public void CheckForBranchedAttributes(DocumentTemplateElement aElement, IConstraint aTemplateConstraint) { if (aTemplateConstraint.IsBranch || aTemplateConstraint.IsBranchIdentifier) //add attributes { AddBranchedAttributes(aElement, aTemplateConstraint); } }
public AssertionLineBuilder WithinContext(DocumentTemplateElement aContextElement, ContextWrapper aWrapper = ContextWrapper.Bracket) { var contextBuilder = new ContextBuilder(aContextElement, this._prefix); _context = contextBuilder.ToString(); _contextWrapper = aWrapper; return(this); }
/// <summary> /// Builds the full context from the given aTemplateConstraint forward. If the given aTemplateConstraint has a parent context then this will be built also, /// using the aPerspectiveConstraint. aPerspectiveConstraint is always the constraint we are requesting the context for. This ensures that we only traverse /// the perspective's children 1 time. /// </summary> /// <param name="aPrefix"></param> /// <param name="aTemplateConstraint"></param> /// <param name="aPerspectiveConstraint"></param> /// <param name="aIgnoreParent">Specifies whether to walk the the parent tree</param> /// <returns></returns> private string CreateFullBranchedParentContext(TemplateConstraint aTemplateConstraint, TemplateConstraint aPerspectiveConstraint = null, bool aIgnoreParent = false, bool isTarget = false) { string constraintParentContext = string.Empty; if (aTemplateConstraint.Parent != null && !aIgnoreParent) { constraintParentContext = CreateFullBranchedParentContext(aTemplateConstraint.ParentConstraint, aTemplateConstraint); } DocumentTemplateElement element = null; DocumentTemplateElementAttribute attribute = null; ContextParser parser = new ContextParser(aTemplateConstraint.Context); parser.Parse(out element, out attribute); if (attribute != null) //we are only looking for attributes { attribute.SingleValue = aTemplateConstraint.Value; } if (element != null) { element.IsBranch = aTemplateConstraint.IsBranch; element.IsBranchIdentifier = aTemplateConstraint.IsBranchIdentifier; ConstraintToDocumentElementHelper.AddElementValueAndDataType(this.prefix, element, aTemplateConstraint); } ContextBuilder builder = ContextBuilder.CreateFromElementAndAttribute(element, attribute, this.prefix); StringBuilder childStrings = new StringBuilder(); foreach (var child in aTemplateConstraint.ChildConstraints) { if (aPerspectiveConstraint == null || aPerspectiveConstraint.Id != child.Id) //since we call ourselves recursively, this ensures we only go down the path of the original caller once. { if (child.IsBranchIdentifier == true) { childStrings.Append(CreateFullBranchedParentContext(child, aIgnoreParent: true)); } } } string context = builder.GetFullyQualifiedContextString() + childStrings; if (element != null && aTemplateConstraint.Parent != null) { if (element.IsBranchIdentifier) { context = "[" + context + "]"; } else { context = "/" + context; } } return(constraintParentContext + context); }
public AssertionLineBuilder(IObjectRepository tdb, DocumentTemplateElement aElement, ImplementationGuideType igType, SimpleSchema igTypeSchema, string prefix = null) : this(tdb, igType, igTypeSchema, igType.SchemaPrefix) { _element = aElement; if (!string.IsNullOrEmpty(prefix)) { this._prefix = prefix; } }
public void TestCDADocumentTemplate_WithValidNamespace_SingleRootElement_RootElementCountIsOne() { var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3"); var element = new DocumentTemplateElement("code"); cdaDocumentTemplate.AddElement(element); Assert.IsNotNull(cdaDocumentTemplate.ChildElements, "cdaDocumentTemplate.RootElements is null, expected instance."); Assert.AreEqual(cdaDocumentTemplate, element.Template, "CDA Document Template was not set on the element properly."); Assert.IsTrue(cdaDocumentTemplate.ChildElements.Count == 1, "Root element count failed, expected 1, actual {0}", cdaDocumentTemplate.ChildElements.Count); }
private string CreateParentContextForElement(DocumentTemplateElement aParentElement, DocumentTemplateElement aElement, IConstraint aConstraint) { string parentContext = string.Empty; if (aConstraint.Parent != null && !aConstraint.Parent.IsBranch) { parentContext = ConstraintToDocumentElementMapper.CreateFullParentContext(this.prefix, aConstraint); } return(parentContext); }
/// <summary> /// Helper function which creates an AssertionLineBuilder for an element given the constraint. This function will examine the constraint's value and datatype /// and add those to the builder if necessary. Also if aGenerateContext == true then it will add the context of the element. /// </summary> /// <param name="aElement">Element to base the AssertionLineBuilder from</param> /// <param name="aTemplateConstraint">TemplateConstraint which has the necessary properties (e.g. Element Value, Data Type) to add to the AssertionLineBuilder</param> /// <param name="aGenerateContext">Flag to determine whether a context should be added as part of the AssertionLineBuilder</param> /// <returns>A new AssertionLineBuilder for the aElement passed in</returns> private AssertionLineBuilder CreateAssertionLineBuilderForElement(DocumentTemplateElement aElement, IConstraint aTemplateConstraint, ref string aParentContext, bool aGenerateContext = true) { //add the value and data type ConstraintToDocumentElementHelper.AddElementValueAndDataType(this.prefix, aElement, aTemplateConstraint); //create builders var builder = new AssertionLineBuilder(this.tdb, aElement, this.igType, this.igTypeSchema); if (aGenerateContext) { ContextBuilder contextBuilder = null; if (aElement.ParentElement != null) //build the context { contextBuilder = new ContextBuilder(aElement.ParentElement, this.prefix); //the context will start from the first parent (or root) builder.WithinContext(string.Format("{0}", contextBuilder.GetFullyQualifiedContextString())); } } var containedTemplates = (from tcr in aTemplateConstraint.References join t in this.allTemplates on tcr.ReferenceIdentifier equals t.Oid where tcr.ReferenceType == ConstraintReferenceTypes.Template select new { Identifier = t.Oid, t.PrimaryContextType }); foreach (var containedTemplate in containedTemplates) { builder.ContainsTemplate(containedTemplate.Identifier, containedTemplate.PrimaryContextType); if (aTemplateConstraint.Parent != null && aTemplateConstraint.Parent.IsBranch) { builder.WithinContext(aParentContext, ContextWrapper.Slash); //put the parent context into the element context, this is a special case where we want the full context within the template assertion aParentContext = string.Empty; //clear the parent context b/c we have put it within the element's context } } if (aTemplateConstraint.Parent != null) { Conformance conformance = ConformanceParser.Parse(aTemplateConstraint.Parent.Conformance); if (conformance == Conformance.SHOULD) { builder.HasOptionalParentContext(); } } //TODO: Refactor this out, hardcoding these special cases for QRDA if (this.prefix.ToLower().Contains("cda")) { aElement.ElementToAttributeOverrideMapping.Add("code", "code"); aElement.ElementToAttributeOverrideMapping.Add("statusCode", "code"); aElement.ElementToAttributeOverrideMapping.Add("realmCode", "code"); aElement.ElementToAttributeOverrideMapping.Add("externalDocument", "classCode"); } return(builder); }
/// <summary> /// Uses back-tracing algorithm to go backwards through the tree /// Helper function which builds the full parent context for a given template constraint. For example, for the template constraint @code with cda:entryRelationship/cda:observation/cda:code[@code] /// this function returns the cda:entryRelationship/cda:observation/cda:code. /// </summary> /// <param name="aElement">current element to start from</param> /// <param name="aTemplateConstraint">constraint which will have its parent chain walked to form path</param> /// <param name="aIncludeElementInPath">determines whether we start the path with the element passed in (true) or its parent (false)</param> /// <returns>full context string</returns> public static string CreateFullParentContext(string aPrefix, IConstraint aTemplateConstraint) { if (aTemplateConstraint == null) { return(string.Empty); } DocumentTemplateElement firstElement = null; DocumentTemplateElement newElement = null; DocumentTemplateElement previousElement = null; DocumentTemplateElementAttribute newAttribute = null; IConstraint currentConstraint = aTemplateConstraint.Parent; while (currentConstraint != null) { //parse the context to determine whether this is element or attribute var contextParser = new ContextParser(currentConstraint.Context); contextParser.Parse(out newElement, out newAttribute); newElement.Attributes.Clear(); if (currentConstraint.IsBranch) //if we hit a branch then we stop b/c we are in the branch's context { break; } if (newElement == null) { break; //there is a broken chain, we have null parent } //add value and data type (if present) ConstraintToDocumentElementHelper.AddElementValueAndDataType(aPrefix, newElement, currentConstraint); //chain the previous element to the child collection of this new one if (previousElement != null) { newElement.AddElement(previousElement); } //get the leaf node if (firstElement == null) { firstElement = newElement; } previousElement = newElement; //walk the parent chain currentConstraint = currentConstraint.Parent; } if (firstElement == null) { return(string.Empty); } else { var contextBuilder = new ContextBuilder(firstElement, aPrefix); return(contextBuilder.GetFullyQualifiedContextString()); } }
public void GenerateContext_SingleElement_Namespace() { var element = new DocumentTemplateElement("code"); var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3"); cdaDocumentTemplate.AddElement(element); var contextBuilder = new ContextBuilder(element, "ems"); var context = contextBuilder.GetRelativeContextString(); var expected = "ems:code"; Assert.IsTrue(context == expected, "Single element did not generate proper context, expected '{0}', actual '{0}'", expected, context); }
public void ParseElementAndAttribute() { string context = "code/@code"; DocumentTemplateElement element = null; DocumentTemplateElementAttribute attribute = null; var parser = new ContextParser(context); parser.Parse(out element, out attribute); Assert.IsNotNull(element, "No element was passed back from the parser."); Assert.IsTrue(element.ElementName == "code", "Element name was incorrect. Expected 'code', Actual '{0}'", element.ElementName); Assert.IsNotNull(attribute, "No attribute was passed back from the parser."); Assert.IsTrue(attribute.AttributeName == "code", "Element name was incorrect. Expected 'code', Actual '{0}'", attribute.AttributeName); }
public void TestCDADocumentTemplate_WithValidNamespace_SingleChildElement_SingleChildElement_ChildCountIsOne() { var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3"); var element = new DocumentTemplateElement("author"); Assert.IsNotNull(element.ChildElements, "element.ChildElements is null, expected instance"); element.AddElement(new DocumentTemplateElement("assignedPerson")); cdaDocumentTemplate.AddElement(element); Assert.IsNotNull(cdaDocumentTemplate.ChildElements, "cdaDocumentTemplate.RootElements is null, expected instance."); Assert.IsTrue(cdaDocumentTemplate.ChildElements.Count == 1, "Root element count failed, expected 1, actual {0}", cdaDocumentTemplate.ChildElements.Count); Assert.IsTrue(cdaDocumentTemplate.ChildElements[0].ChildElements.Count == 1, "Child element count failed, expected 1, actual {0}", cdaDocumentTemplate.ChildElements[0].ChildElements.Count); Assert.AreEqual(cdaDocumentTemplate.ChildElements[0].ChildElements[0].ParentElement, cdaDocumentTemplate.ChildElements[0], "Child element parent was not set properly."); }
public static ContextBuilder CreateFromElementAndAttribute(DocumentTemplateElement aElement, DocumentTemplateElementAttribute aAttribute, string aNameSpace) { if (aAttribute != null) { return(new ContextBuilder(aAttribute, aNameSpace)); } if (aElement != null) { return(new ContextBuilder(aElement, aNameSpace)); } throw new ArgumentException("Must provide a DocumentTemplate Element or an Attribute."); }
/// <summary> /// Checks parent to see if IsBranch attribute is set. If true then adds the sibling elements. /// </summary> /// <param name="aChildElement">Target element that we need to locate siblings for</param> /// <param name="aParentTemplateConstraint">Parent Constraint of the aChildElement</param> /// <param name="aParentElement">Parent Element for the aChildElement</param> /// <param name="aAddedConstraints">Constraints that have already been added to the child collection, we don't need to parse these.</param> static public void CheckForBranchedSiblingElements(DocumentTemplateElement aChildElement, DocumentTemplateElement aParentElement, IConstraint aParentTemplateConstraint, Dictionary <DocumentTemplateElement, IConstraint> aConstraintMap) { if ((aChildElement == null) || (aParentElement == null) || (aParentTemplateConstraint == null)) { return; } if (aParentTemplateConstraint.IsBranch || aParentTemplateConstraint.IsBranchIdentifier) { AddSiblingElements(aChildElement, aParentTemplateConstraint, aParentElement, aConstraintMap); } }
public void ParseMultipleElements() { string context = "entry/observation"; DocumentTemplateElement element = null; DocumentTemplateElementAttribute attribute = null; var parser = new ContextParser(context); parser.Parse(out element, out attribute); Assert.IsNotNull(element, "No element was passed back from the parser."); Assert.IsTrue(element.ElementName == "observation", "Element name was incorrect. Expected 'observation', Actual '{0}'", element.ElementName); Assert.IsNotNull(element.ParentElement, "No parent element was passed back from the parser."); Assert.IsTrue(element.ParentElement.ElementName == "entry", "Element name was incorrect. Expected 'entry', Actual '{0}'", element.ElementName); Assert.IsNull(attribute, "An attribute was passed back from the parser. Exected null."); }
public void GenerateContext_SingleChildElement_2Levels() { var administrativeCodeElement = new DocumentTemplateElement("administrativeGenderCode"); administrativeCodeElement.AddAttribute(new DocumentTemplateElementAttribute("code", "20", string.Empty, "MMG-GENDER-CODE-OID")); var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3"); cdaDocumentTemplate.AddElement(new DocumentTemplateElement("recordTarget") .AddElement(administrativeCodeElement)); var contextBuilder = new ContextBuilder(administrativeCodeElement, "cda"); var context = contextBuilder.GetFullyQualifiedContextString(); var expected = "cda:recordTarget/cda:administrativeGenderCode[@code='20']"; Assert.IsFalse(string.IsNullOrEmpty(context), "Null or empty string returned by context builder"); Assert.IsTrue(context == expected, "Context string was not correct, expected '{0}', actual '{1}'", expected, context); }
private string BuildStringForSiblingElements(DocumentTemplateElement aElement) { var sb = new StringBuilder(); if (aElement.ParentElement != null) { foreach (var sibling in aElement.ParentElement.ChildElements) { if (sibling != aElement) { sb.Append(BuildSingleSiblingElementString(sibling)); } } } return(sb.ToString()); }
public void GenerateContext_SingleElementChildElement_2Levels_SingleAttribute() { var element = new DocumentTemplateElement("assignedPerson"); var attribute = new DocumentTemplateElementAttribute("classCode", "ASSIGNED"); element.AddAttribute(attribute); var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3"); cdaDocumentTemplate.AddElement(new DocumentTemplateElement("custodian") .AddElement(element)); var contextBuilder = new ContextBuilder(attribute, "cda"); var context = contextBuilder.GetRelativeContextString(); var expected = "cda:assignedPerson[@classCode='ASSIGNED']"; Assert.IsFalse(string.IsNullOrEmpty(context), "Null or empty string returned by context builder"); Assert.IsTrue(context == expected, "Context string was not correct, expected '{0}', actual '{1}'", expected, context); }
private string BuildSingleSiblingElementString(DocumentTemplateElement aElement) { var elementAndAttributeString = string.Format("{0}{1}", aElement.ElementName, BuildStringForAttributes(aElement.Attributes)); if (!string.IsNullOrEmpty(elementAndAttributeString)) { if (elementAndAttributeString.IndexOf(':') < 0) { return(string.Format("[{0}:{1}]", _prefix, elementAndAttributeString)); } else if (!string.IsNullOrEmpty(elementAndAttributeString)) { return(string.Format("[{0}]", elementAndAttributeString)); } } return(string.Empty); }
public void Parse(out DocumentTemplateElement aContextElement, out DocumentTemplateElementAttribute aAttribute) { aContextElement = null; //default aAttribute = null; //default var parsedContext = _context.Split('/'); if (parsedContext.Length > 1) //does the context contain a complex element structure (e.g. code/@code) { DocumentTemplateElement parentContextElement = null; for (int i = 0; i < parsedContext.Length; i++) { if (IsAttribute(parsedContext[i])) { aAttribute = new DocumentTemplateElementAttribute(parsedContext[i].Replace("@", "")); aContextElement.AddAttribute(aAttribute); } else { aContextElement = new DocumentTemplateElement(parsedContext[i]); if (parentContextElement != null) { parentContextElement.AddElement(aContextElement); } } parentContextElement = aContextElement; } } else { if (IsAttribute(_context)) { aAttribute = new DocumentTemplateElementAttribute(_context.Replace("@", "")); } else { aContextElement = new DocumentTemplateElement(_context); } } }
public void GenerateSchematronAssertion_Element_With_Value_ConformanceSHALL_CardinalityOneToOne() { //create cda doc var cdaDocumentTemplate = new DocumentTemplate("urn:hl7-org:v3"); //create code element var element = new DocumentTemplateElement("code", "Test"); //add element to doc cdaDocumentTemplate.AddElement(element); //create schematron assertion line builder var builder = new AssertionLineBuilder(element, templateIdentifierXpath, templateVersionIdentifierXpath, "cda"); //define cardinality and conformance var cardinality = CardinalityParser.Parse("1..1"); var conformance = ConformanceParser.Parse("SHALL"); //add element (context comes from doc), conformance, cardinality through fluent interface builder.ConformsTo(conformance).WithCardinality(cardinality); //generate string string assertion = builder.ToString(); //did we generate the correct string? Assert.IsTrue(assertion == @"count(cda:code[translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')='test'])=1", "The generated assertion was not correct. Expected 'count(cda:code[text()='Test'])=1', Actual '{0}'.", assertion); }
/// <summary> /// Helper method which steps through the children for a given constraint (aTemplateConstraint) and attaches any attributes to the /// given element (aElement)). /// </summary> /// <param name="aElement">Element to add the attributes to</param> /// <param name="aTemplateConstraint">Constraint to walk the children to find attributes</param> static private void AddBranchedAttributes(DocumentTemplateElement aElement, IConstraint aTemplateConstraint) { if (aTemplateConstraint.Children != null) { DocumentTemplateElement parsedElement = null; DocumentTemplateElementAttribute parsedAttribute = null; foreach (var child in aTemplateConstraint.Children) { var cp = new ContextParser(child.Context); cp.Parse(out parsedElement, out parsedAttribute); if (parsedElement != null) { parsedElement.IsBranch = child.IsBranch; parsedElement.IsBranchIdentifier = child.IsBranchIdentifier; } if (parsedAttribute != null) //we are only looking for attributes { parsedAttribute.SingleValue = child.Value; aElement.AddAttribute(parsedAttribute); } } } }
public void GenerateSchematronAssertion_Element_ValueSet_SVS_ConformanceSHALL_CardinalityOneToOne() { var element = new DocumentTemplateElement("administrativeGenderCode"); //create schematron assertion line builder, build one at a time (regular interface, see above for fluent interface) var builder = new AssertionLineBuilder(this.tdb, element, this.igType, this.igTypeSchema); //define cardinality var cardinality = CardinalityParser.Parse("1..1"); //add cardinality for the element builder.WithCardinality(cardinality); //define conformance var conformance = ConformanceParser.Parse("SHALL"); //add conformance for the element builder.ConformsTo(conformance); builder.WithinValueSet("4.3.2.1", VocabularyOutputType.SVS_SingleValueSet); //generate string string assertion = builder.ToString(); //did we generate the correct string? string expected = @"count(cda:administrativeGenderCode[@code=document('4.3.2.1.xml')/svs:RetrieveValueSetResponse/svs:ValueSet[@id='4.3.2.1']/svs:ConceptList/svs:Concept/@code])=1"; Assert.IsTrue(assertion == expected, "Assertion string was not correct. Expected '{0}', Actual '{1}'.", expected, assertion); }