10 "github.com/octo/gfitsync/app"
11 "github.com/octo/gfitsync/fitbit"
13 oauth2google "golang.org/x/oauth2/google"
14 fitness "google.golang.org/api/fitness/v1"
15 "google.golang.org/api/googleapi"
16 "google.golang.org/appengine"
17 "google.golang.org/appengine/log"
21 csrfToken = "@CSRFTOKEN@"
24 dataTypeNameCalories = "com.google.calories.expended"
25 dataTypeNameSteps = "com.google.step_count.delta"
26 dataTypeNameHeartrate = "com.google.heart_rate.summary"
29 var oauthConfig = &oauth2.Config{
30 ClientID: "@GOOGLE_CLIENT_ID@",
31 ClientSecret: "@GOOGLE_CLIENT_SECRET@",
32 Endpoint: oauth2google.Endpoint,
33 RedirectURL: "https://kraftakt.octo.it/google/grant",
35 fitness.FitnessActivityWriteScope,
36 fitness.FitnessBodyWriteScope,
40 func Application(ctx context.Context) *fitness.Application {
41 return &fitness.Application{
42 Name: "Fitbit to Google Fit sync",
43 Version: appengine.VersionID(ctx),
44 DetailsUrl: "", // optional
48 func AuthURL() string {
49 return oauthConfig.AuthCodeURL(csrfToken, oauth2.AccessTypeOffline)
52 func ParseToken(ctx context.Context, r *http.Request, u *app.User) error {
53 if state := r.FormValue("state"); state != csrfToken {
54 return fmt.Errorf("invalid state parameter: %q", state)
57 tok, err := oauthConfig.Exchange(ctx, r.FormValue("code"))
62 return u.SetToken(ctx, "Google", tok)
69 func NewClient(ctx context.Context, u *app.User) (*Client, error) {
70 c, err := u.OAuthClient(ctx, "Google", oauthConfig)
75 service, err := fitness.New(c)
85 func DataStreamID(dataSource *fitness.DataSource) string {
88 dataSource.DataType.Name,
89 "@PROJECT_NUMBER@", // FIXME
92 if dev := dataSource.Device; dev != nil {
93 if dev.Manufacturer != "" {
94 fields = append(fields, dev.Manufacturer)
97 fields = append(fields, dev.Model)
100 fields = append(fields, dev.Uid)
104 return strings.Join(fields, ":")
107 func (c *Client) DataSourceCreate(ctx context.Context, dataSource *fitness.DataSource) (string, error) {
108 res, err := c.Service.Users.DataSources.Create(userID, dataSource).Context(ctx).Do()
110 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == http.StatusConflict {
111 if dataSource.DataStreamId != "" {
112 return dataSource.DataStreamId, nil
114 return DataStreamID(dataSource), nil
116 log.Errorf(ctx, "c.Service.Users.DataSources.Create() = (%+v, %v)", res, err)
119 return res.DataStreamId, nil
122 func (c *Client) DataSetPatch(ctx context.Context, dataSourceID string, points []*fitness.DataPoint) error {
123 startTimeNanos, endTimeNanos := int64(-1), int64(-1)
124 for _, p := range points {
125 if startTimeNanos == -1 || startTimeNanos > p.StartTimeNanos {
126 startTimeNanos = p.StartTimeNanos
128 if endTimeNanos == -1 || endTimeNanos < p.EndTimeNanos {
129 endTimeNanos = p.EndTimeNanos
132 datasetID := fmt.Sprintf("%d-%d", startTimeNanos, endTimeNanos)
134 dataset := &fitness.Dataset{
135 DataSourceId: dataSourceID,
136 MinStartTimeNs: startTimeNanos,
137 MaxEndTimeNs: endTimeNanos,
141 _, err := c.Service.Users.DataSources.Datasets.Patch(userID, dataSourceID, datasetID, dataset).Context(ctx).Do()
143 log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Patch() = %v", err)
149 func (c *Client) SetSteps(ctx context.Context, totalSteps int, startOfDay time.Time) error {
150 return c.updateCumulative(ctx,
152 Application: Application(ctx),
153 DataType: &fitness.DataType{
154 Field: []*fitness.DataTypeField{
155 &fitness.DataTypeField{
160 Name: dataTypeNameSteps,
166 IntVal: int64(totalSteps),
171 func (c *Client) SetCalories(ctx context.Context, totalCalories float64, startOfDay time.Time) error {
172 return c.updateCumulative(ctx,
174 Application: Application(ctx),
175 DataType: &fitness.DataType{
176 Field: []*fitness.DataTypeField{
177 &fitness.DataTypeField{
179 Format: "floatPoint",
182 Name: dataTypeNameCalories,
184 Name: "Calories expended",
188 FpVal: totalCalories,
193 func (c *Client) updateCumulative(ctx context.Context, dataSource *fitness.DataSource, rawValue *fitness.Value, startOfDay time.Time) error {
194 switch f := dataSource.DataType.Field[0].Format; f {
196 if rawValue.IntVal == 0 {
200 if rawValue.FpVal == 0 {
204 return fmt.Errorf("unexpected data type field format %q", f)
207 dataSourceID, err := c.DataSourceCreate(ctx, dataSource)
211 dataSource.DataStreamId = dataSourceID
213 endOfDay := startOfDay.Add(24 * time.Hour).Add(-1 * time.Nanosecond)
214 currValue, startTime, err := c.readCumulative(ctx, dataSource, startOfDay, endOfDay)
216 var diffValue fitness.Value
217 if dataSource.DataType.Field[0].Format == "integer" {
218 if rawValue.IntVal == currValue.IntVal {
221 diffValue.IntVal = rawValue.IntVal - currValue.IntVal
222 if diffValue.IntVal < 0 {
223 log.Warningf(ctx, "stored value (%d) is larger than new value (%d); assuming count was reset", currValue.IntVal, rawValue.IntVal)
224 diffValue.IntVal = rawValue.IntVal
226 } else { // if dataSource.DataType.Field[0].Format == "floatPoint"
227 if rawValue.FpVal == currValue.FpVal {
230 diffValue.FpVal = rawValue.FpVal - currValue.FpVal
231 if diffValue.FpVal < 0 {
232 log.Warningf(ctx, "stored value (%g) is larger than new value (%g); assuming count was reset", currValue.FpVal, rawValue.FpVal)
233 diffValue.FpVal = rawValue.FpVal
238 if now := time.Now().In(startOfDay.Location()); now.Before(endOfDay) {
241 log.Debugf(ctx, "adding cumulative data point: %v-%v %+v", startTime, endTime, diffValue)
243 return c.DataSetPatch(ctx, dataSource.DataStreamId, []*fitness.DataPoint{
245 DataTypeName: dataSource.DataType.Name,
246 StartTimeNanos: startTime.UnixNano(),
247 EndTimeNanos: endTime.UnixNano(),
248 Value: []*fitness.Value{&diffValue},
253 func (c *Client) readCumulative(ctx context.Context, dataSource *fitness.DataSource, startTime, endTime time.Time) (*fitness.Value, time.Time, error) {
254 datasetID := fmt.Sprintf("%d-%d", startTime.UnixNano(), endTime.UnixNano())
256 res, err := c.Service.Users.DataSources.Datasets.Get(userID, dataSource.DataStreamId, datasetID).Context(ctx).Do()
258 log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Get(%q, %q) = %v", dataSource.DataStreamId, datasetID, err)
259 return nil, time.Time{}, err
262 if len(res.Point) == 0 {
263 return &fitness.Value{}, startTime, nil
266 var sum fitness.Value
267 maxEndTime := startTime
268 for _, p := range res.Point {
269 switch f := dataSource.DataType.Field[0].Format; f {
271 sum.IntVal += p.Value[0].IntVal
273 sum.FpVal += p.Value[0].FpVal
275 return nil, time.Time{}, fmt.Errorf("unexpected data type field format %q", f)
278 pointEndTime := time.Unix(0, p.EndTimeNanos).In(startTime.Location())
279 if maxEndTime.Before(pointEndTime) {
280 maxEndTime = pointEndTime
284 log.Debugf(ctx, "read cumulative data %s until %v: %+v", dataSource.DataStreamId, maxEndTime, sum)
285 return &sum, maxEndTime, nil
288 type heartRateDuration struct {
291 Duration time.Duration
294 type heartRateDurations []*heartRateDuration
296 func (res heartRateDurations) find(min, max int) (*heartRateDuration, bool) {
297 for _, d := range res {
298 if d.Min != min || d.Max != max {
307 func (c *Client) heartRate(ctx context.Context, dataSource *fitness.DataSource, startTime, endTime time.Time) (heartRateDurations, time.Time, error) {
308 datasetID := fmt.Sprintf("%d-%d", startTime.UnixNano(), endTime.UnixNano())
310 res, err := c.Service.Users.DataSources.Datasets.Get(userID, dataSource.DataStreamId, datasetID).Context(ctx).Do()
312 log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Get(%q, %q) = %v", dataSource.DataStreamId, datasetID, err)
313 return nil, time.Time{}, err
316 if len(res.Point) == 0 {
317 return nil, startTime, nil
320 var results heartRateDurations
321 maxEndTime := startTime
322 for _, p := range res.Point {
323 max := int(p.Value[1].FpVal)
324 min := int(p.Value[2].FpVal)
325 duration := time.Unix(0, p.EndTimeNanos).Sub(time.Unix(0, p.StartTimeNanos))
327 if d, ok := results.find(min, max); ok {
328 d.Duration += duration
330 results = append(results, &heartRateDuration{
337 pointEndTime := time.Unix(0, p.EndTimeNanos).In(startTime.Location())
338 if maxEndTime.Before(pointEndTime) {
339 maxEndTime = pointEndTime
343 return results, maxEndTime, nil
346 func (c *Client) SetHeartRate(ctx context.Context, totalDurations []fitbit.HeartRateZone, startOfDay time.Time) error {
347 dataSource := &fitness.DataSource{
348 Application: Application(ctx),
349 DataType: &fitness.DataType{
350 Field: []*fitness.DataTypeField{
351 &fitness.DataTypeField{
353 Format: "floatPoint",
355 &fitness.DataTypeField{
357 Format: "floatPoint",
359 &fitness.DataTypeField{
361 Format: "floatPoint",
364 Name: dataTypeNameHeartrate,
366 Name: "Heart rate summary",
370 dataSourceID, err := c.DataSourceCreate(ctx, dataSource)
374 dataSource.DataStreamId = dataSourceID
376 endOfDay := startOfDay.Add(24 * time.Hour).Add(-1 * time.Nanosecond)
377 prevDurations, startTime, err := c.heartRate(ctx, dataSource, startOfDay, endOfDay)
379 // calculate the difference between the durations mentioned in
380 // totalDurations and prevDurations and store it in diffDurations.
381 var diffDurations heartRateDurations
382 for _, d := range totalDurations {
383 total := time.Duration(d.Minutes) * time.Minute
385 var prev time.Duration
386 if res, ok := prevDurations.find(d.Min, d.Max); ok {
395 if res, ok := diffDurations.find(d.Min, d.Max); ok {
398 diffDurations = append(diffDurations, &heartRateDuration{
406 // create a fitness.DataPoint for each non-zero duration difference.
407 var dataPoints []*fitness.DataPoint
408 for _, d := range diffDurations {
409 if d.Duration < time.Nanosecond {
413 endTime := startTime.Add(d.Duration)
414 if endTime.After(endOfDay) {
415 log.Warningf(ctx, "heart rate durations exceed one day (current end time: %v)", endTime)
419 average := float64(d.Min+d.Max) / 2.0
420 if d.Min <= restingHeartRate && restingHeartRate <= d.Max {
421 average = float64(restingHeartRate)
424 dataPoints = append(dataPoints, &fitness.DataPoint{
425 DataTypeName: dataSource.DataType.Name,
426 StartTimeNanos: startTime.UnixNano(),
427 EndTimeNanos: endTime.UnixNano(),
428 Value: []*fitness.Value{
433 FpVal: float64(d.Max),
436 FpVal: float64(d.Min),
444 if len(dataPoints) == 0 {
447 return c.DataSetPatch(ctx, dataSource.DataStreamId, dataPoints)