433 lines
12 KiB
Python
433 lines
12 KiB
Python
# for actions related to uploads
|
|
from django.conf import settings
|
|
from django.utils import timezone,translation
|
|
from rowers.tasks import (
|
|
handle_sendemail_unrecognized,handle_sendemailnewcomment,
|
|
handle_sendemailnewresponse, handle_updatedps,
|
|
handle_makeplot,handle_otwsetpower,handle_sendemailtcx,
|
|
handle_sendemailcsv
|
|
)
|
|
|
|
from rowers.models import GraphImage
|
|
|
|
from PIL import Image
|
|
|
|
import numpy as np
|
|
import yaml
|
|
import argparse
|
|
import yamllint
|
|
from subprocess import call
|
|
import re
|
|
|
|
from verbalexpressions import VerEx
|
|
import re
|
|
|
|
import django_rq
|
|
queue = django_rq.get_queue('default')
|
|
queuelow = django_rq.get_queue('low')
|
|
queuehigh = django_rq.get_queue('low')
|
|
|
|
from types import workouttypes,boattypes
|
|
|
|
try:
|
|
from cStringIO import StringIO
|
|
except:
|
|
from StringIO import StringIO
|
|
|
|
from rowers.utils import (
|
|
geo_distance,serialize_list,deserialize_list,uniqify,
|
|
str2bool,range_to_color_hex,absolute,myqueue
|
|
)
|
|
|
|
def cleanbody(body):
|
|
regex = r".*---\n([\s\S]*?)\.\.\..*"
|
|
matches = re.finditer(regex,body)
|
|
|
|
for m in matches:
|
|
|
|
if m != None:
|
|
body = m.group(0)
|
|
|
|
return body
|
|
|
|
# currently only matches one chart
|
|
def matchchart(line):
|
|
results = []
|
|
testert = '^((chart)|(plot))'
|
|
tester2t = testert+'(.*)(dist)'
|
|
tester3t = testert+'(.*)(time)'
|
|
tester4t = testert+'(.*)(pie)'
|
|
|
|
tester = re.compile(testert)
|
|
tester2 = re.compile(tester2t)
|
|
tester3 = re.compile(tester3t)
|
|
tester4 = re.compile(tester4t)
|
|
|
|
if tester.match(line.lower()):
|
|
if tester2.match(line.lower()):
|
|
return 'distanceplot'
|
|
if tester3.match(line.lower()):
|
|
return 'timeplot'
|
|
if tester3.match(line.lower()):
|
|
return 'pieplot'
|
|
|
|
def matchsync(line):
|
|
results = []
|
|
tester = '((sync)|(synchronization)|(export))'
|
|
tester2 = tester+'(.*)((c2)|(concept2)|(logbook))'
|
|
tester3 = tester+'(.*)((tp)|(trainingpeaks))'
|
|
tester4 = tester+'(.*)(strava)'
|
|
tester5 = tester+'(.*)((st)|(sporttracks))'
|
|
tester6 = tester+'(.*)((rk)|(runkeeper))'
|
|
tester7 = tester+'(.*)((mapmyfitness)|(underarmour)|(ua))'
|
|
|
|
tester = re.compile(tester)
|
|
|
|
if tester.match(line.lower()):
|
|
testers = [
|
|
('upload_to_C2',re.compile(tester2)),
|
|
('upload_totp',re.compile(tester3)),
|
|
('upload_to_Strava',re.compile(tester4)),
|
|
('upload_to_SportTracks',re.compile(tester5)),
|
|
('upload_to_RunKeeper',re.compile(tester6)),
|
|
('upload_to_MapMyFitness',re.compile(tester7)),
|
|
]
|
|
for t in testers:
|
|
if t[1].match(line.lower()):
|
|
results.append(t[0])
|
|
|
|
return results
|
|
|
|
def gettypeoptions_body2(uploadoptions,body):
|
|
tester = re.compile('^(workout)')
|
|
testerb = re.compile('^(boat)')
|
|
for line in body.splitlines():
|
|
if tester.match(line.lower()):
|
|
for typ,verb in workouttypes:
|
|
str1 = '^(workout)(.*)({a})'.format(
|
|
a = typ
|
|
)
|
|
testert = re.compile(str1)
|
|
if testert.match(line.lower()):
|
|
uploadoptions['workouttype'] = typ
|
|
if testerb.match(line.lower()):
|
|
for typ,verb in boattypes:
|
|
str1 = '^(boat)(.*)({a})'.format(
|
|
a = typ
|
|
)
|
|
testert = re.compile(str1)
|
|
if testert.match(line.lower()):
|
|
uploadoptions['boattype'] = typ
|
|
|
|
return uploadoptions
|
|
|
|
def getprivateoptions_body2(uploadoptions,body):
|
|
tester = re.compile('^(priva)')
|
|
for line in body.splitlines():
|
|
if tester.match(line.lower()):
|
|
v = True
|
|
negs = ['false','False','None','no']
|
|
for neg in negs:
|
|
tstr = re.compile('^(.*)'+neg)
|
|
|
|
if tstr.match(line.lower()):
|
|
v = False
|
|
|
|
uploadoptions['makeprivate'] = v
|
|
|
|
return uploadoptions
|
|
|
|
def getplotoptions_body2(uploadoptions,body):
|
|
for line in body.splitlines():
|
|
chart = matchchart(line)
|
|
if chart:
|
|
uploadoptions['make_plot'] = True
|
|
uploadoptions['plottype'] = chart
|
|
|
|
return uploadoptions
|
|
|
|
def getsyncoptions_body2(uploadoptions,body):
|
|
result = []
|
|
for line in body.splitlines():
|
|
result = result+matchsync(line)
|
|
|
|
result = list(set(result))
|
|
|
|
for r in result:
|
|
uploadoptions[r] = True
|
|
|
|
return uploadoptions
|
|
|
|
def getsyncoptions(uploadoptions,values):
|
|
try:
|
|
value = values.lower()
|
|
values = [values]
|
|
except AttributeError:
|
|
pass
|
|
|
|
for v in values:
|
|
try:
|
|
v = v.lower()
|
|
|
|
if v in ['c2','concept2','logbook']:
|
|
uploadoptions['upload_to_C2'] = True
|
|
if v in ['tp','trainingpeaks']:
|
|
uploadoptions['upload_totp'] = True
|
|
if v in ['strava']:
|
|
uploadoptions['upload_to_Strava'] = True
|
|
if v in ['st','sporttracks']:
|
|
uploadoptions['upload_to_SportTracks'] = True
|
|
if v in ['rk','runkeeper']:
|
|
uploadoptions['upload_to_RunKeeper'] = True
|
|
if v in ['ua','underarmour','mapmyfitness']:
|
|
uploadoptions['upload_to_MapMyFitness'] = True
|
|
except AttributeError:
|
|
pass
|
|
|
|
return uploadoptions
|
|
|
|
def getplotoptions(uploadoptions,value):
|
|
try:
|
|
v = value.lower()
|
|
if v in ['pieplot','timeplot','distanceplot']:
|
|
uploadoptions['make_plot'] = True
|
|
uploadoptions['plottype'] = v
|
|
elif 'pie' in v:
|
|
uploadoptions['make_plot'] = True
|
|
uploadoptions['plottype'] = 'pieplot'
|
|
elif 'distance' in v:
|
|
uploadoptions['make_plot'] = True
|
|
uploadoptions['plottype'] = 'distanceplot'
|
|
elif 'time' in v:
|
|
uploadoptions['make_plot'] = True
|
|
uploadoptions['plottype'] = 'timeplot'
|
|
except TypeError:
|
|
pass
|
|
|
|
return uploadoptions
|
|
|
|
|
|
def gettype(uploadoptions,value,key):
|
|
workouttype = 'rower'
|
|
for type,verb in workouttypes:
|
|
if value == type:
|
|
workouttype = type
|
|
if value == verb:
|
|
workouttype = type
|
|
|
|
uploadoptions[key] = workouttype
|
|
|
|
return uploadoptions
|
|
|
|
def getboattype(uploadoptions,value,key):
|
|
boattype = '1x'
|
|
for type,verb in boattypes:
|
|
if value == type:
|
|
boattype = type
|
|
if value == verb:
|
|
boattype = type
|
|
|
|
uploadoptions[key] = boattype
|
|
|
|
return uploadoptions
|
|
|
|
|
|
def getboolean(uploadoptions,value,key):
|
|
b = True
|
|
if not value:
|
|
b = False
|
|
if value in [False,'false','False',None,'no']:
|
|
b = False
|
|
|
|
uploadoptions[key] = b
|
|
|
|
return uploadoptions
|
|
|
|
def upload_options(body):
|
|
uploadoptions = {}
|
|
body = cleanbody(body)
|
|
try:
|
|
yml = (yaml.load(body))
|
|
if yml and 'fromuploadform' in yml:
|
|
return yml
|
|
try:
|
|
for key, value in yml.iteritems():
|
|
lowkey = key.lower()
|
|
if lowkey == 'sync' or lowkey == 'synchronization':
|
|
uploadoptions = getsyncoptions(uploadoptions,value)
|
|
if lowkey == 'chart' or lowkey == 'static' or lowkey == 'plot':
|
|
uploadoptions = getplotoptions(uploadoptions,value)
|
|
if 'priva' in lowkey:
|
|
uploadoptions = getboolean(uploadoptions,value,'makeprivate')
|
|
if 'workout' in lowkey:
|
|
uploadoptions = gettype(uploadoptions,value,'workouttype')
|
|
if 'boat' in lowkey:
|
|
uploadoptions = getboattype(uploadoptions,value,'boattype')
|
|
except AttributeError:
|
|
#pass
|
|
raise yaml.YAMLError
|
|
except yaml.YAMLError as exc:
|
|
try:
|
|
uploadoptions = getplotoptions_body2(uploadoptions,body)
|
|
uploadoptions = getsyncoptions_body2(uploadoptions,body)
|
|
uploadoptions = getprivateoptions_body2(uploadoptions,body)
|
|
typeoptions = gettypeoptions_body2(uploadoptions,body)
|
|
except IOError:
|
|
pm = exc.problem_mark
|
|
strpm = str(pm)
|
|
pbm = "Your email has an issue on line {} at position {}. The error is: ".format(
|
|
pm.line+1,
|
|
pm.column+1,
|
|
)+strpm
|
|
return {'error':pbm}
|
|
|
|
if uploadoptions == {}:
|
|
uploadoptions['message'] = 'No parsing issue. No valid commands detected'
|
|
|
|
return uploadoptions
|
|
|
|
def make_plot(r,w,f1,f2,plottype,title,imagename='',plotnr=0):
|
|
if imagename == '':
|
|
imagename = f1[:-4]+'.png'
|
|
fullpathimagename = 'static/plots/'+imagename
|
|
|
|
powerperc = 100*np.array([r.pw_ut2,
|
|
r.pw_ut1,
|
|
r.pw_at,
|
|
r.pw_tr,r.pw_an])/r.ftp
|
|
|
|
ftp = float(r.ftp)
|
|
if w.workouttype in ('water','coastal'):
|
|
ftp = ftp*(100.-r.otwslack)/100.
|
|
|
|
hrpwrdata = {
|
|
'hrmax':r.max,
|
|
'hrut2':r.ut2,
|
|
'hrut1':r.ut1,
|
|
'hrat':r.at,
|
|
'hrtr':r.tr,
|
|
'hran':r.an,
|
|
'ftp':ftp,
|
|
'powerperc':serialize_list(powerperc),
|
|
'powerzones':serialize_list(r.powerzones),
|
|
}
|
|
|
|
# make plot - asynchronous task
|
|
plotnrs = {
|
|
'timeplot':1,
|
|
'distanceplot':2,
|
|
'pieplot':3,
|
|
}
|
|
|
|
if plotnr == 0:
|
|
plotnr = plotnrs[plottype]
|
|
|
|
if w.workouttype in ('water','coastal'):
|
|
plotnr = plotnr+3
|
|
|
|
|
|
job = myqueue(queue,handle_makeplot,f1,f2,
|
|
title,hrpwrdata,
|
|
plotnr,imagename)
|
|
|
|
try:
|
|
width,height = Image.open(fullpathimagename).size
|
|
except:
|
|
width = 1200
|
|
height = 600
|
|
|
|
imgs = GraphImage.objects.filter(workout=w)
|
|
if len(imgs) < 7:
|
|
i = GraphImage(workout=w,
|
|
creationdatetime=timezone.now(),
|
|
filename=fullpathimagename,
|
|
width=width,height=height)
|
|
|
|
i.save()
|
|
else:
|
|
return 0,'You have reached the maximum number of static images for this workout. Delete an image first'
|
|
|
|
return i.id,job.id
|
|
|
|
import c2stuff,stravastuff,sporttracksstuff,runkeeperstuff
|
|
import underarmourstuff,tpstuff
|
|
|
|
def set_workouttype(w,options):
|
|
try:
|
|
w.workouttype = options['workouttype']
|
|
w.save()
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
w.boattype = options['boattype']
|
|
w.save()
|
|
except KeyError:
|
|
pass
|
|
|
|
return 1
|
|
|
|
def make_private(w,options):
|
|
if 'makeprivate' in options and options['makeprivate']:
|
|
w.privacy = 'hidden'
|
|
w.save()
|
|
|
|
return 1
|
|
|
|
def do_sync(w,options):
|
|
if 'upload_to_C2' in options and options['upload_to_C2']:
|
|
try:
|
|
message,id = c2stuff.workout_c2_upload(w.user.user,w)
|
|
except c2stuff.C2NoTokenError:
|
|
id = 0
|
|
message = "Something went wrong with the Concept2 sync"
|
|
|
|
if 'upload_to_Strava' in options and options['upload_to_Strava']:
|
|
try:
|
|
message,id = stravastuff.workout_strava_upload(
|
|
w.user.user,w
|
|
)
|
|
except stravastuff.StravaNoTokenError:
|
|
id = 0
|
|
message = "Please connect to Strava first"
|
|
|
|
|
|
if 'upload_to_SportTracks' in options and options['upload_to_SportTracks']:
|
|
try:
|
|
message,id = sporttracksstuff.workout_sporttracks_upload(
|
|
w.user.user,w
|
|
)
|
|
except sporttracksstuff.SportTracksNoTokenError:
|
|
message = "Please connect to SportTracks first"
|
|
id = 0
|
|
|
|
|
|
if 'upload_to_RunKeeper' in options and options['upload_to_RunKeeper']:
|
|
try:
|
|
message,id = runkeeperstuff.workout_runkeeper_upload(
|
|
w.user.user,w
|
|
)
|
|
except runkeeperstuff.RunKeeperNoTokenError:
|
|
message = "Please connect to Runkeeper first"
|
|
id = 0
|
|
|
|
if 'upload_to_MapMyFitness' in options and options['upload_to_MapMyFitness']:
|
|
try:
|
|
message,id = underarmourstuff.workout_ua_upload(
|
|
w.user.user,w
|
|
)
|
|
except underarmourstuff.UnderArmourNoTokenError:
|
|
message = "Please connect to MapMyFitness first"
|
|
id = 0
|
|
|
|
|
|
if 'upload_to_TrainingPeaks' in options and options['upload_to_TrainingPeaks']:
|
|
try:
|
|
message,id = tpstuff.workout_tp_upload(
|
|
w.user.user,w
|
|
)
|
|
except tpstuff.TPNoTokenError:
|
|
message = "Please connect to TrainingPeaks first"
|
|
id = 0
|
|
|
|
return 1
|