st half implemented

rowers/tasks.py

@@ -447,6 +447,174 @@ def handle_c2_sync(workoutid, url, headers, data, debug=False, **kwargs):
 
     return 1
 
+def splitstdata(lijst):
+    t = []
+    latlong = []
+    while len(lijst) >= 2:
+        t.append(lijst[0])
+        latlong.append(lijst[1])
+        lijst = lijst[2:]
+
+    return [np.array(t), np.array(latlong)]
+
+@app.task
+def handle_sporttracks_workout_from_data(user, importid, data, strokedata, source,
+                                          workoutsource, debug=False, **kwargs):
+
+    try:
+        workouttype = data['type']
+    except KeyError:  # pragma: no cover
+        workouttype = 'other'
+
+    if workouttype not in [x[0] for x in Workout.workouttypes]:
+        workouttype = 'other'
+    try:
+        comments = data['comments']
+    except:
+        comments = ''
+
+    r = Rower.objects.get(user=user)
+    rowdatetime = iso8601.parse_date(data['start_time'])
+    starttimeunix = arrow.get(rowdatetime).timestamp()
+
+    try:
+        title = data['name']
+    except:  # pragma: no cover
+        title = "Imported data"
+
+    try:
+        res = splitstdata(data['distance'])
+        distance = res[1]
+        times_distance = res[0]
+    except KeyError:  # pragma: no cover
+        try:
+            res = splitstdata(data['heartrate'])
+            times_distance = res[0]
+            distance = 0*times_distance
+        except KeyError:
+            return (0, "No distance or heart rate data in the workout")
+
+    try:
+        locs = data['location']
+
+        res = splitstdata(locs)
+        times_location = res[0]
+        latlong = res[1]
+        latcoord = []
+        loncoord = []
+
+        for coord in latlong:
+            lat = coord[0]
+            lon = coord[1]
+            latcoord.append(lat)
+            loncoord.append(lon)
+    except:
+        times_location = times_distance
+        latcoord = np.zeros(len(times_distance))
+        loncoord = np.zeros(len(times_distance))
+        if workouttype in mytypes.otwtypes:  # pragma: no cover
+            workouttype = 'rower'
+
+    try:
+        res = splitstdata(data['cadence'])
+        times_spm = res[0]
+        spm = res[1]
+    except KeyError:  # pragma: no cover
+        times_spm = times_distance
+        spm = 0*times_distance
+
+    try:
+        res = splitstdata(data['heartrate'])
+        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)
+    latseries = latseries.groupby(latseries.index).first()
+    lonseries = pd.Series(loncoord, index=times_location)
+    lonseries = lonseries.groupby(lonseries.index).first()
+    spmseries = pd.Series(spm, index=times_spm)
+    spmseries = spmseries.groupby(spmseries.index).first()
+    hrseries = pd.Series(hr, index=times_hr)
+    hrseries = hrseries.groupby(hrseries.index).first()
+
+    # 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
+    unixtime[0] = starttimeunix
+
+    df['TimeStamp (sec)'] = unixtime
+
+    dt = np.diff(cum_time).mean()
+    wsize = round(5./dt)
+
+    velo2 = ewmovingaverage(velo, wsize)
+
+    df[' Stroke500mPace (sec/500m)'] = 500./velo2
+
+    df = df.fillna(0)
+
+    df.sort_values(by='TimeStamp (sec)', ascending=True)
+
+
+    csvfilename = 'media/{code}_{importid}.csv'.format(
+        importid=importid,
+        code=uuid4().hex[:16]
+    )
+
+    res = df.to_csv(csvfilename+'.gz', index_label='index',
+                    compression='gzip')
+
+    uploadoptions = {
+        'secret': UPLOAD_SERVICE_SECRET,
+        'user': user.id,
+        'file': csvfilename+'.gz',
+        'title': '',
+        'workouttype': workouttype,
+        'boattype': '1x',
+        'sporttracksid': importid,
+        'title':title,
+    }
+    session = requests.session()
+    newHeaders = {'Content-type': 'application/json', 'Accept': 'text/plain'}
+    session.headers.update(newHeaders)
+    _ = session.post(UPLOAD_SERVICE_URL, json=uploadoptions)
+    
+    return 1
+
 
 @app.task
 def handle_sporttracks_sync(workoutid, url, headers, data, debug=False, **kwargs):