From 70d6b9af6e5265c57d3e92bb3b08f902c45cedfc Mon Sep 17 00:00:00 2001
From: Florian Forster <ff@octo.it>
Date: Mon, 15 Jan 2018 10:02:19 +0100
Subject: [PATCH] Refactor writing of step values via the generic methods.

---
 gfit/gfit.go | 104 ++++++++++-------------------------------------------------
 1 file changed, 17 insertions(+), 87 deletions(-)

diff --git a/gfit/gfit.go b/gfit/gfit.go
index ac4815e..7540bf4 100644
--- a/gfit/gfit.go
+++ b/gfit/gfit.go
@@ -144,96 +144,26 @@ func (c *Client) DataSetPatch(ctx context.Context, dataSourceID string, points [
 	return nil
 }
 
-func (c *Client) Steps(ctx context.Context, startTime, endTime time.Time) (int, time.Time, error) {
-	dataSourceID := DataStreamID(&fitness.DataSource{
-		Type: "raw",
-		DataType: &fitness.DataType{
-			Name: dataTypeNameSteps,
-		},
-	})
-	datasetID := fmt.Sprintf("%d-%d", startTime.UnixNano(), endTime.UnixNano())
-
-	res, err := c.Service.Users.DataSources.Datasets.Get(userID, dataSourceID, datasetID).Context(ctx).Do()
-	if err != nil {
-		log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Get(%q, %q) = %v",
-			dataSourceID, datasetID, err)
-		return 0, time.Time{}, err
-	}
-
-	if len(res.Point) == 0 {
-		return 0, startTime, nil
-	}
-
-	steps := 0
-	maxEndTime := startTime
-	for _, p := range res.Point {
-		pointEndTime := time.Unix(0, p.EndTimeNanos).In(startTime.Location())
-		value := p.Value[0].IntVal
-
-		steps += int(value)
-		if maxEndTime.Before(pointEndTime) {
-			maxEndTime = pointEndTime
-		}
-	}
-
-	log.Debugf(ctx, "Google Fit has data points until %v: %d steps", maxEndTime, steps)
-	return steps, maxEndTime, nil
-}
-
 func (c *Client) SetSteps(ctx context.Context, totalSteps int, startOfDay time.Time) error {
-	if totalSteps == 0 {
-		return nil
-	}
-
-	dataSourceID, err := c.DataSourceCreate(ctx, &fitness.DataSource{
-		Application:    Application(ctx),
-		DataStreamName: "", // "daily summary"?
-		DataType: &fitness.DataType{
-			Field: []*fitness.DataTypeField{
-				&fitness.DataTypeField{
-					Format: "integer",
-					Name:   "steps",
+	return c.updateCumulative(ctx,
+		&fitness.DataSource{
+			Application: Application(ctx),
+			DataType: &fitness.DataType{
+				Field: []*fitness.DataTypeField{
+					&fitness.DataTypeField{
+						Name:   "steps",
+						Format: "integer",
+					},
 				},
+				Name: dataTypeNameSteps,
 			},
-			Name: dataTypeNameSteps,
+			Name: "Step Count",
+			Type: "raw",
 		},
-		Name: "Step Count",
-		Type: "raw",
-		// Type: "derived",
-	})
-	if err != nil {
-		return err
-	}
-
-	endOfDay := startOfDay.Add(24 * time.Hour).Add(-1 * time.Nanosecond)
-	prevSteps, startTime, err := c.Steps(ctx, startOfDay, endOfDay)
-	if totalSteps == prevSteps {
-		return nil
-	}
-	diffSteps := totalSteps - prevSteps
-	if diffSteps < 0 {
-		log.Warningf(ctx, "c.Steps returned %d steps, but current count is %d", prevSteps, totalSteps)
-		diffSteps = totalSteps
-	}
-	endTime := endOfDay
-	if now := time.Now().In(startOfDay.Location()); now.Before(endOfDay) {
-		endTime = now
-	}
-	log.Debugf(ctx, "new data point: %v-%v %d steps", startTime, endTime, diffSteps)
-
-	return c.DataSetPatch(ctx, dataSourceID, []*fitness.DataPoint{
-		&fitness.DataPoint{
-			ComputationTimeMillis: time.Now().UnixNano() / 1000000,
-			DataTypeName:          dataTypeNameSteps,
-			StartTimeNanos:        startTime.UnixNano(),
-			EndTimeNanos:          endTime.UnixNano(),
-			Value: []*fitness.Value{
-				&fitness.Value{
-					IntVal: int64(diffSteps),
-				},
-			},
+		&fitness.Value{
+			IntVal: int64(totalSteps),
 		},
-	})
+		startOfDay)
 }
 
 func (c *Client) SetCalories(ctx context.Context, totalCalories float64, startOfDay time.Time) error {
@@ -306,7 +236,7 @@ func (c *Client) updateCumulative(ctx context.Context, dataSource *fitness.DataS
 	if now := time.Now().In(startOfDay.Location()); now.Before(endOfDay) {
 		endTime = now
 	}
-	log.Debugf(ctx, "new cumulative data point: [%v--%v] %+v", startTime, endTime, diffValue)
+	log.Debugf(ctx, "adding cumulative data point: %v-%v %+v", startTime, endTime, diffValue)
 
 	return c.DataSetPatch(ctx, dataSource.DataStreamId, []*fitness.DataPoint{
 		&fitness.DataPoint{
@@ -349,6 +279,6 @@ func (c *Client) readCumulative(ctx context.Context, dataSource *fitness.DataSou
 		}
 	}
 
-	log.Debugf(ctx, "Google Fit has data points for %s until %v: %+v", dataSource.DataStreamId, maxEndTime, sum)
+	log.Debugf(ctx, "read cumulative data %s until %v: %+v", dataSource.DataStreamId, maxEndTime, sum)
 	return &sum, maxEndTime, nil
 }
-- 
2.11.0