private static XmlDocument Serialize(IGraphable graph)
        {
            using (var ms = new MemoryStream())
            using (var xmlWriter = XmlWriter.Create(ms, new XmlWriterSettings { Indent = true }))
            using (var xsw = new XmlStateWriter(xmlWriter))
            {
                var structureFormatter = CreateStructureFormater();
                xsw.WriteStartElement("ClinicalDocument", "urn:hl7-org:v3");
                xsw.WriteAttributeString("xmlns", "xsi", null, XmlIts1Formatter.NS_XSI);
                xsw.WriteAttributeString("xmlns", null, null, "urn:hl7-org:v3");
                xsw.WriteAttributeString("xmlns", "custom", null, CustomNamespace);
                xsw.WriteAttributeString("xsi", "type", XmlIts1Formatter.NS_XSI, "custom:ClinicalDocument");

                structureFormatter.Graph(xsw, graph);
                xsw.Close();
                ms.Seek(0, SeekOrigin.Begin);
                Debug.WriteLine(Encoding.UTF8.GetString(ms.ToArray()));
                using (var reader = new XmlTextReader(ms))
                {
                    var result = new XmlDocument();
                    result.Load(reader);
                    return result;
                }
            }
        }
Exemple #2
0
        /// <summary>
        /// Illustrates formatting a message
        /// </summary>
        private static void FormatInstance(IGraphable message)
        {
            Console.WriteLine("Formatting...");

            // We'll indent the output
            XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(Console.OpenStandardOutput(), new XmlWriterSettings() { Indent = true }));
            m_formatter.Graph(xw, message);
            xw.Flush();
        }
 public void UVPEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>(), bValue = null;
     aValue.Probability = (decimal)0.0f;
     aValue.Value = new MARC.Everest.DataTypes.INT(0);
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
 /// <summary>
 /// Write the content of <paramref name="graph"/> onto <paramref name="writer"/>.
 /// </summary>
 /// <param name="writer">The writer to serialize <paramref name="graph"/>.</param>
 /// <param name="graph">The object to graph to <paramref name="writer"/>.</param>
 public override void WriteObjectContent(System.Xml.XmlDictionaryWriter writer, object graph)
 {
     
     XmlStateWriter xsw = new XmlStateWriter(writer as XmlWriter);
     var result = Formatter.Graph(xsw, (IGraphable)graph);
     this.Details = result.Details;
     this.ResultCode = result.Code;
 }
Exemple #5
0
        /// <summary>
        /// Graphs object <paramref name="o"/> onto stream <paramref name="s"/>
        /// </summary>
        /// <param name="s">The stream to which <paramref name="o"/> is to be graphed</param>
        /// <param name="o">The object to be graphed</param>
        /// <returns>A <see cref="T:MARC.Everest.Formatters.XML.ITS1.Its1FormatterGraphResult"/> structure contianing the 
        /// results of formatting</returns>
        /// <seealso cref="F:Graph(System.Xml.XmlWriter,MARC.Everest.Interfaces.IGraphable)"/>
        public IFormatterGraphResult Graph(Stream s, IGraphable o)
        {
            ThrowIfDisposed();

            XmlWriter xwtr = XmlWriter.Create(s);
            XmlStateWriter xw = new XmlStateWriter(xwtr);

            if (o == null)
                return new XmlIts1FormatterGraphResult(ResultCode.AcceptedNonConformant, null);


            //TODO: Length will never be less than 0 so the logic should be > 0 instead of != 0.
            bool needsRoot = o.GetType().GetCustomAttributes(typeof(InteractionAttribute), true).Length == 0;
            if (needsRoot)
            {
                object[] sa = o.GetType().GetCustomAttributes(typeof(StructureAttribute), true);
                needsRoot = sa.Length == 0 || !(sa[0] as StructureAttribute).IsEntryPoint;
                if (needsRoot)
                {
                    xw.WriteStartElement(o.GetType().FullName, "urn:hl7-org:v3");
                    xw.WriteAttributeString("xmlns", "xsi", null, XmlIts1Formatter.NS_XSI);

                }

            }

            // Determine if this is not an interaction
            var result = Graph(xw, o);

            if (needsRoot)
                xw.WriteEndElement();

            xw.Flush();
            return result;
        }
 public void ADEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.AD aValue = new MARC.Everest.DataTypes.AD(), bValue = null;
     aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.PostalAddressUse>>(0) { new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.PostalAddressUse>(MARC.Everest.DataTypes.PostalAddressUse.HomeAddress) };
     aValue.IsNotOrdered = false;
     aValue.Part.Add(new MARC.Everest.DataTypes.ADXP("123 Main Street West", MARC.Everest.DataTypes.AddressPartType.AddressLine));
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test", "urn:hl7-org:v3");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.AD>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.AD)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
 public void EIVLEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>(), bValue = null;
     aValue.Event = new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.DomainTimingEventType>(MARC.Everest.DataTypes.DomainTimingEventType.BeforeMeal);
     aValue.Offset = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.PQ>(new MARC.Everest.DataTypes.PQ((decimal)0, "0"));
     aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
 public void COEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.CO aValue = new MARC.Everest.DataTypes.CO(), bValue = null;
     aValue.OriginalText = new MARC.Everest.DataTypes.ED(new System.Byte[] { 0 }, "0");
     aValue.Code = new MARC.Everest.DataTypes.CD<System.String>("0");
     aValue.Code.CodeSystem = "0";
     aValue.Code.CodeSystemName = "0";
     aValue.Code.CodeSystemVersion = "0";
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.CO>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.CO)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
 public void EDEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.ED aValue = new MARC.Everest.DataTypes.ED(), bValue = null;
     aValue.Data = new System.Byte[] { 0 };
     aValue.Compression = new System.Nullable<MARC.Everest.DataTypes.Interfaces.EncapsulatedDataCompression>(MARC.Everest.DataTypes.Interfaces.EncapsulatedDataCompression.DF);
     aValue.Representation = MARC.Everest.DataTypes.Interfaces.EncapsulatedDataRepresentation.TXT;
     aValue.Language = "0";
     aValue.MediaType = "0";
     aValue.IntegrityCheck = new System.Byte[] { 0 };
     aValue.IntegrityCheckAlgorithm = new System.Nullable<MARC.Everest.DataTypes.Interfaces.EncapsulatedDataIntegrityAlgorithm>(MARC.Everest.DataTypes.Interfaces.EncapsulatedDataIntegrityAlgorithm.SHA1);
     aValue.Thumbnail = new MARC.Everest.DataTypes.ED(new System.Byte[] { 0 }, "0");
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.ED>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.ED)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
Exemple #10
0
        public void EV_1089SETParseTest()
        {
            PRPA_IN201305UV02 test = new PRPA_IN201305UV02();
            test.Sender = new RMIM.UV.NE2010.MCCI_MT100200UV01.Sender();
            test.Sender.Device = new RMIM.UV.NE2010.MCCI_MT100200UV01.Device();
            test.Sender.Device.Id = new SET<II>() { NullFlavor = NullFlavor.NoInformation };

            XmlIts1Formatter fmtr = new XmlIts1Formatter();
            fmtr.GraphAides.Add(new DatatypeFormatter());

            var sw = new StringWriter();
            XmlStateWriter writer = new XmlStateWriter(XmlWriter.Create(sw));
            fmtr.Graph(writer, test);
            writer.Flush();
            String xmlString = sw.ToString();

            StringReader sr = new StringReader(xmlString);
            XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
            var result = fmtr.Parse(rdr);
            Assert.IsNotNull(result.Structure as PRPA_IN201305UV02);
            Assert.IsNotNull((result.Structure as PRPA_IN201305UV02).Sender.Device.Id);
            //Assert.AreEqual(test, result.Structure);
        }
        public void ExtractingUnsupportedPropertiesTest01()
        {   
            XmlWriter xw = null;

            try
            {
                XmlIts1Formatter its1Formatter = new XmlIts1Formatter()
                {
                    ValidateConformance = false,
                    CreateRequiredElements = true
                };

                // Assign R1 graphing aide
                its1Formatter.GraphAides.Add(new DatatypeFormatter(){
                    ValidateConformance = true,
                    CompatibilityMode = DatatypeFormatterCompatibilityMode.Universal
                });

                // initialize the XmlWriter & State Writer
                StringWriter sw = new StringWriter();

                // Initialize XmlWriter and state writer
                xw = XmlWriter.Create(sw, new XmlWriterSettings() { Indent = true });
                XmlStateWriter xsw = new XmlStateWriter(xw);

                // Create and populate an instance of type 'Patient'
                var instance = Utils.CreatePatient(
                    Guid.NewGuid(),
                    new EN(),
                    new AD(PostalAddressUse.VacationHome,
                        new ADXP[] { }
                    )
                    {
                        // populate AD properties to see which are not supported
                        ControlActExt = "populated",
                        ControlActRoot = "populated",
                        Flavor = "AD.BASIC",
                        IsNotOrdered = true,
                        UpdateMode = new CS<UpdateMode>(),
                        Use = new SET<CS<PostalAddressUse>>(),
                        UseablePeriod = new GTS(),
                        ValidTimeHigh = new TS(),
                        ValidTimeLow = new TS(),
                        NullFlavor = null
                    },
                    new TEL()
                );
                
                // Format
                var result = its1Formatter.Graph(xsw, instance);

                // Iterate through the result details and get the unsupported details
                foreach (var dtl in result.Details)
                {
                    if (dtl is UnsupportedDatatypeR1PropertyResultDetail)
                    {
                        var unsupp = dtl as UnsupportedDatatypeR1PropertyResultDetail;
                        Console.WriteLine("The porperty '{0}' in datatype '{1}' was not formatted!",
                            unsupp.PropertyName, unsupp.DatatypeName);
                    }
                }
                // Flush the xml state writer
                xsw.Flush();
            }
            finally
            {
                if (xw != null)
                    xw.Close();
            }
        }// end test method
Exemple #12
0
        private static void MakeCCDA()
        {
            // We can speed up initial serialization by loading a cached formatter assembly
            MARC.Everest.Formatters.XML.ITS1.Formatter fmtr = new MARC.Everest.Formatters.XML.ITS1.Formatter();
            fmtr.GraphAides.Add(new DatatypeFormatter());
            fmtr.ValidateConformance = false;

            ClinicalDocument ccda = new ClinicalDocument();

            MakeCCDAHeader(ccda);

            MakeCCDABody(ccda);

            Console.Clear();
            Console.WriteLine("CCD Generated");
            Console.ReadKey();

            //ValidateCCDA(ccda);

            XmlStateWriter xsw = new XmlStateWriter(XmlWriter.Create("D:\\EverestPoC.xml", new XmlWriterSettings() { Indent = true }));
            DateTime start = DateTime.Now;
            var result = fmtr.Graph(xsw, ccda);
            xsw.Flush();
        }
Exemple #13
0
        public void IVLInclusiveFormattingTest()
        {
            IVL<INT> intIvl = new IVL<INT>(1, 4);
            intIvl.LowClosed = true;
            intIvl.HighClosed = false;
            MemoryStream ms = new MemoryStream();
            XmlStateWriter writer = new XmlStateWriter(XmlWriter.Create(ms));
            writer.WriteStartElement("ivl", "urn:hl7-org:v3");
            MARC.Everest.Formatters.XML.Datatypes.R1.DatatypeFormatter fmtr = new MARC.Everest.Formatters.XML.Datatypes.R1.DatatypeFormatter();
            fmtr.Graph(writer, intIvl);
            writer.Close();
            ms.Seek(0, SeekOrigin.Begin);
            XmlDocument d = new XmlDocument();
            d.Load(ms);
            Tracer.Trace(d.OuterXml);
            Assert.IsTrue(d.OuterXml.Contains("inclusive"));

        }
        public void BuildPatientTest02()
        {
            // Flag used to verify if the graph result
            // contains details alongside its errors.
            bool noDetails = true;

            // Flag used to verify that the create instance is valid.
            bool valInstance = false;

            // Create a formatter with a graph aide
            XmlIts1Formatter fmtr = new XmlIts1Formatter();

            // Gets or sets a list of aide formatters
            // that assist in the formatting of this instance
            fmtr.GraphAides.Add(new DatatypeFormatter());

            // Format to a string
            StringWriter sw = new StringWriter();
            XmlStateWriter xmlSw = new XmlStateWriter(
                XmlWriter.Create(sw, new XmlWriterSettings() { Indent = true })
                );

            // Call our method here with invalid instance identifier.
            var patient = Utils.CreatePatient(
                new II(),
                EN.CreateEN(EntityNameUse.Legal,
                    new ENXP("John", EntityNamePartType.Given),
                    new ENXP("Smith", EntityNamePartType.Family)
                    ),
                AD.CreateAD(PostalAddressUse.HomeAddress,
                    "123 Main Street West",
                    "Hamilton",
                    "Ontario",
                    "Canada"
                ),
                "*****@*****.**"
            );

            // Format to the formatter
            var result = fmtr.Graph(xmlSw, patient);

            // Flush and close
            xmlSw.Close();

            // Output to console
            Console.WriteLine("XML:");
            Console.WriteLine(sw.ToString());

            // If we get errors, set error catching flag to false and
            // print the details of each error.
            if (result.Details.Count() > 0)
            {
                noDetails = false;
                Console.WriteLine("validation:");
                foreach (var dtl in result.Details)
                    Console.WriteLine("{0} : {1}", dtl.Type, dtl.Message);
            }
            else
            {
                valInstance = true;
            }

            // Assert:  Either there are no errors,
            //          or there are details in the 'details' collection.
            if (noDetails)
            {
                Assert.AreEqual(valInstance, true);
            }
            else if (!valInstance)
            {
                Assert.AreEqual(noDetails, false);
            }
            else
            {
                // Test fails
                Assert.Fail();
            }
        }
Exemple #15
0
        static void Main(string[] args)
        {
            // Create a formatter with a graph aide
            XmlIts1Formatter fmtr = new XmlIts1Formatter();

            // Gets or sets a list of aide formatters
            // that assist in the formatting of this instance
            fmtr.GraphAides.Add(new DatatypeFormatter());

            // Format to a string
            StringWriter sw = new StringWriter();
            XmlStateWriter xmlSw = new XmlStateWriter(
                XmlWriter.Create(sw, new XmlWriterSettings(){Indent = true})
                );

            // Call our method here...
            var patient = CreatePatient(
                Guid.NewGuid(),
                EN.CreateEN(EntityNameUse.Legal,
                    new ENXP ("John", EntityNamePartType.Given),
                    new ENXP ("Smith", EntityNamePartType.Family)
                    ),
                AD.CreateAD(PostalAddressUse.HomeAddress,
                    "123 Main Street West",
                    "Hamilton",
                    "Ontario",
                    "Canada"
                ),
                 "*****@*****.**"
                );

            // Format to the formatter
            var details = fmtr.Graph(xmlSw, patient);

            // Flush and close
            xmlSw.Close();

            // Output to console
            Console.WriteLine("XML: ");
            Console.WriteLine(sw.ToString());
            Console.WriteLine("Validation:");
            foreach (var dtl in details.Details) {
                Console.WriteLine("{0} : {1}", dtl.Type, dtl.Message);
            }
            Console.ReadKey();
        }
Exemple #16
0
 public void IIEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.II aValue = new MARC.Everest.DataTypes.II(), bValue = null;
     aValue.Root = "0";
     aValue.Extension = "0";
     aValue.Displayable = false;
     aValue.Use = new System.Nullable<MARC.Everest.DataTypes.IdentifierUse>(MARC.Everest.DataTypes.IdentifierUse.Business);
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.II>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.II)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
Exemple #17
0
        public void EV_1110_DefaultUniprocessorCustomTypeTest()
        {

            // Load a sample because I don't want to write a full construction method
            ClinicalDocument clinicalDocument = null;
            using (Stream inStream = typeof(EV_1110).Assembly.GetManifestResourceStream("MARC.Everest.Test.Resources.phrDocTesting_140219112155-0500.xml"))
            {
                XmlIts1Formatter fmtr = new XmlIts1Formatter();
                fmtr.ValidateConformance = false;
                fmtr.GraphAides.Add(new ClinicalDocumentDatatypeFormatter());
                var result = fmtr.Parse(XmlReader.Create(inStream), typeof(ClinicalDocument));
                clinicalDocument = result.Structure as ClinicalDocument;
            }

            var observation = new ObservationMyProfile()
                {
                    MoodCode = x_ActMoodDocumentObservation.Eventoccurrence,
                    Code = "3202-20",
                    EntryRelationship = new List<EntryRelationship>()
                    {
                        new EntryRelationship(x_ActRelationshipEntryRelationship.HasComponent, true)
                        {
                            ClinicalStatement = new ObservationMyProfile()
                        }
                    }
                }
            ;


            CascadeNullFlavor(observation.EntryRelationship[0], NullFlavor.Unknown);

            // Cascade a null flavor on one of the entries
            clinicalDocument.Component.GetBodyChoiceIfStructuredBody().Component[1].Section.Entry.Add(new Entry(
                x_ActRelationshipEntry.HasComponent,
                false,
                observation
            ));

            // Cascade a null flavor on one of the entries
            clinicalDocument.Component.GetBodyChoiceIfStructuredBody().Component[2].Section.Entry.Add(new Entry(
                x_ActRelationshipEntry.HasComponent,
                false,
                observation
            ));

            // Cascade a null flavor on one of the entries
            clinicalDocument.Component.GetBodyChoiceIfStructuredBody().Component[3].Section.Entry.Add(new Entry(
                x_ActRelationshipEntry.HasComponent,
                false,
                observation
            ));

            StringWriter sw = new StringWriter();
            using (XmlWriter xw = XmlWriter.Create(sw, new XmlWriterSettings() { Indent = true }))
            {
                XmlIts1Formatter fmtr = new XmlIts1Formatter();
                fmtr.ValidateConformance = false;
                fmtr.GraphAides.Add(new ClinicalDocumentDatatypeFormatter());
                fmtr.Settings = SettingsType.DefaultUniprocessor;
                fmtr.Settings |= SettingsType.SuppressXsiNil;
                fmtr.Settings |= SettingsType.SuppressNullEnforcement;
                fmtr.Settings |= SettingsType.AlwaysCheckForOverrides;
                fmtr.RegisterXSITypeName("POCD_MT000040.Observation", typeof(MARC.Everest.Test.Regressions.EV_1102.ObservationWithConfidentialityCode));

                using (XmlStateWriter xsw = new XmlStateWriter(xw))
                {
                    xsw.WriteStartElement("hl7", "ClinicalDocument", "urn:hl7-org:v3");
                    xsw.WriteAttributeString("xmlns", "xsi", null, XmlIts1Formatter.NS_XSI);
                    xsw.WriteAttributeString("schemaLocation", XmlIts1Formatter.NS_XSI, @"urn:hl7-org:v3 Schemas/CDA-PITO-E2E.xsd");
                    xsw.WriteAttributeString("xmlns", null, null, @"urn:hl7-org:v3");
                    xsw.WriteAttributeString("xmlns", "hl7", null, @"urn:hl7-org:v3");
                    xsw.WriteAttributeString("xmlns", "e2e", null, @"http://standards.pito.bc.ca/E2E-DTC/cda");
                    xsw.WriteAttributeString("xmlns", "xs", null, @"http://www.w3.org/2001/XMLSchema");

                    
                    IFormatterGraphResult result = fmtr.Graph(xsw, clinicalDocument);
                    foreach (ResultDetail itm in result.Details)
                        Trace.WriteLine(String.Format("{0}:{1} @ {2}", itm.Type, itm.Message, itm.Location));
                    xsw.WriteEndElement(); // clinical document
                    xsw.Flush();
                }
            }

            Trace.WriteLine(sw.ToString());
            Regex re = new Regex(@"\<entryRelationship.*/\>");
            if (re.IsMatch(sw.ToString()))
                Assert.Fail("Output of entry relationship is not as expected");

        }
Exemple #18
0
 public void IVLEqualsSerializationLowTest()
 {
     MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>(), bValue = null;
     aValue.Low = new MARC.Everest.DataTypes.INT(0);
     aValue.LowClosed = false;
     //aValue.High = new MARC.Everest.DataTypes.INT(0);
     //aValue.HighIncluded = false;
     //aValue.Width = new MARC.Everest.DataTypes.PQ(0, "0");
     aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
        public void CreateReqElemOutputTest02()
        {
            XmlWriter xw = null;
            Stream s = null;
            try
            {
                /* STREAMWRITER CODE 
                s = File.Create("C:/Test Files/example85Data2.xml");
                StreamWriter sw1 = new StreamWriter(s);

                /* END STREAMWRITER CODE */


                // Setup the formatter
                var its1Formatter = new XmlIts1Formatter()
                {
                    ValidateConformance = true,
                    CreateRequiredElements = true
                };
                its1Formatter.GraphAides.Add(new DatatypeFormatter()
                {
                    ValidateConformance = false
                }
                    );

                // Initialize the XmlWriter & State writer
                StringWriter sw = new StringWriter();
                xw = XmlWriter.Create(sw, new XmlWriterSettings() { Indent = true });

                // State writer should always be used
                XmlStateWriter xsw = new XmlStateWriter(xw);

                // Create an instance
                REPC_IN000076CA instance = new REPC_IN000076CA(
                    Guid.NewGuid(),
                    DateTime.Now,
                    ResponseMode.Immediate,
                    REPC_IN000076CA.GetInteractionId(),
                    REPC_IN000076CA.GetProfileId(),
                    ProcessingID.Production,
                    AcknowledgementCondition.Always,
                    new MARC.Everest.RMIM.CA.R020402.MCCI_MT002200CA.Receiver(),
                    new MARC.Everest.RMIM.CA.R020402.MCCI_MT002200CA.Sender()
                );
                instance.controlActEvent =
                    new MARC.Everest.RMIM.CA.R020402.MCAI_MT700210CA.ControlActEvent
                        <MARC.Everest.RMIM.CA.R020402.REPC_MT220001CA.Document>();

                // Format
                var result = its1Formatter.Graph(xsw, instance);
                
                /* STREAMWRITER CODE 
                var result2 = its1Formatter.Graph(s, instance);
                // Close streamwriter
                sw1.Close();
                /* END STREAMWRITER CODE */

                // Flush the xml state writer
                xsw.Flush();

                if (result.Code != ResultCode.Accepted)
                {
                    Console.WriteLine("RESULT CODE: {0}", result.Code);
                    foreach (var detail in result.Details)
                    {
                        Console.WriteLine("{0}: {1}", detail.Type, detail.Message);
                    }
                }
                 
                // Assert: Instance is not conformant.
                Assert.AreEqual(ResultCode.Rejected, result.Code);

                /* STREAMWRITER CODE 
                // Validate that the written file contains the two injected strings.
                StreamReader sr = new StreamReader("C:/Test Files/example85Data2.xml");

                String xmlFromFile = "";
                // write everything in the stream to the console
                while (!sr.EndOfStream)
                {
                    // store lines into a string
                    xmlFromFile += sr.ReadLine();
                }

                // Write xml from the file onto the console
                Console.WriteLine(xmlFromFile);
                /* END STREAMWRITER CODE */
            }
            finally
            {
                if (xw != null)
                    xw.Close();
            }
        }// end test method
Exemple #20
0
        public void ENEqualsSerializationTest()
        {
            MARC.Everest.DataTypes.EN aValue = new MARC.Everest.DataTypes.EN(), bValue = null;
            aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.EntityNameUse>>(MARC.Everest.DataTypes.EntityNameUse.Legal);
            aValue.Flavor = "0";
            aValue.Part.Add(new MARC.Everest.DataTypes.ENXP("Bob", MARC.Everest.DataTypes.EntityNamePartType.Given));
            aValue.Part.Add(new MARC.Everest.DataTypes.ENXP("Dole", MARC.Everest.DataTypes.EntityNamePartType.Family));

            StringWriter sw = new StringWriter();
            DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
            XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
            xw.WriteStartElement("test");
            fmtr.Graph(xw, aValue);
            xw.WriteEndElement(); // comp
            xw.Flush();
            StringReader sr = new StringReader(sw.ToString());
            XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
            rdr.Read(); rdr.Read();
            bValue = Util.Convert<MARC.Everest.DataTypes.EN>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.EN)).Structure);
            Assert.AreEqual(aValue, bValue);
        }
Exemple #21
0
        public void SXPRSTMixedComponentsFormatting()
        {

            SXPR<RTO<INT, INT>> test = SXPR<RTO<INT, INT>>.CreateSXPR(new IVL<RTO<INT,INT>>(new RTO<INT,INT>(1,3), new RTO<INT,INT>(2,3)),
                new PIVL<RTO<INT,INT>>(
                    new IVL<RTO<INT,INT>>(new RTO<INT,INT>(2,3),new RTO<INT,INT>(5,6)),
                    new PQ((decimal)1.0, "y")
                )
                //new SXCM<RTO<INT,INT>>(new RTO<INT,INT>(1,2)) { Operator = SetOperator.A },
                //new IVL<RTO<INT,INT>>(new RTO<INT,INT>(1,2)) { Operator = SetOperator.Intersect 
                );

            StringWriter sw = new StringWriter();
            DatatypeFormatter fmtr = new DatatypeFormatter();
            XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw));
            xw.WriteStartElement("sxpr");
            fmtr.Graph(xw, test);
            xw.WriteEndElement(); // comp
            xw.Flush();
            Tracer.Trace(sw.ToString());
            StringReader sr = new StringReader(sw.ToString());
            XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
            rdr.Read(); rdr.Read();
            var parse = fmtr.Parse(rdr, typeof(SXPR<RTO<INT, INT>>)).Structure as SXPR<RTO<INT, INT>>;
            Assert.AreEqual(parse.Count, test.Count);
            for (int i = 0; i < parse.Count; i++)
                Assert.AreEqual(parse[i].GetType(), test[i].GetType());

        }
Exemple #22
0
 public void ADXPEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.ADXP aValue = new MARC.Everest.DataTypes.ADXP(), bValue = null;
     aValue.Value = "0";
     aValue.Code = "0";
     aValue.Type = new System.Nullable<MARC.Everest.DataTypes.AddressPartType>(MARC.Everest.DataTypes.AddressPartType.AddressLine);
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.ADXP>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.ADXP)).Structure);
     bValue.Type = MARC.Everest.DataTypes.AddressPartType.AddressLine;
     Assert.AreEqual(aValue, bValue);
 }
Exemple #23
0
        public void SXPRTSMixedComponentsFormatting()
        {
            SXPR<TS> test = SXPR<TS>.CreateSXPR(new IVL<TS>(DateTime.Now, DateTime.Now.AddDays(1)),
                new PIVL<TS>(
                    new IVL<TS>(DateTime.Now, DateTime.Now.AddDays(1)),
                    new PQ((decimal)1.0, "y")
                ),
                //new SXCM<TS>(DateTime.Now) { Operator = SetOperator.A },
                new IVL<TS>(DateTime.Now) { Operator = SetOperator.Intersect },
                new EIVL<TS>(DomainTimingEventType.BeforeLunch,
                    new IVL<PQ>(
                        new PQ((decimal)1.0, "d")
                        )
                ) { Operator = SetOperator.Inclusive });

            StringWriter sw = new StringWriter();
            DatatypeFormatter fmtr = new DatatypeFormatter();
            XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw));
            xw.WriteStartElement("sxpr");
            fmtr.Graph(xw, test);
            xw.WriteEndElement(); // comp
            xw.Flush();
            Tracer.Trace(sw.ToString());
            StringReader sr = new StringReader(sw.ToString());
            XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
            rdr.Read(); rdr.Read();
            var parse = fmtr.Parse(rdr, typeof(SXPR<TS>)).Structure as SXPR<TS>;
            Assert.AreEqual(parse.Count, test.Count);
            for (int i = 0; i < parse.Count; i++)
                Assert.AreEqual(parse[i].GetType(), test[i].GetType());

        }
Exemple #24
0
 public void TELEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.TEL aValue = new MARC.Everest.DataTypes.TEL(), bValue = null;
     aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse>>(0) { new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse>(MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse.Home) };
     aValue.UseablePeriod = new MARC.Everest.DataTypes.GTS(new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.TS>(new MARC.Everest.DataTypes.TS(DateTime.Parse("2011-1-10"))));
     aValue.Value = "0";
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.TEL>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.TEL)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
        public void XmlStateWriterTest01()
        {

            // Initialize the XmlWriter & State writer
            StringWriter sw = new StringWriter();
            var xw = XmlWriter.Create(sw, new XmlWriterSettings() { Indent = true });

            // Write something at the start
            xw.WriteStartElement("myHl7ExampleInstance");
            xw.WriteAttributeString("interactionId", "MCCI_IN000000UV01");

            // State writer should always be used
            XmlStateWriter xsw = new XmlStateWriter(xw);

            // Create a simple instance
            MCCI_IN000000UV01 instance = new MCCI_IN000000UV01(
                Guid.NewGuid(),
                DateTime.Now,
                MCCI_IN000000UV01.GetInteractionId(),
                ProcessingID.Production,
                "P",
                AcknowledgementCondition.Always);

            // Setup the formatter
            IXmlStructureFormatter structureFormatter = new XmlIts1Formatter()
            {
                ValidateConformance = false
            };

            structureFormatter.GraphAides.Add(new DatatypeFormatter());

            // Print current path of the xmlwriter before formatting instance
            var writeStatePreFormat = xsw.WriteState;
            Console.WriteLine("Write state pre-format: {0}", writeStatePreFormat);

            // Format
            var result = structureFormatter.Graph(xsw, instance);

            // Print current path of the xmlwriter after formatting instance
            var writeStatePostFormat = xsw.WriteState;
            Console.WriteLine("Write state post-format: {0}", writeStatePostFormat);

            // Test that the write states before and after formatting has changed.
            // This demonstrates how the state of the xml writer can be tracked while runnning.
            Assert.AreNotEqual(writeStatePreFormat, writeStatePostFormat);

            // Flush state writer
            xsw.Flush();

            // finish the stream
            xw.WriteEndElement();
        }
Exemple #26
0
 public void PIVLEqualsSerializationTest()
 {
     MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>(), bValue = null;
     aValue.Phase = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>(new MARC.Everest.DataTypes.INT(0));
     aValue.Period = new MARC.Everest.DataTypes.PQ((decimal)0, "0");
     aValue.Alignment = new System.Nullable<MARC.Everest.DataTypes.CalendarCycle>(MARC.Everest.DataTypes.CalendarCycle.Year);
     aValue.InstitutionSpecified = false;
     aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
     aValue.Flavor = "0";
     StringWriter sw = new StringWriter();
     DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
     XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
     xw.WriteStartElement("test");
     fmtr.Graph(xw, aValue);
     xw.WriteEndElement(); // comp
     xw.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
     rdr.Read(); rdr.Read();
     bValue = Util.Convert<MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>)).Structure);
     Assert.AreEqual(aValue, bValue);
 }
Exemple #27
0
        /// <summary>
        /// Graphs <paramref name="o"/> onto the <see cref="T:System.Xml.XmlWriter"/> <paramref name="s"/>
        /// </summary>
        /// <param name="s">The <see cref="T:System.Xml.XmlWriter"/> that should be used to graph the object</param>
        /// <param name="o">The <see cref="T:MARC.Everest.Interfaces.IGraphable"/> that should be graphed</param>
        /// <returns>A <see cref="T:MARC.Everest.Formatters.XML.ITS1.Its1FormatterGraphResult"/> containing the results of the graph</returns>
        /// <remarks>
        /// <para>
        /// This particular overload of the Graph method can be used to graph objects into a <see cref="T:System.Xml.XmlWriter"/> and can provide
        /// an opportunity to use Everest as an assistant (or XmlSerializerSurrogate) for more complex systems like WCF.
        /// </para>
        /// <example>
        /// <code lang="cs" title="Using Everest as a Serializer Assistant">
        /// <![CDATA[
        /// StringWriter sw = new StringWriter();
        /// XmlWriter writer = XmlWriter.Create(sw);
        /// writer.WriteStartElement("hello", "urn:my-org");
        /// 
        /// Formatter f = new Formatter();
        /// f.GraphAides.Add(typeof(MARC.Everest.Formatters.XML.DataTypes.R1.Formatter));
        /// f.ValidateConformance = false;
        /// f.Graph(writer, new MCCI_IN000002CA());
        /// 
        /// writer.WriteEndElement();
        /// writer.Close();
        /// Console.WriteLine(sw.ToString());
        /// 
        /// ]]>
        /// </code>
        /// outputs
        /// <code lang="xml" title="Output of example">
        /// <![CDATA[
        /// <hello xmlns="urn:my-org">
        ///     <MCCI_IN000002CA xmlns="urn:hl7-org:v3"/>
        /// </hello>
        /// ]]>
        /// </code>
        /// </example>
        /// <para>
        /// When using this method, it is recommended that you pass a <see cref="T:MARC.Everest.Xml.XmlStateWriter"/> as it 
        /// will allow the formatter to give additional location information when reporting issues.
        /// </para>
        /// </remarks>
        public IFormatterGraphResult Graph(XmlWriter s, IGraphable o)
        {
            ThrowIfDisposed();

            var resultContext = new XmlIts1FormatterGraphResult(ResultCode.Accepted, null);

            IGraphable context = null;
            // Clear out result cache
            if (s.WriteState == WriteState.Start || String.IsNullOrEmpty(s.ToString()) || o is IInteraction)
                context = o;

            if (!(s is XmlStateWriter))
                s = new XmlStateWriter(s);

            if (o == null)
                resultContext.Code = ResultCode.AcceptedNonConformant;
            else
            {
                GraphObject(s, o, o.GetType(), context, resultContext);
                resultContext.Code = CalculateResultCode(resultContext.Details);
            }

            return resultContext;
        }