done all except mapmyfitness

rowers/c2stuff.py

@@ -15,6 +15,7 @@ from django.utils import timezone
 from datetime import datetime
 from datetime import timedelta
 import time
+from time import strftime
 
 # Django
 from django.shortcuts import render_to_response
@@ -25,7 +26,7 @@ from django.contrib.auth.models import User
 from django.contrib.auth.decorators import login_required
 import dataprep
 import pytz
-from rowingdata import rowingdata
+from rowingdata import rowingdata, make_cumvalues
 import pandas as pd
 import numpy as np
 from rowers.models import Rower,Workout
@@ -36,6 +37,8 @@ from requests import Request, Session
 
 from utils import myqueue,uniqify,isprorower, custom_exception_handler, NoTokenError
 
+from uuid import uuid4
+
 from rowers.types import otwtypes
 
 from rowsandall_app.settings import C2_CLIENT_ID, C2_REDIRECT_URI, C2_CLIENT_SECRET
@@ -540,7 +543,7 @@ def make_authorization_url(request):
     return HttpResponseRedirect(url)
 
 # Get workout from C2 ID
-def get_c2_workout(user,c2id):
+def get_workout(user,c2id):
     r = Rower.objects.get(user=user)
     if (r.c2token == '') or (r.c2token is None):
 	s = "Token doesn't exist. Need to authorize"
@@ -557,7 +560,24 @@ def get_c2_workout(user,c2id):
 	url = "https://log.concept2.com/api/users/me/results/"+str(c2id)
 	s = requests.get(url,headers=headers)
 
-    return s
+    data = s.json()['data']
+    splitdata = None
+
+    if 'workout' in data:
+        if 'splits' in data['workout']:
+            splitdata = data['workout']['splits']
+        if 'intervals' in data['workout']:
+            splitdata = data['workout']['intervals']
+
+    # Check if workout has stroke data, and get the stroke data
+    if data['stroke_data']:
+	res2 = get_c2_workout_strokes(user,c2id)
+	if res2.status_code == 200:
+	    strokedata = pd.DataFrame.from_dict(res2.json()['data'])
+    else:
+        strokedata = pd.DataFrame()
+    
+    return data,strokedata
 
 # Get stroke data belonging to C2 ID
 def get_c2_workout_strokes(user,c2id):
@@ -725,3 +745,154 @@ def rower_c2_token_refresh(user):
     else:
         return None
 
+# Create workout data from Strava or Concept2
+# data and create the associated Workout object and save it
+def add_workout_from_data(user,importid,data,strokedata,
+                          source='c2',splitdata=None,
+                          workoutsource='concept2'):
+    try:
+        workouttype = data['type']
+    except KeyError:
+        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'
+
+    r = Rower.objects.get(user=user)
+    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'
+
+    starttimeunix = arrow.get(rowdatetime).timestamp
+
+    res = make_cumvalues(0.1*strokedata['t'])
+    cum_time = res[0]
+    lapidx = res[1]
+
+    unixtime = cum_time+starttimeunix
+    # unixtime[0] = starttimeunix
+    seconds = 0.1*strokedata.ix[:,'t']
+
+    nr_rows = len(unixtime)
+
+    try:
+	latcoord = strokedata.ix[:,'lat']
+	loncoord = strokedata.ix[:,'lon']
+    except:
+	latcoord = np.zeros(nr_rows)
+	loncoord = np.zeros(nr_rows)
+
+
+    try:
+	strokelength = strokedata.ix[:,'strokelength']
+    except:
+	strokelength = np.zeros(nr_rows)
+
+    dist2 = 0.1*strokedata.ix[:,'d']
+
+    try:
+        spm = strokedata.ix[:,'spm']
+    except KeyError:
+        spm = 0*dist2
+        
+    try:
+        hr = strokedata.ix[:,'hr']
+    except KeyError:
+        hr = 0*spm
+    pace = strokedata.ix[:,'p']/10.
+    pace = np.clip(pace,0,1e4)
+    pace = pace.replace(0,300)
+
+    velo = 500./pace
+
+    power = 2.8*velo**3
+    
+    # save csv
+    # Create data frame with all necessary data to write to csv
+    df = pd.DataFrame({'TimeStamp (sec)':unixtime,
+		       ' Horizontal (meters)': dist2,
+		       ' Cadence (stokes/min)':spm,
+		       ' HRCur (bpm)':hr,
+		       ' longitude':loncoord,
+		       ' latitude':latcoord,
+		       ' Stroke500mPace (sec/500m)':pace,
+		       ' Power (watts)':power,
+		       ' DragFactor':np.zeros(nr_rows),
+		       ' DriveLength (meters)':np.zeros(nr_rows),
+		       ' StrokeDistance (meters)':strokelength,
+		       ' DriveTime (ms)':np.zeros(nr_rows),
+		       ' StrokeRecoveryTime (ms)':np.zeros(nr_rows),
+		       ' AverageDriveForce (lbs)':np.zeros(nr_rows),
+		       ' PeakDriveForce (lbs)':np.zeros(nr_rows),
+		       ' lapIdx':lapidx,
+		       ' ElapsedTime (sec)':seconds
+		       })
+
+    
+    df.sort_values(by='TimeStamp (sec)',ascending=True)
+	
+    timestr = strftime("%Y%m%d-%H%M%S")
+
+
+    # Create CSV file name and save data to CSV file
+    csvfilename ='media/{code}_{importid}.csv'.format(
+        importid=importid,
+        code = uuid4().hex[:16]
+        )
+
+    res =  df.to_csv(csvfilename+'.gz',index_label='index',
+                     compression='gzip')
+
+
+    # with Concept2
+    if source=='c2':
+        try:
+            totaldist = data['distance']
+            totaltime = data['time']/10.
+        except KeyError:
+            totaldist = 0
+            totaltime = 0
+    else:
+        totaldist = 0
+        totaltime = 0
+
+    id,message = dataprep.save_workout_database(
+        csvfilename,r,
+        workouttype=workouttype,
+        title=title,notes=comments,
+        workoutsource=workoutsource,
+        dosummary=True
+    )
+
+            
+
+    return id,message