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 dataTypeNameDistance = "com.google.distance.delta"
26 dataTypeNameSteps = "com.google.step_count.delta"
27 dataTypeNameHeartrate = "com.google.heart_rate.summary"
30 var oauthConfig = &oauth2.Config{
31 ClientID: "@GOOGLE_CLIENT_ID@",
32 ClientSecret: "@GOOGLE_CLIENT_SECRET@",
33 Endpoint: oauth2google.Endpoint,
34 RedirectURL: "https://kraftakt.octo.it/google/grant",
36 fitness.FitnessActivityWriteScope,
37 fitness.FitnessBodyWriteScope,
38 fitness.FitnessLocationWriteScope,
42 func Application(ctx context.Context) *fitness.Application {
43 return &fitness.Application{
44 Name: "Fitbit to Google Fit sync",
45 Version: appengine.VersionID(ctx),
46 DetailsUrl: "", // optional
50 func AuthURL() string {
51 return oauthConfig.AuthCodeURL(csrfToken, oauth2.AccessTypeOffline)
54 func ParseToken(ctx context.Context, r *http.Request, u *app.User) error {
55 if state := r.FormValue("state"); state != csrfToken {
56 return fmt.Errorf("invalid state parameter: %q", state)
59 tok, err := oauthConfig.Exchange(ctx, r.FormValue("code"))
64 return u.SetToken(ctx, "Google", tok)
71 func NewClient(ctx context.Context, u *app.User) (*Client, error) {
72 c, err := u.OAuthClient(ctx, "Google", oauthConfig)
77 service, err := fitness.New(c)
87 func DataStreamID(dataSource *fitness.DataSource) string {
90 dataSource.DataType.Name,
91 "@PROJECT_NUMBER@", // FIXME
94 if dev := dataSource.Device; dev != nil {
95 if dev.Manufacturer != "" {
96 fields = append(fields, dev.Manufacturer)
99 fields = append(fields, dev.Model)
102 fields = append(fields, dev.Uid)
106 if dataSource.DataStreamName != "" {
107 fields = append(fields, dataSource.DataStreamName)
110 return strings.Join(fields, ":")
113 func (c *Client) DataSourceCreate(ctx context.Context, dataSource *fitness.DataSource) (string, error) {
114 res, err := c.Service.Users.DataSources.Create(userID, dataSource).Context(ctx).Do()
116 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == http.StatusConflict {
117 if dataSource.DataStreamId != "" {
118 return dataSource.DataStreamId, nil
120 return DataStreamID(dataSource), nil
122 log.Errorf(ctx, "c.Service.Users.DataSources.Create() = (%+v, %v)", res, err)
125 return res.DataStreamId, nil
128 func (c *Client) DataSetPatch(ctx context.Context, dataSourceID string, points []*fitness.DataPoint) error {
129 startTimeNanos, endTimeNanos := int64(-1), int64(-1)
130 for _, p := range points {
131 if startTimeNanos == -1 || startTimeNanos > p.StartTimeNanos {
132 startTimeNanos = p.StartTimeNanos
134 if endTimeNanos == -1 || endTimeNanos < p.EndTimeNanos {
135 endTimeNanos = p.EndTimeNanos
138 datasetID := fmt.Sprintf("%d-%d", startTimeNanos, endTimeNanos)
140 dataset := &fitness.Dataset{
141 DataSourceId: dataSourceID,
142 MinStartTimeNs: startTimeNanos,
143 MaxEndTimeNs: endTimeNanos,
147 _, err := c.Service.Users.DataSources.Datasets.Patch(userID, dataSourceID, datasetID, dataset).Context(ctx).Do()
149 log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Patch() = %v", err)
155 func (c *Client) SetDistance(ctx context.Context, meters float64, startOfDay time.Time) error {
156 return c.updateCumulative(ctx,
158 Application: Application(ctx),
159 DataType: &fitness.DataType{
160 Field: []*fitness.DataTypeField{
161 &fitness.DataTypeField{
163 Format: "floatPoint",
166 Name: dataTypeNameDistance,
168 Name: "Distance covered",
177 func (c *Client) SetSteps(ctx context.Context, totalSteps int, startOfDay time.Time) error {
178 return c.updateCumulative(ctx,
180 Application: Application(ctx),
181 DataType: &fitness.DataType{
182 Field: []*fitness.DataTypeField{
183 &fitness.DataTypeField{
188 Name: dataTypeNameSteps,
194 IntVal: int64(totalSteps),
199 func (c *Client) SetCalories(ctx context.Context, totalCalories float64, startOfDay time.Time) error {
200 return c.updateCumulative(ctx,
202 Application: Application(ctx),
203 DataType: &fitness.DataType{
204 Field: []*fitness.DataTypeField{
205 &fitness.DataTypeField{
207 Format: "floatPoint",
210 Name: dataTypeNameCalories,
212 Name: "Calories expended",
216 FpVal: totalCalories,
221 func (c *Client) updateCumulative(ctx context.Context, dataSource *fitness.DataSource, rawValue *fitness.Value, startOfDay time.Time) error {
222 switch f := dataSource.DataType.Field[0].Format; f {
224 if rawValue.IntVal == 0 {
228 if rawValue.FpVal == 0 {
232 return fmt.Errorf("unexpected data type field format %q", f)
235 dataSourceID, err := c.DataSourceCreate(ctx, dataSource)
239 dataSource.DataStreamId = dataSourceID
241 endOfDay := startOfDay.Add(24 * time.Hour).Add(-1 * time.Nanosecond)
242 currValue, startTime, err := c.readCumulative(ctx, dataSource, startOfDay, endOfDay)
244 var diffValue fitness.Value
245 if dataSource.DataType.Field[0].Format == "integer" {
246 if rawValue.IntVal == currValue.IntVal {
249 diffValue.IntVal = rawValue.IntVal - currValue.IntVal
250 if diffValue.IntVal < 0 {
251 log.Warningf(ctx, "stored value (%d) is larger than new value (%d); assuming count was reset", currValue.IntVal, rawValue.IntVal)
252 diffValue.IntVal = rawValue.IntVal
254 } else { // if dataSource.DataType.Field[0].Format == "floatPoint"
255 if rawValue.FpVal == currValue.FpVal {
258 diffValue.FpVal = rawValue.FpVal - currValue.FpVal
259 if diffValue.FpVal < 0 {
260 log.Warningf(ctx, "stored value (%g) is larger than new value (%g); assuming count was reset", currValue.FpVal, rawValue.FpVal)
261 diffValue.FpVal = rawValue.FpVal
266 if now := time.Now().In(startOfDay.Location()); now.Before(endOfDay) {
269 log.Debugf(ctx, "adding cumulative data point: %v-%v %+v", startTime, endTime, diffValue)
271 return c.DataSetPatch(ctx, dataSource.DataStreamId, []*fitness.DataPoint{
273 DataTypeName: dataSource.DataType.Name,
274 StartTimeNanos: startTime.UnixNano(),
275 EndTimeNanos: endTime.UnixNano(),
276 Value: []*fitness.Value{&diffValue},
281 func (c *Client) readCumulative(ctx context.Context, dataSource *fitness.DataSource, startTime, endTime time.Time) (*fitness.Value, time.Time, error) {
282 datasetID := fmt.Sprintf("%d-%d", startTime.UnixNano(), endTime.UnixNano())
284 res, err := c.Service.Users.DataSources.Datasets.Get(userID, dataSource.DataStreamId, datasetID).Context(ctx).Do()
286 log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Get(%q, %q) = %v", dataSource.DataStreamId, datasetID, err)
287 return nil, time.Time{}, err
290 if len(res.Point) == 0 {
291 return &fitness.Value{}, startTime, nil
294 var sum fitness.Value
295 maxEndTime := startTime
296 for _, p := range res.Point {
297 switch f := dataSource.DataType.Field[0].Format; f {
299 sum.IntVal += p.Value[0].IntVal
301 sum.FpVal += p.Value[0].FpVal
303 return nil, time.Time{}, fmt.Errorf("unexpected data type field format %q", f)
306 pointEndTime := time.Unix(0, p.EndTimeNanos).In(startTime.Location())
307 if maxEndTime.Before(pointEndTime) {
308 maxEndTime = pointEndTime
312 log.Debugf(ctx, "read cumulative data %s until %v: %+v", dataSource.DataStreamId, maxEndTime, sum)
313 return &sum, maxEndTime, nil
316 type heartRateDuration struct {
319 Duration time.Duration
322 type heartRateDurations []*heartRateDuration
324 func (res heartRateDurations) find(min, max int) (*heartRateDuration, bool) {
325 for _, d := range res {
326 if d.Min != min || d.Max != max {
335 func (c *Client) heartRate(ctx context.Context, dataSource *fitness.DataSource, startTime, endTime time.Time) (heartRateDurations, time.Time, error) {
336 datasetID := fmt.Sprintf("%d-%d", startTime.UnixNano(), endTime.UnixNano())
338 res, err := c.Service.Users.DataSources.Datasets.Get(userID, dataSource.DataStreamId, datasetID).Context(ctx).Do()
340 log.Errorf(ctx, "c.Service.Users.DataSources.Datasets.Get(%q, %q) = %v", dataSource.DataStreamId, datasetID, err)
341 return nil, time.Time{}, err
344 if len(res.Point) == 0 {
345 return nil, startTime, nil
348 var results heartRateDurations
349 maxEndTime := startTime
350 for _, p := range res.Point {
351 max := int(p.Value[1].FpVal)
352 min := int(p.Value[2].FpVal)
353 duration := time.Unix(0, p.EndTimeNanos).Sub(time.Unix(0, p.StartTimeNanos))
355 if d, ok := results.find(min, max); ok {
356 d.Duration += duration
358 results = append(results, &heartRateDuration{
365 pointEndTime := time.Unix(0, p.EndTimeNanos).In(startTime.Location())
366 if maxEndTime.Before(pointEndTime) {
367 maxEndTime = pointEndTime
371 return results, maxEndTime, nil
374 func (c *Client) SetHeartRate(ctx context.Context, totalDurations []fitbit.HeartRateZone, restingHeartRate int, startOfDay time.Time) error {
375 dataSource := &fitness.DataSource{
376 Application: Application(ctx),
377 DataType: &fitness.DataType{
378 Field: []*fitness.DataTypeField{
379 &fitness.DataTypeField{
381 Format: "floatPoint",
383 &fitness.DataTypeField{
385 Format: "floatPoint",
387 &fitness.DataTypeField{
389 Format: "floatPoint",
392 Name: dataTypeNameHeartrate,
394 Name: "Heart rate summary",
398 dataSourceID, err := c.DataSourceCreate(ctx, dataSource)
402 dataSource.DataStreamId = dataSourceID
404 endOfDay := startOfDay.Add(24 * time.Hour).Add(-1 * time.Nanosecond)
405 prevDurations, startTime, err := c.heartRate(ctx, dataSource, startOfDay, endOfDay)
407 // calculate the difference between the durations mentioned in
408 // totalDurations and prevDurations and store it in diffDurations.
409 var diffDurations heartRateDurations
410 for _, d := range totalDurations {
411 total := time.Duration(d.Minutes) * time.Minute
413 var prev time.Duration
414 if res, ok := prevDurations.find(d.Min, d.Max); ok {
423 if res, ok := diffDurations.find(d.Min, d.Max); ok {
426 diffDurations = append(diffDurations, &heartRateDuration{
434 // create a fitness.DataPoint for each non-zero duration difference.
435 var dataPoints []*fitness.DataPoint
436 for _, d := range diffDurations {
437 if d.Duration < time.Nanosecond {
441 endTime := startTime.Add(d.Duration)
442 if endTime.After(endOfDay) {
443 log.Warningf(ctx, "heart rate durations exceed one day (current end time: %v)", endTime)
447 average := float64(d.Min+d.Max) / 2.0
448 if d.Min <= restingHeartRate && restingHeartRate <= d.Max {
449 average = float64(restingHeartRate)
452 dataPoints = append(dataPoints, &fitness.DataPoint{
453 DataTypeName: dataSource.DataType.Name,
454 StartTimeNanos: startTime.UnixNano(),
455 EndTimeNanos: endTime.UnixNano(),
456 Value: []*fitness.Value{
461 FpVal: float64(d.Max),
464 FpVal: float64(d.Min),
472 if len(dataPoints) == 0 {
475 return c.DataSetPatch(ctx, dataSource.DataStreamId, dataPoints)