rowsandall/rowers/tests.py

#from __future__ import print_function
from bs4 import BeautifulSoup
import re

from django.test import TestCase, Client,override_settings
from django.core.management import call_command
from django.utils.six import StringIO
from django.test.client import RequestFactory
from .views import checkworkoutuser,c2_open
from rowers.models import Workout, User, Rower, WorkoutForm,RowerForm,GraphImage
from rowers.forms import DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail
import rowers.plots as plots
import rowers.interactiveplots as iplots
import datetime
from rowingdata import rowingdata as rdata
from rowingdata import rower as rrower
from django.utils import timezone
from rowers.rows import handle_uploaded_file
from django.core.files.uploadedfile import SimpleUploadedFile
from time import strftime,strptime,mktime,time,daylight
import os
from rowers.tasks import handle_makeplot
from rowers.utils import serialize_list,deserialize_list
from rowers.utils import NoTokenError
from shutil import copyfile
from nose.tools import assert_true
from mock import Mock, patch
from minimocktest import MockTestCase
import pandas as pd
import rowers.c2stuff as c2stuff

import json
import numpy as np

from rowers import urls
from rowers.views import error500_view,error404_view,error400_view,error403_view

from dataprep import delete_strokedata

from redis import StrictRedis
redis_connection = StrictRedis()

        
class DjangoTestCase(TestCase, MockTestCase):
    def _pre_setup(self):
	MockTestCase.setUp(self)
	TestCase._pre_setup(self)
	self.client = Client()

    def _post_teardown(self):
	TestCase._post_teardown(self)
	MockTestCase.tearDown(self)
        delete_strokedata(1)

def mocked_requests(*args, **kwargs):
    with open('rowers/testdata/c2jsonworkoutdata.txt','r') as infile:
        c2workoutdata = json.load(infile)

    with open('rowers/testdata/c2jsonstrokedata.txt','r') as infile:
        c2strokedata = json.load(infile)

    c2workoutlist = json.load(open('rowers/testdata/c2workoutlist.txt'))

    c2uploadjson = {
        "data": {
            "id": 339,
            "user_id": 1,
            "date": "2015-08-05 13:15:41",
            "timezone": "Europe/London",
            "date_utc": "2015-08-05 12:15:41",
            "distance": 5649,
            "type": "rower",
            "time": 8649,
            "time_formatted": "14:24.9",
            "workout_type": "JustRow",
            "source": "ErgData",
            "weight_class": "H",
            "verified": True,
            "ranked": False
        }
    }
    
    stravaworkoutlist = json.load(open('rowers/testdata/stravaworkoutlist.txt'))
    sporttracksworkoutlist = json.load(open('rowers/testdata/sporttracksworkouts.txt'))

    rkworkoutlistjson = json.load(open('rowers/testdata/rkworkoutslist.txt','r'))
    uaworkoutlistjson = json.load(open('rowers/testdata/uaworkoutlist.txt','r'))
    
    stravasummaryjson = json.load(open('rowers/testdata/stravaworkoutsummary.txt','r'))

    stravatimejson = json.load(open('rowers/testdata/stravatimetestdata.txt','r'))
    stravavelojson = json.load(open('rowers/testdata/stravavelotestdata.txt','r'))
    stravadistancejson = json.load(open('rowers/testdata/stravadistancetestdata.txt','r'))
    stravalatlongjson = json.load(open('rowers/testdata/stravalatlongtestdata.txt','r'))
    stravahrjson = json.load(open('rowers/testdata/stravahrtestdata.txt','r'))
    stravaspmjson = json.load(open('rowers/testdata/stravaspmtestdata.txt','r'))

    uapostworkoutjson = json.load(open('rowers/testdata/uapostworkoutresponse.txt','r'))

    tpuploadresponse = json.load(open('rowers/testdata/tpuploadresponse.txt','r'))
    
    stravastreamjson = {
        'time':stravatimejson,
        'velocity_smooth':stravavelojson,
        'distance':stravadistancejson,
        'latlng':stravalatlongjson,
        'heartrate':stravahrjson,
        'cadence':stravaspmjson,
        }

    ststrokesjson = json.load(open('rowers/testdata/sporttracksstrokedata.txt','r'))

    rkstrokesjson = json.load(open('rowers/testdata/rkstrokes.txt','r'))

    uastrokesjson = json.load(open('rowers/testdata/uastrokes.txt','r'))
    uauserjson = json.load(open('rowers/testdata/uauser.txt','r'))

    class MockResponse:
        def __init__(self, json_data, status_code):
            self.json_data = json_data
            self.status_code = status_code

        def json(self):
            return self.json_data


    class MockHeaderResponse:
        def __init__(self, header_data, status_code):
            self.headers = header_data
            self.status_code = status_code
        
    class MockSession:
        def send(self,prepped):
            # prepped.url
            # prepped.body (post data)
            # prepped.headers
            # prepped.method
            
            json_data = {
                'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
                'expires_in': 604800,
                'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
            }

            return MockResponse(json_data,200)

    if not args:
        return MockSession()
        
    c2tester = re.compile('.*?log\.concept2\.com')
    stravatester = re.compile('.*?strava\.com')
    sttester = re.compile('.*?sporttracks\.mobi')
    rktester = re.compile('.*?runkeeper\.com')
    uatester = re.compile('.*?mapmyfitness\.com')
    tptester = re.compile('.*?trainingpeaks\.com')
        
    c2importregex = '.*?concept2.com\/api\/users\/me\/results\/\d+'
    c2importtester = re.compile(c2importregex)

    c2uploadregex = '.*?concept2.com\/api\/users\/\d+\/results$'
    c2uploadtester = re.compile(c2uploadregex)

    c2strokesregex = '.*?concept2.com\/api\/users\/me\/results\/\d+\/strokes'
    c2strokestester = re.compile(c2strokesregex)

    c2workoutlistregex = '.*?concept2\.com\/api\/users\/me\/results\?page=\d'
    c2workoutlisttester = re.compile(c2workoutlistregex)

    stravaworkoutlistregex = '.*?strava\.com\/api\/v3\/athlete\/activities'
    stravaworkoutlisttester = re.compile(stravaworkoutlistregex)

    stravastreamregex = '.*?strava\.com\/api\/v3\/activities\/\d+\/streams\/(\w.*?)\?'
    stravastreamtester = re.compile(stravastreamregex)

    stravasummaryregex = '.*?strava\.com\/api\/v3\/activities\/\d+$'
    stravasummarytester = re.compile(stravasummaryregex)

    stuploadregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities.json$'
    stuploadtester = re.compile(stuploadregex)

    stworkoutlistregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities$'
    stworkoutlisttester = re.compile(stworkoutlistregex)

    ststrokesregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities/\d+$'
    ststrokestester = re.compile(ststrokesregex)

    rkuploadregex = '.*?api\.runkeeper\.com\/fitnessActivities$'
    rkuploadtester = re.compile(rkuploadregex)
    rkuserregex = '.*?api\.runkeeper\.com\/user$'
    rkusertester = re.compile(rkuserregex)
    rkstrokesregex = '.*?api\.runkeeper\.com\/fitnessActivities/\d+$'
    rkstrokestester = re.compile(rkstrokesregex)

    uaapiregex = '.*?api\.ua\.com'
    uaapitester = re.compile(uaapiregex)

    uauploadregex = '.*?api\.ua\.com\/v7.1\/workout\/$'
    uauploadtester = re.compile(uauploadregex)

    uastrokesregex = '.*?api\.ua\.com\/v7.1\/workout\/\d+'
    uastrokestester = re.compile(uastrokesregex)

    ualistregex = '.*?api\.ua\.com\/v7.1\/workout\/\?user'
    ualisttester = re.compile(ualistregex)

    uauserregex = '.*?api\.ua\.com\/v7.1\/user\/self\/'
    uausertester = re.compile(uauserregex)

    tpuploadregex = '.*?trainingpeaks\.com\/v1\/file'
    tpuploadtester = re.compile(tpuploadregex)

    if tptester.match(args[0]):
        if 'token' in args[0]:
            json_data = {
                'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
                'expires_in': 604800,
                'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
            }
            return MockResponse(json_data,200)
        elif tpuploadtester.match(args[0]):
            return MockResponse(tpuploadresponse,200)
    
    if uaapitester.match(args[0]):
        if 'access_token' in args[0]:
            json_data = {
                'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
                'expires_in': 604800,
                'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
            }
            return MockResponse(json_data,200)
        elif uauploadtester.match(args[0]):
            if 'data' in kwargs:
                return MockResponse(uapostworkoutjson,200)
        elif uastrokestester.match(args[0]):
            return MockResponse(uastrokesjson,200)
        elif ualisttester.match(args[0]):
            return MockResponse(uaworkoutlistjson,200)
        elif uausertester.match(args[0]):
            return MockResponse(uauserjson,200)
            
                
    if uatester.match(args[0]):
        if 'access_token' in args[0]:
            json_data = {
                'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
                'expires_in': 604800,
                'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
            }
            return MockResponse(json_data,200)
            
    
    if rktester.match(args[0]):
        if 'token' in args[0]:
            json_data = {
                'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
                'expires_in': 604800,
                'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
            }
            return MockResponse(json_data,200)
        elif rkuploadtester.match(args[0]):
            if 'data' in kwargs:
                # post
                header_data = {
                    'Location': '/fitnessActivities/12'
                }
                return MockHeaderResponse(header_data,200)
            else:
                json_data = rkworkoutlistjson
                return MockResponse(json_data,200)
        elif rkusertester.match(args[0]):
            json_data = {
                "userID": 1234567890,
                "profile": "/profile",
                "settings": "/settings",
                "fitness_activities": "/fitnessActivities",
                "strength_training_activities": "/strengthTrainingActivities",
                "background_activities": "/backgroundActivities",
                "sleep": "/sleep",
                "nutrition": "/nutrition",
                "weight": "/weight",
                "general_measurements": "/generalMeasurements",
                "diabetes": "/diabetes",
                "records": "/records",
                "team": "/team"
            }
            return MockResponse(json_data, 200)
        elif rkstrokestester.match(args[0]):
            return MockResponse(rkstrokesjson,200)
    
    if sttester.match(args[0]):
        if 'oauth2/token' in args[0]:
            json_data = {
                'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
                'expires_in': 604800,
                'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
            }
            return MockResponse(json_data,200)
        if ststrokestester.match(args[0]):
            return MockResponse(ststrokesjson,200)
        if stuploadtester.match(args[0]):
            json_data = {
                "uris": [
                    "https://api.sporttracks.mobi/api/v2/fitnessActivities/123456.json"
                ]
            }
            return MockResponse(json_data, 200)
        if stworkoutlisttester.match(args[0]):
            return MockResponse(sporttracksworkoutlist,200)

    
    if stravatester.match(args[0]):
        if stravaworkoutlisttester.match(args[0]):
            return MockResponse(stravaworkoutlist,200)
        if stravastreamtester.match(args[0]):
            metric = stravastreamtester.match(args[0]).group(1)
            json_data = stravastreamjson[metric]
            return MockResponse(json_data,200)
        elif stravasummarytester.match(args[0]):
            return MockResponse(stravasummaryjson,200)
    
    if c2tester.match(args[0]):
        if c2uploadtester.match(args[0]):
            return MockResponse(c2uploadjson,201)
        if c2strokestester.match(args[0]):
            return MockResponse(c2strokedata,200)
        elif c2importtester.match(args[0]):
            return MockResponse(c2workoutdata,200)            
        elif c2workoutlisttester.match(args[0]):
            return MockResponse(c2workoutlist,200)
        elif 'access_token' in args[0]:
            json_data = {
                'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
                'expires_in': 604800,
                'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
            }
            return MockResponse(json_data,200)
        elif 'users/me' in args[0]:
            json_data = {
                'data': {
                    'username': 'john',
                    'id': 1234,
                    }
                }
            return MockResponse(json_data,200)
        elif 'results' in args[0]:
            json_data = {
                'data': {
                    'id': 1223,
                    }
                }
        else:
            return MockResponse(c2workoutdata,200)

    return MockResponse(None,404)


class C2Objects(DjangoTestCase):
    def setUp(self):
        self.c = Client()
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')

        self.u.first_name = 'John'
        self.u.last_name = 'Sander'
        self.u.save()
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )

        self.r.c2token = '12'
        self.r.c2refreshtoken = 'ab'
        self.r.tokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1)
        self.r.save()
	self.c.login(username='john',password='koeinsloot')

	self.nu = datetime.datetime.now()
        
	filename = 'rowers/testdata/testdata.csv'
	
	rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2,
		    hrut1=self.r.ut1,hrat=self.r.at,
		    hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp)
	row = rdata(filename,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)
	tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds))

	duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths)


	workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
	workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')

	self.w = Workout.objects.create(
            name='testworkout',workouttype='On-water',
	    user=self.r,date=self.nu.strftime('%Y-%m-%d'),
	    starttime=workoutstarttime,
            startdatetime=row.rowdatetime,
	    duration=duration,distance=totaldist,
	    csvfilename=filename
        )

        
    @patch('rowers.c2stuff.requests.Session', side_effect=mocked_requests)
    def test_c2_callback(self, mock_post):
        response = self.c.get('/call_back?code=dsdoij232s',follow=True)

        
        self.assertEqual(response.status_code, 200)

        
    @patch('rowers.c2stuff.Session', side_effect=mocked_requests)
    def test_c2_token_refresh(self, mock_post):
        response = self.c.get('/rowers/me/c2refresh/',follow=True)

        self.assertEqual(response.status_code, 200)


    @patch('rowers.c2stuff.requests.post', side_effect=mocked_requests)
    @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests)
    def test_c2_upload(self, mock_get, mock_post):
        response = self.c.get('/rowers/workout/1/c2uploadw/')

        self.assertRedirects(response,
                             expected_url = '/rowers/workout/1/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.url, '/rowers/workout/1/edit')
        self.assertEqual(response.status_code, 302)

    @patch('rowers.c2stuff.requests.post', side_effect=mocked_requests)
    def test_c2_list(self, mock_get):
        response = self.c.get('/rowers/workout/c2list',follow=True)

        self.assertEqual(response.status_code,200)
        
    @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests)
    def test_c2_import(self, mock_get):

        response = self.c.get('/rowers/workout/c2import/12/',follow=True)

        self.assertRedirects(response,
                             expected_url='/rowers/workout/2/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        
    def test_strokedata(self):
	with open('rowers/testdata/c2stroketestdata.txt','r') as infile:
	    res = json.load(infile)

	strokedata = pd.DataFrame.from_dict(res['data'])

	with open('rowers/testdata/c2testdata.txt','r') as infile:
	    res = json.load(infile)

	data = res['data']

	from rowers.views import add_workout_from_strokedata

	res = add_workout_from_strokedata(self.u,1,data,strokedata,source='c2')

    def test_strokedatanohr(self):
	with open('rowers/testdata/c2strokedatanohr.txt','r') as infile:
	    res = json.load(infile)

	strokedata = pd.DataFrame.from_dict(res['data'])

	with open('rowers/testdata/c2testdata.txt','r') as infile:
	    res = json.load(infile)

	data = res['data']

	from rowers.views import add_workout_from_strokedata


	res = add_workout_from_strokedata(self.u,1,data,strokedata,source='c2')

        
class StravaObjects(DjangoTestCase):
    def setUp(self):
        self.c = Client()
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')

        self.u.first_name = 'John'
        self.u.last_name = 'Sander'
        self.u.save()
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )

        self.r.stravatoken = '12'

        self.r.save()
	self.c.login(username='john',password='koeinsloot')

    @patch('rowers.stravastuff.requests.post', side_effect=mocked_requests)
    def test_strava_list(self, mock_get):
        response = self.c.get('/rowers/workout/stravaimport/',follow=True)

        self.assertEqual(response.status_code,200)

    @patch('rowers.utils.requests.get', side_effect=mocked_requests)
    def test_strava_import(self, mock_get):

        response = self.c.get('/rowers/workout/stravaimport/12',follow=True)

        self.assertRedirects(response,
                             expected_url='/rowers/workout/1/edit',
                             status_code=301,target_status_code=200)

        self.assertEqual(response.status_code, 200)


        
class STObjects(DjangoTestCase):    
    def setUp(self):
        self.c = Client()
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')

        self.u.first_name = 'John'
        self.u.last_name = 'Sander'
        self.u.save()
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )


        self.r.sporttrackstoken = '12'
        self.r.sporttracksrefreshtoken = '12'
        self.r.sporttrackstokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1)
        self.r.save()

	self.c.login(username='john',password='koeinsloot')

	self.nu = datetime.datetime.now()
        
	filename = 'rowers/testdata/testdata.csv'
	
	rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2,
		    hrut1=self.r.ut1,hrat=self.r.at,
		    hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp)
	row = rdata(filename,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)
	tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds))

	duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths)


	workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
	workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')

	self.w = Workout.objects.create(
            name='testworkout',workouttype='On-water',
	    user=self.r,date=self.nu.strftime('%Y-%m-%d'),
	    starttime=workoutstarttime,
            startdatetime=row.rowdatetime,
	    duration=duration,distance=totaldist,
	    csvfilename=filename
        )

    @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests)
    def test_sporttracks_callback(self, mock_post):
        response = self.c.get('/sporttracks_callback?code=dsdoij232s',follow=True)

        
        self.assertEqual(response.status_code, 200)

        
    @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests)
    def test_sporttracks_token_refresh(self, mock_post):
        response = self.c.get('/rowers/me/sporttracksrefresh/',follow=True)

        self.assertEqual(response.status_code, 200)


    @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests)
    @patch('rowers.sporttracksstuff.requests.get', side_effect=mocked_requests)
    def test_sporttracks_upload(self, mock_get, mock_post):
        response = self.c.get('/rowers/workout/1/sporttracksuploadw/')

        self.assertRedirects(response,
                             expected_url = '/rowers/workout/1/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.url, '/rowers/workout/1/edit')
        self.assertEqual(response.status_code, 302)

    @patch('rowers.sporttracksstuff.requests.get', side_effect=mocked_requests)
    def test_sporttracks_list(self, mock_get):
        response = self.c.get('/rowers/workout/sporttracksimport',follow=True)

        self.assertEqual(response.status_code,200)
        
    @patch('rowers.imports.requests.get', side_effect=mocked_requests)
    def test_sporttracks_import(self, mock_get):

        response = self.c.get('/rowers/workout/sporttracksimport/12/',follow=True)

        self.assertRedirects(response,
                             expected_url='/rowers/workout/2/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

    def test_strokedata(self):
	with open('rowers/testdata/sporttrackstestdata.txt','r') as infile:
	    data = json.load(infile)

	from rowers.sporttracksstuff import add_workout_from_data

	res = add_workout_from_data(self.u,1,data,data)

    def test_strokedatanohr(self):
	with open('rowers/testdata/sporttrackstestnohr.txt','r') as infile:
	    data = json.load(infile)

	from rowers.sporttracksstuff import add_workout_from_data



	res = add_workout_from_data(self.u,1,data,data)

class RunKeeperObjects(DjangoTestCase):    
    def setUp(self):
        self.c = Client()
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')

        self.u.first_name = 'John'
        self.u.last_name = 'Sander'
        self.u.save()
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )


        self.r.runkeepertoken = '12'

        self.r.save()

	self.c.login(username='john',password='koeinsloot')

	self.nu = datetime.datetime.now()
        
	filename = 'rowers/testdata/testdata.csv'
	
	rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2,
		    hrut1=self.r.ut1,hrat=self.r.at,
		    hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp)
	row = rdata(filename,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)
	tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds))

	duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths)


	workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
	workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')

	self.w = Workout.objects.create(
            name='testworkout',workouttype='On-water',
	    user=self.r,date=self.nu.strftime('%Y-%m-%d'),
	    starttime=workoutstarttime,
            startdatetime=row.rowdatetime,
	    duration=duration,distance=totaldist,
	    csvfilename=filename
        )

    @patch('rowers.runkeeperstuff.requests.post', side_effect=mocked_requests)
    def test_runkeeper_callback(self, mock_post):
        response = self.c.get('/runkeeper_callback?code=dsdoij232s',follow=True)

        self.assertEqual(response.status_code, 200)

    @patch('rowers.runkeeperstuff.requests.post', side_effect=mocked_requests)
    @patch('rowers.runkeeperstuff.requests.get', side_effect=mocked_requests)
    def test_runkeeper_upload(self, mock_get, mock_post):
        response = self.c.get('/rowers/workout/1/runkeeperuploadw/')

        self.assertRedirects(response,
                             expected_url = '/rowers/workout/1/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.url, '/rowers/workout/1/edit')
        self.assertEqual(response.status_code, 302)

    @patch('rowers.runkeeperstuff.requests.get', side_effect=mocked_requests)
    def test_runkeeper_list(self, mock_get):
        response = self.c.get('/rowers/workout/runkeeperimport',follow=True)

        self.assertEqual(response.status_code,200)
        
    @patch('rowers.imports.requests.get', side_effect=mocked_requests)
    def test_runkeeper_import(self, mock_get):

        response = self.c.get('/rowers/workout/runkeeperimport/12/',follow=True)

        self.assertRedirects(response,
                             expected_url='/rowers/workout/2/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)


        
class UAObjects(DjangoTestCase):    
    def setUp(self):
        self.c = Client()
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')

        self.u.first_name = 'John'
        self.u.last_name = 'Sander'
        self.u.save()
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )


        self.r.underarmourtoken = '12'
        self.r.underarmourrefreshtoken = '12'
        self.r.underarmourtokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1)
        self.r.save()

	self.c.login(username='john',password='koeinsloot')

	self.nu = datetime.datetime.now()
        
	filename = 'rowers/testdata/testdata.csv'
	
	rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2,
		    hrut1=self.r.ut1,hrat=self.r.at,
		    hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp)
	row = rdata(filename,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)
	tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds))

	duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths)


	workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
	workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')

	self.w = Workout.objects.create(
            name='testworkout',workouttype='On-water',
	    user=self.r,date=self.nu.strftime('%Y-%m-%d'),
	    starttime=workoutstarttime,
            startdatetime=row.rowdatetime,
	    duration=duration,distance=totaldist,
	    csvfilename=filename
        )

    @patch('rowers.imports.requests.post', side_effect=mocked_requests)
    def test_underarmour_callback(self, mock_post):
        response = self.c.get('/underarmour_callback?code=dsdoij232s',follow=True)

        
        self.assertEqual(response.status_code, 200)

        
    @patch('rowers.underarmourstuff.requests.post', side_effect=mocked_requests)
    def test_underarmour_token_refresh(self, mock_post):
        response = self.c.get('/rowers/me/underarmourrefresh/',follow=True)

        self.assertEqual(response.status_code, 200)


    @patch('rowers.underarmourstuff.requests.post', side_effect=mocked_requests)
    @patch('rowers.underarmourstuff.requests.get', side_effect=mocked_requests)
    def test_underarmour_upload(self, mock_get, mock_post):
        response = self.c.get('/rowers/workout/1/underarmouruploadw/')

        self.assertRedirects(response,
                             expected_url = '/rowers/workout/1/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.url, '/rowers/workout/1/edit')
        self.assertEqual(response.status_code, 302)

    @patch('rowers.underarmourstuff.requests.get', side_effect=mocked_requests)
    def test_underarmour_list(self, mock_get):
        response = self.c.get('/rowers/workout/underarmourimport',follow=True)

        self.assertEqual(response.status_code,200)
        
    @patch('rowers.imports.requests.get', side_effect=mocked_requests)
    def test_underarmour_import(self, mock_get):

        response = self.c.get('/rowers/workout/underarmourimport/12/',follow=True)

        self.assertRedirects(response,
                             expected_url='/rowers/workout/2/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)


class TPObjects(DjangoTestCase):    
    def setUp(self):
        self.c = Client()
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')

        self.u.first_name = 'John'
        self.u.last_name = 'Sander'
        self.u.save()
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )


        self.r.tptoken = '12'
        self.r.tprefreshtoken = '12'
        self.r.tptokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1)
        self.r.save()

	self.c.login(username='john',password='koeinsloot')

	self.nu = datetime.datetime.now()
        
	filename = 'rowers/testdata/testdata.csv'
	
	rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2,
		    hrut1=self.r.ut1,hrat=self.r.at,
		    hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp)
	row = rdata(filename,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)
	tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds))

	duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths)


	workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
	workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')

	self.w = Workout.objects.create(
            name='testworkout',workouttype='On-water',
	    user=self.r,date=self.nu.strftime('%Y-%m-%d'),
	    starttime=workoutstarttime,
            startdatetime=row.rowdatetime,
	    duration=duration,distance=totaldist,
	    csvfilename=filename
        )

    @patch('rowers.imports.requests.post', side_effect=mocked_requests)
    def test_tp_callback(self, mock_post):
        response = self.c.get('/tp_callback?code=dsdoij232s',follow=True)

        
        self.assertEqual(response.status_code, 200)

        
    @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests)
    def test_tp_token_refresh(self, mock_post):
        response = self.c.get('/rowers/me/tprefresh/',follow=True)

        self.assertEqual(response.status_code, 200)


    @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests)
    @patch('rowers.tpstuff.requests.get', side_effect=mocked_requests)
    def test_tp_upload(self, mock_get, mock_post):
        response = self.c.get('/rowers/workout/1/tpuploadw/')

        self.assertRedirects(response,
                             expected_url = '/rowers/workout/1/edit',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.url, '/rowers/workout/1/edit')
        self.assertEqual(response.status_code, 302)



        
class TestErrorPages(TestCase):
    def test_error_handlers(self):

        self.assertTrue(urls.handler404.endswith('.error404_view'))
        self.assertTrue(urls.handler500.endswith('.error500_view'))
        factory = RequestFactory()
        request = factory.get('/')
        response = error404_view(request)
        self.assertEqual(response.status_code, 404)
        self.assertIn('404 Page not found', unicode(response))
        response = error500_view(request)
        self.assertEqual(response.status_code, 500)
        self.assertIn('500 Internal Server Error', unicode(response))

class NewUserRegistrationTest(TestCase):
    def setUp(self):
	self.c = Client()
        redis_connection.publish('tasks','KILL')

    def test_newuser(self):
        form_data = {
	    'first_name':'Jan',
	    'last_name':'Roeiert',
	    'email':'jan@loop.nl',
            'username':'janderoeiert',
            'password1':'aapindewei2',
            'password2':'aapindewei2',
            'tos':True,
            'weightcategory':'hwt',
            'sex':'male',
            'birthdate':datetime.datetime(year=1970,month=4,day=2)
	    }

	form = RegistrationFormUniqueEmail(form_data)
        self.assertTrue(form.is_valid())
    
	response = self.c.post('/rowers/register', form_data, follow=True)
        
	self.assertRedirects(response,
                             expected_url='/rowers/register/thankyou/',
			     status_code=302,target_status_code=200)

from django_mailbox.models import Mailbox,MessageAttachment,Message

class AutoExportTests(TestCase):
    def setUp(self):
        redis_connection.publish('tasks','KILL')
	u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')
	r = Rower.objects.create(user=u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )

        r.c2_auto_export = True
        r.sporttracks_auto_export = True
        r.mapmyfitness_auto_export = True
        r.trainingpeaks_auto_export = True

        r.save()

	nu = datetime.datetime.now()
        workoutsbox = Mailbox.objects.create(name='workouts')
        workoutsbox.save()
        failbox = Mailbox.objects.create(name='Failed')
        failbox.save()

        filename = 'testdata.csv'

        m = Message(mailbox=workoutsbox,
                    from_header = u.email,
                    subject = filename,
                    body="""
---
workouttype: water
boattype: 2x
...
                    """)
        m.save()
        a2 = 'media/mailbox_attachments/'+filename
        copyfile('rowers/testdata/'+filename,a2)
        a = MessageAttachment(message=m,document=a2[6:])
        a.save()

    def tearDown(self):
        for filename in os.listdir('media/mailbox_attachments'):
            path = os.path.join('media/mailbox_attachments/',filename)
            if not os.path.isdir(path):
                os.remove(path)

    @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests)
    @patch('rowers.tpstuff.requests.get', side_effect=mocked_requests)
    def test_emailprocessing(self, mock_post, mock_get):
        out = StringIO()
        call_command('processemail', stdout=out, testing=True)
        self.assertIn('Successfully processed email attachments',out.getvalue())
        
class EmailTests(TestCase):
    def setUp(self):
        redis_connection.publish('tasks','KILL')
	u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')
	r = Rower.objects.create(user=u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )
	
	nu = datetime.datetime.now()
        workoutsbox = Mailbox.objects.create(name='workouts')
        workoutsbox.save()
        failbox = Mailbox.objects.create(name='Failed')
        failbox.save()
        
        for filename in os.listdir('rowers/testdata/emails'):
            m = Message(mailbox=workoutsbox,
                        from_header = u.email,
                        subject = filename,
                        body="""
---
chart: time
workouttype: water
boattype: 4x
...
                        """)
            m.save()
            a2 = 'media/mailbox_attachments/'+filename
            copyfile('rowers/testdata/emails/'+filename,a2)
            a = MessageAttachment(message=m,document=a2[6:])
            a.save()

    def tearDown(self):
        for filename in os.listdir('media/mailbox_attachments'):
            path = os.path.join('media/mailbox_attachments/',filename)
            if not os.path.isdir(path):
                os.remove(path)
            
    def test_emailprocessing(self):
        out = StringIO()
        call_command('processemail', stdout=out,testing=True)
        self.assertIn('Successfully processed email attachments',out.getvalue())
        
        
class WorkoutTests(TestCase):
    def setUp(self):
        redis_connection.publish('tasks','KILL')
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )
	nu = datetime.datetime.now()
	self.w = Workout.objects.create(name='testworkout',
                                        workouttype='On-water',
				   user=self.r,date=nu.strftime('%Y-%m-%d'),
				   starttime=nu.strftime('%H:%M:%S'),
				   duration="0:55:00",distance=8000)

    def test_checkworkoutuser(self):
	self.assertEqual(checkworkoutuser(self.u,self.w),True)

class C2Tests(TestCase):
    def setUp(self):
        redis_connection.publish('tasks','KILL')
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )
	self.nu = datetime.datetime.now()
	self.w = Workout.objects.create(name='testworkout',workouttype='On-water',
				   user=r,date=nu.strftime('%Y-%m-%d'),
				   starttime=nu.strftime('%H:%M:%S'),
				   duration="0:55:00",distance=8000)

    def c2_notokentest(self):
	thetoken = c2_open(self.u)
	# should raise NoTokenError
	self.assertRaises(NoTokenError)

class DataTest(TestCase):
    def setUp(self):
        redis_connection.publish('tasks','KILL')
	u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')
	r = Rower.objects.create(user=u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )
	self.nu = datetime.datetime.now()


    def test_workoutform(self):
	form_data = {
	    'name':'test',
	    'date':'2016-05-01',
	    'starttime':'07:53:00',
            'timezone':'UTC',
	    'duration':'0:55:00.1',
	    'distance':8000,
	    'notes':'Aap noot \n mies',
            'weightcategory':'lwt',
	    'workouttype':'water',
            'boattype':'1x',
            'private':False,
	    }
	form = WorkoutForm(data=form_data)
	self.assertTrue(form.is_valid())

    def test_rower_form_withvalidnumbers(self):
	form_data = {
	    'max':192,
	    'rest':48,
	    'ut2':105,
	    'ut1':148,
	    'at':160,
	    'tr':167,
	    'an':180,
	    'weightcategory':'lwt',
	    }
	form = RowerForm(data=form_data)
	self.assertTrue(form.is_valid())


    def test_rower_form_twoequalvalues(self):
	form_data = {
	    'max':192,
	    'rest':48,
	    'ut2':105,
	    'ut1':105,
	    'at':160,
	    'an':180,
	    'tr':167,
	    'weightcategory':'lwt',
	    }
	form = RowerForm(data=form_data)
	self.assertFalse(form.is_valid())

    def test_rower_form_abovemaxallowed(self):
	form_data = {
	    'max':300,
	    'rest':48,
	    'ut2':105,
	    'ut1':148,
	    'at':160,
	    'an':180,
	    'tr':167,
	    'weightcategory':'lwt',
	    }
	form = RowerForm(data=form_data)
	self.assertFalse(form.is_valid())

    def test_rower_form_wrongorder(self):
	form_data = {
	    'max':192,
	    'rest':48,
	    'ut2':20,
	    'ut1':148,
	    'at':160,
	    'an':180,
	    'tr':167,
	    'weightcategory':'lwt',
	    }
	form = RowerForm(data=form_data)
	self.assertFalse(form.is_valid())

    def test_rower_form_belowminalloed(self):
	form_data = {
	    'max':192,
	    'rest':2,
	    'ut2':105,
	    'ut1':148,
	    'at':160,
	    'an':180,
	    'tr':167,
	    'weightcategory':'lwt',
	    }
	form = RowerForm(data=form_data)
	self.assertFalse(form.is_valid())

    def test_rower_form_wrongorder2(self):
	form_data = {
	    'max':192,
	    'rest':48,
	    'ut2':105,
	    'ut1':170,
	    'at':160,
	    'an':180,
	    'tr':167,
	    'weightcategory':'lwt',
	    }
	form = RowerForm(data=form_data)
	self.assertFalse(form.is_valid())

    def test_painsled(self):
	filename = 'rowers/testdata/testdata.csv'
	f = open(filename,'rb')
	file_data = {'file': SimpleUploadedFile(f.name, f.read())}
	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    }

	form = DocumentsForm(form_data,file_data)
	self.assertTrue(form.is_valid())
        
	f.close()

	u = User.objects.get(username='john')
	r = Rower.objects.get(user=u)
	
	rr = rrower(hrmax=r.max,hrut2=r.ut2,
		    hrut1=r.ut1,hrat=r.at,
		    hrtr=r.tr,hran=r.an,ftp=r.ftp)
	row = rdata(filename,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)
	tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds))

	duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths)


	workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
	workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')

	w = Workout.objects.create(name='testworkout',workouttype='On-water',
				   user=r,date=self.nu.strftime('%Y-%m-%d'),
				   starttime=workoutstarttime,
				   duration=duration,distance=totaldist,
				   csvfilename=filename)


	fig1 = plots.mkplot(row,'test')
	res = iplots.interactive_chart(w.id)
	res = iplots.interactive_chart(w.id,promember=1)
	res = iplots.interactive_bar_chart(w.id)
	res = iplots.interactive_bar_chart(w.id,promember=1)
	res = iplots.interactive_flex_chart2(w.id,promember=0,xparam='time',
					    yparam1='pace',yparam2='hr')
	res = iplots.interactive_flex_chart2(w.id,promember=0,xparam='distance',
					    yparam1='pace',yparam2='hr')
	res = iplots.interactive_flex_chart2(w.id,promember=0,xparam='time',
					    yparam1='pace',yparam2='spm')
	res = iplots.interactive_flex_chart2(w.id,promember=0,xparam='distance',
					    yparam1='pace',yparam2='spm')

	res = iplots.interactive_flex_chart2(w.id,promember=1,xparam='time',
					    yparam1='pace',yparam2='hr')
	res = iplots.interactive_flex_chart2(w.id,promember=1,xparam='distance',
					    yparam1='pace',yparam2='hr')
	res = iplots.interactive_flex_chart2(w.id,promember=1,xparam='time',
					    yparam1='pace',yparam2='spm')
	res = iplots.interactive_flex_chart2(w.id,promember=1,xparam='distance',
					    yparam1='pace',yparam2='spm')

	


class ViewTest(TestCase):
    def setUp(self):
        redis_connection.publish('tasks','KILL')
	self.c = Client()
	self.u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')
	self.r = Rower.objects.create(user=self.u,gdproptin=True,
                                 gdproptindate=timezone.now()
        )
	self.nu = datetime.datetime.now()

    def test_upload_view_notloggedin(self):
	response = self.c.post('/rowers/workout/upload/',follow=True)


	self.assertRedirects(response, expected_url='/login/?next=/rowers/workout/upload/',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)
	
    def test_upload_view_sled(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/testdata.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)
	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)

	f.close()

	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	response = self.c.get('/rowers/workout/1/', form_data, follow=True)
	self.assertEqual(response.status_code, 200)

        response = self.c.get('/rowers/workout/1/edit', form_data, follow=True)
        self.assertEqual(response.status_code, 200)
        

        response = self.c.get('/rowers/workout/1/histo', form_data, follow=True)
	self.assertEqual(response.status_code, 200)

	form_data = {
            'name':'aap',
            'date':'2016-11-05',
            'starttime':'09:07:14',
            'timezone':'Europe/Berlin',
            'duration':'1:00:00.5',
            'distance':'15000',
            'weightcategory':'hwt',
            'workouttype':'rower',
            'boattype':'1x',
            'private':True,
            'notes':'noot mies',
            }
        form = WorkoutForm(data=form_data)
        self.assertTrue(form.is_valid())
        response = self.c.post('/rowers/workout/1/edit', form_data, follow=True)
	self.assertEqual(response.status_code, 200)
        

        w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')


    def test_upload_view_notloggedin(self):
	response = self.c.post('/rowers/workout/upload/',follow=True)


	self.assertRedirects(response, expected_url='/login/?next=/rowers/workout/upload/',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)
	
    def test_upload_view_sled_negativetime(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/tim.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_C2':False,
	    'upload_to_Strava':False,
	    'upload_to_SportTracks':False,
	    'upload_to_RunKeeper':False,
	    'upload_to_MapMyFitness':False,
	    'plottype':'timeplot',
	    'file': f,
            'makeprivate':False,
            'landingpage':'workout_edit_view',
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)

	f.close()

	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	response = self.c.get('/rowers/workout/1/', form_data, follow=True)
	self.assertEqual(response.status_code, 200)
	
	
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

	
	

    def test_upload_view_sled_noname(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/testdata.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)

	f.close()

	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_logcard(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/logcard.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'',
	    'workouttype':'rower',
            'boattype': '1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)

	f.close()

	self.assertRedirects(response,
                             expected_url='/rowers/workout/upload/',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)



	
    def test_upload_view_TCX_CN(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/crewnerddata.tcx'
	f = open(filename,'rb')
	file_data = {'file': f}

	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	f.close()
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	filename = 'rowers/testdata/crewnerddata.CSV'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {}
	form = CNsummaryForm(form_data,file_data)

	response = self.c.post('rowers/workout/1/crewnerdsummary',
			       form_data,
			       follow=True)

	f.close()

	self.assertEqual(response.status_code, 200)
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_TCX_SpeedCoach2a(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/Speedcoach2example.csv'
	f = open(filename,'rb')
	file_data = {'file': f}

	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	f.close()
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_TCX_SpeedCoach2b(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/Speedcoach2example.csv'
	f = open(filename,'rb')
	file_data = {'file': f}

	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	f.close()
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')



    def test_upload_view_TCX_SpeedCoach2c(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/speedcoach3test3.csv'
	f = open(filename,'rb')
	file_data = {'file': f}

	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	f.close()
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_SpeedCoach2v127(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/SpeedCoach2Linkv1.27.csv'
	f = open(filename,'rb')
	file_data = {'file': f}

	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	f.close()
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')


    def test_upload_view_SpeedCoach2v127intervals(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/SpeedCoach2Link_interval.csv'
	f = open(filename,'rb')
	file_data = {'file': f}

	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	f.close()
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')


    def test_upload_view_TCX_NoHR(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/NoHR.tcx'
	f = open(filename,'rb')
	file_data = {'file': f}

	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	f.close()
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)

	self.assertEqual(response.status_code, 200)

	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_TCX_CN(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/rowinginmotionexample.tcx'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'water',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)
	self.assertEqual(response.status_code, 200)

	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_RP(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/RP_testdata.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)
	self.assertEqual(response.status_code, 200)
	
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_Mystery(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/mystery.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)
	self.assertEqual(response.status_code, 200)
	
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_RP_interval(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/RP_interval.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)
	self.assertEqual(response.status_code, 200)
	
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

        
    def test_upload_view_sled_desktop(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/painsled_desktop_example.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)
	self.assertEqual(response.status_code, 200)
	
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_sled_ergdata(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/ergdata_example.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)
	self.assertEqual(response.status_code, 200)
	
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_sled_boatcoach(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/boatcoach.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)
	self.assertEqual(response.status_code, 200)
	
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

    def test_upload_view_sled_ergstick(self):
	self.c.login(username='john',password='koeinsloot')
	
	filename = 'rowers/testdata/ergstick.csv'
	f = open(filename,'rb')
	file_data = {'file': f}
	form_data = {
	    'title':'test',
	    'workouttype':'rower',
            'boattype':'1x',
	    'notes':'aap noot mies',
	    'make_plot':False,
	    'upload_to_c2':False,
	    'plottype':'timeplot',
	    'file': f,
	    }

	form = DocumentsForm(form_data,file_data)

	response = self.c.post('/rowers/workout/upload/', form_data, follow=True)
	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
			     status_code=302,target_status_code=200)
	self.assertEqual(response.status_code, 200)
	
	w = Workout.objects.get(id=1)
	f_to_be_deleted = w.csvfilename
	os.remove(f_to_be_deleted+'.gz')

        
#    def test_upload_view_FIT_SpeedCoach2a(self):
#	self.c.login(username='john',password='koeinsloot')
	
#	filename = 'rowers/testdata/3x250m.fit'
#	with open(filename,'rb') as f: 

#	    file_data = {'file': f}

#	    form_data = {
#		'title':'test',
#		'workouttype':'water',
#            'boattype':'1x',
#		'notes':'aap noot mies',
#		'make_plot':False,
#		'upload_to_c2':False,
#		'plottype':'timeplot',
#		'file': f,
#		}

#	    form = DocumentsForm(form_data,file_data)

#	    response = self.c.post('/rowers/workout/upload/',
#				   form_data, follow=True,
#				   format='multipart')
#	f.close()
#	self.assertRedirects(response, expected_url='/rowers/workout/1/edit',
#			     status_code=302,target_status_code=200)

#	self.assertEqual(response.status_code, 200)

#	w = Workout.objects.get(id=1)
#	f_to_be_deleted = w.csvfilename
#	os.remove(f_to_be_deleted+'.gz')

class subroutinetests(TestCase):
    def setUp(self):
        redis_connection.publish('tasks','KILL')
	u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')
	r = Rower.objects.create(user=u)
	nu = datetime.datetime.now()
	filename = 'rowers/testdata/testdata.csv'
	self.w = Workout.objects.create(name='testworkout',
					workouttype='On-water',
					user=r,date=nu.strftime('%Y-%m-%d'),
					starttime=nu.strftime('%H:%M:%S'),
					duration="0:55:00",distance=8000,
					csvfilename=filename)


    def c2stuff(self):
	data = c2stuff.createc2workoutdata(self.w)
	jsond = json.dumps(data)
	data = c2stuff.createc2workoutdata_as_splits(w)
	jsond = json.dumps(data)



class PlotTests(TestCase):
    def setUp(self):
        redis_connection.publish('tasks','KILL')
	u = User.objects.create_user('john',
				     'sander@ds.ds',
				     'koeinsloot')
	r = Rower.objects.create(user=u)
	self.nu = datetime.datetime.now()
	filename = 'rowers/testdata/testdata.csv'
	self.wotw = Workout.objects.create(name='testworkout',
					workouttype='On-water',
					user=r,date=self.nu.strftime('%Y-%m-%d'),
					starttime=self.nu.strftime('%H:%M:%S'),
					duration="0:55:00",distance=8000,
					csvfilename=filename)
	
	self.wote = Workout.objects.create(name='testworkout',
					workouttype='Indoor Rower',
					user=r,date=self.nu.strftime('%Y-%m-%d'),
					starttime=self.nu.strftime('%H:%M:%S'),
					duration="0:55:00",distance=8000,
					csvfilename=filename)
	
        #	timestr = strftime("%Y%m%d-%H%M%S")
        #	imagename = f1+timestr+'.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

        
	self.hrdata = {
	    'hrmax':r.max,
	    'hrut2':r.ut2,
	    'hrut1':r.ut1,
	    'hrat':r.at,
	    'hrtr':r.tr,
	    'hran':r.an,
	    'ftp':r.ftp,
            'powerperc':serialize_list(powerperc),
            'powerzones':serialize_list(r.powerzones),
	}


    def test_ote_plots(self):
	w = self.wote
	f1 = 'testdata.csv'[:-4] 
	timestr = strftime("%Y%m%d-%H%M%S")
	imagename = f1+timestr+'.png'
	fullpathimagename = 'static/plots/'+imagename
	# make plot - asynchronous task
	plotnr = 1
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 1
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 2
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 3
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 4
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 5
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 6
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 7
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 8
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 13
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

    def test_otw_plots(self):
	w = self.wotw
	f1 = 'testdata.csv'[:-4] 
	timestr = strftime("%Y%m%d-%H%M%S")
	imagename = f1+timestr+'.png'
	fullpathimagename = 'static/plots/'+imagename
	# make plot - asynchronous task
	plotnr = 1
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 1
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 2
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 3
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 4
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 5
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 6
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 7
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 8
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 9
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)

	plotnr = 13
	if (w.workouttype=='water'):
	    plotnr = plotnr+3
		    
	res = handle_makeplot(f1,w.csvfilename,
			      w.name,self.hrdata,plotnr,imagename)
	i = GraphImage(workout=w,creationdatetime=self.nu,
			   filename=fullpathimagename)
	os.remove(fullpathimagename)