Merge pull request #819 from tidepool-org/BACK-3461-trend-rate-units

[BACK-3461] Add trend rate units to cbg data type

Author: darinkrauss

data/blood/glucose/glucose.go

@@ -10,15 +10,25 @@ const (
 	MmolL = "mmol/L"
 	Mmoll = "mmol/l"
 
+	MmolLMinute = "mmol/L/minute"
+
 	MgdL = "mg/dL"
 	Mgdl = "mg/dl"
 
+	MgdLMinute = "mg/dL/minute"
+
 	MmolLMinimum float64 = 0.0
 	MmolLMaximum float64 = 55.0
 
+	MmolLMinuteMinimum float64 = -5.5
+	MmolLMinuteMaximum float64 = 5.5
+
 	MgdLMinimum float64 = 0.0
 	MgdLMaximum float64 = 1000.0
 
+	MgdLMinuteMinimum float64 = -100.0
+	MgdLMinuteMaximum float64 = 100.0
+
 	// MmolLToMgdLConversionFactor is MgdL Per MmolL.
 	//
 	// Reminder: The molecular mass of glucose is ≈ 180 g/mol.
@@ -34,6 +44,10 @@ func Units() []string {
 	return []string{MmolL, Mmoll, MgdL, Mgdl}
 }
 
+func RateUnits() []string {
+	return []string{MmolLMinute, MgdLMinute}
+}
+
 func ValueRangeForUnits(units *string) (float64, float64) {
 	if units != nil {
 		switch *units {
@@ -60,7 +74,41 @@ func NormalizeValueForUnits(value *float64, units *string) *float64 {
 	if value != nil && units != nil {
 		switch *units {
 		case MgdL, Mgdl:
-			intValue := int(*value/MmolLToMgdLConversionFactor*MmolLToMgdLPrecisionFactor + 0.5)
+			intValue := int(*value/MmolLToMgdLConversionFactor*MmolLToMgdLPrecisionFactor + math.Copysign(0.5, *value))
+			floatValue := float64(intValue) / MmolLToMgdLPrecisionFactor
+			return &floatValue
+		}
+	}
+	return value
+}
+
+func ValueRangeForRateUnits(rateUnits *string) (float64, float64) {
+	if rateUnits != nil {
+		switch *rateUnits {
+		case MmolLMinute:
+			return MmolLMinuteMinimum, MmolLMinuteMaximum
+		case MgdLMinute:
+			return MgdLMinuteMinimum, MgdLMinuteMaximum
+		}
+	}
+	return -math.MaxFloat64, math.MaxFloat64
+}
+
+func NormalizeRateUnits(rateUnits *string) *string {
+	if rateUnits != nil {
+		switch *rateUnits {
+		case MmolLMinute, MgdLMinute:
+			return pointer.FromString(MmolLMinute)
+		}
+	}
+	return rateUnits
+}
+
+func NormalizeValueForRateUnits(value *float64, rateUnits *string) *float64 {
+	if value != nil && rateUnits != nil {
+		switch *rateUnits {
+		case MgdLMinute:
+			intValue := int(*value/MmolLToMgdLConversionFactor*MmolLToMgdLPrecisionFactor + math.Copysign(0.5, *value))
 			floatValue := float64(intValue) / MmolLToMgdLPrecisionFactor
 			return &floatValue
 		}

data/blood/glucose/glucose_test.go

@@ -19,6 +19,10 @@ var _ = Describe("Glucose", func() {
 		Expect(glucose.Mmoll).To(Equal("mmol/l"))
 	})
 
+	It("has MmolLMinute", func() {
+		Expect(glucose.MmolLMinute).To(Equal("mmol/L/minute"))
+	})
+
 	It("has MgdL", func() {
 		Expect(glucose.MgdL).To(Equal("mg/dL"))
 	})
@@ -27,6 +31,10 @@ var _ = Describe("Glucose", func() {
 		Expect(glucose.Mgdl).To(Equal("mg/dl"))
 	})
 
+	It("has MgdLMinute", func() {
+		Expect(glucose.MgdLMinute).To(Equal("mg/dL/minute"))
+	})
+
 	It("has MmolLMinimum", func() {
 		Expect(glucose.MmolLMinimum).To(Equal(0.0))
 	})
@@ -35,6 +43,14 @@ var _ = Describe("Glucose", func() {
 		Expect(glucose.MmolLMaximum).To(Equal(55.0))
 	})
 
+	It("has MmolLMinuteMinimum", func() {
+		Expect(glucose.MmolLMinuteMinimum).To(Equal(-5.5))
+	})
+
+	It("has MmolLMinuteMaximum", func() {
+		Expect(glucose.MmolLMinuteMaximum).To(Equal(5.5))
+	})
+
 	It("has MgdLMinimum", func() {
 		Expect(glucose.MgdLMinimum).To(Equal(0.0))
 	})
@@ -43,6 +59,14 @@ var _ = Describe("Glucose", func() {
 		Expect(glucose.MgdLMaximum).To(Equal(1000.0))
 	})
 
+	It("has MgdLMinuteMinimum", func() {
+		Expect(glucose.MgdLMinuteMinimum).To(Equal(-100.0))
+	})
+
+	It("has MgdLMinuteMaximum", func() {
+		Expect(glucose.MgdLMinuteMaximum).To(Equal(100.0))
+	})
+
 	It("has MmolLToMgdLConversionFactor", func() {
 		Expect(glucose.MmolLToMgdLConversionFactor).To(Equal(18.01559))
 	})
@@ -57,6 +81,12 @@ var _ = Describe("Glucose", func() {
 		})
 	})
 
+	Context("RateUnits", func() {
+		It("returns the expected units", func() {
+			Expect(glucose.RateUnits()).To(ConsistOf("mmol/L/minute", "mg/dL/minute"))
+		})
+	})
+
 	DescribeTable("ValueRangeForUnits",
 		func(units *string, expectedLower float64, expectedUpper float64) {
 			actualLower, actualUpper := glucose.ValueRangeForUnits(units)
@@ -125,4 +155,67 @@ var _ = Describe("Glucose", func() {
 			}
 		})
 	})
+
+	DescribeTable("ValueRangeForRateUnits",
+		func(rateUnits *string, expectedLower float64, expectedUpper float64) {
+			actualLower, actualUpper := glucose.ValueRangeForRateUnits(rateUnits)
+			Expect(actualLower).To(Equal(expectedLower))
+			Expect(actualUpper).To(Equal(expectedUpper))
+		},
+		Entry("returns no range for nil", nil, -math.MaxFloat64, math.MaxFloat64),
+		Entry("returns no range for unknown units", pointer.FromString("unknown"), -math.MaxFloat64, math.MaxFloat64),
+		Entry("returns expected range for mmol/L/minute units", pointer.FromString("mmol/L/minute"), -5.5, 5.5),
+		Entry("returns expected range for mg/dL/minute units", pointer.FromString("mg/dL/minute"), -100.0, 100.0),
+	)
+
+	DescribeTable("NormalizeRateUnits",
+		func(rateUnits *string, expectedRateUnits *string) {
+			actualRateUnits := glucose.NormalizeRateUnits(rateUnits)
+			if expectedRateUnits == nil {
+				Expect(actualRateUnits).To(BeNil())
+			} else {
+				Expect(actualRateUnits).ToNot(BeNil())
+				Expect(*actualRateUnits).To(Equal(*expectedRateUnits))
+			}
+		},
+		Entry("returns nil for nil", nil, nil),
+		Entry("returns unchanged units for unknown units", pointer.FromString("unknown"), pointer.FromString("unknown")),
+		Entry("returns mmol/L/minute for mmol/L/minute", pointer.FromString("mmol/L/minute"), pointer.FromString("mmol/L/minute")),
+		Entry("returns mmol/L/minute for mg/dL/minute", pointer.FromString("mg/dL/minute"), pointer.FromString("mmol/L/minute")),
+	)
+
+	Context("NormalizeValueForRateUnits", func() {
+		DescribeTable("given value and units",
+			func(value *float64, rateUnits *string, expectedValue *float64) {
+				actualValue := glucose.NormalizeValueForRateUnits(value, rateUnits)
+				if expectedValue == nil {
+					Expect(actualValue).To(BeNil())
+				} else {
+					Expect(actualValue).ToNot(BeNil())
+					Expect(*actualValue).To(Equal(*expectedValue))
+				}
+			},
+			Entry("returns nil for nil value", nil, pointer.FromString("mmol/L/minute"), nil),
+			Entry("returns unchanged value for nil units", pointer.FromFloat64(1.0), nil, pointer.FromFloat64(1.0)),
+			Entry("returns unchanged value for unknown units", pointer.FromFloat64(1.0), pointer.FromString("unknown"), pointer.FromFloat64(1.0)),
+			Entry("returns unchanged value for mmol/L/minute units", pointer.FromFloat64(1.0), pointer.FromString("mmol/L/minute"), pointer.FromFloat64(1.0)),
+			Entry("returns converted value for mg/dL/minute units", pointer.FromFloat64(18.0), pointer.FromString("mg/dL/minute"), pointer.FromFloat64(0.99913)),
+		)
+
+		It("properly normalizes a range of mmol/L/minute values", func() {
+			for value := glucose.MmolLMinuteMinimum; value <= glucose.MmolLMinuteMaximum; value += 0.1 {
+				normalizedValue := glucose.NormalizeValueForRateUnits(pointer.FromFloat64(float64(value)), pointer.FromString("mmol/L/minute"))
+				Expect(normalizedValue).ToNot(BeNil())
+				Expect(*normalizedValue).To(Equal(value))
+			}
+		})
+
+		It("properly normalizes a range of mg/dL/minute values", func() {
+			for value := int(glucose.MgdLMinuteMinimum); value <= int(glucose.MgdLMinuteMaximum); value++ {
+				normalizedValue := glucose.NormalizeValueForRateUnits(pointer.FromFloat64(float64(value)), pointer.FromString("mg/dL/minute"))
+				Expect(normalizedValue).ToNot(BeNil())
+				Expect(int(*normalizedValue*18.01559 + math.Copysign(0.5, float64(value)))).To(Equal(value))
+			}
+		})
+	})
 })

data/blood/glucose/test/target.go

@@ -84,6 +84,26 @@ func ExpectNormalizedValue(value *float64, expectedValue *float64, units *string
 	}
 }
 
+func ExpectNormalizedRateUnits(value *string, expectedValue *string) {
+	if expectedValue != nil {
+		gomega.Expect(value).ToNot(gomega.BeNil())
+		gomega.Expect(*value).To(gomega.Equal(*dataBloodGlucose.NormalizeRateUnits(expectedValue)))
+		*expectedValue = *value
+	} else {
+		gomega.Expect(value).To(gomega.BeNil())
+	}
+}
+
+func ExpectNormalizedRateValue(value *float64, expectedValue *float64, units *string) {
+	if expectedValue != nil {
+		gomega.Expect(value).ToNot(gomega.BeNil())
+		gomega.Expect(*value).To(gomega.Equal(*dataBloodGlucose.NormalizeValueForRateUnits(expectedValue, units)))
+		*expectedValue = *value
+	} else {
+		gomega.Expect(value).To(gomega.BeNil())
+	}
+}
+
 func ExpectNormalizedTarget(datum *dataBloodGlucose.Target, expectedDatum *dataBloodGlucose.Target, units *string) {
 	gomega.Expect(datum).ToNot(gomega.BeNil())
 	gomega.Expect(expectedDatum).ToNot(gomega.BeNil())

data/types/blood/glucose/continuous/continuous.go

@@ -2,7 +2,8 @@ package continuous
 
 import (
 	"github.com/tidepool-org/platform/data"
-	"github.com/tidepool-org/platform/data/types/blood/glucose"
+	dataBloodGlucose "github.com/tidepool-org/platform/data/blood/glucose"
+	dataTypesBloodGlucose "github.com/tidepool-org/platform/data/types/blood/glucose"
 	"github.com/tidepool-org/platform/structure"
 )
 
@@ -17,27 +18,34 @@ const (
 	RapidFall    = "rapidFall"
 	RapidRise    = "rapidRise"
 
-	TrendRateMaximum      = 100
-	TrendRateMinimum      = -100
 	SampleIntervalMinimum = 0
 	SampleIntervalMaximum = 24 * 60 * 60 * 1000
 )
 
 func Trends() []string {
-	return []string{ConstantRate, SlowFall, SlowRise, ModerateFall, ModerateRise, RapidFall, RapidRise}
+	return []string{
+		ConstantRate,
+		SlowFall,
+		SlowRise,
+		ModerateFall,
+		ModerateRise,
+		RapidFall,
+		RapidRise,
+	}
 }
 
 type Continuous struct {
-	glucose.Glucose `bson:",inline"`
-	Trend           *string  `json:"trend,omitempty" bson:"trend,omitempty"`
-	TrendRate       *float64 `json:"trendRate,omitempty" bson:"trendRate,omitempty"`
-	SampleInterval  *int     `json:"sampleInterval,omitempty" bson:"sampleInterval,omitempty"`
-	Backfilled      *bool    `json:"backfilled,omitempty" bson:"backfilled,omitempty"`
+	dataTypesBloodGlucose.Glucose `bson:",inline"`
+	Trend                         *string  `json:"trend,omitempty" bson:"trend,omitempty"`
+	TrendRateUnits                *string  `json:"trendRateUnits,omitempty" bson:"trendRateUnits,omitempty"`
+	TrendRate                     *float64 `json:"trendRate,omitempty" bson:"trendRate,omitempty"`
+	SampleInterval                *int     `json:"sampleInterval,omitempty" bson:"sampleInterval,omitempty"`
+	Backfilled                    *bool    `json:"backfilled,omitempty" bson:"backfilled,omitempty"`
 }
 
 func New() *Continuous {
 	return &Continuous{
-		Glucose: glucose.New(Type),
+		Glucose: dataTypesBloodGlucose.New(Type),
 	}
 }
 
@@ -49,6 +57,7 @@ func (c *Continuous) Parse(parser structure.ObjectParser) {
 	c.Glucose.Parse(parser)
 
 	c.Trend = parser.String("trend")
+	c.TrendRateUnits = parser.String("trendRateUnits")
 	c.TrendRate = parser.Float64("trendRate")
 	c.SampleInterval = parser.Int("sampleInterval")
 	c.Backfilled = parser.Bool("backfilled")
@@ -66,7 +75,12 @@ func (c *Continuous) Validate(validator structure.Validator) {
 	}
 
 	validator.String("trend", c.Trend).OneOf(Trends()...)
-	validator.Float64("trendRate", c.TrendRate).InRange(TrendRateMinimum, TrendRateMaximum)
+	if trendRateUnitsValidator := validator.String("trendRateUnits", c.TrendRateUnits); c.TrendRate != nil {
+		trendRateUnitsValidator.Exists().OneOf(dataBloodGlucose.RateUnits()...)
+	} else {
+		trendRateUnitsValidator.NotExists()
+	}
+	validator.Float64("trendRate", c.TrendRate).InRange(dataBloodGlucose.ValueRangeForRateUnits(c.TrendRateUnits))
 	validator.Int("sampleInterval", c.SampleInterval).InRange(SampleIntervalMinimum, SampleIntervalMaximum)
 }
 
@@ -76,4 +90,10 @@ func (c *Continuous) Normalize(normalizer data.Normalizer) {
 	}
 
 	c.Glucose.Normalize(normalizer)
+
+	if normalizer.Origin() == structure.OriginExternal {
+		rateUnits := c.TrendRateUnits
+		c.TrendRateUnits = dataBloodGlucose.NormalizeRateUnits(rateUnits)
+		c.TrendRate = dataBloodGlucose.NormalizeValueForRateUnits(c.TrendRate, rateUnits)
+	}
 }