done all except mapmyfitness

rowers/runkeeperstuff.py

@@ -12,6 +12,8 @@ from datetime import datetime
 import numpy as np
 from dateutil import parser
 import time
+import dateutil
+from time import strftime
 import math
 from math import sin,cos,atan2,sqrt
 import os,sys
@@ -29,7 +31,10 @@ from django.contrib.auth.decorators import login_required
 from rowingdata import rowingdata
 import pandas as pd
 from rowers.models import Rower,Workout,checkworkoutuser
-
+from uuid import uuid4
+import iso8601
+import arrow
+from rowers import types
 from rowsandall_app.settings import (
     C2_CLIENT_ID, C2_REDIRECT_URI, C2_CLIENT_SECRET,
     STRAVA_CLIENT_ID, STRAVA_REDIRECT_URI, STRAVA_CLIENT_SECRET,
@@ -38,6 +43,27 @@ from rowsandall_app.settings import (
 
 from utils import geo_distance,ewmovingaverage,NoTokenError, custom_exception_handler
 
+def splitrunkeeperlatlongdata(lijst,tname,latname,lonname):
+    t = []
+    lat = []
+    lon = []
+    for d in lijst:
+        t.append(d[tname])
+        lat.append(d[latname])
+        lon.append(d[lonname])
+
+    return [np.array(t),np.array(lat),np.array(lon)]
+
+def splitrunkeeperdata(lijst,xname,yname):
+    x = []
+    y = []
+    for d in lijst:
+        x.append(d[xname])
+        y.append(d[yname])
+
+    return [np.array(x),np.array(y)]
+
+import dataprep
 
 # Checks if user has SportTracks token, renews them if they are expired
 def runkeeper_open(user):
@@ -75,7 +101,6 @@ def get_token(code):
 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": RUNKEEPER_CLIENT_ID,
@@ -105,7 +130,7 @@ def get_runkeeper_workout_list(user):
     return s
 
 # Get workout summary data by Runkeeper ID
-def get_runkeeper_workout(user,runkeeperid):
+def get_workout(user,runkeeperid):
     r = Rower.objects.get(user=user)
     if (r.runkeepertoken == '') or (r.runkeepertoken is None):
 	return custom_exception_handler(401,s)
@@ -119,7 +144,16 @@ def get_runkeeper_workout(user,runkeeperid):
 	url = "https://api.runkeeper.com/fitnessActivities/"+str(runkeeperid)
 	s = requests.get(url,headers=headers)
 
-    return s
+    try:
+        data = s.json()
+    except ValueError:
+        data = {}
+
+    strokedata = pd.DataFrame.from_dict({
+        key: pd.Series(value) for key, value in data.items()
+    })
+        
+    return data,strokedata
 
 # Create Workout Data for upload to SportTracks
 def createrunkeeperworkoutdata(w):
@@ -328,3 +362,183 @@ def workout_runkeeper_upload(user,w):
         return message, rkid
 
     return message,rkid
+
+# Create workout from RunKeeper Data
+def add_workout_from_data(user,importid,data,strokedata,source='runkeeper',
+                          workoutsource='runkeeper'):
+    # To Do - add utcoffset to time
+    workouttype = data['type']
+    if workouttype not in [x[0] for x in Workout.workouttypes]:
+	workouttype = 'other'
+    try:
+	comments = data['notes']
+    except:
+	comments = ''
+    
+    try:
+	utcoffset = tz(data['utcoffset'])
+    except:
+	utcoffset = 0
+
+    r = Rower.objects.get(user=user)
+
+    try:
+	rowdatetime = iso8601.parse_date(data['start_time'])
+    except iso8601.ParseError:
+	try:
+	    rowdatetime = datetime.strptime(data['start_time'],"%Y-%m-%d %H:%M:%S")
+	    rowdatetime = thetimezone.localize(rowdatetime).astimezone(utc)
+	except ValueError:
+	    try:
+		rowdatetime = dateutil.parser.parse(data['start_time'])
+		#rowdatetime = thetimezone.localize(rowdatetime).astimezone(utc)
+	    except:
+		rowdatetime = datetime.strptime(data['date'],"%Y-%m-%d %H:%M:%S")
+		rowdatetime = thetimezone.localize(rowdatetime).astimezone(utc)
+    starttimeunix = arrow.get(rowdatetime).timestamp
+    #starttimeunix = mktime(rowdatetime.utctimetuple())
+    starttimeunix += utcoffset*3600
+    
+	
+    try:
+	title = data['name']
+    except:
+	title = "Imported data"
+
+
+
+    res = splitrunkeeperdata(data['distance'],'timestamp','distance')
+
+    distance = res[1]
+    times_distance = res[0]
+
+    try:
+	l = data['path']
+    
+	res = splitrunkeeperlatlongdata(l,'timestamp','latitude','longitude')
+	times_location = res[0]
+	latcoord = res[1]
+	loncoord = res[2]
+
+    except:
+	times_location = times_distance
+	latcoord = np.zeros(len(times_distance))
+	loncoord = np.zeros(len(times_distance))
+        if workouttype in types.otwtypes:
+            workouttype = 'rower'
+	
+    try:
+	res = splitrunkeeperdata(data['cadence'],'timestamp','cadence')
+	times_spm = res[0]
+	spm = res[1]
+    except KeyError:
+	times_spm = times_distance
+	spm = 0*times_distance
+    
+    try:
+	res = splitrunkeeperdata(data['heart_rate'],'timestamp','heart_rate')
+	hr = res[1]
+	times_hr = res[0]
+    except KeyError:
+	times_hr = times_distance
+	hr = 0*times_distance
+
+
+    # create data series and remove duplicates
+    distseries = pd.Series(distance,index=times_distance)
+    distseries = distseries.groupby(distseries.index).first()
+    latseries = pd.Series(latcoord,index=times_location)
+    try:
+        latseries = latseries.groupby(latseries.index).first()
+    except TypeError:
+        latseries = 0.0*distseries
+        
+    lonseries = pd.Series(loncoord,index=times_location)
+    try:
+        lonseries = lonseries.groupby(lonseries.index).first()
+    except TypeError:
+        lonseries = 0.0*distseries
+        
+    spmseries = pd.Series(spm,index=times_spm)
+    spmseries = spmseries.groupby(spmseries.index).first()
+    hrseries = pd.Series(hr,index=times_hr)
+    try:
+        hrseries = hrseries.groupby(hrseries.index).first()
+    except TypeError:
+        hrseries = 0*distseries
+
+
+    # Create dicts and big dataframe
+    d = {
+	' Horizontal (meters)': distseries,
+	' latitude': latseries,
+	' longitude': lonseries,
+	' Cadence (stokes/min)': spmseries,
+	' HRCur (bpm)' : hrseries,
+	}
+
+    
+
+    df = pd.DataFrame(d)
+
+    df = df.groupby(level=0).last()
+
+    cum_time = df.index.values
+    df[' ElapsedTime (sec)'] = cum_time
+
+    velo = df[' Horizontal (meters)'].diff()/df[' ElapsedTime (sec)'].diff()
+    
+    df[' Power (watts)'] = 0.0*velo
+
+    nr_rows = len(velo.values)
+
+    df[' DriveLength (meters)'] = np.zeros(nr_rows)
+    df[' StrokeDistance (meters)'] = np.zeros(nr_rows)
+    df[' DriveTime (ms)'] = np.zeros(nr_rows)
+    df[' StrokeRecoveryTime (ms)'] = np.zeros(nr_rows)
+    df[' AverageDriveForce (lbs)'] = np.zeros(nr_rows)
+    df[' PeakDriveForce (lbs)'] = np.zeros(nr_rows)
+    df[' lapIdx'] = np.zeros(nr_rows)
+
+
+
+    unixtime = cum_time+starttimeunix
+    try:
+        unixtime[0] = starttimeunix
+    except IndexError:
+        return (0,'No data to import')
+        
+    df['TimeStamp (sec)'] = unixtime
+
+ 
+    dt = np.diff(cum_time).mean()
+    wsize = round(5./dt)
+
+    # velo2 = stravastuff.ewmovingaverage(velo,wsize)
+
+    # df[' Stroke500mPace (sec/500m)'] = 500./velo2
+
+
+    df = df.fillna(0)
+
+    df.sort_values(by='TimeStamp (sec)',ascending=True)
+	
+    timestr = strftime("%Y%m%d-%H%M%S")
+
+#    csvfilename ='media/Import_'+str(importid)+'.csv'
+    csvfilename ='media/{code}_{importid}.csv'.format(
+        importid=importid,
+        code = uuid4().hex[:16]
+        )
+
+    res =  df.to_csv(csvfilename+'.gz',index_label='index',
+                     compression='gzip')
+
+    id,message = dataprep.save_workout_database(csvfilename,r,
+                                                workouttype=workouttype,
+                                                workoutsource='runkeeper',
+                                                title=title,
+                                                notes=comments)
+
+    return (id,message)
+