621 lines
18 KiB
Python
621 lines
18 KiB
Python
# All the functionality needed to connect to Strava
|
|
|
|
# Python
|
|
import oauth2 as oauth
|
|
import cgi
|
|
import requests
|
|
import requests.auth
|
|
import json
|
|
import yaml
|
|
from django.utils import timezone
|
|
from datetime import datetime
|
|
import numpy as np
|
|
from dateutil import parser
|
|
import time
|
|
import math
|
|
from math import sin,cos,atan2,sqrt
|
|
import os,sys
|
|
import gzip
|
|
from scipy import optimize
|
|
from scipy.signal import savgol_filter
|
|
|
|
from pytz import timezone as tz,utc
|
|
|
|
# Django
|
|
from django.shortcuts import render_to_response
|
|
from django.http import HttpResponseRedirect, HttpResponse,JsonResponse
|
|
from django.conf import settings
|
|
from django.contrib.auth import authenticate, login, logout
|
|
from django.contrib.auth.models import User
|
|
from django.contrib.auth.decorators import login_required
|
|
|
|
from django_mailbox.models import Message,Mailbox,MessageAttachment
|
|
|
|
import django_rq
|
|
queue = django_rq.get_queue('default')
|
|
queuelow = django_rq.get_queue('low')
|
|
queuehigh = django_rq.get_queue('low')
|
|
|
|
|
|
# Project
|
|
# from .models import Profile
|
|
from rowingdata import rowingdata
|
|
import pandas as pd
|
|
from rowers.models import Rower,Workout
|
|
from rowers.models import checkworkoutuser
|
|
import dataprep
|
|
from dataprep import columndict
|
|
from utils import uniqify,isprorower,myqueue,NoTokenError, custom_exception_handler
|
|
from uuid import uuid4
|
|
import stravalib
|
|
from stravalib.exc import ActivityUploadFailed,TimeoutExceeded
|
|
import iso8601
|
|
from iso8601 import ParseError
|
|
|
|
import pytz
|
|
import arrow
|
|
|
|
|
|
|
|
from rowsandall_app.settings import C2_CLIENT_ID, C2_REDIRECT_URI, C2_CLIENT_SECRET, STRAVA_CLIENT_ID, STRAVA_REDIRECT_URI, STRAVA_CLIENT_SECRET
|
|
|
|
try:
|
|
from json.decoder import JSONDecodeError
|
|
except ImportError:
|
|
JSONDecodeError = ValueError
|
|
|
|
|
|
from utils import geo_distance,ewmovingaverage
|
|
|
|
|
|
|
|
|
|
# Exchange access code for long-lived access token
|
|
def get_token(code):
|
|
client_auth = requests.auth.HTTPBasicAuth(STRAVA_CLIENT_ID, STRAVA_CLIENT_SECRET)
|
|
post_data = {"grant_type": "authorization_code",
|
|
"code": code,
|
|
"redirect_uri": STRAVA_REDIRECT_URI,
|
|
"client_secret": STRAVA_CLIENT_SECRET,
|
|
"client_id":STRAVA_CLIENT_ID,
|
|
}
|
|
headers = {'user-agent': 'sanderroosendaal'}
|
|
response = requests.post("https://www.strava.com/oauth/token",
|
|
data=post_data,
|
|
headers=headers)
|
|
try:
|
|
token_json = response.json()
|
|
thetoken = token_json['access_token']
|
|
except (KeyError,JSONDecodeError):
|
|
thetoken = 0
|
|
|
|
return [thetoken]
|
|
|
|
# Make authorization URL including random string
|
|
def make_authorization_url(request):
|
|
# Generate a random string for the state parameter
|
|
# Save it for use later to prevent xsrf attacks
|
|
|
|
state = str(uuid4())
|
|
|
|
params = {"client_id": STRAVA_CLIENT_ID,
|
|
"response_type": "code",
|
|
"redirect_uri": STRAVA_REDIRECT_URI,
|
|
"scope":"write"}
|
|
import urllib
|
|
url = "https://www.strava.com/oauth/authorize" +urllib.urlencode(params)
|
|
|
|
return HttpResponseRedirect(url)
|
|
|
|
# Get list of workouts available on Strava
|
|
def get_strava_workout_list(user,limit_n=0):
|
|
r = Rower.objects.get(user=user)
|
|
if (r.stravatoken == '') or (r.stravatoken is None):
|
|
s = "Token doesn't exist. Need to authorize"
|
|
return custom_exception_handler(401,s)
|
|
else:
|
|
# ready to fetch. Hurray
|
|
authorizationstring = str('Bearer ' + r.stravatoken)
|
|
headers = {'Authorization': authorizationstring,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json'}
|
|
|
|
url = "https://www.strava.com/api/v3/athlete/activities"
|
|
|
|
if limit_n==0:
|
|
params = {}
|
|
else:
|
|
params = {'per_page':limit_n}
|
|
|
|
s = requests.get(url,headers=headers,params=params)
|
|
|
|
return s
|
|
|
|
|
|
# gets all new Strava workouts for a rower
|
|
def get_strava_workouts(rower):
|
|
|
|
if not isprorower(rower):
|
|
return 0
|
|
|
|
res = get_strava_workout_list(rower.user,limit_n=10)
|
|
|
|
if (res.status_code != 200):
|
|
return 0
|
|
else:
|
|
stravaids = [int(item['id']) for item in res.json()]
|
|
|
|
alldata = {}
|
|
for item in res.json():
|
|
alldata[item['id']] = item
|
|
|
|
knownstravaids = uniqify([
|
|
w.uploadedtostrava for w in Workout.objects.filter(user=rower)
|
|
])
|
|
newids = [stravaid for stravaid in stravaids if not stravaid in knownstravaids]
|
|
|
|
|
|
for stravaid in newids:
|
|
result = create_async_workout(alldata,rower.user,stravaid)
|
|
|
|
return 1
|
|
|
|
def create_async_workout(alldata,user,stravaid,debug=False):
|
|
data = alldata[stravaid]
|
|
r = Rower.objects.get(user=user)
|
|
distance = data['distance']
|
|
stravaid = data['id']
|
|
try:
|
|
workouttype = data['type']
|
|
except:
|
|
workouttype = 'rower'
|
|
|
|
if workouttype not in [x[0] for x in Workout.workouttypes]:
|
|
workouttype = 'other'
|
|
|
|
try:
|
|
comments = data['comments']
|
|
except:
|
|
comments = ' '
|
|
|
|
try:
|
|
thetimezone = tz(data['timezone'])
|
|
except:
|
|
thetimezone = 'UTC'
|
|
|
|
try:
|
|
rowdatetime = iso8601.parse_date(data['date_utc'])
|
|
except KeyError:
|
|
rowdatetime = iso8601.parse_date(data['start_date'])
|
|
except ParseError:
|
|
rowdatetime = iso8601.parse_date(data['date'])
|
|
|
|
try:
|
|
c2intervaltype = data['workout_type']
|
|
|
|
except KeyError:
|
|
c2intervaltype = ''
|
|
|
|
try:
|
|
title = data['name']
|
|
except KeyError:
|
|
title = ""
|
|
try:
|
|
t = data['comments'].split('\n', 1)[0]
|
|
title += t[:20]
|
|
except:
|
|
title = 'Imported'
|
|
|
|
workoutdate = rowdatetime.astimezone(
|
|
pytz.timezone(thetimezone)
|
|
).strftime('%Y-%m-%d')
|
|
|
|
starttime = rowdatetime.astimezone(
|
|
pytz.timezone(thetimezone)
|
|
).strftime('%H:%m:%S')
|
|
|
|
totaltime = data['elapsed_time']
|
|
duration = dataprep.totaltime_sec_to_string(totaltime)
|
|
|
|
weightcategory = 'hwt'
|
|
|
|
# Create CSV file name and save data to CSV file
|
|
csvfilename ='media/mailbox_attachments/{code}_{importid}.csv'.format(
|
|
importid=stravaid,
|
|
code = uuid4().hex[:16]
|
|
)
|
|
|
|
|
|
|
|
# Check if workout has stroke data, and get the stroke data
|
|
|
|
starttimeunix = arrow.get(rowdatetime).timestamp
|
|
|
|
result = handle_strava_import_stroke_data(
|
|
title,
|
|
user.email,
|
|
r.stravatoken,
|
|
stravaid,
|
|
starttimeunix,
|
|
csvfilename,
|
|
)
|
|
|
|
return 1
|
|
|
|
from utils import get_strava_stream
|
|
|
|
# Get a Strava workout summary data and stroke data by ID
|
|
def get_strava_workout(user,stravaid):
|
|
r = Rower.objects.get(user=user)
|
|
if (r.stravatoken == '') or (r.stravatoken is None):
|
|
s = "Token doesn't exist. Need to authorize"
|
|
return custom_exception_handler(401,s)
|
|
else:
|
|
# ready to fetch. Hurray
|
|
fetchresolution = 'high'
|
|
series_type = 'time'
|
|
authorizationstring = str('Bearer ' + r.stravatoken)
|
|
headers = {'Authorization': authorizationstring,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json',
|
|
'resolution': 'medium',}
|
|
url = "https://www.strava.com/api/v3/activities/"+str(stravaid)
|
|
workoutsummary = requests.get(url,headers=headers).json()
|
|
|
|
workoutsummary['timezone'] = "Etc/UTC"
|
|
startdatetime = workoutsummary['start_date']
|
|
|
|
spmjson = get_strava_stream(r,'cadence',stravaid)
|
|
hrjson = get_strava_stream(r,'heartrate',stravaid)
|
|
timejson = get_strava_stream(r,'time',stravaid)
|
|
velojson = get_strava_stream(r,'velocity_smooth',stravaid)
|
|
distancejson = get_strava_stream(r,'distance',stravaid)
|
|
latlongjson = get_strava_stream(r,'latlng',stravaid)
|
|
|
|
try:
|
|
t = np.array(timejson.json()[0]['data'])
|
|
nr_rows = len(t)
|
|
d = np.array(distancejson.json()[1]['data'])
|
|
if nr_rows == 0:
|
|
return (0,"Error: Time data had zero length")
|
|
except IndexError:
|
|
d = 0*t
|
|
# return (0,"Error: No Distance information in the Strava data")
|
|
except KeyError:
|
|
return (0,"something went wrong with the Strava import")
|
|
|
|
try:
|
|
spm = np.array(spmjson.json()[1]['data'])
|
|
except:
|
|
spm = np.zeros(nr_rows)
|
|
|
|
try:
|
|
hr = np.array(hrjson.json()[1]['data'])
|
|
except IndexError:
|
|
hr = np.zeros(nr_rows)
|
|
except KeyError:
|
|
hr = np.zeros(nr_rows)
|
|
|
|
try:
|
|
velo = np.array(velojson.json()[1]['data'])
|
|
except IndexError:
|
|
velo = np.zeros(nr_rows)
|
|
except KeyError:
|
|
velo = np.zeros(nr_rows)
|
|
|
|
dt = np.diff(t).mean()
|
|
wsize = round(5./dt)
|
|
|
|
velo2 = ewmovingaverage(velo,wsize)
|
|
coords = np.array(latlongjson.json()[0]['data'])
|
|
try:
|
|
lat = coords[:,0]
|
|
lon = coords[:,1]
|
|
except IndexError:
|
|
lat = np.zeros(len(t))
|
|
lon = np.zeros(len(t))
|
|
except KeyError:
|
|
lat = np.zeros(len(t))
|
|
lon = np.zeros(len(t))
|
|
|
|
|
|
|
|
|
|
strokelength = velo*60./(spm)
|
|
strokelength[np.isinf(strokelength)] = 0.0
|
|
|
|
pace = 500./(1.0*velo2)
|
|
pace[np.isinf(pace)] = 0.0
|
|
|
|
df = pd.DataFrame({'t':10*t,
|
|
'd':10*d,
|
|
'p':10*pace,
|
|
'spm':spm,
|
|
'hr':hr,
|
|
'lat':lat,
|
|
'lon':lon,
|
|
'strokelength':strokelength,
|
|
})
|
|
|
|
# startdatetime = datetime.datetime.strptime(startdatetime,"%Y-%m-%d-%H:%M:%S")
|
|
|
|
return [workoutsummary,df]
|
|
|
|
# Generate Workout data for Strava (a TCX file)
|
|
def createstravaworkoutdata(w,dozip=True):
|
|
filename = w.csvfilename
|
|
try:
|
|
row = rowingdata(filename)
|
|
except IOError:
|
|
data = dataprep.read_df_sql(w.id)
|
|
try:
|
|
datalength = len(data)
|
|
except AttributeError:
|
|
datalength = 0
|
|
|
|
if datalength != 0:
|
|
data.rename(columns = columndict,inplace=True)
|
|
res = data.to_csv(w.csvfilename+'.gz',
|
|
index_label='index',
|
|
compression='gzip')
|
|
try:
|
|
row = rowingdata(filename)
|
|
except IOError:
|
|
return '','Error - could not find rowing data'
|
|
else:
|
|
return '','Error - could not find rowing data'
|
|
|
|
tcxfilename = filename[:-4]+'.tcx'
|
|
try:
|
|
newnotes = w.notes+'\n from '+w.workoutsource+' via rowsandall.com'
|
|
except TypeError:
|
|
newnotes = 'from '+w.workoutsource+' via rowsandall.com'
|
|
|
|
row.exporttotcx(tcxfilename,notes=newnotes)
|
|
if dozip:
|
|
gzfilename = tcxfilename+'.gz'
|
|
with file(tcxfilename,'rb') as inF:
|
|
s = inF.read()
|
|
with gzip.GzipFile(gzfilename,'wb') as outF:
|
|
outF.write(s)
|
|
|
|
try:
|
|
os.remove(tcxfilename)
|
|
except WindowError:
|
|
pass
|
|
|
|
return gzfilename,""
|
|
|
|
else:
|
|
return tcxfilename,""
|
|
|
|
|
|
# Upload the TCX file to Strava and set the workout activity type
|
|
# to rowing on Strava
|
|
def handle_stravaexport(f2,workoutname,stravatoken,description='',
|
|
activity_type='Rowing'):
|
|
# w = Workout.objects.get(id=workoutid)
|
|
client = stravalib.Client(access_token=stravatoken)
|
|
|
|
try:
|
|
act = client.upload_activity(f2,'tcx.gz',name=workoutname)
|
|
except:
|
|
return {0,'Strava upload failed'}
|
|
try:
|
|
res = act.wait(poll_interval=5.0,timeout=30)
|
|
message = 'Workout successfully synchronized to Strava'
|
|
except:
|
|
res = 0
|
|
message = 'Strava upload timed out'
|
|
|
|
|
|
# description doesn't work yet. Have to wait for stravalib to update
|
|
if res:
|
|
try:
|
|
act = client.update_activity(res.id,activity_type=activity_type,description=description,device_name='Rowsandall.com')
|
|
except TypeError:
|
|
act = client.update_activity(res.id,activity_type=activity_type,description=description)
|
|
else:
|
|
message = 'Strava activity update timed out.'
|
|
return (0,message)
|
|
|
|
return (res.id,message)
|
|
|
|
|
|
def workout_strava_upload(user,w):
|
|
message = "Uploading to Strava"
|
|
stravaid=-1
|
|
r = Rower.objects.get(user=user)
|
|
res = -1
|
|
if (r.stravatoken == '') or (r.stravatoken is None):
|
|
s = "Token doesn't exist. Need to authorize"
|
|
raise NoTokenError("Your hovercraft is full of eels")
|
|
else:
|
|
if (checkworkoutuser(user,w)):
|
|
try:
|
|
tcxfile,tcxmesg = createstravaworkoutdata(w)
|
|
if tcxfile:
|
|
with open(tcxfile,'rb') as f:
|
|
res,mes = handle_stravaexport(f,w.name,
|
|
r.stravatoken,
|
|
description=w.notes+'\n from '+w.workoutsource+' via rowsandall.com')
|
|
if res==0:
|
|
message = mes
|
|
w.uploadedtostrava = -1
|
|
stravaid = -1
|
|
w.save()
|
|
try:
|
|
os.remove(tcxfile)
|
|
except WindowsError:
|
|
pass
|
|
return message,stravaid
|
|
|
|
w.uploadedtostrava = res
|
|
w.save()
|
|
try:
|
|
os.remove(tcxfile)
|
|
except WindowsError:
|
|
pass
|
|
message = mes
|
|
stravaid = res
|
|
return message,stravaid
|
|
else:
|
|
message = "Strava TCX data error "+tcxmesg
|
|
w.uploadedtostrava = -1
|
|
stravaid = -1
|
|
w.save()
|
|
return message, stravaid
|
|
|
|
except ActivityUploadFailed as e:
|
|
message = "Strava Upload error: %s" % e
|
|
w.uploadedtostrava = -1
|
|
stravaid = -1
|
|
w.save()
|
|
os.remove(tcxfile)
|
|
return message,stravaid
|
|
return message,stravaid
|
|
return message,stravaid
|
|
|
|
|
|
def handle_strava_import_stroke_data(title,
|
|
useremail,
|
|
stravatoken,
|
|
stravaid,
|
|
starttimeunix,
|
|
csvfilename,debug=True,**kwargs):
|
|
# ready to fetch. Hurray
|
|
|
|
fetchresolution = 'high'
|
|
series_type = 'time'
|
|
authorizationstring = str('Bearer ' + stravatoken)
|
|
headers = {'Authorization': authorizationstring,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json',
|
|
'resolution': 'medium',}
|
|
url = "https://www.strava.com/api/v3/activities/"+str(stravaid)
|
|
workoutsummary = requests.get(url,headers=headers).json()
|
|
|
|
workoutsummary['timezone'] = "Etc/UTC"
|
|
startdatetime = workoutsummary['start_date']
|
|
|
|
r = type('Rower', (object,), {"stravatoken": stravatoken})
|
|
|
|
spmjson = get_strava_stream(r,'cadence',stravaid)
|
|
hrjson = get_strava_stream(r,'heartrate',stravaid)
|
|
timejson = get_strava_stream(r,'time',stravaid)
|
|
velojson = get_strava_stream(r,'velocity_smooth',stravaid)
|
|
distancejson = get_strava_stream(r,'distance',stravaid)
|
|
latlongjson = get_strava_stream(r,'latlng',stravaid)
|
|
wattsjson = get_strava_stream(r,'watts',stravaid)
|
|
|
|
try:
|
|
t = np.array(timejson.json()[0]['data'])
|
|
nr_rows = len(t)
|
|
d = np.array(distancejson.json()[1]['data'])
|
|
if nr_rows == 0:
|
|
return 0
|
|
except IndexError:
|
|
d = 0*t
|
|
# return (0,"Error: No Distance information in the Strava data")
|
|
except KeyError:
|
|
return 0
|
|
|
|
try:
|
|
spm = np.array(spmjson.json()[1]['data'])
|
|
except:
|
|
spm = np.zeros(nr_rows)
|
|
|
|
try:
|
|
watts = np.array(wattsjson.json()[1]['data'])
|
|
except:
|
|
watts = np.zeros(nr_rows)
|
|
|
|
try:
|
|
hr = np.array(hrjson.json()[1]['data'])
|
|
except IndexError:
|
|
hr = np.zeros(nr_rows)
|
|
except KeyError:
|
|
hr = np.zeros(nr_rows)
|
|
|
|
try:
|
|
velo = np.array(velojson.json()[1]['data'])
|
|
except IndexError:
|
|
velo = np.zeros(nr_rows)
|
|
except KeyError:
|
|
velo = np.zeros(nr_rows)
|
|
|
|
f = np.diff(t).mean()
|
|
if f != 0:
|
|
windowsize = 2*(int(10./(f)))+1
|
|
else:
|
|
windowsize = 1
|
|
|
|
if windowsize > 3 and windowsize < len(velo):
|
|
velo2 = savgol_filter(velo,windowsize,3)
|
|
else:
|
|
velo2 = velo
|
|
|
|
coords = np.array(latlongjson.json()[0]['data'])
|
|
try:
|
|
lat = coords[:,0]
|
|
lon = coords[:,1]
|
|
except IndexError:
|
|
lat = np.zeros(len(t))
|
|
lon = np.zeros(len(t))
|
|
except KeyError:
|
|
lat = np.zeros(len(t))
|
|
lon = np.zeros(len(t))
|
|
|
|
strokelength = velo*60./(spm)
|
|
strokelength[np.isinf(strokelength)] = 0.0
|
|
|
|
pace = 500./(1.0*velo2)
|
|
pace[np.isinf(pace)] = 0.0
|
|
|
|
unixtime = starttimeunix+t
|
|
|
|
strokedistance = 60.*velo2/spm
|
|
|
|
nr_strokes = len(t)
|
|
|
|
df = pd.DataFrame({'TimeStamp (sec)':unixtime,
|
|
' ElapsedTime (sec)':t,
|
|
' Horizontal (meters)':d,
|
|
' Stroke500mPace (sec/500m)':pace,
|
|
' Cadence (stokes/min)':spm,
|
|
' HRCur (bpm)':hr,
|
|
' latitude':lat,
|
|
' longitude':lon,
|
|
' StrokeDistance (meters)':strokelength,
|
|
'cum_dist':d,
|
|
' DragFactor':np.zeros(nr_strokes),
|
|
' DriveLength (meters)':np.zeros(nr_strokes),
|
|
' StrokeDistance (meters)':strokedistance,
|
|
' DriveTime (ms)':np.zeros(nr_strokes),
|
|
' StrokeRecoveryTime (ms)':np.zeros(nr_strokes),
|
|
' AverageDriveForce (lbs)':np.zeros(nr_strokes),
|
|
' PeakDriveForce (lbs)':np.zeros(nr_strokes),
|
|
' lapIdx':np.zeros(nr_strokes),
|
|
' Power (watts)':watts,
|
|
})
|
|
|
|
|
|
df.sort_values(by='TimeStamp (sec)',ascending=True)
|
|
|
|
res = df.to_csv(csvfilename,index_label='index')
|
|
|
|
workoutsbox = Mailbox.objects.filter(name='workouts')[0]
|
|
|
|
body = 'stravaid {stravaid}'.format(stravaid=stravaid)
|
|
|
|
msg = Message(mailbox=workoutsbox,
|
|
from_header=useremail,
|
|
subject=title,
|
|
body=body)
|
|
msg.save()
|
|
|
|
a = MessageAttachment(message=msg,document=csvfilename[6:])
|
|
a.save()
|
|
|
|
return res
|