259 lines
7.3 KiB
Python
259 lines
7.3 KiB
Python
from django.http import HttpResponse,Http404,HttpResponseRedirect
|
|
from django.template import Template, Context
|
|
from django.template.loader import get_template
|
|
from django.shortcuts import render, redirect, render_to_response
|
|
from django.conf import settings
|
|
from rowsandall_app.forms import ContactForm,DocumentsForm
|
|
from django.core.mail import send_mail
|
|
from django.core.urlresolvers import reverse
|
|
from matplotlib.pyplot import figure, axes, pie, title
|
|
from matplotlib.backends.backend_agg import FigureCanvasAgg
|
|
from matplotlib.ticker import MultipleLocator,FuncFormatter,NullFormatter
|
|
import matplotlib.pyplot as plt
|
|
from rowingdata import rower as rrower
|
|
from rowingdata import main as rmain
|
|
from rowingdata import rowingdata as rdata
|
|
from rowingdata import TCXParser
|
|
import StringIO
|
|
from django.contrib.auth.decorators import login_required
|
|
|
|
import django_rq
|
|
queue = django_rq.get_queue('default')
|
|
|
|
import datetime
|
|
import pandas as pd
|
|
import os
|
|
import numpy as np
|
|
import json
|
|
import mpld3
|
|
|
|
from rctasks import addrc
|
|
|
|
from rows import *
|
|
from rowers.tasks import add as addtask
|
|
from rowers.tasks import handle_makeplot
|
|
from celery.result import AsyncResult
|
|
from celery.exceptions import TimeoutError
|
|
from rowers.models import Rower,User,Workout,GraphImage
|
|
|
|
|
|
def showStaticImage(request,imagename):
|
|
return render(request, 'image_page.html', {'imagename': imagename})
|
|
|
|
def rootview(request):
|
|
magicsentence = rmain()
|
|
return render(request, 'frontpage.html', {'versionstring': magicsentence})
|
|
|
|
|
|
def version(request):
|
|
magicsentence = rmain()
|
|
return render(request, 'base.html', {'versionstring': magicsentence})
|
|
|
|
def rowingdata(request,formloc):
|
|
if request.method == 'POST':
|
|
form = DocumentsForm(request.POST,request.FILES)
|
|
|
|
if form.is_valid():
|
|
f = request.FILES['file']
|
|
t = request.POST['title']
|
|
res = handle_uploaded_file(f)
|
|
f1 = res[0]
|
|
f2 = res[1]
|
|
row = rdata(f2)
|
|
fig1 = row.get_timeplot_erg(t)
|
|
|
|
canvas = FigureCanvasAgg(fig1)
|
|
# response = HttpResponse(content_type='image/png')
|
|
# canvas.print_png(response)
|
|
imagename = f1+'.png'
|
|
plt.savefig('static/plots/'+imagename,format='png')
|
|
plt.close(fig1)
|
|
response = render(request,'image_page.html',{'imagename':'plots/'+imagename})
|
|
|
|
else:
|
|
response = HttpResponse("invalid form")
|
|
|
|
return response
|
|
else:
|
|
form = DocumentsForm()
|
|
return render(request, 'document_form.html',
|
|
{'form':form, 'formloc': formloc})
|
|
|
|
@login_required()
|
|
def nrowingdata(request,formloc):
|
|
if request.method == 'POST':
|
|
form = DocumentsForm(request.POST,request.FILES)
|
|
|
|
if form.is_valid():
|
|
f = request.FILES['file']
|
|
res = handle_uploaded_file(f)
|
|
t = request.POST['title']
|
|
fileformat = request.POST['fileformat']
|
|
workouttype = request.POST['workouttype']
|
|
notes = request.POST['notes']
|
|
|
|
f1 = res[0] # file name
|
|
f2 = res[1] # file name incl media directory
|
|
|
|
# handle TCX
|
|
if (fileformat == 'tcx'):
|
|
row = TCXParser(f2)
|
|
f_to_be_deleted = f2
|
|
# should delete file
|
|
f2 = f2+'.csv'
|
|
row.write_csv(f2)
|
|
os.remove(f_to_be_deleted)
|
|
|
|
imagename = f1+'.png'
|
|
fullpathimagename = 'static/plots/'+imagename
|
|
u = request.user
|
|
r = Rower.objects.get(user=request.user)
|
|
hrdata = {
|
|
'hrmax':r.max,
|
|
'hrut2':r.ut2,
|
|
'hrut1':r.ut1,
|
|
'hrat':r.at,
|
|
'hrtr':r.tr,
|
|
'hran':r.an,
|
|
}
|
|
|
|
# make plot - asynchronous task
|
|
res = handle_makeplot.delay(f1,f2,t,hrdata)
|
|
|
|
# make workout and put in database
|
|
rr = rrower(hrmax=r.max,hrut2=r.ut2,
|
|
hrut1=r.ut1,hrat=r.at,
|
|
hrtr=r.tr,hran=r.an)
|
|
row = rdata(f2,rower=rr)
|
|
totaldist = row.df['cum_dist'].max()
|
|
totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min()
|
|
totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)']
|
|
|
|
|
|
hours = int(totaltime/3600.)
|
|
minutes = int((totaltime - 3600.*hours)/60.)
|
|
seconds = int(totaltime - 3600.*hours - 60.*minutes)
|
|
|
|
duration = "%s:%s:%s" % (hours,minutes,seconds)
|
|
|
|
|
|
workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
|
|
workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')
|
|
|
|
# check for duplicate start times
|
|
r = Rower.objects.get(user=request.user)
|
|
|
|
ws = Workout.objects.filter(starttime=workoutstarttime,
|
|
user=r)
|
|
if (len(ws) != 0):
|
|
print "Warning: This workout probably already exists in the database"
|
|
|
|
w = Workout(user=r,name=t,date=workoutdate,workouttype=workouttype,
|
|
duration=duration,distance=totaldist,
|
|
weightcategory=r.weightcategory,
|
|
starttime=workoutstarttime,
|
|
csvfilename=f2,notes=notes)
|
|
w.save()
|
|
|
|
i = GraphImage(workout=w,creationdatetime=datetime.datetime.now(),
|
|
filename=fullpathimagename)
|
|
i.save()
|
|
|
|
url = reverse(waitforplot,args=[str(res.id)])
|
|
return HttpResponseRedirect(url)
|
|
|
|
else:
|
|
response = HttpResponse("invalid form")
|
|
|
|
return response
|
|
else:
|
|
form = DocumentsForm()
|
|
return render(request, 'document_form.html',
|
|
{'form':form, 'formloc': formloc})
|
|
|
|
|
|
|
|
def uploadfile(request,formloc):
|
|
if request.method == 'POST':
|
|
form = DocumentsForm(request.POST, request.FILES)
|
|
|
|
if form.is_valid():
|
|
result = handle_uploaded_file(request.FILES['file'])
|
|
return HttpResponse("succes! "+result)
|
|
else:
|
|
return HttpResponse("Invalid Form")
|
|
else:
|
|
form = DocumentsForm()
|
|
return render(request, 'document_form.html',
|
|
{'form': form, 'formloc':formloc})
|
|
|
|
@login_required()
|
|
def add(request,x,y):
|
|
if settings.DEBUG:
|
|
task = addtask.apply_async((int(x),int(y)),countdown=10)
|
|
task_id = AsyncResult(task)
|
|
print task.id
|
|
else:
|
|
task = queue.enqueue(addrc,x,y,0)
|
|
task_id = task.id
|
|
|
|
url = reverse(wait,args=[str(task_id)])
|
|
return HttpResponseRedirect(url)
|
|
|
|
|
|
|
|
|
|
def wait(request,task_id=""):
|
|
if settings.DEBUG:
|
|
res = AsyncResult(task_id)
|
|
else:
|
|
res = queue.fetch_job(task_id)
|
|
if (res.status == 'SUCCESS') or (res.status == 'finished'):
|
|
return HttpResponse("Task complete. Result: "+str(res.result))
|
|
else:
|
|
m = "Task status: "+str(res.status)
|
|
return render(request,'waiting_page.html',{'message':m})
|
|
return HttpResponse("Task status: "+str(res.status)+". <p>Hit reload to check again")
|
|
|
|
|
|
def waitforplot(request,task_id=""):
|
|
res = AsyncResult(task_id)
|
|
if (res.status == 'SUCCESS'):
|
|
url = reverse(showplot,args=[str(res.result)])
|
|
return HttpResponseRedirect(url)
|
|
else:
|
|
m = "Task status: "+str(res.status)
|
|
|
|
return render(request,'waiting_page.html',{'message':m})
|
|
|
|
def showplot(request,imagename=""):
|
|
return render(request,'image_page.html',{'imagename':'plots/'+imagename})
|
|
|
|
|
|
def contact(request):
|
|
if request.method == 'POST':
|
|
form = ContactForm(request.POST)
|
|
if form.is_valid():
|
|
cd = form.cleaned_data
|
|
send_mail(
|
|
cd['subject'],
|
|
cd['message'],
|
|
cd.get('email', 'noreply@example.com'),
|
|
['siteowner@example.com'],
|
|
)
|
|
return HttpResponseRedirect('/contact/thanks/')
|
|
else:
|
|
form = ContactForm()
|
|
return render(request, 'contact_form.html', {'form': form})
|
|
|
|
def interactiveplot(request):
|
|
x = np.linspace(-10,10,num=1200)
|
|
y = x**2-5*x+4
|
|
fig = plt.figure(figsize=(6,5))
|
|
graph = plt.plot(x,y)
|
|
g = mpld3.fig_to_html(fig)
|
|
# js_data = json.dumps(mpld3.fig_to_dict(fig))
|
|
plt.close()
|
|
# return render(request,'interactiveplot.html',{"my_data":js_data})
|
|
return HttpResponse(g)
|