Example #1
0
 private void HandleQualifier(XmlElement element, CodedTypeR2 <Code> codedType, ParseContext context, XmlToModelResult result
                              )
 {
     if (QualifierAllowed())
     {
         ParseContext newContext = ParseContextImpl.Create("CR", typeof(Code), context);
         XmlNodeList  qualifiers = element.GetElementsByTagName("qualifier");
         for (int i = 0, length = qualifiers.Count; i < length; i++)
         {
             XmlElement qualifierElement = (XmlElement)qualifiers.Item(i);
             // only want direct child node qualifiers
             if (qualifierElement.ParentNode.Equals(element))
             {
                 BareANY anyCr = new CrR2ElementParser().Parse(newContext, qualifierElement, result);
                 if (anyCr != null && anyCr.BareValue != null)
                 {
                     codedType.Qualifier.Add((CodeRole)anyCr.BareValue);
                 }
             }
         }
     }
     else
     {
         ValidateUnallowedChildNode(context.Type, element, result, "qualifier");
     }
 }
Example #2
0
        private void HandleConstraints(CodedTypeR2 <Code> codedType, ConstrainedDatatype constraints, XmlElement element, Hl7Errors
                                       errors)
        {
            ErrorLogger logger = new _ErrorLogger_127(errors, element);

            this.constraintsHandler.HandleConstraints(constraints, codedType, logger);
        }
Example #3
0
        private void HandleCodeAndCodeSystem(XmlElement element, CodedTypeR2 <Code> codedType, ParseContext context, XmlToModelResult
                                             result)
        {
            string code       = GetAttributeValue(element, STANDARD_CODE_ATTRIBUTE_NAME);
            string codeSystem = null;

            if (element.HasAttribute(CODE_SYSTEM_ATTRIBUTE_NAME))
            {
                if (CodeSystemAllowed())
                {
                    codeSystem = StringUtils.TrimToNull(GetAttributeValue(element, CODE_SYSTEM_ATTRIBUTE_NAME));
                }
                else
                {
                    LogValueNotAllowed(CODE_SYSTEM_ATTRIBUTE_NAME, element, context, result);
                }
            }
            //MBR-335: In some cases we have fixed values that are not part of the generated API and that have
            //values that do not conform to the expected return type. In this case, just fake up a value as
            //it will be discarded later in HL7SourceMapper. See PolicyActivity.GuarantorPerformerAssignedEntity
            //in ccda r1_1 message set for an example. i.e. GUAR is not a valid RoleClass
            bool relaxCodeCheck = context.IsFixedValue();
            Code actualCode     = this.codeLookupUtils.GetCorrespondingCode(code, codeSystem, context.GetExpectedReturnType(), element, context
                                                                            .Type, result, true, relaxCodeCheck);

            codedType.Code = actualCode;
        }
Example #4
0
        public static object ConvertCodedTypeR2(CodedTypeR2 <Code> source, Type parameterType)
        {
            if (source == null)
            {
                return(null);
            }
            Type codedType    = typeof(CodedTypeR2 <>);
            Type baseCodeType = typeof(Code);
            Type genericType;

            if (!baseCodeType.IsAssignableFrom(parameterType))
            {
                genericType = codedType.MakeGenericType(baseCodeType);
            }
            else
            {
                genericType = codedType.MakeGenericType(parameterType);
            }
            object result = Activator.CreateInstance(genericType);

            genericType.GetProperty("Code").SetValue(result, source.Code, null);
            genericType.GetProperty("CodeSystemName").SetValue(result, source.CodeSystemName, null);
            genericType.GetProperty("CodeSystemVersion").SetValue(result, source.CodeSystemVersion, null);
            genericType.GetProperty("DisplayName").SetValue(result, source.DisplayName, null);
            genericType.GetProperty("NullFlavorForTranslationOnly").SetValue(result, source.NullFlavorForTranslationOnly, null);
            genericType.GetProperty("OriginalText").SetValue(result, source.OriginalText, null);
            genericType.GetProperty("Qualifier").SetValue(result, source.Qualifier, null);
            genericType.GetProperty("Translation").SetValue(result, source.Translation, null);
            genericType.GetProperty("SimpleValue").SetValue(result, source.SimpleValue, null);
            genericType.GetProperty("Operator").SetValue(result, source.Operator, null);
            genericType.GetProperty("Value").SetValue(result, source.Value, null);
            genericType.GetProperty("ValidTime").SetValue(result, source.ValidTime, null);
            genericType.GetProperty("Qty").SetValue(result, source.Qty, null);
            return(result);
        }
Example #5
0
        public virtual void TestValidFull()
        {
            Interval <PlatformDate> interval = IntervalFactory.CreateLowHigh <PlatformDate>(new DateWithPattern(DateUtil.GetDate(2006,
                                                                                                                                 11, 25), "yyyyMMdd"), new DateWithPattern(DateUtil.GetDate(2007, 0, 2), "yyyyMMdd"));
            CodedTypeR2 <Code> translation1 = new CodedTypeR2 <Code>();

            translation1.Code = CeRxDomainTestValues.KILOGRAM;
            CodedTypeR2 <Code> translation2 = new CodedTypeR2 <Code>();

            translation2.Code = CeRxDomainTestValues.FLUID_OUNCE;
            CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>();

            codedType.Code              = CeRxDomainTestValues.CENTIMETRE;
            codedType.CodeSystemName    = "aCodeSystemName";
            codedType.CodeSystemVersion = "aCodeSystemVersion";
            codedType.DisplayName       = "aDisplayName";
            codedType.Translation.Add(translation1);
            codedType.Translation.Add(translation2);
            codedType.ValidTime = interval;
            EncapsulatedData originalText = new EncapsulatedData();

            originalText.Content   = "some original text";
            codedType.OriginalText = originalText;
            string result = new HxitCeR2PropertyFormatter().Format(GetContext("name", "HXIT<CE>"), new CE_R2Impl <Code>(codedType));

            Assert.IsTrue(this.result.IsValid());
            AssertXml("result", "<name code=\"cm\" codeSystem=\"1.2.3.4\" codeSystemName=\"aCodeSystemName\" codeSystemVersion=\"aCodeSystemVersion\" displayName=\"aDisplayName\">"
                      + "<originalText>some original text</originalText>" + "<translation code=\"kg\" codeSystem=\"1.2.3.4\"/>" + "<translation code=\"[foz_br]\" codeSystem=\"1.2.3.4\"/>"
                      + "<validTime><low value=\"20061225\"/><high value=\"20070102\"/></validTime>" + "</name>", StringUtils.Trim(result), true
                      );
        }
Example #6
0
        public virtual void TestGetCodeValidArgument()
        {
            CodedTypeR2 <UnitsOfMeasureCaseSensitive> codedType = new CodedTypeR2 <UnitsOfMeasureCaseSensitive>();

            codedType.Code = Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive.CUP;
            Assert.AreEqual(codedType.Code, CodedTypeR2Helper.GetCode(codedType));
        }
Example #7
0
 private void HandleOriginalText(XmlElement element, CodedTypeR2 <Code> codedType, ParseContext context, XmlToModelResult result
                                 )
 {
     if (OriginalTextAllowed())
     {
         IList <XmlElement> originalTextElements = GetNamedElements("originalText", element);
         if (originalTextElements.Count > 0)
         {
             if (originalTextElements.Count > 1)
             {
                 RecordError("Only one original text element is allowed.", element, context, result);
             }
             ParseContext newContext         = ParseContextImpl.Create("ED", context);
             BareANY      parsedOriginalText = this.edParser.Parse(newContext, originalTextElements[0], result);
             if (parsedOriginalText != null)
             {
                 codedType.OriginalText = (EncapsulatedData)parsedOriginalText.BareValue;
             }
         }
     }
     else
     {
         ValidateUnallowedChildNode(context.Type, element, result, "originalText");
     }
 }
Example #8
0
        public virtual void TestFormatPhysicalQuantityValidWithTranslations()
        {
            CodedTypeR2 <Code> translation1 = new CodedTypeR2 <Code>();

            translation1.Code = Ca.Infoway.Messagebuilder.Domainvalue.Payload.AdministrativeGender.MALE;
            CodedTypeR2 <Code> translation2 = new CodedTypeR2 <Code>();

            translation2.Code = Ca.Infoway.Messagebuilder.Domainvalue.Controlact.ActStatus.ACTIVE;
            string quantity = "33.45";

            Ca.Infoway.Messagebuilder.Domainvalue.UnitsOfMeasureCaseSensitive unit = CeRxDomainTestValues.ENZYME_UNIT_MICROMOLES_MINUTE_PER_LITRE;
            PhysicalQuantity physicalQuantity = new PhysicalQuantity();

            physicalQuantity.Quantity = new BigDecimal(quantity);
            physicalQuantity.Unit     = unit;
            physicalQuantity.Translation.Add(translation1);
            physicalQuantity.Translation.Add(translation2);
            IDictionary <string, string> result = new PqR2PropertyFormatterTest.TestablePqR2PropertyFormatter().GetAttributeNameValuePairsForTest
                                                      (CreateContext("PQ"), physicalQuantity, null);

            Assert.AreEqual(2, result.Count, "map size");
            Assert.IsTrue(result.ContainsKey("value"), "key as expected");
            Assert.AreEqual(quantity, result.SafeGet("value"), "value");
            Assert.IsTrue(result.ContainsKey("unit"), "unit key as expected");
            Assert.AreEqual(unit.CodeValue, result.SafeGet("unit"), "unit");
            string xml = new PqR2PropertyFormatterTest.TestablePqR2PropertyFormatter().Format(CreateContext("PQ"), new PQImpl(physicalQuantity
                                                                                                                              ), 0);

            AssertXml("should see translations", "<name unit=\"U/L\" value=\"33.45\"><translation code=\"M\" codeSystem=\"2.16.840.1.113883.5.1\" displayName=\"Male\"/><translation code=\"active\" codeSystem=\"2.16.840.1.113883.5.14\" displayName=\"Active\"/></name>"
                      , xml);
        }
Example #9
0
        public virtual void TestEverythingSpecified()
        {
            CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>();

            codedType.Code              = CeRxDomainTestValues.CENTIMETRE;
            codedType.CodeSystemName    = "aCodeSystemName";
            codedType.CodeSystemVersion = "aCodeSystemVersion";
            codedType.DisplayName       = "aDisplayName";
            codedType.SimpleValue       = "simpleValue";
            codedType.Operator          = SetOperator.CONVEX_HULL;
            codedType.Value             = BigDecimal.ONE;
            codedType.Translation.Add(new CodedTypeR2 <Code>());
            codedType.Qualifier.Add(new CodeRole());
            EncapsulatedData originalText = new EncapsulatedData();

            originalText.Content   = "some original text";
            codedType.OriginalText = originalText;
            CV_R2 <Code> cv     = new CV_R2Impl <Code>(codedType);
            string       result = new CvR2PropertyFormatter().Format(GetContext("name", "CV"), cv);

            Assert.IsFalse(this.result.IsValid());
            Assert.AreEqual(5, this.result.GetHl7Errors().Count);
            AssertXml("result", "<name code=\"cm\" codeSystem=\"1.2.3.4\" codeSystemName=\"aCodeSystemName\" codeSystemVersion=\"aCodeSystemVersion\" displayName=\"aDisplayName\"><originalText>some original text</originalText></name>"
                      , StringUtils.Trim(result), true);
        }
Example #10
0
        public virtual void TestEverythingSpecified()
        {
            CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>();

            codedType.Code           = CeRxDomainTestValues.CENTIMETRE;
            codedType.CodeSystemName = "aCodeSystemName";
            // Doesn't appear in the output, but shouldn't log an error either
            codedType.CodeSystemVersion = "aCodeSystemVersion";
            codedType.DisplayName       = "aDisplayName";
            // Doesn't appear in the output, but shouldn't log an error either
            codedType.SimpleValue = "simpleValue";
            codedType.Operator    = SetOperator.CONVEX_HULL;
            codedType.Value       = BigDecimal.ONE;
            codedType.Translation.Add(new CodedTypeR2 <Code>());
            codedType.Qualifier.Add(new CodeRole());
            EncapsulatedData originalText = new EncapsulatedData();

            originalText.Content   = "original text not allowed for CS";
            codedType.OriginalText = originalText;
            CS_R2 <Code> cs     = new CS_R2Impl <Code>(codedType);
            string       result = new CsR2PropertyFormatter().Format(GetContext("name", "CS"), cs);

            Assert.IsFalse(this.result.IsValid());
            Assert.AreEqual(7, this.result.GetHl7Errors().Count);
            Assert.AreEqual("<name code=\"cm\"/>", StringUtils.Trim(result), "result");
        }
Example #11
0
        public virtual void TestValidFull()
        {
            CodedTypeR2 <Code> translation1 = new CodedTypeR2 <Code>();

            translation1.Code = CeRxDomainTestValues.KILOGRAM;
            CodedTypeR2 <Code> translation2 = new CodedTypeR2 <Code>();

            translation2.Code = CeRxDomainTestValues.FLUID_OUNCE;
            CodedTypeR2 <Code> translation3 = new CodedTypeR2 <Code>();

            translation3.Code = new _Code_62();
            translation3.NullFlavorForTranslationOnly = Ca.Infoway.Messagebuilder.Domainvalue.Nullflavor.NullFlavor.OTHER;
            CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>();

            codedType.Code              = CeRxDomainTestValues.CENTIMETRE;
            codedType.CodeSystemName    = "aCodeSystemName";
            codedType.CodeSystemVersion = "aCodeSystemVersion";
            codedType.DisplayName       = "aDisplayName";
            codedType.Translation.Add(translation1);
            codedType.Translation.Add(translation2);
            codedType.Translation.Add(translation3);
            EncapsulatedData originalText = new EncapsulatedData();

            originalText.Content   = "some original text";
            codedType.OriginalText = originalText;
            string result = new CeR2PropertyFormatter().Format(GetContext("name", "CE"), new CE_R2Impl <Code>(codedType));

            Assert.IsTrue(this.result.IsValid());
            AssertXml("result", "<name code=\"cm\" codeSystem=\"1.2.3.4\" codeSystemName=\"aCodeSystemName\" codeSystemVersion=\"aCodeSystemVersion\" displayName=\"aDisplayName\">"
                      + "<originalText>some original text</originalText>" + "<translation code=\"kg\" codeSystem=\"1.2.3.4\"/>" + "<translation code=\"[foz_br]\" codeSystem=\"1.2.3.4\"/>"
                      + "<translation codeSystem=\"1.2.3.4\" nullFlavor=\"OTH\"/>" + "</name>", StringUtils.Trim(result), true);
        }
Example #12
0
        public override BareANY Parse(ParseContext context, XmlNode node, XmlToModelResult result)
        {
            BareANY            codedTypeAny = DoCreateR2DataTypeInstance(context);
            XmlElement         element      = (XmlElement)node;
            CodedTypeR2 <Code> codedType    = new CodedTypeR2 <Code>();

            // attributes
            HandleNullFlavor(element, codedTypeAny, context, result);
            HandleCodeAndCodeSystem(element, codedType, context, result);
            HandleCodeSystemName(element, codedType, context, result);
            HandleCodeSystemVersion(element, codedType, context, result);
            HandleDisplayName(element, codedType, context, result);
            HandleValue(element, codedType, context, result);
            HandleQty(element, codedType, context, result);
            HandleOperator(element, codedTypeAny, codedType, context, result);
            // elements
            HandleSimpleValue(element, codedType, context, result);
            HandleOriginalText(element, codedType, context, result);
            HandleQualifier(element, codedType, context, result);
            HandleTranslation(element, codedType, context, result);
            HandleValidTime(element, codedType, context, result);
            HandleConstraints(codedType, context.GetConstraints(), element, result);
            // want to return null if no attributes or elements are present
            if (codedType.IsEmpty())
            {
                codedType = null;
            }
            ((BareANYImpl)codedTypeAny).BareValue = CodedTypeR2Helper.ConvertCodedTypeR2(codedType, context.GetExpectedReturnType());
            return(codedTypeAny);
        }
Example #13
0
 private void HandleTranslation(XmlElement element, CodedTypeR2 <Code> codedType, ParseContext context, XmlToModelResult result
                                )
 {
     if (TranslationAllowed())
     {
         // we have no knowledge of what domain the translation may belong to (I imagine code system could allow for a reverse lookup at some point)
         ParseContext newContext   = ParseContextImpl.Create("CD", typeof(Code), context);
         XmlNodeList  translations = element.GetElementsByTagName("translation");
         for (int i = 0, length = translations.Count; i < length; i++)
         {
             XmlElement translationElement = (XmlElement)translations.Item(i);
             // only want direct child node translations
             if (translationElement.ParentNode.Equals(element))
             {
                 CodedTypeR2 <Code> parsedTranslation = ParseTranslation(translationElement, newContext, result);
                 if (parsedTranslation != null)
                 {
                     codedType.Translation.Add(parsedTranslation);
                 }
             }
         }
     }
     else
     {
         ValidateUnallowedChildNode(context.Type, element, result, "translation");
     }
 }
Example #14
0
        private void HandleConstraints(CodedTypeR2 <Code> codedType, ConstrainedDatatype constraints, string propertyPath, Hl7Errors
                                       errors)
        {
            ErrorLogger logger = new _ErrorLogger_109(errors, propertyPath);

            this.constraintsHandler.HandleConstraints(constraints, codedType, logger);
        }
Example #15
0
        private string FormatValue(FormatContext context, CodedTypeR2 <Code> value, int indentLevel)
        {
            FormatContext newContext = new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl("CD", Ca.Infoway.Messagebuilder.Xml.ConformanceLevel
                                                                                                                 .OPTIONAL, Cardinality.Create("0-1"), "value", context);

            return(this.cdFormatter.Format(newContext, new CD_R2Impl <Code>(value), indentLevel));
        }
Example #16
0
        public virtual void TestPassingConstraints()
        {
            CodedTypeR2 <Code>  codedType   = CreateCodedType();
            ConstrainedDatatype constraints = CreateConstraints(true);

            this.constraintsHandler.HandleConstraints(constraints, codedType, this.errorLogger);
            Assert.IsTrue(this.errors.IsEmpty());
        }
Example #17
0
        private void HandleConstraints(Code code, ConstrainedDatatype constraints, XmlElement element, Hl7Errors errors)
        {
            // only code/codeSystem passed to constraints handler for now (only qualifier and codeSystem are currently checked for constraints)
            CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>(code);
            ErrorLogger        logger    = new _ErrorLogger_79(errors, element);

            this.constraintsHandler.HandleConstraints(constraints, codedType, logger);
        }
Example #18
0
        private bool HasChildContent(CodedTypeR2 <Code> codedType, FormatContext context)
        {
            bool hasChildContent = (OriginalTextAllowed() && HasOriginalText(codedType));

            hasChildContent |= (QualifierAllowed() && HasQualifier(codedType));
            hasChildContent |= (TranslationAllowed() && HasTranslation(codedType));
            hasChildContent |= (ValidTimeAllowed() && HasValidTime(codedType));
            return(hasChildContent);
        }
Example #19
0
        public virtual void TestMissingQualifierPassesWhenQualifier0To1()
        {
            ConstrainedDatatype constraints = CreateConstraints(false);
            CodedTypeR2 <Code>  codedType   = CreateCodedType();

            codedType.Qualifier.Clear();
            this.constraintsHandler.HandleConstraints(constraints, codedType, this.errorLogger);
            Assert.IsTrue(this.errors.IsEmpty());
        }
Example #20
0
 private void CreateChildContent(CodedTypeR2 <Code> codedType, FormatContext context, int indentLevel, StringBuilder result
                                 )
 {
     HandleOriginalText(codedType, indentLevel, result, context);
     HandleQualifier(codedType, indentLevel, result, context);
     HandleTranslation(codedType, indentLevel, result, context);
     HandleValidTime(codedType, indentLevel, result, context);
     HandleSimpleValue(codedType, result, context);
 }
Example #21
0
 private void HandleOperator(XmlElement element, BareANY codedTypeAny, CodedTypeR2 <Code> codedType, ParseContext context,
                             XmlToModelResult result)
 {
     // the operator is specified as defaulting to "I", but let's only allow process the attribute when not a nullFlavor (or if operator has been explicitly provided)
     if (element.HasAttribute("operator") || codedTypeAny.NullFlavor == null)
     {
         SetOperator @operator = this.operatorHelper.HandleOperator(element, context, result, new ANYImpl <object>());
         codedType.Operator = @operator;
     }
 }
Example #22
0
        public virtual void TestValidFull()
        {
            CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>();

            codedType.Code = CeRxDomainTestValues.CENTIMETRE;
            string result = new CsR2PropertyFormatter().Format(GetContext("name", "CS"), new CS_R2Impl <Code>(codedType));

            Assert.IsTrue(this.result.IsValid());
            Assert.AreEqual("<name code=\"cm\"/>", StringUtils.Trim(result), "result");
        }
Example #23
0
        public virtual void TestMissingQualifierNameCodeAndQualifierNameCodeSystem()
        {
            ConstrainedDatatype constraints = CreateConstraints(true);
            CodedTypeR2 <Code>  codedType   = CreateCodedType();

            codedType.Qualifier[0].Name = new CodedTypeR2 <Code>();
            this.constraintsHandler.HandleConstraints(constraints, codedType, this.errorLogger);
            Assert.IsTrue(this.errors.IsEmpty());
            Assert.AreEqual("121139", codedType.Qualifier[0].Name.GetCodeValue());
            Assert.AreEqual("1.2.840.10008.2.16.4", codedType.Qualifier[0].Name.GetCodeSystem());
        }
Example #24
0
        private CodedTypeR2 <Code> CreateCodedType()
        {
            Code               codeWithFixedCodeSystem = this.trivialCodeResolver.Lookup <ActStatus>(TYPE, "aCode", "1.2.840.10008.2.6.1");
            Code               name      = this.trivialCodeResolver.Lookup <ActStatus>(TYPE, "121139", "1.2.840.10008.2.16.4");
            Code               value     = this.trivialCodeResolver.Lookup <ActStatus>(TYPE, "anotherCode", "1.2.88888888");
            CodeRole           qualifier = new CodeRole(new CodedTypeR2 <Code>(name), new CodedTypeR2 <Code>(value));
            CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>(codeWithFixedCodeSystem);

            codedType.Qualifier.Add(qualifier);
            return(codedType);
        }
Example #25
0
        public virtual void TestMissingQualifierValueCodeAndCodeSystemPasses()
        {
            ConstrainedDatatype constraints = CreateConstraints(true);
            CodedTypeR2 <Code>  codedType   = CreateCodedType();

            codedType.Qualifier[0].Value = new CodedTypeR2 <Code>();
            this.constraintsHandler.HandleConstraints(constraints, codedType, this.errorLogger);
            Assert.IsTrue(this.errors.IsEmpty());
            Assert.IsNull(codedType.Qualifier[0].Value.GetCodeValue());
            Assert.IsNull(codedType.Qualifier[0].Value.GetCodeSystem());
        }
Example #26
0
 private void HandleSimpleValue(CodedTypeR2 <Code> codedType, StringBuilder result, FormatContext context)
 {
     // simpleValue (String)
     if (HasSimpleValue(codedType))
     {
         if (SimpleValueAllowed())
         {
             result.Append(XmlStringEscape.Escape(codedType.SimpleValue));
         }
     }
 }
Example #27
0
        protected override CodedTypeR2 <Code> ParseTranslation(XmlElement translationElement, ParseContext newContext, XmlToModelResult
                                                               result)
        {
            BareANY            anyResult   = new CdR2ElementParser().Parse(newContext, translationElement, result);
            CodedTypeR2 <Code> translation = anyResult == null ? null : (CodedTypeR2 <Code>)anyResult.BareValue;

            if (translation != null)
            {
                translation.NullFlavorForTranslationOnly = anyResult == null ? null : anyResult.NullFlavor;
            }
            return(translation);
        }
Example #28
0
        public virtual void TestMissingQualifierValue()
        {
            ConstrainedDatatype constraints = CreateConstraints(true);
            CodedTypeR2 <Code>  codedType   = CreateCodedType();

            codedType.Qualifier[0].Value = null;
            this.constraintsHandler.HandleConstraints(constraints, codedType, this.errorLogger);
            Assert.IsFalse(this.errors.IsEmpty());
            Assert.AreEqual(1, this.errors.Count);
            Assert.AreEqual(Hl7ErrorCode.CDA_MANDATORY_CONSTRAINT_MISSING, this.errors[0].GetHl7ErrorCode());
            Assert.IsTrue(this.errors[0].GetMessage().Contains(" qualifier.value "));
        }
        private CodedTypeR2 <ConsultDocumentType> GetLoincCode()
        {
            ConsultDocumentType code = CodeResolverRegistry.Lookup <ConsultDocumentType>(typeof(ConsultDocumentType), "11488-4", "2.16.840.1.113883.6.1");

            CodedTypeR2 <ConsultDocumentType> loincCode = new CodedTypeR2 <ConsultDocumentType>();

            loincCode.Code           = code;
            loincCode.CodeSystemName = "LOINC";
            loincCode.DisplayName    = "ConsultationNote";

            return(loincCode);
        }
Example #30
0
        public virtual void TestEverythingSpecified()
        {
            CodedTypeR2 <Code> translation1 = new CodedTypeR2 <Code>();

            translation1.Code = CeRxDomainTestValues.KILOGRAM;
            CodedTypeR2 <Code> translation2 = new CodedTypeR2 <Code>();

            translation2.Code = CeRxDomainTestValues.FLUID_OUNCE;
            CodedTypeR2 <Code> name1 = new CodedTypeR2 <Code>();

            name1.Code = CeRxDomainTestValues.CENTIMETRE;
            CodedTypeR2 <Code> name2 = new CodedTypeR2 <Code>();

            name2.Code = Ca.Infoway.Messagebuilder.Domainvalue.Payload.AdministrativeGender.MALE;
            CodedTypeR2 <Code> value1 = new CodedTypeR2 <Code>();

            value1.Code = Ca.Infoway.Messagebuilder.Domainvalue.Controlact.ActStatus.NORMAL;
            CodedTypeR2 <Code> value2 = new CodedTypeR2 <Code>();

            value2.Code = Ca.Infoway.Messagebuilder.Domainvalue.Controlact.ActClass.ACT;
            CodeRole           codeRole1 = new CodeRole(name1, value1, true);
            CodeRole           codeRole2 = new CodeRole(name2, value2, true);
            CodedTypeR2 <Code> codedType = new CodedTypeR2 <Code>();

            codedType.Code              = CeRxDomainTestValues.CENTIMETRE;
            codedType.CodeSystemName    = "aCodeSystemName";
            codedType.CodeSystemVersion = "aCodeSystemVersion";
            codedType.DisplayName       = "aDisplayName";
            codedType.SimpleValue       = "simpleValue";
            codedType.Operator          = SetOperator.CONVEX_HULL;
            codedType.Value             = BigDecimal.ONE;
            codedType.Operator          = SetOperator.INTERSECT;
            codedType.Qualifier.Add(codeRole1);
            codedType.Qualifier.Add(codeRole2);
            codedType.Translation.Add(translation1);
            codedType.Translation.Add(translation2);
            codedType.Qty = 1122;
            EncapsulatedData originalText = new EncapsulatedData();

            originalText.Content   = "some original text";
            codedType.OriginalText = originalText;
            BXIT <CodedTypeR2 <Code> > sxcm_cd = new BXITImpl <CodedTypeR2 <Code> >(codedType);
            string result = new BxitCdR2PropertyFormatter().Format(GetContext("name", "BXIT<CD>"), sxcm_cd);

            Assert.IsFalse(this.result.IsValid());
            Assert.AreEqual(3, this.result.GetHl7Errors().Count);
            AssertXml("result", "<name code=\"cm\" codeSystem=\"1.2.3.4\" codeSystemName=\"aCodeSystemName\" codeSystemVersion=\"aCodeSystemVersion\" displayName=\"aDisplayName\" qty=\"1122\">"
                      + "<originalText>some original text</originalText>" + "<qualifier inverted=\"true\"><name code=\"cm\" codeSystem=\"1.2.3.4\"/><value code=\"normal\" codeSystem=\"2.16.840.1.113883.5.14\" displayName=\"Normal\"/></qualifier>"
                      + "<qualifier inverted=\"true\"><name code=\"M\" codeSystem=\"2.16.840.1.113883.5.1\" displayName=\"Male\"/><value code=\"ACT\" codeSystem=\"2.16.840.1.113883.5.6\" displayName=\"Act\"/></qualifier>"
                      + "<translation code=\"kg\" codeSystem=\"1.2.3.4\"/>" + "<translation code=\"[foz_br]\" codeSystem=\"1.2.3.4\"/>" + "</name>"
                      , StringUtils.Trim(result), true);
        }