10 "github.com/octo/kraftakt/app"
11 "github.com/octo/kraftakt/fitbit"
12 "github.com/octo/retry"
14 oauth2google "golang.org/x/oauth2/google"
15 fitness "google.golang.org/api/fitness/v1"
16 "google.golang.org/api/googleapi"
17 "google.golang.org/appengine"
18 "google.golang.org/appengine/log"
24 dataTypeNameCalories = "com.google.calories.expended"
25 dataTypeNameDistance = "com.google.distance.delta"
26 dataTypeNameSteps = "com.google.step_count.delta"
27 dataTypeNameHeartrate = "com.google.heart_rate.summary"
28 dataTypeNameActivitySegment = "com.google.activity.segment"
31 func oauthConfig() *oauth2.Config {
32 return &oauth2.Config{
33 ClientID: app.Config.GoogleClientID,
34 ClientSecret: app.Config.GoogleClientSecret,
35 Endpoint: oauth2google.Endpoint,
36 RedirectURL: "https://kraftakt.octo.it/google/grant",
38 fitness.FitnessActivityWriteScope,
39 fitness.FitnessBodyWriteScope,
40 fitness.FitnessLocationWriteScope,
45 func AuthURL(ctx context.Context, u *app.User) string {
46 return oauthConfig().AuthCodeURL(u.Sign("Google"), oauth2.AccessTypeOffline)
49 func Application(ctx context.Context) *fitness.Application {
50 return &fitness.Application{
52 Version: appengine.VersionID(ctx),
53 DetailsUrl: "", // optional
57 func ParseToken(ctx context.Context, r *http.Request, u *app.User) error {
58 if state := r.FormValue("state"); state != u.Sign("Google") {
59 return fmt.Errorf("invalid state parameter: %q", state)
62 tok, err := oauthConfig().Exchange(ctx, r.FormValue("code"))
67 return u.SetToken(ctx, "Google", tok)
75 func NewClient(ctx context.Context, u *app.User) (*Client, error) {
76 c, err := u.OAuthClient(ctx, "Google", oauthConfig())
81 service, err := fitness.New(c)
92 func (c *Client) DeleteToken(ctx context.Context) error {
93 return c.appUser.DeleteToken(ctx, "Google")
96 func DataStreamID(dataSource *fitness.DataSource) string {
99 dataSource.DataType.Name,
100 app.Config.ProjectNumber,
103 if dev := dataSource.Device; dev != nil {
104 if dev.Manufacturer != "" {
105 fields = append(fields, dev.Manufacturer)
108 fields = append(fields, dev.Model)
111 fields = append(fields, dev.Uid)
115 if dataSource.DataStreamName != "" {
116 fields = append(fields, dataSource.DataStreamName)
119 return strings.Join(fields, ":")
122 func wrapGoogleError(err error) error {
127 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code >= 400 && gerr.Code < 500 {
128 return retry.Abort(err)
134 func (c *Client) DataSourceCreate(ctx context.Context, dataSource *fitness.DataSource) (string, error) {
135 var dataStreamID string
136 err := retry.Do(ctx, func(ctx context.Context) error {
137 res, err := c.Service.Users.DataSources.Create(userID, dataSource).Context(ctx).Do()
139 return wrapGoogleError(err)
141 dataStreamID = res.DataStreamId
145 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == http.StatusConflict {
146 if dataSource.DataStreamId != "" {
147 return dataSource.DataStreamId, nil
149 return DataStreamID(dataSource), nil
151 log.Errorf(ctx, "c.Service.Users.DataSources.Create(%q) = %v", DataStreamID(dataSource), err)
154 return dataStreamID, nil
157 func (c *Client) DatasetGet(ctx context.Context, dataStreamID string, startTime, endTime time.Time) (*fitness.Dataset, error) {
158 datasetID := fmt.Sprintf("%d-%d", startTime.UnixNano(), endTime.UnixNano())
160 var dataset *fitness.Dataset
161 err := retry.Do(ctx, func(ctx context.Context) error {
162 res, err := c.Service.Users.DataSources.Datasets.Get(userID, dataStreamID, datasetID).Context(ctx).Do()
164 return wrapGoogleError(err)
170 log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Get(%q, %q) = %v", dataStreamID, datasetID, err)
176 func (c *Client) DatasetPatch(ctx context.Context, dataSourceID string, points []*fitness.DataPoint) error {
177 startTimeNanos, endTimeNanos := int64(-1), int64(-1)
178 for _, p := range points {
179 if startTimeNanos == -1 || startTimeNanos > p.StartTimeNanos {
180 startTimeNanos = p.StartTimeNanos
182 if endTimeNanos == -1 || endTimeNanos < p.EndTimeNanos {
183 endTimeNanos = p.EndTimeNanos
186 datasetID := fmt.Sprintf("%d-%d", startTimeNanos, endTimeNanos)
188 dataset := &fitness.Dataset{
189 DataSourceId: dataSourceID,
190 MinStartTimeNs: startTimeNanos,
191 MaxEndTimeNs: endTimeNanos,
195 err := retry.Do(ctx, func(ctx context.Context) error {
196 _, err := c.Service.Users.DataSources.Datasets.Patch(userID, dataSourceID, datasetID, dataset).Context(ctx).Do()
197 return wrapGoogleError(err)
200 log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Patch() = %v", err)
206 func (c *Client) SetDistance(ctx context.Context, meters float64, startOfDay time.Time) error {
207 return c.updateCumulative(ctx,
209 Application: Application(ctx),
210 DataType: &fitness.DataType{
211 Field: []*fitness.DataTypeField{
212 &fitness.DataTypeField{
214 Format: "floatPoint",
217 Name: dataTypeNameDistance,
219 Name: "Distance covered",
228 func (c *Client) SetSteps(ctx context.Context, totalSteps int, startOfDay time.Time) error {
229 return c.updateCumulative(ctx,
231 Application: Application(ctx),
232 DataType: &fitness.DataType{
233 Field: []*fitness.DataTypeField{
234 &fitness.DataTypeField{
239 Name: dataTypeNameSteps,
245 IntVal: int64(totalSteps),
250 func (c *Client) SetCalories(ctx context.Context, totalCalories float64, startOfDay time.Time) error {
251 return c.updateCumulative(ctx,
253 Application: Application(ctx),
254 DataType: &fitness.DataType{
255 Field: []*fitness.DataTypeField{
256 &fitness.DataTypeField{
258 Format: "floatPoint",
261 Name: dataTypeNameCalories,
263 Name: "Calories expended",
267 FpVal: totalCalories,
272 type Activity struct {
278 func (a Activity) String() string {
279 return fmt.Sprintf("%s-%s %d", a.Start.Format("15:04:05"), a.End.Format("15:04:05"), a.Type)
282 func (c *Client) SetActivities(ctx context.Context, activities []Activity, startOfDay time.Time) error {
283 if len(activities) == 0 {
287 dataStreamID, err := c.DataSourceCreate(ctx, &fitness.DataSource{
288 Application: Application(ctx),
289 DataType: &fitness.DataType{
290 Field: []*fitness.DataTypeField{
291 &fitness.DataTypeField{
296 Name: dataTypeNameActivitySegment,
304 endOfDay := startOfDay.Add(24 * time.Hour).Add(-1 * time.Nanosecond)
306 dataset, err := c.DatasetGet(ctx, dataStreamID, startOfDay, endOfDay)
311 var dataPoints []*fitness.DataPoint
313 for _, a := range activities {
314 startTimeNanos := a.Start.UnixNano()
315 endTimeNanos := a.End.UnixNano()
317 for _, p := range dataset.Point {
318 if p.StartTimeNanos == startTimeNanos && p.EndTimeNanos == endTimeNanos && p.Value[0].IntVal == a.Type {
319 log.Debugf(ctx, "activity %s already stored in Google Fit", a)
324 log.Debugf(ctx, "activity %s will be added to Google Fit", a)
325 dataPoints = append(dataPoints, &fitness.DataPoint{
326 DataTypeName: dataTypeNameActivitySegment,
327 StartTimeNanos: startTimeNanos,
328 EndTimeNanos: endTimeNanos,
329 Value: []*fitness.Value{
330 &fitness.Value{IntVal: a.Type},
335 if len(dataPoints) == 0 {
339 return c.DatasetPatch(ctx, dataStreamID, dataPoints)
342 func (c *Client) updateCumulative(ctx context.Context, dataSource *fitness.DataSource, rawValue *fitness.Value, startOfDay time.Time) error {
343 switch f := dataSource.DataType.Field[0].Format; f {
345 if rawValue.IntVal == 0 {
349 if rawValue.FpVal == 0 {
353 return fmt.Errorf("unexpected data type field format %q", f)
356 dataSourceID, err := c.DataSourceCreate(ctx, dataSource)
360 dataSource.DataStreamId = dataSourceID
362 endOfDay := startOfDay.Add(24 * time.Hour).Add(-1 * time.Nanosecond)
363 currValue, startTime, err := c.readCumulative(ctx, dataSource, startOfDay, endOfDay)
368 var diffValue fitness.Value
369 if dataSource.DataType.Field[0].Format == "integer" {
370 if rawValue.IntVal == currValue.IntVal {
373 diffValue.IntVal = rawValue.IntVal - currValue.IntVal
374 if diffValue.IntVal < 0 {
375 log.Warningf(ctx, "stored value (%d) is larger than new value (%d); assuming count was reset", currValue.IntVal, rawValue.IntVal)
376 diffValue.IntVal = rawValue.IntVal
378 } else { // if dataSource.DataType.Field[0].Format == "floatPoint"
379 if rawValue.FpVal == currValue.FpVal {
382 diffValue.FpVal = rawValue.FpVal - currValue.FpVal
383 if diffValue.FpVal < 0 {
384 log.Warningf(ctx, "stored value (%g) is larger than new value (%g); assuming count was reset", currValue.FpVal, rawValue.FpVal)
385 diffValue.FpVal = rawValue.FpVal
390 if now := time.Now().In(startOfDay.Location()); now.Before(endOfDay) {
393 log.Debugf(ctx, "add cumulative data %s until %v: %+v", dataSource.DataStreamId, endTime, diffValue)
395 return c.DatasetPatch(ctx, dataSource.DataStreamId, []*fitness.DataPoint{
397 DataTypeName: dataSource.DataType.Name,
398 StartTimeNanos: startTime.UnixNano(),
399 EndTimeNanos: endTime.UnixNano(),
400 Value: []*fitness.Value{&diffValue},
405 func (c *Client) readCumulative(ctx context.Context, dataSource *fitness.DataSource, startTime, endTime time.Time) (*fitness.Value, time.Time, error) {
406 dataset, err := c.DatasetGet(ctx, dataSource.DataStreamId, startTime, endTime)
408 return nil, time.Time{}, err
411 if len(dataset.Point) == 0 {
412 log.Debugf(ctx, "read cumulative data %s until %v: []", dataSource.DataStreamId, endTime)
413 return &fitness.Value{}, startTime, nil
416 var sum fitness.Value
417 maxEndTime := startTime
418 for _, p := range dataset.Point {
419 switch f := dataSource.DataType.Field[0].Format; f {
421 sum.IntVal += p.Value[0].IntVal
423 sum.FpVal += p.Value[0].FpVal
425 return nil, time.Time{}, fmt.Errorf("unexpected data type field format %q", f)
428 pointEndTime := time.Unix(0, p.EndTimeNanos).In(startTime.Location())
429 if maxEndTime.Before(pointEndTime) {
430 maxEndTime = pointEndTime
434 log.Debugf(ctx, "read cumulative data %s until %v: %+v", dataSource.DataStreamId, maxEndTime, sum)
435 return &sum, maxEndTime, nil
438 type heartRateDuration struct {
441 Duration time.Duration
444 type heartRateDurations []*heartRateDuration
446 func (res heartRateDurations) find(min, max int) (*heartRateDuration, bool) {
447 for _, d := range res {
448 if d.Min != min || d.Max != max {
457 func (c *Client) heartRate(ctx context.Context, dataSource *fitness.DataSource, startTime, endTime time.Time) (heartRateDurations, time.Time, error) {
458 dataset, err := c.DatasetGet(ctx, dataSource.DataStreamId, startTime, endTime)
460 return nil, time.Time{}, err
463 if len(dataset.Point) == 0 {
464 return nil, startTime, nil
467 var results heartRateDurations
468 maxEndTime := startTime
469 for _, p := range dataset.Point {
470 max := int(p.Value[1].FpVal)
471 min := int(p.Value[2].FpVal)
472 duration := time.Unix(0, p.EndTimeNanos).Sub(time.Unix(0, p.StartTimeNanos))
474 if d, ok := results.find(min, max); ok {
475 d.Duration += duration
477 results = append(results, &heartRateDuration{
484 pointEndTime := time.Unix(0, p.EndTimeNanos).In(startTime.Location())
485 if maxEndTime.Before(pointEndTime) {
486 maxEndTime = pointEndTime
490 return results, maxEndTime, nil
493 func (c *Client) SetHeartRate(ctx context.Context, totalDurations []fitbit.HeartRateZone, restingHeartRate int, startOfDay time.Time) error {
494 dataSource := &fitness.DataSource{
495 Application: Application(ctx),
496 DataType: &fitness.DataType{
497 Field: []*fitness.DataTypeField{
498 &fitness.DataTypeField{
500 Format: "floatPoint",
502 &fitness.DataTypeField{
504 Format: "floatPoint",
506 &fitness.DataTypeField{
508 Format: "floatPoint",
511 Name: dataTypeNameHeartrate,
513 Name: "Heart rate summary",
517 dataSourceID, err := c.DataSourceCreate(ctx, dataSource)
521 dataSource.DataStreamId = dataSourceID
523 endOfDay := startOfDay.Add(24 * time.Hour).Add(-1 * time.Nanosecond)
524 prevDurations, startTime, err := c.heartRate(ctx, dataSource, startOfDay, endOfDay)
526 // calculate the difference between the durations mentioned in
527 // totalDurations and prevDurations and store it in diffDurations.
528 var diffDurations heartRateDurations
529 for _, d := range totalDurations {
530 total := time.Duration(d.Minutes) * time.Minute
532 var prev time.Duration
533 if res, ok := prevDurations.find(d.Min, d.Max); ok {
542 if res, ok := diffDurations.find(d.Min, d.Max); ok {
545 diffDurations = append(diffDurations, &heartRateDuration{
553 // create a fitness.DataPoint for each non-zero duration difference.
554 var dataPoints []*fitness.DataPoint
555 for _, d := range diffDurations {
556 if d.Duration < time.Nanosecond {
560 endTime := startTime.Add(d.Duration)
561 if endTime.After(endOfDay) {
562 log.Warningf(ctx, "heart rate durations exceed one day (current end time: %v)", endTime)
566 average := float64(d.Min+d.Max) / 2.0
567 if d.Min <= restingHeartRate && restingHeartRate <= d.Max {
568 average = float64(restingHeartRate)
571 dataPoints = append(dataPoints, &fitness.DataPoint{
572 DataTypeName: dataSource.DataType.Name,
573 StartTimeNanos: startTime.UnixNano(),
574 EndTimeNanos: endTime.UnixNano(),
575 Value: []*fitness.Value{
580 FpVal: float64(d.Max),
583 FpVal: float64(d.Min),
591 if len(dataPoints) == 0 {
594 return c.DatasetPatch(ctx, dataSource.DataStreamId, dataPoints)