kraftakt.go

   1 package kraftakt
   2
   3 import (
   4         "context"
   5         "encoding/json"
   6         "fmt"
   7         "io/ioutil"
   8         "net/http"
   9         "sync"
  10         "time"
  11
  12         "github.com/octo/kraftakt/app"
  13         "github.com/octo/kraftakt/fitbit"
  14         "github.com/octo/kraftakt/gfit"
  15         "google.golang.org/appengine"
  16         "google.golang.org/appengine/datastore"
  17         "google.golang.org/appengine/delay"
  18         "google.golang.org/appengine/log"
  19         "google.golang.org/appengine/user"
  20 )
  21
  22 var delayedHandleNotifications = delay.Func("handleNotifications", handleNotifications)
  23
  24 func init() {
  25         http.HandleFunc("/fitbit/setup", fitbitSetupHandler)
  26         http.Handle("/fitbit/grant", AuthenticatedHandler(fitbitGrantHandler))
  27         http.Handle("/fitbit/notify", ContextHandler(fitbitNotifyHandler))
  28         http.HandleFunc("/google/setup", googleSetupHandler)
  29         http.Handle("/google/grant", AuthenticatedHandler(googleGrantHandler))
  30         http.Handle("/", AuthenticatedHandler(indexHandler))
  31 }
  32
  33 // ContextHandler implements http.Handler
  34 type ContextHandler func(context.Context, http.ResponseWriter, *http.Request) error
  35
  36 func (hndl ContextHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  37         ctx := appengine.NewContext(r)
  38
  39         if err := app.LoadConfig(ctx); err != nil {
  40                 http.Error(w, err.Error(), http.StatusInternalServerError)
  41                 return
  42         }
  43
  44         if err := hndl(ctx, w, r); err != nil {
  45                 http.Error(w, err.Error(), http.StatusInternalServerError)
  46                 return
  47         }
  48 }
  49
  50 type AuthenticatedHandler func(context.Context, http.ResponseWriter, *http.Request, *app.User) error
  51
  52 func (hndl AuthenticatedHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  53         ctx := appengine.NewContext(r)
  54
  55         if err := app.LoadConfig(ctx); err != nil {
  56                 http.Error(w, err.Error(), http.StatusInternalServerError)
  57                 return
  58         }
  59
  60         gaeUser := user.Current(ctx)
  61         if gaeUser == nil {
  62                 url, err := user.LoginURL(ctx, r.URL.String())
  63                 if err != nil {
  64                         http.Error(w, err.Error(), http.StatusInternalServerError)
  65                         return
  66                 }
  67                 http.Redirect(w, r, url, http.StatusTemporaryRedirect)
  68                 return
  69         }
  70
  71         u, err := app.NewUser(ctx, gaeUser.Email)
  72         if err != nil {
  73                 http.Error(w, err.Error(), http.StatusInternalServerError)
  74                 return
  75         }
  76
  77         if err := hndl(ctx, w, r, u); err != nil {
  78                 http.Error(w, err.Error(), http.StatusInternalServerError)
  79                 return
  80         }
  81 }
  82
  83 func indexHandler(ctx context.Context, w http.ResponseWriter, r *http.Request, u *app.User) error {
  84         _, err := u.Token(ctx, "Fitbit")
  85         if err != nil && err != datastore.ErrNoSuchEntity {
  86                 return err
  87         }
  88         haveFitbitToken := err == nil
  89
  90         _, err = u.Token(ctx, "Google")
  91         if err != nil && err != datastore.ErrNoSuchEntity {
  92                 return err
  93         }
  94         haveGoogleToken := err == nil
  95
  96         fmt.Fprintln(w, "<html><head><title>Kraftakt</title></head>")
  97         fmt.Fprintln(w, "<body><h1>Kraftakt</h1>")
  98
  99         fmt.Fprintln(w, "<p><strong>Kraftakt</strong> copies your <em>Fitbit</em> data to <em>Google Fit</em>, seconds after you sync.</p>")
 100
 101         fmt.Fprintf(w, "<p>Hello %s</p>\n", user.Current(ctx).Email)
 102         fmt.Fprintln(w, "<ul>")
 103
 104         fmt.Fprint(w, "<li>Fitbit: ")
 105         if haveFitbitToken {
 106                 fmt.Fprint(w, `<strong style="color: DarkGreen;">Authorized</strong>`)
 107         } else {
 108                 fmt.Fprint(w, `<strong style="color: DarkRed;">Not authorized</strong> (<a href="/fitbit/setup">Authorize</a>)`)
 109         }
 110         fmt.Fprintln(w, "</li>")
 111
 112         fmt.Fprint(w, "<li>Google Fit: ")
 113         if haveGoogleToken {
 114                 fmt.Fprint(w, `<strong style="color: DarkGreen;">Authorized</strong>`)
 115         } else {
 116                 fmt.Fprint(w, `<strong style="color: DarkRed;">Not authorized</strong> (<a href="/google/setup">Authorize</a>)`)
 117         }
 118         fmt.Fprintln(w, "</li>")
 119
 120         fmt.Fprintln(w, "</ul>")
 121         fmt.Fprintln(w, "</body></html>")
 122
 123         return nil
 124 }
 125
 126 func fitbitSetupHandler(w http.ResponseWriter, r *http.Request) {
 127         http.Redirect(w, r, fitbit.AuthURL(), http.StatusTemporaryRedirect)
 128 }
 129
 130 func fitbitGrantHandler(ctx context.Context, w http.ResponseWriter, r *http.Request, u *app.User) error {
 131         if err := fitbit.ParseToken(ctx, r, u); err != nil {
 132                 return err
 133         }
 134         c, err := fitbit.NewClient(ctx, "-", u)
 135         if err != nil {
 136                 return err
 137         }
 138
 139         for _, collection := range []string{"activities", "sleep"} {
 140                 if err := c.Subscribe(ctx, collection); err != nil {
 141                         return fmt.Errorf("c.Subscribe(%q) = %v", collection, err)
 142                 }
 143                 log.Infof(ctx, "Successfully subscribed to %q", collection)
 144         }
 145
 146         redirectURL := r.URL
 147         redirectURL.Path = "/"
 148         redirectURL.RawQuery = ""
 149         redirectURL.Fragment = ""
 150         http.Redirect(w, r, redirectURL.String(), http.StatusTemporaryRedirect)
 151         return nil
 152 }
 153
 154 func googleSetupHandler(w http.ResponseWriter, r *http.Request) {
 155         http.Redirect(w, r, gfit.AuthURL(), http.StatusTemporaryRedirect)
 156 }
 157
 158 func googleGrantHandler(ctx context.Context, w http.ResponseWriter, r *http.Request, u *app.User) error {
 159         if err := gfit.ParseToken(ctx, r, u); err != nil {
 160                 return err
 161         }
 162
 163         redirectURL := r.URL
 164         redirectURL.Path = "/"
 165         redirectURL.RawQuery = ""
 166         redirectURL.Fragment = ""
 167         http.Redirect(w, r, redirectURL.String(), http.StatusTemporaryRedirect)
 168         return nil
 169 }
 170
 171 // fitbitNotifyHandler is called by Fitbit whenever there are updates to a
 172 // subscription. It verifies the payload, splits it into individual
 173 // notifications and adds it to the taskqueue service.
 174 func fitbitNotifyHandler(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
 175         defer r.Body.Close()
 176
 177         fitbitTimeout := 3 * time.Second
 178         ctx, cancel := context.WithTimeout(ctx, fitbitTimeout)
 179         defer cancel()
 180
 181         // this is used when setting up a new subscriber in the UI. Once set
 182         // up, this code path should not be triggered.
 183         if verify := r.FormValue("verify"); verify != "" {
 184                 if verify == app.Config.FitbitSubscriberCode {
 185                         w.WriteHeader(http.StatusNoContent)
 186                 } else {
 187                         w.WriteHeader(http.StatusNotFound)
 188                 }
 189                 return nil
 190         }
 191
 192         data, err := ioutil.ReadAll(r.Body)
 193         if err != nil {
 194                 return err
 195         }
 196
 197         // Fitbit recommendation: "If signature verification fails, you should
 198         // respond with a 404"
 199         if !fitbit.CheckSignature(ctx, data, r.Header.Get("X-Fitbit-Signature")) {
 200                 w.WriteHeader(http.StatusNotFound)
 201                 return nil
 202         }
 203
 204         if err := delayedHandleNotifications.Call(ctx, data); err != nil {
 205                 return err
 206         }
 207
 208         w.WriteHeader(http.StatusCreated)
 209         return nil
 210 }
 211
 212 // handleNotifications parses fitbit notifications and requests the individual
 213 // activities from Fitbit. It is executed asynchronously via the delay package.
 214 func handleNotifications(ctx context.Context, payload []byte) error {
 215         if err := app.LoadConfig(ctx); err != nil {
 216                 return err
 217         }
 218
 219         var subscriptions []fitbit.Subscription
 220         if err := json.Unmarshal(payload, &subscriptions); err != nil {
 221                 return err
 222         }
 223
 224         for _, s := range subscriptions {
 225                 if s.CollectionType != "activities" {
 226                         log.Warningf(ctx, "ignoring collection type %q", s.CollectionType)
 227                         continue
 228                 }
 229
 230                 if err := handleNotification(ctx, &s); err != nil {
 231                         log.Errorf(ctx, "handleNotification() = %v", err)
 232                         continue
 233                 }
 234         }
 235
 236         return nil
 237 }
 238
 239 func handleNotification(ctx context.Context, s *fitbit.Subscription) error {
 240         u, err := app.UserByID(ctx, s.SubscriptionID)
 241         if err != nil {
 242                 return err
 243         }
 244
 245         fitbitClient, err := fitbit.NewClient(ctx, s.OwnerID, u)
 246         if err != nil {
 247                 return err
 248         }
 249
 250         var (
 251                 wg      = &sync.WaitGroup{}
 252                 errs    appengine.MultiError
 253                 summary *fitbit.ActivitySummary
 254                 profile *fitbit.Profile
 255         )
 256
 257         wg.Add(1)
 258         go func() {
 259                 var err error
 260                 summary, err = fitbitClient.ActivitySummary(ctx, s.Date)
 261                 if err != nil {
 262                         errs = append(errs, fmt.Errorf("fitbitClient.ActivitySummary(%q) = %v", s.Date, err))
 263                 }
 264                 wg.Done()
 265         }()
 266
 267         wg.Add(1)
 268         go func() {
 269                 var err error
 270                 profile, err = fitbitClient.Profile(ctx)
 271                 if err != nil {
 272                         errs = append(errs, fmt.Errorf("fitbitClient.Profile(%q) = %v", s.Date, err))
 273                 }
 274                 wg.Done()
 275         }()
 276
 277         wg.Wait()
 278         if len(errs) != 0 {
 279                 return errs
 280         }
 281
 282         tm, err := time.ParseInLocation("2006-01-02", s.Date, profile.Timezone)
 283         if err != nil {
 284                 return err
 285         }
 286
 287         log.Debugf(ctx, "%s (%s) took %d steps on %s",
 288                 profile.Name, u.Email, summary.Summary.Steps, tm)
 289
 290         gfitClient, err := gfit.NewClient(ctx, u)
 291         if err != nil {
 292                 return err
 293         }
 294
 295         wg.Add(1)
 296         go func() {
 297                 if err := gfitClient.SetSteps(ctx, summary.Summary.Steps, tm); err != nil {
 298                         errs = append(errs, fmt.Errorf("gfitClient.SetSteps(%d) = %v", summary.Summary.Steps, err))
 299                 }
 300                 wg.Done()
 301         }()
 302
 303         wg.Add(1)
 304         go func() {
 305                 if err := gfitClient.SetCalories(ctx, summary.Summary.CaloriesOut, tm); err != nil {
 306                         errs = append(errs, fmt.Errorf("gfitClient.SetCalories(%d) = %v", summary.Summary.CaloriesOut, err))
 307                 }
 308                 wg.Done()
 309         }()
 310
 311         wg.Add(1)
 312         go func() {
 313                 defer wg.Done()
 314
 315                 var distanceMeters float64
 316                 for _, d := range summary.Summary.Distances {
 317                         if d.Activity != "total" {
 318                                 continue
 319                         }
 320                         distanceMeters = 1000.0 * d.Distance
 321                         break
 322                 }
 323                 if err := gfitClient.SetDistance(ctx, distanceMeters, tm); err != nil {
 324                         errs = append(errs, fmt.Errorf("gfitClient.SetDistance(%d) = %v", distanceMeters, err))
 325                         return
 326                 }
 327         }()
 328
 329         wg.Add(1)
 330         go func() {
 331                 if err := gfitClient.SetHeartRate(ctx, summary.Summary.HeartRateZones, summary.Summary.RestingHeartRate, tm); err != nil {
 332                         errs = append(errs, fmt.Errorf("gfitClient.SetHeartRate() = %v", err))
 333                 }
 334                 wg.Done()
 335         }()
 336
 337         wg.Add(1)
 338         go func() {
 339                 defer wg.Done()
 340
 341                 var activities []gfit.Activity
 342                 for _, a := range summary.Activities {
 343                         if !a.HasStartTime {
 344                                 continue
 345                         }
 346
 347                         startTime, err := time.ParseInLocation("2006-01-02T15:04", a.StartDate+"T"+a.StartTime, profile.Timezone)
 348                         if err != nil {
 349                                 errs = append(errs, fmt.Errorf("gfitClient.SetActivities() = %v", err))
 350                                 return
 351                         }
 352                         endTime := startTime.Add(time.Duration(a.Duration) * time.Millisecond)
 353
 354                         activities = append(activities, gfit.Activity{
 355                                 Start: startTime,
 356                                 End:   endTime,
 357                                 Type:  gfit.ParseFitbitActivity(a.Name),
 358                         })
 359                 }
 360                 if err := gfitClient.SetActivities(ctx, activities, tm); err != nil {
 361                         errs = append(errs, fmt.Errorf("gfitClient.SetActivities() = %v", err))
 362                         return
 363                 }
 364         }()
 365
 366         wg.Wait()
 367
 368         if len(errs) != 0 {
 369                 return errs
 370         }
 371         return nil
 372 }