459 lines
13 KiB
Python
459 lines
13 KiB
Python
# All the functionality needed to connect to Runkeeper
|
|
|
|
# Python
|
|
import oauth2 as oauth
|
|
import cgi
|
|
import pytz
|
|
import requests
|
|
import requests.auth
|
|
import json
|
|
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 urllib
|
|
|
|
# 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
|
|
|
|
# Project
|
|
# from .models import Profile
|
|
from rowingdata import rowingdata
|
|
import pandas as pd
|
|
from rowers.models import Rower,Workout,checkworkoutuser
|
|
|
|
from rowsandall_app.settings import (
|
|
C2_CLIENT_ID, C2_REDIRECT_URI, C2_CLIENT_SECRET,
|
|
STRAVA_CLIENT_ID, STRAVA_REDIRECT_URI, STRAVA_CLIENT_SECRET,
|
|
UNDERARMOUR_CLIENT_ID, UNDERARMOUR_CLIENT_SECRET,
|
|
UNDERARMOUR_REDIRECT_URI,UNDERARMOUR_CLIENT_KEY,
|
|
)
|
|
|
|
# Custom error class - to raise a NoTokenError
|
|
class UnderArmourNoTokenError(Exception):
|
|
def __init__(self,value):
|
|
self.value=value
|
|
|
|
def __str__(self):
|
|
return repr(self.value)
|
|
|
|
# Exponentially weighted moving average
|
|
# Used for data smoothing of the jagged data obtained by Strava
|
|
# See bitbucket issue 72
|
|
def ewmovingaverage(interval,window_size):
|
|
# Experimental code using Exponential Weighted moving average
|
|
|
|
try:
|
|
intervaldf = pd.DataFrame({'v':interval})
|
|
idf_ewma1 = intervaldf.ewm(span=window_size)
|
|
idf_ewma2 = intervaldf[::-1].ewm(span=window_size)
|
|
|
|
i_ewma1 = idf_ewma1.mean().ix[:,'v']
|
|
i_ewma2 = idf_ewma2.mean().ix[:,'v']
|
|
|
|
interval2 = np.vstack((i_ewma1,i_ewma2[::-1]))
|
|
interval2 = np.mean( interval2, axis=0) # average
|
|
except ValueError:
|
|
interval2 = interval
|
|
|
|
return interval2
|
|
|
|
from utils import geo_distance
|
|
|
|
|
|
# Custom exception handler, returns a 401 HTTP message
|
|
# with exception details in the json data
|
|
def custom_exception_handler(exc,message):
|
|
|
|
response = {
|
|
"errors": [
|
|
{
|
|
"code": str(exc),
|
|
"detail": message,
|
|
}
|
|
]
|
|
}
|
|
|
|
res = HttpResponse(message)
|
|
res.status_code = 401
|
|
res.json = json.dumps(response)
|
|
|
|
return res
|
|
|
|
# Checks if user has UnderArmour token, renews them if they are expired
|
|
def underarmour_open(user):
|
|
r = Rower.objects.get(user=user)
|
|
if (r.underarmourtoken == '') or (r.underarmourtoken is None):
|
|
s = "Token doesn't exist. Need to authorize"
|
|
raise UnderArmourNoTokenError("User has no token")
|
|
else:
|
|
if (timezone.now()>r.underarmourtokenexpirydate):
|
|
thetoken = rower_underarmour_token_refresh(user)
|
|
else:
|
|
thetoken = r.underarmourtoken
|
|
|
|
return thetoken
|
|
|
|
# Refresh ST token using refresh token
|
|
def do_refresh_token(refreshtoken,access_token):
|
|
client_auth = requests.auth.HTTPBasicAuth(UNDERARMOUR_CLIENT_KEY, UNDERARMOUR_CLIENT_SECRET)
|
|
post_data = {"grant_type": "refresh_token",
|
|
"client_secret": UNDERARMOUR_CLIENT_SECRET,
|
|
"client_id":UNDERARMOUR_CLIENT_KEY,
|
|
"refresh_token": refreshtoken,
|
|
}
|
|
headers = {'user-agent': 'sanderroosendaal',
|
|
"Api-Key":UNDERARMOUR_CLIENT_KEY,
|
|
'Accept': 'application/json',
|
|
'Content-Type': 'application/x-www-form-urlencoded',
|
|
'authorization': 'Bearer %s' % access_token}
|
|
|
|
url = "https://api.ua.com/v7.1/oauth2/access_token/"
|
|
|
|
response = requests.post(url,
|
|
data=post_data,
|
|
headers=headers)
|
|
|
|
token_json = response.json()
|
|
thetoken = token_json['access_token']
|
|
expires_in = token_json['expires_in']
|
|
try:
|
|
refresh_token = token_json['refresh_token']
|
|
except KeyError:
|
|
refresh_token = refreshtoken
|
|
|
|
return [thetoken,expires_in,refresh_token]
|
|
|
|
# Exchange access code for long-lived access token
|
|
def get_token(code):
|
|
client_auth = requests.auth.HTTPBasicAuth(UNDERARMOUR_CLIENT_KEY, UNDERARMOUR_CLIENT_SECRET)
|
|
post_data = {
|
|
"grant_type": "authorization_code",
|
|
"code": code,
|
|
"client_secret": UNDERARMOUR_CLIENT_SECRET,
|
|
"client_id":UNDERARMOUR_CLIENT_KEY,
|
|
}
|
|
headers = {
|
|
'user-agent': 'sanderroosendaal',
|
|
"Api-Key":UNDERARMOUR_CLIENT_KEY,
|
|
}
|
|
|
|
response = requests.post("https://api.ua.com/v7.1/oauth2/access_token/",
|
|
data=post_data,
|
|
headers=headers)
|
|
try:
|
|
token_json = response.json()
|
|
thetoken = token_json['access_token']
|
|
expires_in = token_json['expires_in']
|
|
refresh_token = token_json['refresh_token']
|
|
except KeyError:
|
|
thetoken = 0
|
|
expires_in = 30
|
|
refresh_token = ''
|
|
|
|
return thetoken,expires_in,refresh_token
|
|
|
|
# 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
|
|
from uuid import uuid4
|
|
state = str(uuid4())
|
|
|
|
params = {"client_id": UNDERARMOUR_CLIENT_KEY,
|
|
"response_type": "code",
|
|
"redirect_uri": UNDERARMOUR_REDIRECT_URI,
|
|
}
|
|
url = "https://www.mapmyfitness.com/v7.1/oauth2/uacf/authorize/" +urllib.urlencode(params)
|
|
|
|
return HttpResponseRedirect(url)
|
|
|
|
# Get list of workouts available on Underarmour
|
|
def get_underarmour_workout_list(user):
|
|
r = Rower.objects.get(user=user)
|
|
if (r.underarmourtoken == '') or (r.underarmourtoken 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.underarmourtoken)
|
|
headers = {'Authorization': authorizationstring,
|
|
'Api-Key': UNDERARMOUR_CLIENT_KEY,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json'}
|
|
url = "https://api.ua.com/v7.1/workout/?user="+str(get_userid(r.underarmourtoken))
|
|
|
|
s = requests.get(url,headers=headers)
|
|
|
|
return s
|
|
|
|
# Get workout summary data by Underarmour ID
|
|
def get_underarmour_workout(user,underarmourid):
|
|
r = Rower.objects.get(user=user)
|
|
if (r.underarmourtoken == '') or (r.underarmourtoken is None):
|
|
return custom_exception_handler(401,s)
|
|
s = "Token doesn't exist. Need to authorize"
|
|
else:
|
|
# ready to fetch. Hurray
|
|
authorizationstring = str('Bearer ' + r.underarmourtoken)
|
|
headers = {'Authorization': authorizationstring,
|
|
'Api-Key': UNDERARMOUR_CLIENT_KEY,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json'}
|
|
url = "https://api.ua.com/v7.1/workout/"+str(underarmourid)+"/?field_set=time_series"
|
|
s = requests.get(url,headers=headers)
|
|
|
|
return s
|
|
|
|
# Create Workout Data for upload to Underarmour
|
|
def createunderarmourworkoutdata(w):
|
|
filename = w.csvfilename
|
|
try:
|
|
row = rowingdata(filename)
|
|
except:
|
|
return 0
|
|
|
|
averagehr = int(row.df[' HRCur (bpm)'].mean())
|
|
maxhr = int(row.df[' HRCur (bpm)'].max())
|
|
duration = w.duration.hour*3600
|
|
duration += w.duration.minute*60
|
|
duration += w.duration.second
|
|
duration += +1.0e-6*w.duration.microsecond
|
|
name = w.name
|
|
try:
|
|
notes = w.notes+'\n from '+w.workoutsource+' via rowsandall.com'
|
|
except TypeError:
|
|
notes = 'from '+w.workoutsource+' via rowsandall.com'
|
|
|
|
# adding diff, trying to see if this is valid
|
|
#t = row.df.ix[:,'TimeStamp (sec)'].values-10*row.df.ix[0,'TimeStamp (sec)']
|
|
t = row.df.ix[:,'TimeStamp (sec)'].values-row.df.ix[0,'TimeStamp (sec)']
|
|
t[0] = t[1]
|
|
|
|
d = row.df.ix[:,'cum_dist'].values
|
|
d[0] = d[1]
|
|
t = t.astype(int)
|
|
d = d.astype(int)
|
|
spm = row.df[' Cadence (stokes/min)'].astype(int)
|
|
spm[0] = spm[1]
|
|
hr = row.df[' HRCur (bpm)'].astype(int)
|
|
|
|
haslatlon=1
|
|
|
|
try:
|
|
lat = row.df[' latitude'].values
|
|
lon = row.df[' longitude'].values
|
|
if not lat.std() and not lon.std():
|
|
haslatlon = 0
|
|
except KeyError:
|
|
haslatlon = 0
|
|
|
|
# path data
|
|
if haslatlon:
|
|
locdata = []
|
|
for e in zip(t,lat,lon):
|
|
point = {
|
|
'lat':e[1],
|
|
'lng':e[2],
|
|
'elevation':0,
|
|
}
|
|
locdata.append([e[0],point])
|
|
|
|
hrdata = []
|
|
for e in zip(t,hr):
|
|
point = [e[0],
|
|
e[1]
|
|
]
|
|
hrdata.append(point)
|
|
|
|
distancedata = []
|
|
for e in zip(t,d):
|
|
point = [e[0],
|
|
e[1]
|
|
]
|
|
distancedata.append(point)
|
|
|
|
spmdata = []
|
|
for e in zip(t,spm):
|
|
spmdata.append([e[0],e[1]])
|
|
|
|
st = w.startdatetime.astimezone(pytz.timezone(w.timezone))
|
|
start_time = st.isoformat()
|
|
|
|
timeseries = {
|
|
"distance": distancedata,
|
|
"heartrate": hrdata,
|
|
"cadence": spmdata,
|
|
}
|
|
|
|
aggregrates = {
|
|
"elapsed_time_total": int(duration),
|
|
"distance_total": int(max(d)),
|
|
"heartrate_avg": averagehr,
|
|
"heart_rate_min": int(min(hr)),
|
|
"heart_rate_max": int(max(hr)),
|
|
}
|
|
|
|
|
|
# if haslatlon:
|
|
# timeseries["position"] = locdata
|
|
|
|
data = {
|
|
"name": name,
|
|
"start_datetime": start_time,
|
|
"time_series": timeseries,
|
|
"start_locale_timezone": "Etc/UTC",
|
|
"activity_type": "/v7.1/activity_type/128/",
|
|
"notes": notes,
|
|
}
|
|
|
|
return data
|
|
|
|
# Obtain Underarmour Workout ID and activity type
|
|
def get_idfromuri(user,links):
|
|
id = links['self'][0]['id']
|
|
typeid = links['activity_type'][0]['id']
|
|
|
|
|
|
typename = get_typefromid(typeid,user)
|
|
|
|
return id,typename
|
|
|
|
def getidfromresponse(response):
|
|
t = json.loads(response.text)
|
|
|
|
links = t["_links"]
|
|
|
|
id = links["self"][0]["id"]
|
|
|
|
return int(id)
|
|
|
|
def refresh_ua_actlist(user):
|
|
r = Rower.objects.get(user=user)
|
|
authorizationstring = str('Bearer ' + r.underarmourtoken)
|
|
headers = {'Authorization': authorizationstring,
|
|
'Api-Key': UNDERARMOUR_CLIENT_KEY,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json'}
|
|
url = "https://api.ua.com/v7.1/activity_type/"
|
|
response = requests.get(url,headers=headers)
|
|
|
|
me_json = response.json()
|
|
types = me_json["_embedded"]["activity_types"]
|
|
w = {int(t["_links"]["self"][0]["id"]):t["name"] for t in types}
|
|
wdf = pd.Series(w,name='Name')
|
|
wdf.to_csv('static/rigging/ua2.csv',index_label='id',header=True)
|
|
return w
|
|
|
|
try:
|
|
activities = pd.read_csv('static/rigging/ua2.csv',index_col='id')
|
|
actdict = activities.to_dict()['Name']
|
|
except:
|
|
actdict = {}
|
|
|
|
|
|
def get_typefromid(typeid,user):
|
|
r = Rower.objects.get(user=user)
|
|
try:
|
|
res = actdict[int(typeid)]
|
|
except KeyError:
|
|
authorizationstring = str('Bearer ' + r.underarmourtoken)
|
|
headers = {'Authorization': authorizationstring,
|
|
'Api-Key': UNDERARMOUR_CLIENT_KEY,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json'}
|
|
url = "https://api.ua.com/v7.1/activity_type/"+str(typeid)
|
|
response = requests.get(url,headers=headers)
|
|
|
|
me_json = response.json()
|
|
|
|
try:
|
|
res = me_json['name']
|
|
except KeyError:
|
|
res = 0
|
|
|
|
return res
|
|
|
|
|
|
|
|
# Get user id, having access token
|
|
# Handy for checking if the API access is working
|
|
def get_userid(access_token):
|
|
authorizationstring = str('Bearer ' + access_token)
|
|
headers = {'Authorization': authorizationstring,
|
|
'Api-Key': UNDERARMOUR_CLIENT_KEY,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json'}
|
|
url = "https://api.ua.com/v7.1/user/self"
|
|
response = requests.get(url,headers=headers)
|
|
|
|
me_json = response.json()
|
|
|
|
try:
|
|
res = me_json['id']
|
|
except KeyError:
|
|
res = 0
|
|
|
|
return res
|
|
|
|
def workout_ua_upload(user,w):
|
|
message = "Uploading to MapMyFitness"
|
|
uaid = 0
|
|
|
|
r = w.user
|
|
|
|
thetoken = underarmour_open(r.user)
|
|
|
|
# ready to upload. Hurray
|
|
|
|
if (checkworkoutuser(user,w)):
|
|
data = createunderarmourworkoutdata(w)
|
|
# return HttpResponse(json.dumps(data))
|
|
if not data:
|
|
message = "Data error"
|
|
uaid = 0
|
|
return message, uaid
|
|
|
|
authorizationstring = str('Bearer ' + thetoken)
|
|
headers = {'Authorization': authorizationstring,
|
|
'Api-Key': UNDERARMOUR_CLIENT_KEY,
|
|
'user-agent': 'sanderroosendaal',
|
|
'Content-Type': 'application/json',
|
|
}
|
|
|
|
url = "https://api.ua.com/v7.1/workout/"
|
|
response = requests.post(url,headers=headers,data=json.dumps(data))
|
|
|
|
# check for duplicate error first
|
|
if (response.status_code == 409 ):
|
|
message = "Duplicate error"
|
|
w.uploadedtounderarmour = -1
|
|
uaid = -1
|
|
w.save()
|
|
elif (response.status_code == 201 or response.status_code==200):
|
|
uaid = getidfromresponse(response)
|
|
w.uploadedtounderarmour = uaid
|
|
w.save()
|
|
return 'Successfully synchronized with MapMyFitness',uaid
|
|
else:
|
|
s = response
|
|
message = "Something went wrong in workout_underarmour_upload_view: %s - %s" % (s.reason,s.text)
|
|
uaid = 0
|
|
return message, uaid
|
|
|
|
else:
|
|
message = "You are not authorized to upload this workout"
|
|
uaid = 0
|
|
return message, uaid
|
|
|
|
return message, uaid
|