Merge branch 'master' into jf_deduplication

Author: jh-bate

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,28 +155,87 @@ var _ = Describe("Glucose", func() {
 			}
 		})
 	})
+
 	Context("NormalizeValueForUnitsWithFullPrecision", func() {
 		DescribeTable("given value and units",
 			func(value *float64, units *string, expectedValue *float64) {
 				actualValue := glucose.NormalizeValueForUnitsWithFullPrecision(value, units)
-				if expectedValue == nil {
-					Expect(actualValue).To(BeNil())
-				} else {
-					Expect(actualValue).ToNot(BeNil())
-					Expect(*actualValue).To(Equal(*expectedValue))
-				}
+				Expect(actualValue).To(Equal(expectedValue))
 			},
 			Entry("returns nil for nil value", nil, pointer.FromString("mmol/L"), nil),
 			Entry("returns unchanged value for nil units", pointer.FromFloat64(10.0), nil, pointer.FromFloat64(10.0)),
 			Entry("returns unchanged value for unknown units", pointer.FromFloat64(10.0), pointer.FromString("unknown"), pointer.FromFloat64(10.0)),
 			Entry("returns unchanged value for mmol/L units", pointer.FromFloat64(10.0), pointer.FromString("mmol/L"), pointer.FromFloat64(10.0)),
 			Entry("returns unchanged value for mmol/l units", pointer.FromFloat64(10.0), pointer.FromString("mmol/l"), pointer.FromFloat64(10.0)),
-
 			Entry("returns converted value for mg/dL units", pointer.FromFloat64(140.0), pointer.FromString("mg/dL"), pointer.FromFloat64(7.771047187463747)),
 			Entry("returns converted value for mg/dL units", pointer.FromFloat64(100.0), pointer.FromString("mg/dL"), pointer.FromFloat64(5.550747991045533)),
 			Entry("returns converted value for mg/dl units", pointer.FromFloat64(80.0), pointer.FromString("mg/dl"), pointer.FromFloat64(4.440598392836427)),
 			Entry("returns converted value for mg/dl units", pointer.FromFloat64(69.0), pointer.FromString("mg/dl"), pointer.FromFloat64(3.830016113821418)),
 			Entry("returns converted value for mg/dl units", pointer.FromFloat64(50.0), pointer.FromString("mg/dl"), pointer.FromFloat64(2.7753739955227665)),
 		)
 	})
+
+	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/service/api/v1/partners.go

@@ -0,0 +1,46 @@
+package v1
+
+import (
+	"net/http"
+	"os"
+
+	dataService "github.com/tidepool-org/platform/data/service"
+	"github.com/tidepool-org/platform/request"
+)
+
+// TODO: https://tidepool.atlassian.net/browse/BACK-3394 - This implementation is a
+// temporary placeholder to allow bootstrapping of the Abbott OAuth client workflow.
+// Will need to migrate this to environment variables and add minimal authorization.
+// For now, though, this is acceptable since it isn't revealing anything that is not
+// already available in other locations (i.e. other public repos).
+
+func PartnersSector(dataServiceContext dataService.Context) {
+	res := dataServiceContext.Response()
+	req := dataServiceContext.Request()
+	responder := request.MustNewResponder(res, req)
+
+	if partnerSectorIdentifers, ok := namespacePartnerSectorIdentifers[os.Getenv("POD_NAMESPACE")]; ok {
+		if sectorIdentifier, ok := partnerSectorIdentifers[req.PathParam("partner")]; ok {
+			responder.Data(http.StatusOK, sectorIdentifier)
+			return
+		}
+	}
+
+	responder.Data(http.StatusOK, []string{})
+}
+
+var namespacePartnerSectorIdentifers = map[string]map[string][]string{
+	"external": {
+		"abbott": {
+			"https://external.integration.tidepool.org/v1/oauth/abbott/redirect",
+			"https://external.integration.tidepool.org/v1/oauth/abbott-private-1/redirect",
+			"https://external.integration.tidepool.org/v1/oauth/abbott-private-2/redirect",
+			"https://qa1.development.tidepool.org/v1/oauth/abbott/redirect",
+			"https://qa2.development.tidepool.org/v1/oauth/abbott/redirect",
+			"https://qa3.development.tidepool.org/v1/oauth/abbott/redirect",
+			"https://qa4.development.tidepool.org/v1/oauth/abbott/redirect",
+			"https://qa5.development.tidepool.org/v1/oauth/abbott/redirect",
+			"https://dev1.dev.tidepool.org/v1/oauth/abbott/redirect",
+		},
+	},
+}

data/service/api/v1/v1.go

@@ -20,6 +20,8 @@ func Routes() []service.Route {
 		service.Put("/v1/data_sets/:dataSetId", DataSetsUpdate, api.RequireAuth),
 		service.Get("/v1/time", TimeGet),
 		service.Post("/v1/users/:userId/data_sets", UsersDataSetsCreate, api.RequireAuth),
+
+		service.Get("/v1/partners/:partner/sector", PartnersSector),
 	}
 
 	routes = append(routes, DataSetsRoutes()...)