internal static Height ToHeight(this Observation observation)
        {
            var height = observation.ToThingBase <ItemTypes.Height>();

            height.Value = ObservationToHealthVault.GetThingValueFromQuantity <Length>(observation.Value as Quantity);
            height.When  = ObservationToHealthVault.GetHealthVaultTimeFromEffectiveDate(observation.Effective);

            return(height);
        }
        internal static Weight ToWeight(this Observation observation)
        {
            var weight = observation.ToThingBase <ItemTypes.Weight>();

            weight.Value = ObservationToHealthVault.GetThingValueFromQuantity <WeightValue>(observation.Value as Quantity);

            weight.When = ObservationToHealthVault.GetWhenFromEffective(observation.Effective);

            return(weight);
        }
Example #3
0
        internal static BodyDimension ToBodyDimension(this Observation observation)
        {
            var bodyDimension = observation.ToThingBase <BodyDimension>();

            bodyDimension.Value = ObservationToHealthVault.GetThingValueFromQuantity <Length>(observation.Value as Quantity);
            bodyDimension.When  = ObservationToHealthVault.GetApproximateDateTimeFromEffectiveDate(observation.Effective);

            if (observation.Method != null)
            {
                bodyDimension.MeasurementName = observation.Method.ToCodableValue();
            }

            return(bodyDimension);
        }
Example #4
0
        internal static BloodGlucose ToBloodGlucose(this Observation observation)
        {
            var bloodGlucose = observation.ToThingBase <BloodGlucose>();

            bloodGlucose.Value = ObservationToHealthVault.GetThingValueFromQuantity <BloodGlucoseMeasurement>(observation.Value as Quantity);

            bloodGlucose.When = ObservationToHealthVault.GetWhenFromEffective(observation.Effective);

            var bloodGlucoseExtension = observation.GetExtension(HealthVaultExtensions.BloodGlucose);

            if (bloodGlucoseExtension != null)
            {
                bloodGlucose.MeasurementContext          = bloodGlucoseExtension.GetExtensionValue <CodeableConcept>(HealthVaultExtensions.BloodGlucoseMeasurementContext).ToCodableValue();
                bloodGlucose.OutsideOperatingTemperature = bloodGlucoseExtension.GetBoolExtension(HealthVaultExtensions.OutsideOperatingTemperatureExtensionName);
                bloodGlucose.IsControlTest = bloodGlucoseExtension.GetBoolExtension(HealthVaultExtensions.IsControlTestExtensionName);

                Normalcy normalcy;
                if (Enum.TryParse <Normalcy>(bloodGlucoseExtension.GetStringExtension(HealthVaultExtensions.ReadingNormalcyExtensionName), out normalcy))
                {
                    bloodGlucose.ReadingNormalcy = normalcy;
                }
            }

            if (observation.Code != null && observation.Code.Coding != null)
            {
                foreach (var code in observation.Code.Coding)
                {
                    if (HealthVaultVocabularies.SystemContainsHealthVaultUrl(code.System))
                    {
                        bloodGlucose.GlucoseMeasurementType = observation.Method.ToCodableValue();
                    }
                    else
                    {
                        bloodGlucose.SetGlucoseMeasurementType(
                            code.Display,
                            code.Code,
                            HealthVaultVocabularies.Fhir,
                            code.System,
                            code.Version);
                    }
                }
            }

            return(bloodGlucose);
        }