public static ItemTypes.Immunization ToHealthVault(this Hl7.Fhir.Model.Immunization fhirImmunization)
        {
            ItemTypes.Immunization hvImmunization = fhirImmunization.ToThingBase <ItemTypes.Immunization>();

            hvImmunization.Name = fhirImmunization.VaccineCode.ToCodableValue();

            if (!fhirImmunization.DateElement.IsNullOrEmpty())
            {
                hvImmunization.DateAdministrated = fhirImmunization.DateElement.ToAproximateDateTime();
            }

            if (!fhirImmunization.Practitioner.IsNullOrEmpty())
            {
                hvImmunization.Administrator = GetProvider(fhirImmunization);
            }

            if (!fhirImmunization.Manufacturer.IsNullOrEmpty())
            {
                hvImmunization.Manufacturer = GetManufacturer(fhirImmunization);
            }

            hvImmunization.Lot   = fhirImmunization.LotNumber;
            hvImmunization.Route = fhirImmunization.Route.ToCodableValue();
            if (fhirImmunization.ExpirationDateElement != null)
            {
                hvImmunization.ExpirationDate = fhirImmunization.ExpirationDateElement.ToAproximateDateTime().ApproximateDate;
            }
            hvImmunization.AnatomicSurface = fhirImmunization.Site.ToCodableValue();

            Extension immunizationExtension = fhirImmunization.GetExtension(HealthVaultExtensions.ImmunizationDetail);

            if (immunizationExtension != null)
            {
                hvImmunization.Sequence     = immunizationExtension.GetStringExtension(HealthVaultExtensions.ImmunizationDetailSequence);
                hvImmunization.Consent      = immunizationExtension.GetStringExtension(HealthVaultExtensions.ImmunizationDetailConcent);
                hvImmunization.AdverseEvent = immunizationExtension.GetStringExtension(HealthVaultExtensions.ImmunizationDetailAdverseEvent);
            }

            if (!fhirImmunization.Note.IsNullOrEmpty())
            {
                fhirImmunization.Note.ForEach(note =>
                {
                    string separator = string.Empty;
                    if (!string.IsNullOrEmpty(hvImmunization.CommonData.Note))
                    {
                        separator = Environment.NewLine; //Let's separate each note with new line
                    }

                    hvImmunization.CommonData.Note += $"{separator}{note.Text}";
                });
            }

            return(hvImmunization);
        }
        public void WhenImmunizationTransformedToFhir_ThenValuesAreEqual()
        {
            var now           = new LocalDateTime(2017, 9, 21, 18, 55, 10, 100);
            var afterOneMonth = new LocalDate(2017, 10, 20);
            var immunization  = new ItemTypes.Immunization
            {
                Name = new CodableValue("cholera vaccine", new CodedValue {
                    Value          = "26",
                    Family         = "HL7",
                    VocabularyName = "vaccines-cvx",
                    Version        = "2.3 09_2008"
                }),
                DateAdministrated = new ApproximateDateTime(now),
                Administrator     = new PersonItem
                {
                    Name = new Name
                    {
                        Full = "Justin Case"
                    }
                },
                Manufacturer = new CodableValue("Baxter Healthcare Corporation", new CodedValue
                {
                    Value          = "BA",
                    Family         = "HL7",
                    VocabularyName = "vaccine-manufacturers-mvx",
                    Version        = "2.3 07_2008"
                }),
                Lot   = "AAJN11K",
                Route = new CodableValue("By mouth", new CodedValue
                {
                    Value          = "po",
                    Family         = "wc",
                    VocabularyName = "medication-routes",
                    Version        = "2"
                }),
                ExpirationDate  = new ApproximateDate(afterOneMonth),
                Sequence        = "Last",
                AnatomicSurface = new CodableValue("Metacarpophalangeal joint structure of index finger", new CodedValue {
                    Value          = "289002",
                    VocabularyName = "SnomedBodyLocation",
                    Family         = "Snomed",
                    Version        = "Jan2008"
                }),
                AdverseEvent = "Something bad happened",
                Consent      = "A concent from parent goes here"
            };

            immunization.CommonData.Note = "Some note goes here";

            Hl7.Fhir.Model.Immunization fhirImmunization = immunization.ToFhir();

            Assert.IsNotNull(fhirImmunization);
            Assert.AreEqual(immunization.Name.Text, fhirImmunization.VaccineCode.Text);
            Assert.AreEqual(now.ToDateTimeUnspecified(), fhirImmunization.DateElement.ToDateTimeOffset());

            var containedPractitioner = fhirImmunization.Contained.Where(resource => resource.GetType().Equals(typeof(Practitioner))).SingleOrDefault() as Practitioner;

            Assert.IsNotNull(containedPractitioner);
            Assert.AreEqual(immunization.Administrator.Name.Full, containedPractitioner.Name.Single().Text);

            var containedOrganization = fhirImmunization.Contained.Where(resource => resource.GetType().Equals(typeof(FhirOrganization))).SingleOrDefault() as FhirOrganization;

            Assert.IsNotNull(containedOrganization);
            Assert.AreEqual(immunization.Manufacturer.Text, containedOrganization.Name);

            Assert.AreEqual(immunization.Lot, fhirImmunization.LotNumber);
            Assert.AreEqual(immunization.Route.Text, fhirImmunization.Route.Text);
            Assert.AreEqual(afterOneMonth.ToDateTimeUnspecified().ToUniversalTime(), fhirImmunization.ExpirationDateElement.ToPartialDateTime().Value.ToUniversalTime());
            Assert.AreEqual(immunization.AnatomicSurface.Text, fhirImmunization.Site.Text);

            var immunizationExtension = fhirImmunization.GetExtension(HealthVaultExtensions.ImmunizationDetail);

            Assert.AreEqual(immunization.AdverseEvent, immunizationExtension.GetStringExtension(HealthVaultExtensions.ImmunizationDetailAdverseEvent));
            Assert.AreEqual(immunization.Consent, immunizationExtension.GetStringExtension(HealthVaultExtensions.ImmunizationDetailConcent));
            Assert.AreEqual(immunization.Sequence, immunizationExtension.GetStringExtension(HealthVaultExtensions.ImmunizationDetailSequence));

            Assert.IsFalse(fhirImmunization.Note.IsNullOrEmpty());
            Assert.AreEqual(immunization.CommonData.Note, fhirImmunization.Note.First().Text);
        }
        internal static Hl7.Fhir.Model.Immunization ToFhirInternal(ItemTypes.Immunization hvImmunization, Hl7.Fhir.Model.Immunization fhirImmunization)
        {
            fhirImmunization.VaccineCode = hvImmunization.Name.ToFhir();
            fhirImmunization.DateElement = hvImmunization.DateAdministrated.ToFhir();

            if (hvImmunization.Administrator != null)
            {
                fhirImmunization.Practitioner.Add(new Hl7.Fhir.Model.Immunization.PractitionerComponent
                {
                    Actor = AddContainedResource(fhirImmunization, hvImmunization.Administrator.ToFhir())
                });
            }

            if (hvImmunization.Manufacturer != null)
            {
                fhirImmunization.Manufacturer = AddContainedResource(fhirImmunization, new Hl7.Fhir.Model.Organization
                {
                    Name = hvImmunization.Manufacturer.Text
                });
            }

            fhirImmunization.LotNumber             = hvImmunization.Lot;
            fhirImmunization.Route                 = hvImmunization.Route.ToFhir();
            fhirImmunization.ExpirationDateElement = hvImmunization.ExpirationDate.ToFhir();

            if (!string.IsNullOrEmpty(hvImmunization.Sequence) ||
                !string.IsNullOrEmpty(hvImmunization.AdverseEvent) ||
                !string.IsNullOrEmpty(hvImmunization.Consent))
            {
                var immunizationExtension = new Extension
                {
                    Url = HealthVaultExtensions.ImmunizationDetail
                };

                if (!string.IsNullOrEmpty(hvImmunization.Sequence))
                {
                    immunizationExtension.AddExtension(HealthVaultExtensions.ImmunizationDetailSequence, new FhirString(hvImmunization.Sequence));
                }

                if (!string.IsNullOrEmpty(hvImmunization.Consent))
                {
                    immunizationExtension.AddExtension(HealthVaultExtensions.ImmunizationDetailConcent, new FhirString(hvImmunization.Consent));
                }

                if (!string.IsNullOrEmpty(hvImmunization.AdverseEvent))
                {
                    immunizationExtension.AddExtension(HealthVaultExtensions.ImmunizationDetailAdverseEvent, new FhirString(hvImmunization.AdverseEvent));
                }
                fhirImmunization.Extension.Add(immunizationExtension);
            }

            fhirImmunization.Site = hvImmunization.AnatomicSurface.ToFhir();

            fhirImmunization.Note.Add(new Hl7.Fhir.Model.Annotation {
                Text = hvImmunization.CommonData.Note
            });

            //Setting default values that is not available in HealthVault. Let's revisit when a good
            //approach is found for better fidelity between Fhir & HV
            fhirImmunization.Status        = Hl7.Fhir.Model.Immunization.ImmunizationStatusCodes.Completed;
            fhirImmunization.NotGiven      = false;
            fhirImmunization.PrimarySource = true;

            return(fhirImmunization);
        }
 public static Hl7.Fhir.Model.Immunization ToFhir(this ItemTypes.Immunization hvImmunization)
 {
     return(ImmunizationToFhir.ToFhirInternal(hvImmunization, hvImmunization.ToFhirInternal <Hl7.Fhir.Model.Immunization>()));
 }