rowsandall/rowers/views/workoutviews.py

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

from rowers.views.statements import *
import rowers.teams as teams

# Show the EMpower Oarlock generated Stroke Profile
@user_passes_test(ispromember,login_url="/rowers/paidplans/",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workout_forcecurve_view(request,id=0,workstrokesonly=False):
    row = get_workout(id)

    promember=0
    mayedit=0
    if not request.user.is_anonymous:
        r = getrower(request.user)
        result = request.user.is_authenticated and ispromember(request.user)
        if result:
            promember=1
        if request.user == row.user.user:
            mayedit=1

    if not promember:
        return HttpResponseRedirect("/rowers/about/")

    if request.method == 'POST':
        form = ForceCurveOptionsForm(request.POST)
        if form.is_valid():
            includereststrokes = form.cleaned_data['includereststrokes']
            plottype = form.cleaned_data['plottype']
            workstrokesonly = not includereststrokes
        else:
            workstrokesonly = True
            plottype = 'line'
    else:
        form = ForceCurveOptionsForm()
        plottype = 'line'

    script,div,js_resources,css_resources = interactive_forcecurve(
        [row],
        workstrokesonly=workstrokesonly,
        plottype=plottype,
    )

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': row.name
                },
            {
                'url':reverse('workout_forcecurve_view',kwargs={'id':id}),
                'name': 'Empower Force Curve'
                }
            
            ]

    r = getrower(request.user)

    return render(request,
                  'forcecurve_single.html',
                  {
                      'the_script':script,
                      'rower':r,
                      'form':form,
                      'workout':row,
                      'breadcrumbs':breadcrumbs,
                      'active':'nav-workouts',
                      'the_div':div,
                      'js_res': js_resources,
                      'css_res':css_resources,
                      'id':id,
                      'mayedit':mayedit,
                      'teams':get_my_teams(request.user),
                  })

# Test asynchronous tasking and messaging
#@login_required()
#def workout_test_task_view(request,id=0):
#    row = Workout.objects.get(id=id)
#    res = myqueue(queuehigh,addcomment2,request.user.id,row.id)#
#
#
#    url = reverse('workout_edit_view',
#                  kwargs = {
#                      'id':int(id),
#                  })
#    return HttpResponseRedirect(url)

# Show Stroke power histogram for a workout
@login_required()
def workout_histo_view(request,id=0):
    w = get_workout(id)

    promember=0
    mayedit=0
    if not request.user.is_anonymous:
        r = getrower(request.user)
        result = request.user.is_authenticated and ispromember(request.user)
        if result:
            promember=1
            if request.user == w.user.user:
                mayedit=1

    if not promember:
        return HttpResponseRedirect("/rowers/about/")
        
    res = interactive_histoall([w],'power',False)
    script = res[0]
    div = res[1]

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': w.name
                },
            {
                'url':reverse('workout_histo_view',kwargs={'id':id}),
                'name': 'Histogram'
                }
            
            ]


    return render(request,
                  'histo_single.html',
                  {'interactiveplot':script,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'workout':w,
                   'rower':r,
                   'the_div':div,
                   'id':id,
                   'mayedit':mayedit,
                   'teams':get_my_teams(request.user),
                   })




# add a workout manually
@login_required()
def addmanual_view(request):
    r = Rower.objects.get(user=request.user)

    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
        'url':reverse('addmanual_view'),
            'name': 'Add Manual Entry'
                },
    ]
    
    if request.method == 'POST':
        # Form was submitted
        form = WorkoutForm(request.POST)
        metricsform = MetricsForm(request.POST)
        if form.is_valid() and metricsform.is_valid():
            # Get values from form
            name = form.cleaned_data['name']
            if name == '':
                name = 'Manual Entry'
            date = form.cleaned_data['date']
            starttime = form.cleaned_data['starttime']
            workouttype = form.cleaned_data['workouttype']
            duration = form.cleaned_data['duration']
            weightcategory = form.cleaned_data['weightcategory']
            adaptiveclass = form.cleaned_data['adaptiveclass']
            distance = form.cleaned_data['distance']
            notes = form.cleaned_data['notes']
            thetimezone = form.cleaned_data['timezone']
            private = form.cleaned_data['private']
            avghr = metricsform.cleaned_data['avghr']
            avgpwr = metricsform.cleaned_data['avgpwr']
            avgspm = metricsform.cleaned_data['avgspm']
            try:
                ps = form.cleaned_data['plannedsession']
            except KeyError:
                ps = None
                
            try:
                boattype  = request.POST['boattype']
            except KeyError:
                boattype = '1x'
            try:
                privacy = request.POST['privacy']
            except KeyError:
                privacy = 'visible'
            try:
                rankingpiece = form.cleaned_data['rankingpiece']
            except KeyError:
                rankingpiece = False

            try:
                duplicate = form.cleaned_data['duplicate']
            except KeyError:
                duplicate = False
                
            if private:
                privacy = 'private'
            else:
                privacy = 'visible'

            startdatetime = (str(date) + ' ' + str(starttime))
            startdatetime = datetime.datetime.strptime(startdatetime,
                                                       "%Y-%m-%d %H:%M:%S")
            startdatetime = timezone.make_aware(startdatetime)
            startdatetime = startdatetime.astimezone(
                pytz.timezone(thetimezone)
            )


            
            id,message = dataprep.create_row_df(r,
                                                distance,
                                                duration,startdatetime,
                                                weightcategory=weightcategory,
                                                adaptiveclass=adaptiveclass,
                                                avghr=avghr,
                                                rankingpiece=rankingpiece,
                                                avgpwr=avgpwr,
                                                duplicate=duplicate,
                                                avgspm=avgspm,
                                                title = name,
                                                notes=notes,
                                                workouttype=workouttype)



            if message:
                messages.error(request,message)

            if id:
                w = Workout.objects.get(id=id)
                w.rankingpiece = rankingpiece
                w.privacy = privacy
                w.weightcategory = weightcategory
                w.adaptiveclass = adaptiveclass
                w.notes = notes
                w.plannedsession = ps
                w.name = name
                w.workouttype = workouttype
                w.boattype = boattype
                w.save()
                if ps:
                    add_workouts_plannedsession([w],ps,w.user)
                
                messages.info(request,'New workout created')

                url = reverse(
                    'workout_edit_view',
                    kwargs={'id':encoder.encode_hex(id)}
                              )
                return HttpResponseRedirect(url)
        else:
            return render(request,'manualadd.html',
                          {'form':form,
                           'metricsform':metricsform,
                           'breadcrumbs':breadcrumbs,
                           'active':'nav-workouts',
                           })

    initial = {
        'workouttype':'rower',
        'date':datetime.date.today(),
        'starttime':timezone.now(),
        'timezone':r.defaulttimezone,
        'duration':datetime.timedelta(minutes=2),
        'distance':500,
        
    }
    form = WorkoutForm(initial=initial)
    metricsform = MetricsForm()

    return render(request,'manualadd.html',
                  {'form':form,
                   'metricsform':metricsform,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   })

@login_required()
def fitness_metric_view(request,mode='rower',days=42):
    r = getrower(request.user)
    startdate = timezone.now()-datetime.timedelta(days=days)

    # test if not something already done
    ms = PowerTimeFitnessMetric.objects.filter(user=request.user)
    if not ms:
        url = reverse('workouts_view')
        return HttpResponseRedirect(url)
        
    max_workout_id = max([m.last_workout for m in ms])
    last_update_date = max([m.date.strftime('%Y-%m-%d') for m in ms])

        
    now_date = timezone.now().strftime('%Y-%m-%d')

    
    if mode == 'rower':
        workouts = Workout.objects.filter(
            user=r,
            workouttype__in=['rower','dynamic','slides'],
            startdatetime__gte=startdate)
    else:
        workouts = Workout.objects.filter(
            user=r,
            workouttype__in=['water','coastal'],
            startdatetime__gte=startdate)

    theids = [int(w.id) for w in workouts]
    max_id = max(theids)

    if last_update_date >= now_date or max_workout_id >= max_id:
        return HttpResponse("already done today or no new workouts")


    job = myqueue(queue,
                  handle_updatefitnessmetric,
                  request.user.id,mode,theids,
                  )
    
    return HttpResponse("job queued")


@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workout_update_cp_view(request,id=0):
    row = get_workout(id)

    if (checkworkoutuser(request.user,row)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)

    row.rankingpiece = True
    row.save()

    r = getrower(request.user)

    dataprep.runcpupdate(r)
    
    if row.workouttype in mytypes.otwtypes:
        url = reverse('otwrankings_view')
    else:
        url = reverse('oterankings_view')

    return HttpResponseRedirect(url)


# Reload the workout and calculate the summary from the stroke data (lapIDx)
@login_required()
def workout_recalcsummary_view(request,id=0):
    row = get_workout(id)

    if (checkworkoutuser(request.user,row)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)

    filename = row.csvfilename
    rowdata = rdata(filename)
    if rowdata:
        row.summary = rowdata.allstats()
        row.save()
        successmessage = "Summary Updated"
        messages.info(request,successmessage)
        url = reverse('workout_edit_view',
                  kwargs = {
                      'id':id,
                  })
    else:
        message = "Something went wrong. Could not update summary"
        messages.error(request,message)
        url = reverse('workout_edit_view',
                      kwargs = {
                          'id':id,
                          })
        
    return HttpResponseRedirect(url)


# Joining workout
@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workouts_join_view(request):
    promember=0
    if not request.user.is_anonymous:
        r = getrower(request.user)
        result = request.user.is_authenticated and ispromember(request.user)
        if result:
            promember=1

            
    if request.method == 'POST' and 'workouts' in request.POST:
        form = WorkoutMultipleCompareForm(request.POST)
        paramform = WorkoutJoinParamForm(request.POST)
        if form.is_valid() and paramform.is_valid():
            workout_name = paramform.cleaned_data['workout_name']
            set_private = paramform.cleaned_data['set_private']

            cd = form.cleaned_data
            workouts = cd['workouts']
            ids = [int(w.id) for w in workouts]
            request.session['ids'] = ids


            id,message = dataprep.join_workouts(r,ids,
                                                title=workout_name,
                                                setprivate=set_private)
            
            if message:
                messages.error(request,message)

            url = reverse(r.defaultlandingpage,
                          kwargs = {
                            'id':encoder.encode_hex(id),
                          })
        
            return HttpResponseRedirect(url)
                
        else:
            return HttpResponse("form is not valid")
        
    else:
        url = reverse('workouts_join_select')
        return HttpResponseRedirect(url)

@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workouts_join_select(request,
                         startdatestring="",
                         enddatestring="",
                         message='',
                         successmessage='',
                         startdate=timezone.now()-datetime.timedelta(days=30),
                         enddate=timezone.now()+datetime.timedelta(days=1),
                         teamid=0):

    try:
        r = getrower(request.user)
    except Rower.DoesNotExist:
        raise Http404("Rower doesn't exist")


    if 'waterboattype' in request.session:
        waterboattype = request.session['waterboattype']
    else:
        waterboattype = mytypes.waterboattype

        
    if 'modalities' in request.session:
        modalities = request.session['modalities']
        if len(modalities) > 1:
            modality = 'all'
        else:
            modality = modalities[0]
    else:
        modalities = [m[0] for m in mytypes.workouttypes]
        modality = 'all'
            
    if request.method == 'POST' and 'daterange' in request.POST:
        dateform = DateRangeForm(request.POST)
        if dateform.is_valid():
            startdate = dateform.cleaned_data['startdate']
            enddate = dateform.cleaned_data['enddate']
            startdatestring = startdate.strftime('%Y-%m-%d')
            enddatestring = enddate.strftime('%Y-%m-%d')
            request.session['startdate'] = startdatestring
            request.session['enddate'] = enddatestring
    else:
        dateform = DateRangeForm(initial={
            'startdate':startdate,
            'enddate':enddate,
            })

    
    if request.method == 'POST' and 'modality' in request.POST:
        modalityform = TrendFlexModalForm(request.POST)
        if modalityform.is_valid():
            modality = modalityform.cleaned_data['modality']
            waterboattype = modalityform.cleaned_data['waterboattype']
            if modality == 'all':
                modalities = [m[0] for m in mytypes.workouttypes]
            else:
                modalities = [modality]

            if modality != 'water':
                waterboattype = [b[0] for b in mytypes.boattypes]

                
            request.session['modalities'] = modalities
            request.session['waterboattype'] = waterboattype

    negtypes = []
    for b in mytypes.boattypes:
        if b[0] not in waterboattype:
            negtypes.append(b[0])
            
    startdate = datetime.datetime.combine(startdate,datetime.time())
    enddate = datetime.datetime.combine(enddate,datetime.time(23,59,59))
    #enddate = enddate+datetime.timedelta(days=1)

    if startdatestring:
        startdate = iso8601.parse_date(startdatestring)
    if enddatestring:
        enddate = iso8601.parse_date(enddatestring)

    if enddate < startdate:
        s = enddate
        enddate = startdate
        startdate = s

    try:
        theteam = Team.objects.get(id=teamid)
    except Team.DoesNotExist:
        theteam = 0
        
    if r.rowerplan == 'basic' and theteam==0:
        raise PermissionDenied("Access denied")

    if theteam and (theteam.viewing == 'allmembers' or theteam.manager == request.user):
        workouts = Workout.objects.filter(team=theteam,
                                          startdatetime__gte=startdate,
                                          startdatetime__lte=enddate,
                                          workouttype__in=modalities).order_by("-date", "-starttime").exclude(boattype__in=negtypes)
    elif theteam and theteam.viewing == 'coachonly':
        workouts = Workout.objects.filter(team=theteam,user=r,
                                          startdatetime__gte=startdate,
                                          startdatetime__lte=enddate,
                                          workouttype__in=modalities).order_by("-date","-starttime").exclude(boattype__in=negtypes)

            
    else:
        theteam = None
        workouts = Workout.objects.filter(user=r,
                                      startdatetime__gte=startdate,
                                          startdatetime__lte=enddate,
                                          workouttype__in=modalities).order_by("-date", "-starttime").exclude(boattype__in=negtypes)

    query = request.GET.get('q')
    if query:
        query_list = query.split()
        workouts = workouts.filter(
            reduce(operator.and_,
                   (Q(name__icontains=q) for q in query_list)) |
            reduce(operator.and_,
                   (Q(notes__icontains=q) for q in query_list))
            )
        searchform = SearchForm(initial={'q':query})
    else:
        searchform = SearchForm()

    form = WorkoutMultipleCompareForm()
    form.fields["workouts"].queryset = workouts

    if theteam:
        theid = theteam.id
    else:
        theid = 0
        
    joinparamform = WorkoutJoinParamForm()
    modalityform = TrendFlexModalForm(initial={
        'modality':modality,
        'waterboattype':waterboattype
    })


    messages.info(request,successmessage)
    messages.error(request,message)
    
    return render(request, 'workout_join_select.html',
                  {'workouts': workouts,
                   'dateform':dateform,
                   'searchform':searchform,
                   'startdate':startdate,
                   'enddate':enddate,
                   'active':'nav-workouts',
                   'team':theteam,
                   'form':form,
                   'joinparamform':joinparamform,
                   'modalityform':modalityform,
                   'teams':get_my_teams(request.user),
                   })

# Team comparison
@user_passes_test(ispromember,login_url='/rowers/paidplans/',
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def team_comparison_select(request,
                           startdatestring="",
                           enddatestring="",
                           message='',
                           successmessage='',
                           userid=0,
                           startdate=timezone.now()-datetime.timedelta(days=30),
                           enddate=timezone.now(),
                           id=0,
                           teamid=0):

    r = getrequestrower(request,userid=userid)
    requestrower = getrower(request.user)

    request.session.pop('ps',None)

    if 'waterboattype' in request.session:
        waterboattype = request.session['waterboattype']
    else:
        waterboattype = mytypes.waterboattype

    if 'rankingonly' in request.session:
        rankingonly = request.session['rankingonly']
    else:
        rankingonly = False
        
    if 'modalities' in request.session:
        modalities = request.session['modalities']
        if len(modalities) > 1:
            modality = 'all'
        else:
            modality = modalities[0]
    else:
        modalities = [m[0] for m in mytypes.workouttypes]
        modality = 'all'
            
    if request.method == 'POST':
        dateform = DateRangeForm(request.POST)
        if dateform.is_valid():
            startdate = dateform.cleaned_data['startdate']
            enddate = dateform.cleaned_data['enddate']
            startdatestring = startdate.strftime('%Y-%m-%d')
            enddatestring = enddate.strftime('%Y-%m-%d')
            request.session['startdate'] = startdatestring
            request.session['enddate'] = enddatestring

        modalityform = TrendFlexModalForm(request.POST)
        if modalityform.is_valid():
            modality = modalityform.cleaned_data['modality']
            waterboattype = modalityform.cleaned_data['waterboattype']
            if modality == 'all':
                modalities = [m[0] for m in mytypes.workouttypes]
            else:
                modalities = [modality]

            if modality != 'water':
                waterboattype = [b[0] for b in mytypes.boattypes]


            if 'rankingonly' in modalityform.cleaned_data:
                rankingonly = modalityform.cleaned_data['rankingonly']
            else:
                rankingonly = False
                
            request.session['modalities'] = modalities
            request.session['waterboattype'] = waterboattype
    else:
        dateform = DateRangeForm(initial={
            'startdate':startdate,
            'enddate':enddate,
            })
        modalityform = TrendFlexModalForm(initial={
            'modality':modality,
            'waterboattype':waterboattype,
            'rankingonly':rankingonly,
        })

        
    

    negtypes = []
    for b in mytypes.boattypes:
        if b[0] not in waterboattype:
            negtypes.append(b[0])
            
    startdate = datetime.datetime.combine(startdate,datetime.time())
    enddate = datetime.datetime.combine(enddate,datetime.time(23,59,59))
    #enddate = enddate+datetime.timedelta(days=1)

    if startdatestring:
        startdate = iso8601.parse_date(startdatestring)
    if enddatestring:
        enddate = iso8601.parse_date(enddatestring)

    if enddate < startdate:
        s = enddate
        enddate = startdate
        startdate = s

    try:
        theteam = Team.objects.get(id=teamid)
    except Team.DoesNotExist:
        theteam = 0
        
    if theteam and (theteam.viewing == 'allmembers' or theteam.manager == request.user):
        workouts = Workout.objects.filter(team=theteam,
                                          startdatetime__gte=startdate,
                                          startdatetime__lte=enddate,
                                          workouttype__in=modalities).order_by("-date", "-starttime").exclude(boattype__in=negtypes)
    elif theteam and theteam.viewing == 'coachonly':
        workouts = Workout.objects.filter(team=theteam,user=r,
                                          startdatetime__gte=startdate,
                                          startdatetime__lte=enddate,
                                          workouttype__in=modalities).order_by("-date","-starttime").exclude(boattype__in=negtypes)

            
    else:
        theteam = None
        workouts = Workout.objects.filter(user=r,
                                      startdatetime__gte=startdate,
                                          startdatetime__lte=enddate,
                                          workouttype__in=modalities).order_by("-date", "-starttime").exclude(boattype__in=negtypes)

    if rankingonly:
        workouts = workouts.exclude(rankingpiece=False)

    query = request.GET.get('q')
    if query:
        query_list = query.split()
        workouts = workouts.filter(
            reduce(operator.and_,
                   (Q(name__icontains=q) for q in query_list)) |
            reduce(operator.and_,
                   (Q(notes__icontains=q) for q in query_list))
            )
        searchform = SearchForm(initial={'q':query})
    else:
        searchform = SearchForm()

    if id:
        firstworkout = get_workout(id)
        if not checkworkoutuserview(request.user,firstworkout):
            raise PermissionDenied("You are not allowed to use this workout")

        firstworkoutquery = Workout.objects.filter(id=encoder.decode_hex(id))
        workouts = firstworkoutquery | workouts
    else:
        firstworkout = None
        
    form = WorkoutMultipleCompareForm()
    form.fields["workouts"].queryset = workouts
    if id:
        form.fields["workouts"].initial = [firstworkout]
        
        

    if theteam:
        theid = theteam.id
    else:
        theid = 0
        
    chartform = ChartParamChoiceForm(initial={'teamid':0})

    messages.info(request,successmessage)
    messages.error(request,message)
    
    if id:
        breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
            },
            {
                'url':get_workout_default_page(request,id),
                'name': firstworkout.name
                },
            {
                'url':reverse('team_comparison_select',kwargs={'id':id,'teamid':teamid}),
                'name':'Compare Select'
                },
            ]
    else:
        breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
            },
            {
                'url':reverse('team_comparison_select',kwargs={'teamid':teamid}),
                'name': 'Compare Select'
            },
        
        ]

    return render(request, 'team_compare_select.html',
                  {'workouts': workouts,
                   'workout':firstworkout,
                   'dateform':dateform,
                   'startdate':startdate,
                   'enddate':enddate,
                   'team':theteam,
                   'searchform':searchform,
                   'form':form,
                   'rower':r,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'chartform':chartform,
                   'modalityform':modalityform,
                   'teams':get_my_teams(request.user),
                   })

def virtualevent_compare_view(request,id=0):
    results = []

    promember = 0
    if not request.user.is_anonymous:
        r = getrower(request.user)
        result = request.user.is_authenticated and ispromember(request.user)
        if result:
            promember=1
    else:
        r = None

    try:
        race = VirtualRace.objects.get(id=id)
    except VirtualRace.DoesNotExist:
        raise Http404("Virtual Race does not exist")

    if race.sessiontype == 'race':
        script,div = course_map(race.course)
        resultobj = VirtualRaceResult
    else:
        script = ''
        div = ''
        resultobj = IndoorVirtualRaceResult

    results = resultobj.objects.filter(
        race=race,
        workoutid__isnull=False,
        coursecompleted=True,
    ).order_by("duration","-distance")

    workoutids = [result.workoutid for result in results]

    if len(workoutids) == 0:
        url = reverse('virtualevent_view',
                      kwargs={
                          'id':race.id,
                      })

        messages.info(request,'There are no results to display')
        
        return HttpResponseRedirect(url)
            

    if request.method == 'GET':
        xparam = race.sessionmode if race.sessionmode in ['distance','time'] else 'time'
        yparam = 'pace'
        plottype = 'line'
        


        request.session['ids'] = workoutids
        request.session['plottype'] = plottype
        request.session['xparam'] = xparam
        request.session['yparam'] = yparam


        workouts = []
        for id in workoutids:
            try:
                workouts.append(Workout.objects.get(id=id))
            except Workout.DoesNotExist:
                pass

        labeldict = {
            int(w.id): w.__str__() for w in workouts
            }

        chartform = ChartParamChoiceForm(
            initial = {
                'xparam':xparam,
                'yparam':yparam,
                'plottype':plottype,
                'teamid':0
                }
            )
    elif request.method == 'POST':
        chartform = ChartParamChoiceForm(request.POST)
        if chartform.is_valid():
            xparam = chartform.cleaned_data['xparam']
            yparam = chartform.cleaned_data['yparam']
            plottype = chartform.cleaned_data['plottype']
            teamid = chartform.cleaned_data['teamid']
            try:
                workoutids = request.session['ids']
            except KeyError:
                pass
                
            request.session['ids'] = workoutids
            workouts = []
            for id in workoutids:
                try:
                    workouts.append(Workout.objects.get(
                        id=encoder.decode_hex(id)))
                except Workout.DoesNotExist:
                    pass

            labeldict = {
                int(w.id): w.__str__() for w in workouts
                }
    else:
        raise HttpResponse('Only GET and POST allowed',status=405)
                    
            
    res = interactive_multiple_compare_chart(workoutids,xparam,yparam,
                                             promember=promember,
                                             plottype=plottype,
                                             labeldict=labeldict)
    script = res[0]
    div = res[1]
    errormessage = res[3]
    if errormessage != '':
        messages.error(request,errormessage)

    breadcrumbs = [
        {
            'url': reverse('virtualevents_view'),
            'name': 'Racing'
        },
        {
            'url':reverse('virtualevent_view',
                          kwargs={
                              'id':race.id,
                          }
            ),
            'name': race.name
        },
        {
            'url':reverse('virtualevent_compare_view',
                          kwargs={
                              'id':race.id,
                          }
            ),
            'name': 'Compare'
        }
    ]


    return render(request,'multicompare.html',
                  {'interactiveplot':script,
                   'the_div':div,
                   'breadcrumbs':breadcrumbs,
                   'rower':r,
                   'race':race,
                   'results':results,
                   'active':'nav-racing',
                   'promember':promember,
                   'teamid':0,
                   'chartform':chartform,
                   'teams':[]
                   })
        

@login_required()
def plannedsession_compare_view(request,id=0,userid=0):
    r = getrequestrower(request,userid=userid)
    
    try:
        ps = PlannedSession.objects.get(id=id)
    except PlannedSession.DoesNotExist:
        raise Http404("Planned session does not exist")

    m = ps.manager
    mm = m.rower

    if ps.manager != request.user:
        if r.rowerplan == 'coach':
            teams = Team.objects.filter(manager=request.user)
            members = Rower.objects.filter(team__in=teams).distinct()
            teamusers = [m.user for m in members]
            if ps.manager not in teamusers:
                raise PermissionDenied("You do not have access to this session")
            elif r not in ps.rower.all():
                raise PermissionDenied("You do not have access to this session")

    workouts = Workout.objects.filter(plannedsession=ps)

    ids = [int(w.id) for w in workouts]
    
    labeldict = {
        int(w.id): w.__str__() for w in workouts
        }

    xparam = 'time'
    yparam = 'hr'
    plottype = 'line'

    request.session['ids'] = ids
    request.session['xparam'] = xparam
    request.session['yparam'] = yparam
    request.session['plottype'] = plottype
    request.session['ps'] = ps.id

    if ids:
        url = reverse('multi_compare_view',
                      kwargs={'userid':userid,'id':encoder.encode_hex(ids[0])})
    else:
        url = reverse('plannedsession_view',kwargs={'id':ps.id})

    return HttpResponseRedirect(url)

# Team comparison
@login_required()
def multi_compare_view(request,id=0,userid=0):
    promember=0
    if not request.user.is_anonymous:
        r = getrower(request.user)
        result = request.user.is_authenticated and ispromember(request.user)
        if result:
            promember=1

    if request.method == 'POST' and 'workouts' in request.POST:
        form = WorkoutMultipleCompareForm(request.POST)
        chartform = ChartParamChoiceForm(request.POST)
        if form.is_valid() and chartform.is_valid():
            cd = form.cleaned_data
            workouts = cd['workouts']
            xparam = chartform.cleaned_data['xparam']
            yparam = chartform.cleaned_data['yparam']
            plottype = chartform.cleaned_data['plottype']
            teamid = chartform.cleaned_data['teamid']
            ids = [int(w.id) for w in workouts]
            request.session['ids'] = ids

            labeldict = {
                int(w.id): w.__str__() for w in workouts
                }

        else:
            return HttpResponse("Form is not valid")
    elif request.method == 'POST' and 'ids' in request.session:
        chartform = ChartParamChoiceForm(request.POST)
        if chartform.is_valid():
            xparam = chartform.cleaned_data['xparam']
            yparam = chartform.cleaned_data['yparam']
            plottype = chartform.cleaned_data['plottype']
            teamid = chartform.cleaned_data['teamid']
            ids = request.session['ids']
            request.session['ids'] = ids
            workouts = []
            for id in ids:
                try:
                    workouts.append(Workout.objects.get(id=id))
                except Workout.DoesNotExist:
                    pass

            labeldict = {
                int(w.id): w.__str__() for w in workouts
                }
    elif 'ids' in request.session and 'plottype' in request.session:
        xparam = request.session['xparam']
        yparam = request.session['yparam']
        plottype = request.session['plottype']
        teamid = 0
        ids = request.session['ids']
        workouts = []
        for id in ids:
            try:
                workouts.append(Workout.objects.get(id=id))
            except Workout.DoesNotExist:
                pass

        labeldict = {
            int(w.id): w.__str__() for w in workouts
            }
        chartform = ChartParamChoiceForm(
            initial = {
                'xparam':xparam,
                'yparam':yparam,
                'plottype':plottype,
                'teamid':teamid
                }
            )
        
    else:
        url = reverse('team_comparison_select',
                      kwargs={
                          'id':id,
                          'teamid':0})
        return HttpResponseRedirect(url)


    res = interactive_multiple_compare_chart(ids,xparam,yparam,
                                             promember=promember,
                                             plottype=plottype,
                                             labeldict=labeldict)
    script = res[0]
    div = res[1]
    errormessage = res[3]
    if errormessage != '':
        messages.error(request,errormessage)

    r = getrower(request.user)

    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url':reverse('team_comparison_select',kwargs={'teamid':teamid}),
            'name': 'Compare Select'
        },
        {
            'url':reverse('multi_compare_view'),
            'name': 'Comparison Chart'
        }
    ]

    if 'ps' in request.session:
        ps = PlannedSession.objects.get(id=int(request.session['ps']))
        breadcrumbs = [
            {
                'url': reverse('plannedsessions_view',
                               kwargs={'userid':userid}),
                'name': 'Sessions'
            },
            {
            'url':reverse('plannedsession_view',
                          kwargs={
                              'userid':userid,
                              'id':ps.id,
                          }
            ),
            'name': ps.id
            },
            {
            'url':reverse('plannedsession_compare_view',
                          kwargs={
                              'userid':userid,
                              'id':ps.id,
                          }
            ),
            'name': 'Compare'
            }
        ]
        
    
    return render(request,'multicompare.html',
                  {'interactiveplot':script,
                   'the_div':div,
                   'breadcrumbs':breadcrumbs,
                   'rower':r,
                   'active':'nav-workouts',
                   'promember':promember,
                   'teamid':teamid,
                   'chartform':chartform,
                   'teams':get_my_teams(request.user),
                  })


# List Workouts    
@login_required()
def workouts_view(request,message='',successmessage='',
                  teamid=0,rankingonly=False,rowerid=0,userid=0):

    startdate,enddate = get_dates_timeperiod(request,defaulttimeperiod='lastyear')
    request.session['referer'] = absolute(request)['PATH']
    r = getrequestrower(request,rowerid=rowerid,userid=userid)


    # check if access is allowed
    if not checkviewworkouts(request.user,r):
       raise PermissionDenied("Access denied")



    startdate = datetime.datetime.combine(startdate,datetime.time())
    enddate = datetime.datetime.combine(enddate,datetime.time(23,59,59))

    query = None
    if request.method == 'POST':
        dateform = DateRangeForm(request.POST)
        searchform = SearchForm(request.POST)
        if dateform.is_valid():
            startdate = dateform.cleaned_data['startdate']
            enddate = dateform.cleaned_data['enddate']
        if searchform.is_valid():
            query = searchform.cleaned_data['q']
    else:
        dateform = DateRangeForm(initial={
            'startdate':startdate,
            'enddate':enddate,
            })

    startdate = datetime.datetime.combine(startdate,datetime.time())
    enddate = datetime.datetime.combine(enddate,datetime.time(23,59,59))
    #enddate = enddate+datetime.timedelta(days=1)


    if enddate < startdate:
        s = enddate
        enddate = startdate
        startdate = s

        
    startdatestring = startdate.strftime('%Y-%m-%d')
    enddatestring = enddate.strftime('%Y-%m-%d')

    # start date for the small graph
    activity_startdate = enddate-datetime.timedelta(days=15)

    try:
        if utc.localize(enddate) > timezone.now():
            activity_enddate = timezone.now()
            activity_startdate = activity_enddate-datetime.timedelta(days=15)
        else:
            activity_enddate = enddate
    except ValueError:
        activity_enddate = enddate

    g_startdate = activity_startdate
    g_enddate = activity_enddate

    
    if teamid:
        try:
            theteam = Team.objects.get(id=teamid)
        except Team.DoesNotExist:
            raise Http404("Team doesn't exist")

        if theteam.viewing == 'allmembers' or theteam.manager == request.user:
            workouts = Workout.objects.filter(
                team=theteam,
                startdatetime__gte=startdate,
                startdatetime__lte=enddate,
                privacy='visible').order_by("-date","-starttime")
            g_workouts = Workout.objects.filter(
                team=theteam,
                startdatetime__gte=activity_startdate,
                startdatetime__lte=activity_enddate,
                duplicate=False,
                privacy='visible').order_by("-date", "-starttime")
        elif theteam.viewing == 'coachonly':
            workouts = Workout.objects.filter(
                team=theteam,user=r,
                startdatetime__gte=startdate,
                startdatetime__lte=enddate,
                privacy='visible').order_by("-startdatetime")
            g_workouts = Workout.objects.filter(
                team=theteam,user=r,
                startdatetime__gte=activity_startdate,
                enddatetime__lte=activity_enddate,
                duplicate=False,
                privacy='visible').order_by("-startdatetime")


    elif request.user != r.user:
        theteam = None
        workouts = Workout.objects.filter(
            user=r,
            startdatetime__gte=startdate,
            startdatetime__lte=enddate,
            privacy='visible').order_by("-date", "-starttime")
        g_workouts = Workout.objects.filter(
            user=r,
            startdatetime__gte=activity_startdate,
            startdatetime__lte=activity_enddate,
            duplicate=False,
            privacy='visible').order_by("-startdatetime")
    else:
        theteam = None
        workouts = Workout.objects.filter(
            user=r,
            startdatetime__gte=startdate,
            startdatetime__lte=enddate).order_by("-date", "-starttime")
        g_workouts = Workout.objects.filter(
            user=r,
            duplicate=False,
            startdatetime__gte=activity_startdate,
            startdatetime__lte=activity_enddate).order_by("-startdatetime")


    if len(g_workouts) == 0:
        g_workouts = Workout.objects.filter(
            user=r,
            startdatetime__gte=timezone.now()-timedelta(days=15)).order_by("-startdatetime")
        g_enddate = timezone.now()
        g_startdate = (timezone.now()-timedelta(days=15))

        
    if rankingonly:
        workouts = workouts.exclude(rankingpiece=False)

    workoutsnohr = workouts.exclude(averagehr__isnull=False)
    for w in workoutsnohr:
        res = dataprep.workout_trimp(w)
        
    if query:
        query_list = query.split()
        workouts = workouts.filter(
            reduce(operator.and_,
                   (Q(name__icontains=q) for q in query_list)) |
            reduce(operator.and_,
                   (Q(notes__icontains=q) for q in query_list))
            )
        searchform = SearchForm(initial={'q':query})
    else:
        searchform = SearchForm()

    paginator = Paginator(workouts,20) # show 25 workouts per page
    page = request.GET.get('page')

    try:
        workouts = paginator.page(page)
    except PageNotAnInteger:
        workouts = paginator.page(1)
    except EmptyPage:
        workouts = paginator.page(paginator.num_pages)

    today = timezone.now()
    announcements = SiteAnnouncement.objects.filter(
        expires__gte=today
    ).order_by(
        "-created",
        "-id"
    )

    if theteam:
        stack='rower'
    else:
        stack='type'


    script,div = interactive_activitychart(g_workouts,
                                           g_startdate,
                                           g_enddate,
                                           stack=stack)

    
    messages.info(request,successmessage)
    messages.error(request,message)

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
        ]
    timeperiod = startdate.strftime('%Y-%m-%d')+'/'+enddate.strftime('%Y-%m-%d')    
    return render(request, 'list_workouts.html',
                  {'workouts': workouts,
                   'active': 'nav-workouts',
                   'rower':r,
                   'searchform':searchform,
                   'breadcrumbs':breadcrumbs,
                   'dateform':dateform,
                   'startdate':startdate,
                   'enddate':enddate,
                   'announcements':announcements[0:4],
                   'team':theteam,
                   'rankingonly':rankingonly,
                   'teams':get_my_teams(request.user),
                   'interactiveplot':script,
                   'the_div':div,
                   'timeperiod':timeperiod,
                   })




# List of workouts to compare a selected workout to
@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workout_fusion_list(request,id=0,message='',successmessage='',
                            startdatestring="",enddatestring="",
                            startdate=timezone.now()-datetime.timedelta(days=365),
                            enddate=timezone.now()):

    try:
        r = getrower(request.user)
    except Rower.DoesNotExist:
        raise Http404("User has no rower instance")

    u = User.objects.get(id=r.user.id)
    if request.method == 'POST':
        dateform = DateRangeForm(request.POST)
        if dateform.is_valid():
            startdate = dateform.cleaned_data['startdate']
            enddate = dateform.cleaned_data['enddate']
    else:
        dateform = DateRangeForm(initial={
            'startdate':startdate,
            'enddate':enddate,
        })

    if startdatestring:
        startdate = iso8601.parse_date(startdatestring)
    if enddatestring:
        enddate = iso8601.parse_date(enddatestring)

    startdate = datetime.datetime.combine(startdate,datetime.time())
    enddate = datetime.datetime.combine(enddate,datetime.time(23,59,59))
    #enddate = enddate+datetime.timedelta(days=1)
                
    if enddate < startdate:
        s = enddate
        enddate = startdate
        startdate = s

    if id:
        theid = encoder.decode_hex(id)
        
    workouts = Workout.objects.filter(user=r,
                                      startdatetime__gte=startdate,
                                      startdatetime__lte=enddate).order_by("-date", "-starttime").exclude(id=theid)

    query = request.GET.get('q')
    if query:
        query_list = query.split()
        workouts = workouts.filter(
            reduce(operator.and_,
                   (Q(name__icontains=q) for q in query_list)) |
            reduce(operator.and_,
                   (Q(notes__icontains=q) for q in query_list))
            )
        searchform = SearchForm(initial={'q':query})
    else:
        searchform = SearchForm()
        
    paginator = Paginator(workouts,15) # show 25 workouts per page
    page = request.GET.get('page')

    try:
        workouts = paginator.page(page)
    except PageNotAnInteger:
        workouts = paginator.page(1)
    except EmptyPage:
        workouts = paginator.page(paginator.num_pages)
    row = get_workout(id)
        
    messages.info(request,successmessage)
    messages.error(request,message)
    
    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url':get_workout_default_page(request,encoder.encode_hex(row.id)),
            'name': row.name
        },
        {
            'url':reverse('workout_fusion_list',kwargs={'id':id}),
            'name': 'Sensor Fusion'
        }
            
    ]
    
    return render(request, 'fusion_list.html',
                  {'id':id,
                   'workout':row,
                   'rower':r,
                   'searchform':searchform,
                   'active':'nav-workouts',
                   'breadcrumbs':breadcrumbs,
                   'workouts': workouts,
                   'last_name':u.last_name,
                   'first_name':u.first_name,
                   'dateform':dateform,
                   'startdate':startdate,
                   'enddate':enddate,
                   'teams':get_my_teams(request.user),
                  })
 
# Basic view of workout
def workout_view(request,id=0):
    request.session['referer'] = absolute(request)['PATH']
    
    if not request.user.is_anonymous:
        rower = getrower(request.user)
    else:
        rower = None
        
    try:
        row = Workout.objects.get(id=encoder.decode_hex(id))
    except Workout.DoesNotExist:
        raise Http404("Workout doesn't exist")        
        
    comments = WorkoutComment.objects.filter(workout=row)

    aantalcomments = len(comments)


    if row.privacy == 'private' and not checkworkoutuser(request.user,row):
        raise PermissionDenied("Access denied")
        
    g = GraphImage.objects.filter(workout=row).order_by("-creationdatetime")
    for i in g:
        try:
            width,height = Image.open(i.filename).size
            i.width = width
            i.height = height
            i.save()
        except:
            pass
                

        
    # create interactive plot
    res = interactive_chart(encoder.decode_hex(id))
    script = res[0]
    div = res[1]

    # create map
    f1 = row.csvfilename
    rowdata = rdata(f1)
    hascoordinates = 1
    if rowdata != 0:
        try:
            latitude = rowdata.df[' latitude']
            if not latitude.std():
                hascoordinates = 0
        except (KeyError,AttributeError):
            hascoordinates = 0

    else:
        hascoordinates = 0


    if hascoordinates:
        mapscript,mapdiv = leaflet_chart(rowdata.df[' latitude'],
                                         rowdata.df[' longitude'],
                                         row.name)
                                        

    else:
        mapscript = ""
        mapdiv = ""

    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url':reverse('workout_view',kwargs={'id':id}),
            'name': row.name,
        }
        
    ]

    u = row.user.user

    recordsindoor = IndoorVirtualRaceResult.objects.filter(workoutid= row.id)
    records = VirtualRaceResult.objects.filter(workoutid= row.id)
    
    return render(request, 'workout_view.html',
                  {'workout':row,
                   'rower':rower,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'graphs':g,
                   'last_name':u.last_name,
                   'records':records,
                   'recordsindoor':recordsindoor,
                   'first_name':u.first_name,
                   'interactiveplot':script,
                   'aantalcomments':aantalcomments,
                   'mapscript':mapscript,
                   'mapdiv':mapdiv,
                   'teams':get_my_teams(request.user),
                   'the_div':div})
        

# Resets stroke data to raw data (pace)
@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workout_undo_smoothenpace_view(
        request,id=0,message="",successmessage=""
):
    row = get_workout(id)
    r = getrower(request.user)

    if (checkworkoutuser(request.user,row)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)

    filename = row.csvfilename
    row = rdata(filename)
    if row == 0:
        return HttpResponse("Error: CSV Data File Not Found")

    if 'originalvelo' in row.df:
        velo = row.df['originalvelo'].values
        row.df[' Stroke500mPace (sec/500m)'] = 500./velo

    row.write_csv(filename,gzip=True)
    dataprep.update_strokedata(encoder.decode_hex(id),row.df)

    url = reverse(r.defaultlandingpage,
                  kwargs = {
                      'id':id,
                      }
                  )


    return HttpResponseRedirect(url)

        
# Data smoothing of pace data
@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workout_smoothenpace_view(request,id=0,message="",successmessage=""):
    row = get_workout(id)

    previousurl = request.META.get('HTTP_REFERER')

    r = getrower(request.user)
    
    if (checkworkoutuser(request.user,row)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)

    filename = row.csvfilename
    row = rdata(filename)
    if row == 0:
        return HttpResponse("Error: CSV Data File Not Found")

    pace = row.df[' Stroke500mPace (sec/500m)'].values
    velo = 500./pace

    if not 'originalvelo' in row.df:
        row.df['originalvelo'] = velo

    velo2 = stravastuff.ewmovingaverage(velo,5)

    pace2 = 500./abs(velo2)

    row.df[' Stroke500mPace (sec/500m)'] = pace2

    row.df = row.df.fillna(0)

    row.write_csv(filename,gzip=True)
    dataprep.update_strokedata(encoder.decode_hex(id),row.df)

    messages.info(request,'A smoothening filter was applied to your pace data')

    if previousurl:
        url = previousurl
    else:
        url = reverse(r.defaultlandingpage,
                      kwargs = {
                          'id':id,
                      }
        )

    return HttpResponseRedirect(url)

# Process CrewNerd Summary CSV and update summary
@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workout_crewnerd_summary_view(request,id=0,message="",successmessage=""):
    row = get_workout(id)
    r = getrower(request.user)
    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': row.name
                },
            {
                'url':reverse('workout_crewnerd_summary_view',kwargs={'id':id}),
                'name': 'CrewNerd Summary'
                }
            
            ]

    if request.method == 'POST':
        form = CNsummaryForm(request.POST,request.FILES)
        if form.is_valid():
            f = request.FILES['file']
            res = handle_uploaded_file(f)
            fname = res[1]
            try:
                sumd = summarydata(fname)
                row.summary = sumd.allstats()
                row.save()
                os.remove(fname)
                successmessage = "CrewNerd summary added"
                messages.info(request,successmessage)
                url = reverse('workout_edit_view',
                              kwargs = {
                                  'id':id,
                                  })

                return HttpResponseRedirect(url)
            except:
                try:
                    os.remove(fname)
                except:
                    pass
                message = "Something went wrong (workout_crewnerd_summary_view)"
                messages.error(request,message)
                url = reverse('workout_edit_view',
                              kwargs = {
                                  'id':id,
                                  })
                return HttpResponseRedirect(url)
        else:
            return render(request,
                          "cn_form.html",
                          {'form':form,
                           'active':'nav-workouts',
                           'rower':r,
                           'workout':row,
                           'breadcrumbs':breadcrumbs,
                           'teams':get_my_teams(request.user),
                           'id':row.id})
    else:
        form = CNsummaryForm()
        
        return render(request,
                      "cn_form.html",
                      {'form':form,
                       'active':'nav-workouts',
                       'rower':r,
                       'workout':row,
                       'breadcrumbs':breadcrumbs,
                       'teams':get_my_teams(request.user),
                       'id':row.id})
    
# Get weather for given location and date/time
@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workout_downloadwind_view(request,id=0,
                              airportcode=None,
                              message="",successmessage=""):
    row = get_workout(id)

    f1 = row.csvfilename
    if (checkworkoutuser(request.user,row)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)

    # create bearing
    rowdata = rdata(f1)
    if rowdata == 0:
        return HttpResponse("Error: CSV Data File Not Found")

    try:
        bearing = rowdata.df.loc[:,'bearing'].values
    except KeyError:
        rowdata.add_bearing()
        rowdata.write_csv(f1,gzip=True)

    # get wind
    
    try:
        avglat = rowdata.df[' latitude'].mean()
        avglon = rowdata.df[' longitude'].mean()
        avgtime = int(rowdata.df['TimeStamp (sec)'].mean()-rowdata.df.loc[:,'TimeStamp (sec)'].iloc[0])
        startdatetime = dateutil.parser.parse("{}, {}".format(row.date,
                                                              row.starttime))

        starttimeunix = int(arrow.get(row.startdatetime).timestamp)
        #starttimeunix = int(mktime(startdatetime.utctimetuple()))
        avgtime = starttimeunix+avgtime
        winddata = get_wind_data(avglat,avglon,avgtime)
        windspeed = winddata[0]
        windbearing = winddata[1]
        message = winddata[2]
        try:
            row.notes += "\n"+message
        except TypeError:
            if message:
                row.notes += message
                
        row.save()
        rowdata.add_wind(windspeed,windbearing)
        rowdata.write_csv(f1,gzip=True)

        messages.info(request,message)
        
        kwargs = {
            'id':id}

        url = reverse('workout_wind_view',kwargs=kwargs)
        response = HttpResponseRedirect(url)
    except KeyError:
        message = "No latitude/longitude data"
        messages.error(request,message)
        kwargs = {
            'id':id
        }
        url = reverse('workout_wind_view',kwargs=kwargs)
        response = HttpResponseRedirect(url)



    return response

# Get weather for given location and date/time
@user_passes_test(ispromember,login_url="/rowers/paidplans",message="This functionality requires a Pro plan or higher",redirect_field_name=None)
def workout_downloadmetar_view(request,id=0,
                              airportcode=None,
                              message="",successmessage=""):
    row = get_workout(id)

    f1 = row.csvfilename
    if (checkworkoutuser(request.user,row)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)

    # create bearing
    rowdata = rdata(f1)
    if rowdata == 0:
        return HttpResponse("Error: CSV Data File Not Found")

    try:
        bearing = rowdata.df.loc[:,'bearing'].values
    except KeyError:
        rowdata.add_bearing()
        rowdata.write_csv(f1,gzip=True)

    # get wind
    try:
        avglat = rowdata.df[' latitude'].mean()
        avglon = rowdata.df[' longitude'].mean()
        airportcode = get_airport_code(avglat,avglon)[0]
        avgtime = int(rowdata.df['TimeStamp (sec)'].mean()-rowdata.df.loc[:,'TimeStamp (sec)'].iloc[0])
        startdatetime = dateutil.parser.parse("{}, {}".format(row.date,
                                                              row.starttime))
        
        starttimeunix = arrow.get(row.startdatetime).timestamp
        #starttimeunix = int(mktime(startdatetime.utctimetuple()))
        avgtime = starttimeunix +avgtime
        winddata = get_metar_data(airportcode,avgtime)
        windspeed = winddata[0]
        windbearing = winddata[1]
        message = winddata[2]
        try:
            row.notes += "\n"+message
        except TypeError:
            if message:
                row.notes += message
        
        row.save()
        rowdata.add_wind(windspeed,windbearing)
        rowdata.write_csv(f1,gzip=True)
        messages.info(request,message)
        
        kwargs = {
                  'id':id}

        url = reverse('workout_wind_view',kwargs=kwargs)
        response = HttpResponseRedirect(url)
    except KeyError:
        message = "No latitude/longitude data"
        messages.error(request,message)
        kwargs = {
            'id':id
        }
        url = reverse('workout_wind_view',kwargs=kwargs)
        response = HttpResponseRedirect(url)



    return response


# Show form to update wind data
@user_passes_test(ispromember,login_url="/rowers/paidplans",message="This functionality requires a Pro plan or higher",redirect_field_name=None)
def workout_wind_view(request,id=0,message="",successmessage=""):
    row = get_workout(id)
    r = getrower(request.user)
    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': row.name
                },
            {
                'url':reverse('workout_wind_view',kwargs={'id':id}),
                'name': 'Wind'
                }
            
            ]

    if (checkworkoutuser(request.user,row)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)


    # get data
    f1 = row.csvfilename
    u = row.user.user
    r = getrower(u)

    # create bearing
    rowdata = rdata(f1)
    if row == 0:
        return HttpResponse("Error: CSV Data File Not Found")


    hascoordinates = 1
    try:
        latitude = rowdata.df.loc[:,' latitude']
    except KeyError:
        hascoordinates = 0

    if hascoordinates and not latitude.std():
        hascoordinates = 0
        
    try:
        bearing = rowdata.df.loc[:,'bearing'].values
    except KeyError:
        rowdata.add_bearing()
        rowdata.write_csv(f1,gzip=True)
        

    if hascoordinates:
        avglat = rowdata.df[' latitude'].mean()
        avglon = rowdata.df[' longitude'].mean()
        airportcode,newlat,newlon,airportdistance = get_airport_code(avglat,avglon)
        airportcode = airportcode.upper()
        airportdistance = airportdistance[0]
    else:
        airportcode = 'UNKNOWN'
        airportdistance = 0
        

    if request.method == 'POST':
        # process form
        form = UpdateWindForm(request.POST)

        if form.is_valid():
            
            vwind1 = form.cleaned_data['vwind1']
            vwind2 = form.cleaned_data['vwind2']
            dist1 = form.cleaned_data['dist1']
            dist2 = form.cleaned_data['dist2']
            winddirection1 = form.cleaned_data['winddirection1']
            winddirection2 = form.cleaned_data['winddirection2']
            windunit = form.cleaned_data['windunit']

            rowdata.update_wind(vwind1,vwind2,
                                winddirection1,
                                winddirection2,
                                dist1,dist2,
                                units=windunit)

            rowdata.write_csv(f1,gzip=True)

            
        else:
            message = "Invalid Form"
            messages.error(request,message)
            kwargs = {
                'id':id
            }
            url = reverse('workout_wind_view',kwargs=kwargs)
            response = HttpResponseRedirect(url)
            
    else:
        form = UpdateWindForm()

    # create interactive plot
    res = interactive_windchart(encoder.decode_hex(id),promember=1)
    script = res[0]
    div = res[1]

    if hascoordinates:
        gmscript,gmdiv = leaflet_chart(
            rowdata.df[' latitude'],
            rowdata.df[' longitude'],
            row.name)
    else:
        gmscript = ""
        gmdiv = "No GPS data available"


    messages.info(request,successmessage)
    messages.error(request,message)
    
    return render(request,
                  'windedit.html',
                  {'workout':row,
                   'rower':r,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'teams':get_my_teams(request.user),
                   'interactiveplot':script,
                   'form':form,
                   'airport':airportcode,
                   'airportdistance':airportdistance,
                   'the_div':div,
                   'gmap':gmscript,
                   'gmapdiv':gmdiv})
    

# Show form to update River stream data (for river dwellers)
@user_passes_test(ispromember,login_url="/rowers/paidplans",message="This functionality requires a Pro plan or higher",redirect_field_name=None)
def workout_stream_view(request,id=0,message="",successmessage=""):
    row = get_workout(id)
    r = getrower(request.user)

    if (checkworkoutuser(request.user,row)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)


    # create interactive plot
    f1 = row.csvfilename
    u = row.user.user
    r = getrower(u)

    rowdata = rdata(f1)
    if rowdata == 0:
        return HttpResponse("Error: CSV Data File Not Found")

    if request.method == 'POST':
        # process form
        form = UpdateStreamForm(request.POST)

        if form.is_valid():
            
            dist1 = form.cleaned_data['dist1']
            dist2 = form.cleaned_data['dist2']
            stream1 = form.cleaned_data['stream1']
            stream2 = form.cleaned_data['stream2']
            streamunit = form.cleaned_data['streamunit']

            rowdata.update_stream(stream1,stream2,dist1,dist2,
                                units=streamunit)

            rowdata.write_csv(f1,gzip=True)

            
        else:
            message = "Invalid Form"
            messages.error(request,message)
            kwargs = {
                'id':id}
            url = reverse('workout_wind_view',kwargs=kwargs)
            response = HttpResponseRedirect(url)
            
    else:
        form = UpdateStreamForm()

    # create interactive plot
    res = interactive_streamchart(encoder.decode_hex(id),promember=1)
    script = res[0]
    div = res[1]

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': row.name
                },
            {
                'url':reverse('workout_stream_view',kwargs={'id':id}),
                'name': 'Stream'
                }
            
            ]

    messages.info(request,successmessage)
    messages.error(request,message)
    return render(request,
                  'streamedit.html',
                  {'workout':row,
                   'rower':r,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'teams':get_my_teams(request.user),
                   'interactiveplot':script,
                   'form':form,
                   'the_div':div})
    
# Form to set average crew weight and boat type, then run power calcs
@user_passes_test(ispromember, login_url="/rowers/paidplans",redirect_field_name=None)
def workout_otwsetpower_view(request,id=0,message="",successmessage=""):
    w = get_workout(id)
    r = getrower(request.user)

    mayedit = 0
    if request.user == w.user.user:
        mayedit=1
    if checkworkoutuser(request.user,w):
        mayedit=1

    if (checkworkoutuser(request.user,w)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)


    if request.method == 'POST':
        # process form
        form = AdvancedWorkoutForm(request.POST)

        if form.is_valid():
            quick_calc = form.cleaned_data['quick_calc']
            boattype = form.cleaned_data['boattype']
            weightvalue = form.cleaned_data['weightvalue']
            w.boattype = boattype
            w.weightvalue = weightvalue
            w.save()


            # load row data & create power/wind/bearing columns if not set
            f1 = w.csvfilename
            rowdata = rdata(f1)
            if rowdata == 0:
                return HttpResponse("Error: CSV Data File Not Found")
            try:
                vstream = rowdata.df['vstream']
            except KeyError:
                rowdata.add_stream(0)
                rowdata.write_csv(f1,gzip=True)

            try:
                bearing = rowdata.df['bearing']
            except KeyError:
                rowdata.add_bearing()
                rowdata.write_csv(f1,gzip=True)

            try:
                vwind = rowdata.df['vwind']
            except KeyError:
                rowdata.add_wind(0,0)
                rowdata.write_csv(f1,gzip=True)

            # do power calculation (asynchronous)
            r = w.user
            u = r.user

            first_name = u.first_name
            last_name = u.last_name
            emailaddress = u.email

            job = myqueue(queuelow,
                          handle_otwsetpower,f1,boattype,
                          weightvalue,
                          first_name,last_name,emailaddress,id,
                          ps=[r.p0,r.p1,r.p2,r.p3],
                          ratio=r.cpratio,
                          quick_calc = quick_calc,
                          emailbounced = r.emailbounced
            )

            try:
                request.session['async_tasks'] += [(job.id,'otwsetpower')]
            except KeyError:
                request.session['async_tasks'] = [(job.id,'otwsetpower')]

            successmessage = 'Your calculations have been submitted. You will receive an email when they are done. You can check the status of your calculations <a href="/rowers/jobs-status/" target="_blank">here</a>'
            messages.info(request,successmessage)
            kwargs = {
                'id':id}

            try:
                url = request.session['referer']
            except KeyError:
                url = reverse('workout_edit_view',kwargs=kwargs)
                
            response = HttpResponseRedirect(url)
            return response
            
        else:
            message = "Invalid Form"
            messages.error(request,message)
            kwargs = {
                'id':id}
            url = reverse('workout_otwsetpower_view',kwargs=kwargs)
            response = HttpResponseRedirect(url)
            
    else:
        form = AdvancedWorkoutForm(instance=w)

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': w.name
                },
            {
                'url':reverse('workout_otwsetpower_view',kwargs={'id':id}),
                'name': 'OTW Power'
                }
            
            ]

        
    messages.error(request,message)
    messages.info(request,successmessage)
    return render(request,
                  'otwsetpower.html',
                  {'workout':w,
                   'rower':w,
                   'mayedit':mayedit,
                   'active':'nav-workouts',
                   'breadcrumbs':breadcrumbs,
                   'teams':get_my_teams(request.user),
                   'form':form,
                   })

@login_required()
def instroke_view(request,id=0):
    w = get_workout(id)
    r = getrower(request.user)
    mayedit = 0
    if request.user == w.user.user:
        mayedit=1
    if checkworkoutuser(request.user,w):
        mayedit=1

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': w.name
                },
            {
                'url':reverse('instroke_view',kwargs={'id':id}),
                'name': 'In-Stroke Metrics'
                }
            
            ]

#    form = WorkoutForm(instance=row)
    g = GraphImage.objects.filter(workout=w).order_by("-creationdatetime")
    # check if user is owner of this workout

    if (checkworkoutuser(request.user,w)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)

    rowdata = rrdata(csvfile=w.csvfilename)
    try:
        instrokemetrics = rowdata.get_instroke_columns()
        instrokemetrics = [m for m in instrokemetrics if not m in nometrics]
    except AttributeError:
        instrokemetrics = []


    return render(request,
                  'instroke.html',
                  {'workout':w,
                   'rower':r,
                   'active':'nav-workouts',
                   'breadcrumbs':breadcrumbs,
                   'mayedit':mayedit,
                   'teams':get_my_teams(request.user),
                   'instrokemetrics':instrokemetrics,
                   })


# generate instroke chart
@login_required()
def instroke_chart(request,id=0,metric=''):
    w = get_workout(id)

    if (checkworkoutuser(request.user,w)==False):
        message = "You are not allowed to edit this workout"
        messages.error(request,message)
        url = reverse('workouts_view')

        return HttpResponseRedirect(url)

    rowdata = rrdata(csvfile=w.csvfilename)
    instrokemetrics = rowdata.get_instroke_columns()


    if metric in instrokemetrics:
        f1 = w.csvfilename[6:-4]
        timestr = strftime("%Y%m%d-%H%M%S")
        imagename = f1+timestr+'.png'
        fullpathimagename = 'static/plots/'+imagename
        u = w.user.user
        r = getrower(u)
        title = w.name
        fig1 = rowdata.get_plot_instroke(metric)
        canvas = FigureCanvas(fig1)
        canvas.print_figure('static/plots/'+imagename)
        plt.close(fig1)
        fig1.clf()
        gc.collect()

        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:
            messages.error(request,'You have reached the maximum number of static images for this workout. Delete an image first')
        

    r = getrower(request.user)
    url = reverse(r.defaultlandingpage,
                  kwargs = {
                      'id':id,
                      })

    return HttpResponseRedirect(url)


# data explorer
@login_required()
def workout_data_view(request, id=0):

    r = getrower(request.user)
    w = get_workout(id)

    if not checkworkoutuser(request.user,w):
        raise PermissionDenied('Access Denied')

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': w.name
                },
            {
                'url':reverse('workout_data_view',kwargs={'id':id}),
                'name': 'Data Explorer'
                }
            
            ]


    datadf,row = dataprep.getrowdata_db(id=encoder.decode_hex(id))


    datadf.sort_values(['ftime'],inplace=True)

    columns = datadf.columns.values

    to_be_dropped = [
        'id','time','hr_an','hr_at','hr_bottom','hr_max',
        'hr_tr','hr_ut1','hr_ut2','x_right',
    ]
    
    to_be_dropped = [c for c in to_be_dropped if c in columns]
    
    datadf.drop(labels=to_be_dropped,inplace=True,axis=1)
    

    cols = ['ftime','cumdist','fpace','spm',
            'hr','power','driveenergy','drivelength','averageforce',
            'peakforce','distance','drivespeed','workoutstate',
            'catch','finish','peakforceangle','wash','slip','rhythm',
            'effectiveangle','totalangle','distanceperstroke','velo']


    tcols = ['ftime','cumdist','fpace','spm','hr','power']
    
    datadf = datadf[cols]
    datadf.loc[:,'hr'] = datadf['hr'].astype('int')
    datadf.loc[:,'power'] = datadf['power'].astype('int')
    datadf.loc[:,'distance'] = datadf['distance'].astype('int')
    datadf.loc[:,'spm'] = 10*datadf['spm'].astype('int')/10.

            
    if request.method == 'POST':
        form = DataFrameColumnsForm(request.POST)
        if form.is_valid():
            tcols = form.cleaned_data['cols']

    else:
        form = DataFrameColumnsForm(initial = {'cols':tcols})

    datadf = datadf[tcols]
    
    for col in cols:
        try:
            if datadf[col].mean() == 0 and datadf[col].std() == 0:
                datadf.drop(labels=[col],axis=1,inplace=True)
        except (TypeError,KeyError):
            pass

    #    pd.set_option('display.width', 1000)
    #pd.set_option('colheader_justify', 'left')
    
    htmltable = datadf.to_html(
        bold_rows=True,
        show_dimensions=True,border=1,
        classes=['pandastable'],justify='justify'
    )

    return render(request,
                  'workout_data.html',
                  {
                      'htmltable': htmltable,
                      'form':form,
                      'teams':get_my_teams(request.user),
                      'workout': w,
                      'breadcrumbs': breadcrumbs,
                      
                      }
                  )
    

# Stats page
@login_required()
def workout_stats_view(request,id=0,message="",successmessage=""):

    r = getrower(request.user)
    w = get_workout(id)

    mayedit = 0
    if request.user == w.user.user:
        mayedit=1
    if checkworkoutuser(request.user,w):
        mayedit=1

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': w.name
                },
            {
                'url':reverse('workout_stats_view',kwargs={'id':id}),
                'name': 'Stats'
                }
            
            ]

    workstrokesonly = True
    if request.method == 'POST' and 'workstrokesonly' in request.POST:
        workstrokesonly = str2bool(request.POST['workstrokesonly'])


    # prepare data frame
    datadf,row = dataprep.getrowdata_db(id=encoder.decode_hex(id))
    if (checkworkoutuserview(request.user,row)==False):
        raise PermissionDenied('Access Denied')

    datadf = dataprep.clean_df_stats(datadf,workstrokesonly=workstrokesonly)
        
    if datadf.empty:
        datadf,row = dataprep.getrowdata_db(id=encoder.decode_hex(id))
        datadf = dataprep.clean_df_stats(datadf,workstrokesonly=False)
        workstrokesonly=False
        if datadf.empty:
            return HttpResponse("CSV data file not found")

    #datadf['deltat'] = datadf['time'].diff()
        
        
    workoutstateswork = [1,4,5,8,9,6,7]
    workoutstatesrest = [3]
    workoutstatetransition = [0,2,10,11,12,13]


    # Create stats
    stats = {}

    fieldlist,fielddict = dataprep.getstatsfields()
    fielddict.pop('workoutstate')
    fielddict.pop('workoutid')
    
    for field,verbosename in fielddict.items():
        thedict = {
            'mean':datadf[field].mean(),
            'wmean': wavg(datadf, field, 'deltat'),
            'min': datadf[field].min(),
            'std': datadf[field].std(),
            'max': datadf[field].max(),
            'median': datadf[field].median(),
            'firstq':datadf[field].quantile(q=0.25),
            'thirdq':datadf[field].quantile(q=0.75),
            'verbosename':verbosename,
        }
        stats[field] = thedict

    # Create a dict with correlation values
    cor = datadf.corr(method='spearman')
    cor.fillna(value=0,inplace=True)
    cordict = {}
    for field1,verbosename in fielddict.items():
        thedict = {}
        for field2,verbosename in fielddict.items():
            try:
                thedict[field2] = cor.loc[field1,field2]
            except KeyError:
                thedict[field2] = 0

            cordict[field1] = thedict

    # additional non-automated stats
    otherstats = {}

    # Normalized power & TSS
    tss,normp = dataprep.workout_rscore(w)


    if not np.isnan(tss) and tss != 0:
        otherstats['tss'] = {
            'verbose_name':'rScore',
            'value':int(tss),
            'unit':''
        }
    
    if not np.isnan(normp):
        otherstats['np'] = {
            'verbose_name':'rPower',
            'value':int(10*normp)/10.,
            'unit':'Watt'
        }
        
    # HR Drift
    tmax = datadf['time'].max()
    tmin = datadf['time'].min()
    thalf = tmin+0.5*(tmax-tmin)
    mask1 = datadf['time'] < thalf
    mask2 = datadf['time'] > thalf

    hr1 = datadf.loc[mask1,'hr'].mean()
    hr2 = datadf.loc[mask2,'hr'].mean()
            
    pwr1 = datadf.loc[mask1,'power'].mean()
    pwr2 = datadf.loc[mask2,'power'].mean()

    try:
        hrdrift = ((pwr1/hr1)-(pwr2/hr2))/(pwr1/hr1)
        hrdrift *= 100.
        if not np.isnan(hrdrift):
            hrdrift = int(100*hrdrift)/100.
            otherstats['hrdrift'] = {
                'verbose_name': 'Heart Rate Drift',
                'value': hrdrift,
                'unit': '%',
            }
    except (ZeroDivisionError,ValueError):
        pass

    # TRIMP
    trimp,hrtss = dataprep.workout_trimp(w)

    otherstats['trimp'] = {
        'verbose_name': 'TRIMP',
        'value': trimp,
        'unit': ''
    }

    otherstats['hrScore'] = {
        'verbose_name': 'rScore (HR)',
        'value': hrtss,
        'unit':''
        }

    return render(request,
                  'workoutstats.html',
                  {
                      'stats':stats,
                      'teams':get_my_teams(request.user),
                      'workout':w,
                      'rower':r,
                      'mayedit':mayedit,
                      'breadcrumbs':breadcrumbs,
                      'active':'nav-workouts',
                      'workstrokesonly':workstrokesonly,
                      'cordict':cordict,
                      'otherstats':otherstats,
                  })
    


# Change default landing page
@login_required()
def workflow_default_view(request):
    r = getrower(request.user)
    if r.defaultlandingpage == 'workout_edit_view':
        r.defaultlandingpage = 'workout_workflow_view'
    else:
        r.defaultlandingpage = 'workout_edit_view'

    r.save()

    url = reverse('workout_workflow_config2_view')
    
    return HttpResponseRedirect(url)


# Workflow configuration
@login_required()
def workout_workflow_config2_view(request,userid=0):
    request.session['referer'] = absolute(request)['PATH']
    request.session[translation.LANGUAGE_SESSION_KEY] = USER_LANGUAGE
    try:
        workoutid = request.session['lastworkout']
    except KeyError:
        workoutid = 0
        
        
    r = getrequestrower(request,userid=userid,notpermanent=True)

    MiddlePanelFormSet = formset_factory(WorkFlowMiddlePanelElement,extra=1)
    LeftPanelFormSet = formset_factory(WorkFlowLeftPanelElement,extra=1)
    

    if request.method == 'POST':
        wasmiddle =  [1 for key,value in request.POST.items() if 'middlepanel' in key.lower()]
        wasleft = [1 for key,valye in request.POST.items() if 'leftpanel' in key.lower()]
        if wasmiddle:
            middlepanel_formset = MiddlePanelFormSet(request.POST,
                                                     prefix='middlepanel')
            newmiddlepanel = []
            if middlepanel_formset.is_valid():
                for form in middlepanel_formset:
                    value = form.cleaned_data.get('panel')
                    if value != 'None':
                        newmiddlepanel.append(value)


                newmiddlepanel = [i for i in newmiddlepanel if i != None]
                r.workflowmiddlepanel = newmiddlepanel
                try:
                    r.save()
                except IntegrityError:
                    messages.error(request,'Something went wrong')
        if wasleft:
            leftpanel_formset = LeftPanelFormSet(request.POST,
                                                     prefix='leftpanel')
            newleftpanel = []
            if leftpanel_formset.is_valid():
                for form in leftpanel_formset:
                    value = form.cleaned_data.get('panel')
                    if value != 'None':
                        newleftpanel.append(value)


                newleftpanel = [i for i in newleftpanel if i != None]
                r.workflowleftpanel = newleftpanel
                try:
                    r.save()
                except IntegrityError:
                    messages.error(request,'Something went wrong')
                
    leftpanelform_data = [{'panel':panel}
                          for panel in r.workflowleftpanel]

    
    middlepanelform_data = [{'panel':panel}
                          for panel in r.workflowmiddlepanel]

    leftpanel_formset = LeftPanelFormSet(initial=leftpanelform_data,
                                         prefix='leftpanel')
    middlepanel_formset = MiddlePanelFormSet(initial=middlepanelform_data,
                                             prefix='middlepanel')
    
    
    tmplt = 'workflowconfig2.html'

    return render(request,tmplt,
                  {
                      'rower':r,
                      'leftpanel_formset':leftpanel_formset,
                      'middlepanel_formset':middlepanel_formset,
                      'workoutid': workoutid,
                      })



# Workflow View
@login_required()
def workout_workflow_view(request,id):
    request.session['referer'] = absolute(request)['PATH']
    request.session['lastworkout'] = id
    request.session[translation.LANGUAGE_SESSION_KEY] = USER_LANGUAGE
    row = get_workout_permittedview(request.user,id)
    
    r = getrower(request.user)
    result = request.user.is_authenticated and ispromember(request.user)
    if result:
        promember=1
    if request.user == row.user.user:
        mayedit=1

    comments = WorkoutComment.objects.filter(workout=row)

    aantalcomments = len(comments)

    favorites,maxfav = getfavorites(r,row)
    

    charts = get_call()


    if 'panel_map.html' in r.workflowmiddlepanel and rowhascoordinates(row):
        rowdata = rdata(row.csvfilename)
        mapscript,mapdiv = leaflet_chart2(rowdata.df[' latitude'],
                                          rowdata.df[' longitude'],
                                          row.name)
    else:
        mapscript = ''
        mapdiv = ''

        

    statcharts = GraphImage.objects.filter(workout=row)
        

    middleTemplates = []
    for t in r.workflowmiddlepanel:
        try:
            template.loader.get_template(t)
            middleTemplates.append(t)
        except template.TemplateDoesNotExist:
            pass

    leftTemplates = []
    for t in r.workflowleftpanel:
        try:
            template.loader.get_template(t)
            leftTemplates.append(t)
        except template.TemplateDoesNotExist:
            pass

    
    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': row.name
                },
            {
                'url':reverse('workout_workflow_view',kwargs={'id':id}),
                'name': 'View'
                }
            
            ]

    return render(request,
                  'workflow.html',
                  {
                      'middleTemplates':middleTemplates,
                      'leftTemplates':leftTemplates,
                      'active':'nav-workouts',
                      'breadcrumbs':breadcrumbs,
                      'charts':charts,
                      'workout':row,
                      'mapscript':mapscript,
                      'mapdiv':mapdiv,
                      'statcharts':statcharts,
                      'rower':r,
                      'aantalcomments':aantalcomments,
                  })

# The famous flex chart
@login_required()
def workout_flexchart3_view(request,*args,**kwargs):
    
    try:
        id = kwargs['id']
    except KeyError:
        raise Http404("Invalid workout number")
    
    if 'promember' in kwargs:
        promember = kwargs['promember']
    else:
        promember = 0

    try:
        favoritenr = int(request.GET['favoritechart'])
    except:
        favoritenr = -1
        
    row = get_workout(id)

    promember=0
    mayedit=0
    if not request.user.is_anonymous:
        r = getrower(request.user)
        result = request.user.is_authenticated and ispromember(request.user)
        if result:
            promember=1
        if request.user == row.user.user:
            mayedit=1
        if checkworkoutuser(request.user,row):
            mayedit=1

    workouttype = 'ote'
    if row.workouttype in mytypes.otwtypes:
        workouttype = 'otw'

    favorites,maxfav = getfavorites(r,row)

    # check if favoritenr is not out of range
    if favorites:
        try:
            t = favorites[favoritenr].xparam
        except IndexError:
            favoritenr=0
        except AssertionError:
            favoritenr=0
        
    if 'xparam' in kwargs:
        xparam = kwargs['xparam']
    else:
        if favorites:
            xparam = favorites[favoritenr].xparam
        else:
            xparam = 'distance'

    if 'yparam1' in kwargs:
        yparam1 = kwargs['yparam1']
    else:
        if favorites:
            yparam1 = favorites[favoritenr].yparam1
        else:
            yparam1 = 'pace'
            
    if 'yparam2' in kwargs:
        yparam2 = kwargs['yparam2']
        if yparam2 == '':
            yparam2 = 'None'
    else:
        if favorites:
            yparam2 = favorites[favoritenr].yparam2
            if yparam2 == '':
                yparam2 = 'None'
        else:
            yparam2 = 'hr'

    if not request.user.is_anonymous:
        r = getrower(request.user)
        if favoritenr>=0 and r.showfavoritechartnotes:
            try:
                favoritechartnotes = favorites[favoritenr].notes
            except IndexError:
                favoritechartnotes = ''
        else:
            favoritechartnotes = ''
    else:
        favoritechartnotes = ''
        favoritenr = 0
        
    if 'plottype' in kwargs:
        plottype = kwargs['plottype']
    else:
        if favorites:
            plottype = favorites[favoritenr].plottype
        else:
            plottype = 'line'

    if 'workstrokesonly' in kwargs:
        workstrokesonly = kwargs['workstrokesonly']
    else:
        if favorites:
            workstrokesonly = not favorites[favoritenr].reststrokes
        else:
            workstrokesonly = False
            
    if request.method == 'POST' and 'savefavorite' in request.POST:
        if not request.user.is_anonymous:
            workstrokesonly = request.POST['workstrokesonlysave']
            reststrokes = not workstrokesonly
            r = getrower(request.user)
            try:
                range = metrics.yaxmaxima[xparam]
                if yparam1 is not None:
                    range = metrics.yaxmaxima[yparam1]
                if yparam2 is not None:
                    range = metrics.yaxmaxima[yparam2]
                f = FavoriteChart(user=r,xparam=xparam,
                              yparam1=yparam1,yparam2=yparam2,
                              plottype=plottype,workouttype=workouttype,
                              reststrokes=reststrokes)
                f.save()
                
            except KeyError:
                messages.error(request,'We cannot save the ad hoc metrics in a favorite chart')

    if request.method == 'POST' and 'xaxis' in request.POST:
        flexoptionsform = FlexOptionsForm(request.POST)
        if flexoptionsform.is_valid():
            cd = flexoptionsform.cleaned_data
            includereststrokes = cd['includereststrokes']
            plottype = cd['plottype']

            workstrokesonly = not includereststrokes
            
        flexaxesform = FlexAxesForm(request,request.POST)

        if flexaxesform.is_valid():
            cd = flexaxesform.cleaned_data
            xparam = cd['xaxis']
            yparam1 = cd['yaxis1']
            yparam2 = cd['yaxis2']
        else:
            pass


    if not promember:
        for name,d in rowingmetrics:
            if d['type'] != 'basic':
                if xparam == name:
                    xparam = 'time'
                    messages.info(request,'To use '+d['verbose_name']+', you have to be Pro member')
                if yparam1 == name:
                    yparam1 = 'pace'
                    messages.info(request,'To use '+d['verbose_name']+', you have to be Pro member')
                if yparam2 == name:
                    yparam2 = 'spm'
                    messages.info(request,'To use '+d['verbose_name']+', you have to be Pro member')

    # bring back slashes
#    yparam1 = yparam1.replace('_slsh_','/')
#    yparam2 = yparam2.replace('_slsh_','/')
#    xparam = xparam.replace('_slsh_','/')

    # create interactive plot
    try:
        (
            script,
            div,
            js_resources,
            css_resources,
            workstrokesonly
        ) = interactive_flex_chart2(
            encoder.decode_hex(id),xparam=xparam,yparam1=yparam1,
            yparam2=yparam2,
            promember=promember,plottype=plottype,
            workstrokesonly=workstrokesonly
        )
    except ValueError:
        (
            script,
            div,
            js_resources,
            css_resources,
            workstrokesonly
        ) = interactive_flex_chart2(
            encoder.decode_hex(id),xparam=xparam,yparam1=yparam1,
            yparam2=yparam2,
            promember=promember,plottype=plottype,
            workstrokesonly=workstrokesonly
        )
        js_resources = ""
        css_resources = ""

        
    axchoicesbasic = {ax[0]:ax[1] for ax in axes if ax[4]=='basic'}
    axchoicespro = {ax[0]:ax[1] for ax in axes if ax[4]=='pro'}
    noylist = ["time","distance"]
    axchoicesbasic.pop("cumdist")
    
    if row.workouttype in mytypes.otwtypes:
        for name,d in rowingmetrics:
            if d['mode'] == 'erg':
                axchoicespro.pop(name)

    else:
        for name,d in rowingmetrics:
            if d['mode'] == 'water':
                axchoicespro.pop(name)

    from rowers.metrics import nometrics
    
    rowdata = rdata(row.csvfilename)
    try:
        rowdata.set_instroke_metrics()
    except (AttributeError,TypeError):
        pass
    try:
        additionalmetrics = rowdata.get_additional_metrics()
        additionalmetrics = [m for m in additionalmetrics if not m in nometrics]
    except AttributeError:
        additionalmetrics = []


    #    extrametrics = {m.replace('/','_slsh_'):m for m in additionalmetrics}
    extrametrics = additionalmetrics

    #    xparam = xparam.replace('/','_slsh_')
    #    yparam1 = yparam1.replace('/','_slsh_')
    #    yparam2 = yparam2.replace('/','_slsh_')


#    for metric in nometrics:
#        try:
#            extrametrics.pop(metric)
#        except KeyError:
#            pass
        
    initial = {
        'xaxis':xparam,
        'yaxis1':yparam1,
        'yaxis2':yparam2,
    }
    flexaxesform = FlexAxesForm(request,initial=initial,
                                extrametrics=extrametrics)

    initial = {
        'includereststrokes': not workstrokesonly,
        'plottype':plottype
        }

    flexoptionsform = FlexOptionsForm(initial=initial)

    row = Workout.objects.get(id=encoder.decode_hex(id))

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': row.name
                },
            {
                'url':reverse('workout_flexchart3_view',kwargs=kwargs),
                'name': 'Flex Chart'
                }
            
            ]

    
    return render(request,
                  'flexchart3otw.html',
                  {'the_script':script,
                   'the_div':div,
                   'breadcrumbs':breadcrumbs,
                   'rower':r,
                   'active':'nav-workouts',
                   'workout':row,
                   'chartform':flexaxesform,
                   'optionsform':flexoptionsform,
                   'js_res': js_resources,
                   'css_res':css_resources,
                   'teams':get_my_teams(request.user),
                   'id':id,
                   'xparam':xparam,
                   'yparam1':yparam1,
                   'yparam2':yparam2,
                   'plottype':plottype,
                   'axchoicesbasic':axchoicesbasic,
                   'axchoicespro':axchoicespro,
                   'extrametrics':extrametrics,
                   'favoritechartnotes':favoritechartnotes,
                   'noylist':noylist,
                   'mayedit':mayedit,
                   'promember':promember,
                   'workstrokesonly': not workstrokesonly,
                   'favoritenr':favoritenr,
                   'maxfav':maxfav,
                  })
        


# The interactive plot with wind corrected pace for OTW outings
def workout_otwpowerplot_view(request,id=0,message="",successmessage=""):
    w = get_workout(id)
    r = getrower(request.user)

    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url':get_workout_default_page(request,id),
            'name': w.name
        },
        {
            'url':reverse('workout_otwpowerplot_view',kwargs={'id':id}),
            'name': 'Interactive OTW Power Plot'
        }
        
    ]

    # check if user is owner of this workout


    # create interactive plot
    f1 = w.csvfilename
    u = w.user.user
    # r = getrower(u)

    promember=0
    mayedit=0
    if not request.user.is_anonymous:
        r = getrower(request.user)
        result = request.user.is_authenticated and ispromember(request.user)
        if result:
            promember=1
        if request.user == w.user.user:
            mayedit=1

    # create interactive plot
    res = interactive_otw_advanced_pace_chart(encoder.decode_hex(id),promember=promember)
    script = res[0]
    div = res[1]

    messages.error(request,message)
    messages.info(request,successmessage)

    return render(request,
                  'otwinteractive.html',
                  {'workout':w,
                   'rower':r,
                   'active':'nav-workouts',
                   'breadcrumbs':breadcrumbs,
                   'teams':get_my_teams(request.user),
                   'interactiveplot':script,
                   'the_div':div,
                   'mayedit':mayedit})


#
@login_required()
def workout_unsubscribe_view(request,id=0):
    w = get_workout(id)

    if w.privacy == 'private' and w.user.user != request.user:
        return HttpResponseForbidden("Permission error")

    comments = WorkoutComment.objects.filter(workout=w,
                                             user=request.user).order_by("created")

    for c in comments:
        c.notification = False
        c.save()

    form = WorkoutCommentForm()

    successmessage = 'You have been unsubscribed from new comment notifications for this workout'
    
    messages.info(request,successmessage)

    return render(request,
                  'workout_comments.html',
                  {'workout':w,
                   'teams':get_my_teams(request.user),
                   'comments':comments,
                   'form':form,
                   })

        
# list of comments to a workout
@login_required()
def workout_comment_view(request,id=0):
    w = get_workout(id)
    
    if w.privacy == 'private' and w.user.user != request.user:
        return HttpResponseForbidden("Permission error")

    comments = WorkoutComment.objects.filter(workout=w).order_by("created")

    # ok we're permitted
    if request.method == 'POST':
        r = w.user
        form = WorkoutCommentForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            comment = cd['comment']
            comment = bleach.clean(comment)
            try:
                if isinstance(comment,unicode):
                    comment = comment.encode('utf8')
                elif isinstance(comment, str):
                    comment = comment.decode('utf8')
            except:
                pass


            notification = cd['notification']
            c = WorkoutComment(workout=w,user=request.user,comment=comment,
                               notification=notification)
            c.save()
            url = reverse('workout_comment_view',
                          kwargs={
                              'id':id,
                              })
            message = '{name} says: <a href="{url}">{comment}</a>'.format(
                name = request.user.first_name,
                comment = comment,
                url = url,
            )
            if request.user != r.user:    
                a_messages.info(r.user,message.encode('ascii','ignore'))

            res = myqueue(queuehigh,
                          handle_sendemailnewcomment,r.user.first_name,
                          r.user.last_name,
                          r.user.email,
                          request.user.first_name,
                          request.user.last_name,
                          comment,w.name,w.id,
                          emailbounced = r.emailbounced
            )
                
            commenters = {oc.user for oc in comments if oc.notification}
            for u in commenters:
                a_messages.info(u,message)
                if u != request.user and u != r.user:
                    ocr = Rower.objects.get(user=u)
                    res = myqueue(queuelow,
                                  handle_sendemailnewresponse,
                                  u.first_name,
                                  u.last_name,
                                  u.email,
                                  request.user.first_name,
                                  request.user.last_name,
                                  comment,
                                  w.name,
                                  w.id,
                                  c.id,
                                  emailbounced = ocr.emailbounced
                    )

        url = reverse('workout_comment_view',
                      kwargs = {
                          'id':id})
        return HttpResponseRedirect(url)
                
    form = WorkoutCommentForm()

    g = GraphImage.objects.filter(workout=w).order_by("-creationdatetime")
    for i in g:
        try:
            width,height = Image.open(i.filename).size
            i.width = width
            i.height = height
            i.save()
        except:
            pass

    rower = getrower(request.user)

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': w.name
                },
            {
                'url':reverse('workout_comment_view',kwargs={'id':id}),
                'name': 'Comments'
                }
            
            ]
    

    return render(request,
                  'workout_comments.html',
                  {'workout':w,
                   'rower':rower,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'teams':get_my_teams(request.user),
                   'graphs':g,
                   'comments':comments,
                   'form':form,
                  })


        
# The basic edit page
@login_required()
def workout_edit_view(request,id=0,message="",successmessage=""):
    request.session[translation.LANGUAGE_SESSION_KEY] = USER_LANGUAGE
    request.session['referer'] = absolute(request)['PATH']


    row = get_workout(id)


    if (checkworkoutuser(request.user,row)==False):
        raise PermissionDenied("Access denied")

    if request.user.rower.rowerplan == 'basic' and 'speedcoach2' in row.workoutsource:
        data = getsmallrowdata_db(['wash'],ids=[encoder.decode_hex(id)])
        try:
            if data['wash'].std() != 0:
                url = reverse('paidplans')
                messages.info(
                    request,
                    'Some Empower Oarlock data are only available to users with a <a href="{u}">paid plan</a>'.format(u=url)
                )
        except:
            pass

    form = WorkoutForm(instance=row)

    if request.method == 'POST':
        # Form was submitted
        form = WorkoutForm(request.POST,instance=row)
        if form.is_valid():
            # Get values from form
            name = form.cleaned_data['name']
            date = form.cleaned_data['date']
            starttime = form.cleaned_data['starttime']
            workouttype = form.cleaned_data['workouttype']
            weightcategory = form.cleaned_data['weightcategory']
            adaptiveclass = form.cleaned_data['adaptiveclass']
            duration = form.cleaned_data['duration']
            distance = form.cleaned_data['distance']
            private = form.cleaned_data['private']
            notes = form.cleaned_data['notes']
            newdragfactor = form.cleaned_data['dragfactor']
            thetimezone = form.cleaned_data['timezone']

            try:
                ps = form.cleaned_data['plannedsession']
            except KeyError:
                ps = None
                
            try:
                boattype  = request.POST['boattype']
            except KeyError:
                boattype = Workout.objects.get(id=encoder.decode_hex(id)).boattype
            try:
                privacy = request.POST['privacy']
            except KeyError:
                privacy = Workout.objects.get(id=row.id).privacy
            try:
                rankingpiece = form.cleaned_data['rankingpiece']
            except KeyError:
                rankingpiece =- Workout.objects.get(id=row.id).rankingpiece

            try:
                duplicate = form.cleaned_data['duplicate']
            except KeyError:
                duplicate = Workout.objects.get(id=row.id).duplicate

            if private:
                privacy = 'private'
            else:
                privacy = 'visible'
                
            startdatetime = datetime.datetime.combine(
                date,starttime
                )

            try:
                startdatetime = pytz.timezone(thetimezone).localize(
                    startdatetime
                )
            except UnknownTimeZoneError:
                pass

            try:
                # aware object can be in any timezone
                out = startdatetime.astimezone(pytz.utc)
            except (ValueError, TypeError):
                startdatetime = timezone.make_aware(startdatetime)

            try:
                startdatetime = startdatetime.astimezone(pytz.timezone(thetimezone))
            except UnknownTimeZoneError:
                thetimezone = 'UTC'



            row.name  = name
            row.date = date
            row.starttime = starttime
            row.startdatetime = startdatetime
            row.workouttype = workouttype
            row.weightcategory = weightcategory
            row.adaptiveclass = adaptiveclass
            row.notes = notes
            row.duration = duration
            row.distance = distance
            row.boattype = boattype
            row.duplicate = duplicate
            row.privacy = privacy
            row.rankingpiece = rankingpiece
            row.timezone = thetimezone
            row.plannedsession = ps

            dragchanged = False
            if newdragfactor != row.dragfactor:
                row.dragfactor = newdragfactor
                dragchanged = True

            try:
                row.save()
            except IntegrityError:
                pass

            if ps:
                add_workouts_plannedsession([row],ps,row.user)
            
            # change data in csv file
            
            r = rdata(row.csvfilename)
            if dragchanged:
                try:
                    r.change_drag(newdragfactor)
                except AttributeError:
                    pass
                    
            if r == 0:
                return HttpResponse("Error: CSV Data File Not Found")
            r.rowdatetime = startdatetime
            r.write_csv(row.csvfilename,gzip=True)
            dataprep.update_strokedata(encoder.decode_hex(id),r.df)
            successmessage = "Changes saved"

            if rankingpiece:
                dataprep.runcpupdate(row.user,type=row.workouttype)
                
            messages.info(request,successmessage)
            url = reverse('workout_edit_view',
                          kwargs = {
                              'id':encoder.encode_hex(row.id),
                          })
            response = HttpResponseRedirect(url)
                
    #else: # form not POSTed
    form = WorkoutForm(instance=row)

    row = get_workout(id)

    g = GraphImage.objects.filter(workout=row).order_by("-creationdatetime")
    for i in g:
        try:
            width,height = Image.open(i.filename).size
            i.width = width
            i.height = height
            i.save()
        except:
            pass


    # create interactive plot
    f1 = row.csvfilename
    u = row.user.user
    r = getrower(u)
    rowdata = rdata(f1)
    hascoordinates = 1
    if rowdata != 0:
        try:
            latitude = rowdata.df[' latitude']
            longitude = rowdata.df[' longitude']
            if not latitude.std():
                hascoordinates = 0
            if not longitude.std():
                hascoordinates = 0
        except (KeyError,AttributeError):
            hascoordinates = 0

    else:
        hascoordinates = 0


    mapscript = ""
    mapdiv = ""

    if hascoordinates:
        try:
            mapscript,mapdiv = leaflet_chart(
                rowdata.df[' latitude'],
                rowdata.df[' longitude'],
                row.name)
        except KeyError:
            pass

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,encoder.encode_hex(row.id)),
                'name': row.name
                },
            {
                'url':reverse('workout_edit_view',kwargs={'id':encoder.encode_hex(row.id)}),
                'name': 'Edit'
                }
            
            ]

    if row.workouttype in mytypes.otetypes:
        indoorraces = get_indoorraces(row)
    else:
        indoorraces = []

    r = getrower(request.user)
    
    # render page
    return render(request, 'workout_form.html',
                  {'form':form,
                   'workout':row,
                   'teams':get_my_teams(request.user),
                   'graphs':g,
                   'breadcrumbs':breadcrumbs,
                   'rower':r,
                   'indoorraces':indoorraces,
                   'active':'nav-workouts',
                   'mapscript':mapscript,
                   'mapdiv':mapdiv,
                   'rower':r,
                  })




@login_required()
def workout_map_view(request,id=0):
    request.session[translation.LANGUAGE_SESSION_KEY] = USER_LANGUAGE
    request.session['referer'] = absolute(request)['PATH']

    w = get_workout(id)

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': w.name
                },
            {
                'url':reverse('workout_map_view',kwargs={'id':id}),
                'name': 'Map'
                }
            
            ]

    
    # create interactive plot
    f1 = w.csvfilename
    u = w.user.user
    r = getrower(u)
    rowdata = rdata(f1)
    hascoordinates = 1
    if rowdata != 0:
        try:
            latitude = rowdata.df[' latitude']
            if not latitude.std():
                hascoordinates = 0
        except (KeyError,AttributeError):
            hascoordinates = 0

    else:
        hascoordinates = 0


    if hascoordinates:
        mapscript,mapdiv = leaflet_chart2(rowdata.df[' latitude'],
                                         rowdata.df[' longitude'],
                                         w.name)
    else:
        mapscript = ""
        mapdiv = ""
        
    mayedit=0
    if not request.user.is_anonymous:
        r = getrower(request.user)
        result = request.user.is_authenticated and ispromember(request.user)
        if result:
            promember=1
        if request.user == w.user.user:
            mayedit=1

    return render(request, 'map_view.html',
                  {'mapscript':mapscript,
                   'workout':w,
                   'rower':r,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'mapdiv':mapdiv,
                   'mayedit':mayedit,
                   })

            
                    

# Image upload
@login_required()
def workout_uploadimage_view(request,id):
    is_ajax = False
    if request.is_ajax():
        is_ajax = True

    r = getrower(request.user)

    w = get_workout(id)

    breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,id),
                'name': w.name
                },
            {
                'url':reverse('workout_uploadimage_view',kwargs={'id':id}),
                'name': 'Upload Image'
                }
            
            ]

    if not checkworkoutuser(request.user,w):
        raise PermissionDenied("You are not allowed to edit this workout")

    images = GraphImage.objects.filter(workout=w)

    
    if len(images) >= 6:
        message = "You have reached the maximum number of static images for this workout"
        messages.error(request,message)
        url = reverse(r.defaultlandingpage,
                      kwargs = {
                          'id':id,
                          })
        return HttpResponseRedirect(url)

    
    if request.method == 'POST':
        form = ImageForm(request.POST,request.FILES)

        if form.is_valid():
            f = form.cleaned_data['file']

            if f is not None:
                filename,path_and_filename = handle_uploaded_image(f)
                try:
                    width,height = Image.open(path_and_filename).size
                except:
                    message = "Not a valid image"
                    messages.error(request,message)
                    os.remove(path_and_filename)
                    url = reverse('workout_uploadimage_view',
                                  kwargs = {'id':id})

                    if is_ajax:
                        return JSONResponse({'result':0,'url':0})
                    else:
                        return HttpResponseRedirect(url)

                i = GraphImage(workout=w,
                               creationdatetime=timezone.now(),
                               filename = path_and_filename,
                               width=width,height=height)
                i.save()
                
                url = reverse(r.defaultlandingpage,
                              kwargs = {'id':id})
                if is_ajax:
                    return JSONResponse({'result':1,'url':url})
                else:
                    return HttpResponseRedirect(url)
            else:
                messages.error(request,'Something went wrong - no file attached')
                url = reverse('workout_uploadimage_view',
                              kwargs = {'id':id})

                if is_ajax:
                    return JSONResponse({'result':0,'url':0})
                else:
                    return HttpResponseRedirect(url)
        else:
            return HttpResponse("Form is not valid")

    else:
        if not is_ajax:
            form = ImageForm()
            return render(request,'image_form.html',
                          {'form':form,
                           'rower':r,
                           'active':'nav-workouts',
                           'breadcrumbs':breadcrumbs,
                           'teams':get_my_teams(request.user),
                           'workout': w,
                           })
        else:
            return {'result':0}

                
                
# Generic chart creation
@login_required()
def workout_add_chart_view(request,id,plotnr=1):

    w = get_workout(id)
    r = getrower(request.user)

    plotnr = int(plotnr)
    
    if (checkworkoutuser(request.user,w)==False):
        raise PermissionDenied("You are not allowed add plots to this workout")
    else:
        f1 = w.csvfilename[6:-4] 
        timestr = strftime("%Y%m%d-%H%M%S")
        imagename = f1+timestr+'.png'
        u = w.user.user
        r = getrower(u)
        title = w.name
        res,jobid = uploads.make_plot(
            r,w,f1,w.csvfilename,'timeplot',title,plotnr=plotnr,
            imagename=imagename
        )
        if res == 0:
            messages.error(request,jobid)
        else:
            try:
                request.session['async_tasks'] += [(jobid,'make_plot')]
            except KeyError:
                request.session['async_tasks'] = [(jobid,'make_plot')]


    url = reverse(r.defaultlandingpage,kwargs={'id':encoder.encode_hex(w.id)})

    return HttpResponseRedirect(url)





@login_required
def workout_toggle_ranking(request,id=0):
    is_ajax = False
    if request.is_ajax():
        is_ajax = True

    row = get_workout_permitted(request.user,id)

    row.rankingpiece = not row.rankingpiece
    row.save()

    if is_ajax:
        response = JSONResponse({'result':row.rankingpiece},
                                content_type='application/json')

        return response
    else: 
        url = reverse('workouts_view')
        response = HttpResponseRedirect(url)

    return response
        
        
# This is the main view for processing uploaded files
@login_required()
def workout_upload_view(request,
                        uploadoptions={
                            'makeprivate':False,
                            'make_plot':False,
                            'upload_to_C2':False,
                            'plottype':'timeplot',
                            'landingpage':'workout_edit_view',
                        },
                        docformoptions={
                            'workouttype':'rower',
                        }):

    is_ajax = False
    if request.is_ajax():
        is_ajax = True

    r = getrower(request.user)

    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url': reverse('workout_upload_view'),
            'name': 'Upload'
            }
        ]

    if 'uploadoptions' in request.session:
        uploadoptions = request.session['uploadoptions']
        try:
            defaultlandingpage = uploadoptions['landingpage']
        except KeyError:
            uploadoptions['landingpage'] = r.defaultlandingpage
            defaultlandingpage = r.defaultlandingpage
    else:
        request.session['uploadoptions'] = uploadoptions

    if 'docformoptions' in request.session:
        docformoptions = request.session['docformoptions']
    else:
        request.session['docformoptions'] = docformoptions

    try:
        makeprivate = uploadoptions['makeprivate']
    except KeyError:
        makeprivate = False
    try:
        make_plot = uploadoptions['make_plot']
    except KeyError:
        make_plot = False

    try:
        workouttype = docformoptions['workouttype']
    except KeyError:
        workouttype = 'rower'

    try:
        boattype = docformoptions['boattype']
    except KeyError:
        boattype = '1x'

    try:
        workoutsource = uploadoptions['workoutsource']
    except KeyError:
        workoutsource = None

    try:
        plottype = uploadoptions['plottype']
    except KeyError:
        plottype = 'timeplot'

    try:
        landingpage = uploadoptions['landingpage']
    except KeyError:
        landingpage = r.defaultlandingpage
        uploadoptions['landingpage'] = landingpage

    try:
        upload_to_c2 = uploadoptions['upload_to_C2']
    except KeyError:
        upload_to_c2 = False

    try:
        upload_to_strava = uploadoptions['upload_to_Strava']
    except KeyError:
        upload_to_strava = False

    try:
        upload_to_st = uploadoptions['upload_to_SportTracks']
    except KeyError:
        upload_to_st = False

    try:
        upload_to_rk = uploadoptions['upload_to_RunKeeper']
    except KeyError:
        upload_to_rk = False

    try:
        upload_to_ua = uploadoptions['upload_to_MapMyFitness']
    except KeyError:
        upload_to_ua = False

    try:
        upload_to_tp = uploadoptions['upload_to_TrainingPeaks']
    except KeyError:
        upload_to_tp = False


    

    response = {}
    if request.method == 'POST':
        form = DocumentsForm(request.POST,request.FILES)
        optionsform = UploadOptionsForm(request.POST,request=request)

        if form.is_valid():
#           f = request.FILES['file']
            f = form.cleaned_data['file']

            if f is not None:
                res = handle_uploaded_file(f)
            else:
                messages.error(request,
                               "Something went wrong - no file attached")
                url = reverse('workout_upload_view')
                if is_ajax:
                    return JSONResponse({'result':0,'url':0})
                else:
                    return HttpResponseRedirect(url)
                
            t = form.cleaned_data['title']
            workouttype = form.cleaned_data['workouttype']
            boattype = form.cleaned_data['boattype']

            request.session['docformoptions'] = {
                'workouttype':workouttype,
                'boattype': boattype,
                }
            
            notes = form.cleaned_data['notes']
            offline = form.cleaned_data['offline']

            race = None
            if optionsform.is_valid():
                make_plot = optionsform.cleaned_data['make_plot']
                plottype = optionsform.cleaned_data['plottype']
                upload_to_c2 = optionsform.cleaned_data['upload_to_C2']
                upload_to_strava = optionsform.cleaned_data['upload_to_Strava']
                upload_to_st = optionsform.cleaned_data['upload_to_SportTracks']
                upload_to_rk = optionsform.cleaned_data['upload_to_RunKeeper']
                upload_to_ua = optionsform.cleaned_data['upload_to_MapMyFitness']
                upload_to_tp = optionsform.cleaned_data['upload_to_TrainingPeaks']
                makeprivate = optionsform.cleaned_data['makeprivate']
                landingpage = optionsform.cleaned_data['landingpage']

                try:
                    race = optionsform.cleaned_data['submitrace']
                except KeyError:
                    race = None

                uploadoptions = {
                    'makeprivate':makeprivate,
                    'make_plot':make_plot,
                    'plottype':plottype,
                    'upload_to_C2':upload_to_c2,
                    'upload_to_Strava':upload_to_strava,
                    'upload_to_SportTracks':upload_to_st,
                    'upload_to_RunKeeper':upload_to_rk,
                    'upload_to_MapMyFitness':upload_to_ua,
                    'upload_to_TrainingPeaks':upload_to_tp,
                    'landingpage':landingpage,
                    'boattype': boattype,
                    'workouttype': workouttype,
                }


            request.session['uploadoptions'] = uploadoptions

            f1 = res[0] # file name
            f2 = res[1] # file name incl media directory

            if not offline:
                id,message,f2 = dataprep.new_workout_from_file(
                    r,f2,
                    workouttype=workouttype,
                    workoutsource=workoutsource,
                    boattype=boattype,
                    makeprivate=makeprivate,
                    title = t,
                    notes=''
                )
            else:
                workoutsbox = Mailbox.objects.filter(name='workouts')[0]
                uploadoptions['fromuploadform'] = True
                bodyyaml = yaml.safe_dump(
                    uploadoptions,
                    default_flow_style=False
                )
                msg = Message(mailbox=workoutsbox,
                              from_header=r.user.email,
                              subject = t,body=bodyyaml)
                msg.save()
                f3 = 'media/mailbox_attachments/'+f2[6:]
                copyfile(f2,f3)
                f3 = f3[6:]
                a = MessageAttachment(message=msg,document=f3)
                a.save()
                os.remove(f2)
                    
                messages.info(
                    request,
                    "The file was too large to process in real time. It will be processed in a background process. You will receive an email when it is ready")
                url = reverse('workout_upload_view')
                if is_ajax:
                    return JSONResponse({'result':1,'url':url})
                else:
                    response = HttpResponseRedirect(url)
                    return response
                
            if not id:
                messages.error(request,message)
                url = reverse('workout_upload_view')
                if is_ajax:
                    return JSONResponse({'result':0,'url':url})
                else:
                    response = HttpResponseRedirect(url)
                    return response
            elif id == -1:
                message = 'The zip archive will be processed in the background. The files in the archive will only be uploaded without the extra actions. You will receive email when the workouts are ready.'
                messages.info(request,message)
                url = reverse('workout_upload_view')
                if is_ajax:
                    return JSONResponse({'result':1,'url':url})
                else:
                    response = HttpResponseRedirect(url)
                    return response
            else:
                if message:
                    messages.error(request,message)

                w = Workout.objects.get(id=id)

                url = reverse('workout_edit_view',
                              kwargs = {
                                  'id':encoder.encode_hex(w.id),
                              })

                if is_ajax:
                    response = {'result': 1,'url':url}
                else:
                    response = HttpResponseRedirect(url)


            r = getrower(request.user)
            if (make_plot):
                res,jobid = uploads.make_plot(r,w,f1,f2,plottype,t)
                if res == 0:
                    messages.error(request,jobid)
                else:
                    try:
                        request.session['async_tasks'] += [(jobid,'make_plot')]
                    except KeyError:
                        request.session['async_tasks'] = [(jobid,'make_plot')]

            # upload to C2
            if (upload_to_c2):
                try:
                    message,id = c2stuff.workout_c2_upload(request.user,w)
                except NoTokenError:
                    id = 0
                    message = "Something went wrong with the Concept2 sync"
                if id>1:
                    messages.info(request,message)
                else:
                    messages.error(request,message)
                    
            if (upload_to_strava):
                try:
                    message,id = stravastuff.workout_strava_upload(
                        request.user,w
                    )
                except NoTokenError:
                    id = 0
                    message = "Please connect to Strava first"
                if id>1:
                    messages.info(request,message)
                else:
                    messages.error(request,message)
                    
            if (upload_to_st):
                try:
                    message,id = sporttracksstuff.workout_sporttracks_upload(
                        request.user,w
                    )
                except NoTokenError:
                    message = "Please connect to SportTracks first"
                    id = 0
                if id>1:
                    messages.info(request,message)
                else:
                    messages.error(request,message)
                    
            if (upload_to_rk):
                try:
                    message,id = runkeeperstuff.workout_runkeeper_upload(
                        request.user,w
                        )
                except NoTokenError:
                    message = "Please connect to Runkeeper first"
                    id = 0

                if id>1:
                    messages.info(request,message)
                else:
                    messages.error(request,message)


            if (upload_to_ua):
                try:
                    message,id = underarmourstuff.workout_ua_upload(
                        request.user,w
                    )
                except NoTokenError:
                    message = "Please connect to MapMyFitness first"
                    id = 0

                if id>1:
                    messages.info(request,message)
                else:
                    messages.error(request,message)


            if (upload_to_tp):
                try:
                    message,id = tpstuff.workout_tp_upload(
                        request.user,w
                        )
                except NoTokenError:
                    message = "Please connect to TrainingPeaks first"
                    id = 0

                if id>1:
                    messages.info(request,message)
                else:
                    messages.error(request,message)

            if race and race_can_submit(r,race):
                records = IndoorVirtualRaceResult.objects.filter(
                    race=race,
                    userid=r.id
                    )

                if records:
                
                    result,comments,errors,jobid = add_workout_indoorrace(
                        [w],race,r,recordid=records[0].id
                        )

                    if result:
                        messages.info(
                            request,
                            "We have submitted your workout to the race")

                    for c in comments:
                        messages.info(request,c)
                    for er in errors:
                        messages.error(request,er)

                    
            if landingpage != 'workout_upload_view':
                url = reverse(landingpage,
                              kwargs = {
                                  'id':encoder.encode_hex(w.id),
                              })
            else:
                url = reverse(landingpage)

            if is_ajax:
                response = {'result':1,'url':url}
            else:
                response = HttpResponseRedirect(url)
        else:
            if not is_ajax:
                response = render(request,
                                  'document_form.html',
                                  {'form':form,
                                   'teams':get_my_teams(request.user),
                                   'optionsform': optionsform,
                                  })


        if is_ajax:
            return JSONResponse(response)
        else:
            return response
    else:
        if not is_ajax:
            if r.c2_auto_export and isprorower(r):
                uploadoptions['upload_to_C2'] = True

            if r.strava_auto_export and isprorower(r):
                uploadoptions['upload_to_Strava'] = True

            if r.sporttracks_auto_export and isprorower(r):
                uploadoptions['upload_to_SportTracks'] = True

            if r.runkeeper_auto_export and isprorower(r):
                uploadoptions['upload_to_RunKeeper'] = True

            if r.trainingpeaks_auto_export and isprorower(r):
                uploadoptions['upload_to_TrainingPeaks'] = True

            if r.mapmyfitness_auto_export and isprorower(r):
                uploadoptions['upload_to_MapMyFitness'] = True
            
            form = DocumentsForm(initial=docformoptions)
            optionsform = UploadOptionsForm(initial=uploadoptions,
                                            request=request)
            return render(request, 'document_form.html',
                          {'form':form,
                           'active':'nav-workouts',
                           'breadcrumbs':breadcrumbs,
                           'teams':get_my_teams(request.user),
                           'optionsform': optionsform,
                          })
        else:
            return {'result':0}

    
# This is the main view for processing uploaded files
@user_passes_test(iscoachmember,login_url="/rowers/paidplans",redirect_field_name=None,
                  message="This functionality requires a Coach plan or higher")
def team_workout_upload_view(request,message="",
                             successmessage="",
                             uploadoptions={
                                 'make_plot':False,
                                 'plottype':'timeplot',
                             }):

    if 'uploadoptions' in request.session:
        uploadoptions = request.session['uploadoptions']
    else:
        request.session['uploadoptions'] = uploadoptions

    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url': reverse('team_workout_upload_view'),
            'name': 'Team Upload'
            }
        ]


    myteams = Team.objects.filter(manager=request.user)
        
    make_plot = uploadoptions['make_plot']
    plottype = uploadoptions['plottype']

    r = getrower(request.user)
    if request.method == 'POST':
        form = DocumentsForm(request.POST,request.FILES)
        optionsform = TeamUploadOptionsForm(request.POST)
        
        rowerform = TeamInviteForm(request.POST)
        rowerform.fields.pop('email')
        rowers = Rower.objects.filter(coachinggroups__in=[r.mycoachgroup]).distinct()
        rowerform.fields['user'].queryset = User.objects.filter(rower__in=rowers).distinct()
        if form.is_valid():
            f = request.FILES['file']
            res = handle_uploaded_file(f)
            t = form.cleaned_data['title']
            offline = form.cleaned_data['offline']
            boattype = form.cleaned_data['boattype']
            workouttype = form.cleaned_data['workouttype']
            if rowerform.is_valid():
                u = rowerform.cleaned_data['user']
                if u and request.user.rower in teams.rower_get_coaches(u.rower):
                    r = getrower(u)
                else:
                    message = 'Please select a rower'
                    messages.error(request,message)
                    messages.info(request,successmessage)
                    response = render(request,
                              'team_document_form.html',
                             {'form':form,
                              'teams':get_my_teams(request.user),
                              'optionsform': optionsform,
                              'rowerform': rowerform,
                             })

                    return response

                workouttype = form.cleaned_data['workouttype']

            notes = form.cleaned_data['notes']

            if optionsform.is_valid():
                make_plot = optionsform.cleaned_data['make_plot']
                plottype = optionsform.cleaned_data['plottype']

                uploadoptions = {
                    'makeprivate':False,
                    'make_plot':make_plot,
                    'plottype':plottype,
                    'upload_to_C2':False,
                }


            request.session['uploadoptions'] = uploadoptions

            f1 = res[0] # file name
            f2 = res[1] # file name incl media directory


            if not offline:
                id,message,f2 = dataprep.new_workout_from_file(
                    r,f2,
                    workouttype=workouttype,
                    boattype=boattype,
                    makeprivate=False,
                    title = t,
                    notes=''
                )
            else:
                job = myqueue(
                    queuehigh,
                    handle_zip_file,
                    r.user.email,
                    t,
                    f2,
                    emailbounced = r.emailbounced
                )

                messages.info(
                    request,
                    "The file was too large to process in real time. It will be processed in a background process. The user will receive an email when it is ready"
                )

                
                url = reverse('team_workout_upload_view')
                response = HttpResponseRedirect(url)
                return response
                 
                    
            if not id:
                messages.error(request,message)
                url = reverse('team_workout_upload_view')
                response = HttpResponseRedirect(url)
                return response
            elif id == -1:
                message = 'The zip archive will be processed in the background. The files in the archive will only be uploaded without the extra actions. You will receive email when the workouts are ready.'
                messages.info(request,message)
                url = reverse('team_workout_upload_view')
                response = HttpResponseRedirect(url)
                return response

            else:
                successmessage = "The workout was added to the user's account"
                messages.info(request,successmessage)

                url = reverse('team_workout_upload_view')
                    
                response = HttpResponseRedirect(url)
                w = Workout.objects.get(id=id)

            r = getrower(request.user)
            if (make_plot):
                id,jobid = uploads.make_plot(r,w,f1,f2,plottype,t)
                



        else:
            
            response = render(request,
                              'team_document_form.html',
                             {'form':form,
                              'teams':get_my_teams(request.user),
                              'active': 'nav-workouts',
                              'breadcrumbs':breadcrumbs,
                              'optionsform': optionsform,
                              'rowerform': rowerform,
                             })

        return response
    else:
        form = DocumentsForm()
        optionsform = TeamUploadOptionsForm(initial=uploadoptions)
        rowerform = TeamInviteForm()
        rowerform.fields.pop('email')
        rowerform.fields['user'].queryset = User.objects.filter(rower__isnull=False,rower__team__in=myteams).distinct()
        return render(request, 'team_document_form.html',
                      {'form':form, 
#                       'teams':get_my_teams(request.user),
                       'optionsform': optionsform,
                       'active': 'nav-workouts',
                       'breadcrumbs':breadcrumbs,
#                       'rower':r,
                       'rowerform':rowerform,
                      })





# A page with all the recent graphs (searchable on workout name)
@login_required()
def graphs_view(request):
    request.session['referer'] = reverse('graphs_view')
    try:
        r = getrower(request.user)
        workouts = Workout.objects.filter(user=r).order_by("-date", "-starttime")
        query = request.GET.get('q')
        if query:
            query_list = query.split()
            workouts = workouts.filter(
                reduce(operator.and_,
                       (Q(name__icontains=q) for q in query_list)) |
                reduce(operator.and_,
                       (Q(notes__icontains=q) for q in query_list))
                )
            searchform = SearchForm(initial={'q':query})
        else:
            searchform = SearchForm()

        g = GraphImage.objects.filter(workout__in=workouts).order_by("-creationdatetime")


        paginator = Paginator(g,8)
        page = request.GET.get('page')

        try:
            g = paginator.page(page)
        except PageNotAnInteger:
            g = paginator.page(1)
        except EmptyPage:
            g = paginator.page(paginator.num_pages)
            
        return render(request, 'list_graphs.html',
                      {'graphs': g,
                       'searchform':searchform,
                       'active':'nav-workouts',
                       'teams':get_my_teams(request.user),
                      })

    except Rower.DoesNotExist:
        raise Http404("User has no rower instance")

# Show the chart (png image)
def graph_show_view(request,id):
    try:
        g = GraphImage.objects.get(id=id)
        try:
            width,height = Image.open(g.filename).size
            g.width = width
            g.height = height
            g.save()
        except:
            pass
        
        w = Workout.objects.get(id=g.workout.id)
        r = Rower.objects.get(id=w.user.id)

        breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(request,encoder.encode_hex(w.id)),
                'name': w.name
                },
            {
                'url':reverse('graph_show_view',kwargs={'id':id}),
                'name': 'Chart'
                }
            
            ]

        
        return render(request,'show_graph.html',
                      {'graph':g,
                       'teams':get_my_teams(request.user),
                       'workout':w,
                       'breadcrumbs':breadcrumbs,
                       'active':'nav-workouts',
                       'rower':r,})
                         
    except GraphImage.DoesNotExist:
        raise Http404("This graph doesn't exist")
    except Workout.DoesNotExist:
        raise Http404("This workout doesn't exist")
    
# Restore original stroke data and summary
@login_required()
def workout_summary_restore_view(request,id,message="",successmessage=""):
    row = get_workout_permitted(request.user,id)

    s = ""
    # still here - this is a workout we may edit
    f1 = row.csvfilename
    u = row.user.user
    r = getrower(u)
    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 row.workouttype in mytypes.otwtypes:
        ftp = ftp*(100.-r.otwslack)/100.
        
    rr = rrower(hrmax=r.max,hrut2=r.ut2,
                hrut1=r.ut1,hrat=r.at,
                hrtr=r.tr,hran=r.an,ftp=ftp,
                powerperc=powerperc,powerzones=r.powerzones)
    rowdata = rdata(f1,rower=rr)
    if rowdata == 0:
        raise Http404("Error: CSV Data File Not Found")
    rowdata.restoreintervaldata()
    rowdata.write_csv(f1,gzip=True)
    dataprep.update_strokedata(encoder.decode_hex(id),rowdata.df)
    intervalstats = rowdata.allstats()
    row.summary = intervalstats
    row.save()

    # create interactive plot
    try:
        res = interactive_chart(encoder.decode_hex(id),promember=1)
        script = res[0]
        div = res[1]
    except ValueError:
        pass
    

    messages.info(request,'Original Interval Data Restored')
    url = reverse('workout_summary_edit_view',
                  kwargs={
                      'id':encoder.encode_hex(row.id),
                  }                       
    )
    return HttpResponseRedirect(url)

# Split a workout
@user_passes_test(ispromember,login_url="/rowers/paidplans",
                  message="This functionality requires a Pro plan or higher",
                  redirect_field_name=None)
def workout_split_view(request,id=0):
    row = get_workout_permitted(request.user,id)

    r = row.user
    
    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url':get_workout_default_page(request,id),
            'name': row.name
        },
        {
            'url':reverse('workout_split_view',
                          kwargs={'id':id}),
            'name': 'Chart'
        }
            
    ]
    if request.method == 'POST':
        form = WorkoutSplitForm(request.POST)
        if form.is_valid():
            splittime = form.cleaned_data['splittime']
            splitsecond = splittime.hour*3600
            splitsecond += splittime.minute*60
            splitsecond += splittime.second
            splitsecond += splittime.microsecond/1.e6
            splitmode = form.cleaned_data['splitmode']
            try:
                ids,mesgs = dataprep.split_workout(
                    r,row,splitsecond,splitmode
                )
            except IndexError:
                messages.error(request,"Something went wrong in Split")
                
            for message in mesgs:
                messages.info(request,message)


            if request.user == r:
                url = reverse('workouts_view')
            else:
                mgrids = [team.id for team in Team.objects.filter(manager=request.user)]
                rwrids = [team.id for team in r.team.all()]
                teamids = list(set(mgrids) & set(rwrids))
                if len(teamids) > 0:
                    teamid = teamids[0]
                
                    url = reverse('workouts_view',
                                  kwargs={
                                      'teamid':int(teamid),
                                  }
                    )
                else:
                    url = reverse('workouts_view')

            rowname = row.name
            try:
                if isinstance(rowname,unicode):
                    rowname = rowname.encode('utf8')
                elif isinstance(rowname, str):
                    rowname = rowname.decode('utf8')
            except:
                pass
                
            qdict = {'q':rowname}
            url+='?'+urllib.parse.urlencode(qdict)

            return HttpResponseRedirect(url)

    form = WorkoutSplitForm()

    # create interactive plot
    try:
        res = interactive_chart(encoder.decode_hex(id),promember=1)
        script = res[0]
        div = res[1]
    except ValueError:
        pass

    return render(request, 'splitworkout.html',
                  {'form':form,
                   'rower':r,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'workout':row,
                   'thediv':script,
                   'thescript':div,
                  })


# Fuse two workouts
@user_passes_test(ispromember,login_url="/rowers/paidplans",message="This functionality requires a Pro plan or higher",redirect_field_name=None)
def workout_fusion_view(request,id1=0,id2=1):

    try:
        id1 = encoder.decode_hex(id1)
        id2 = encoder.decode_hex(id2)
    except:
        pass
        
    r = getrower(request.user)
    
    try:
        w1 = Workout.objects.get(id=id1)
        w2 = Workout.objects.get(id=id2)
        r = w1.user
        if (checkworkoutuser(request.user,w1)==False) or \
           (checkworkoutuser(request.user,w2)==False):
            raise PermissionDenied("You are not allowed to use these workouts")
    except Workout.DoesNotExist:
        raise Http404("One of the workouts doesn't exist")

    if request.method == 'POST':
        form = FusionMetricChoiceForm(request.POST,instance=w2)
        if form.is_valid():
            cd = form.cleaned_data
            columns = cd['columns']
            timeoffset = cd['offset']
            posneg = cd['posneg']
            if posneg == 'neg':
                timeoffset = -timeoffset

            # Create DataFrame
            df,forceunit = dataprep.datafusion(id1,id2,columns,timeoffset)

            
            idnew,message = dataprep.new_workout_from_df(r,df,
                                                         title='Fused data',
                                                         parent=w1,
                                                         forceunit=forceunit)
            if message != None:
                messages.error(request,message)
            else:
                successmessage = 'Data fused'
                messages.info(request,message)

            url = reverse('workout_edit_view',
                          kwargs={
                              'id':encoder.encode_hex(idnew),
                          })

            return HttpResponseRedirect(url)
    else:        
        form = FusionMetricChoiceForm(instance=w2)
    
    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url':get_workout_default_page(request,encoder.encode_hex(w1.id)),
            'name': encoder.encode_hex(w1.id)
        },
        {
            'url':reverse('workout_fusion_list',
                          kwargs={'id':encoder.encode_hex(id1)}),
            'name': 'Sensor Fusion'
        },
        {
            'url':reverse('workout_fusion_view',
                          kwargs={
                              'id1':encoder.encode_hex(id1),
                              'id2':encoder.encode_hex(id2)
                          }),
            'name': encoder.encode_hex(w2.id)
        }
            
    ]
    
    return render(request, 'fusion.html',
                  {'form':form,
                   'teams':get_my_teams(request.user),
                   'workout':w1,
                   'rower':r,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'workout1':w1,
                   'workout2':w2,
                  })


# Edit the splits/summary
@login_required()
def workout_summary_edit_view(request,id,message="",successmessage=""
                              ):
    row = get_workout_permitted(request.user,id)
    r = getrower(request.user)
    breadcrumbs = [
        {
            'url':'/rowers/list-workouts/',
            'name':'Workouts'
        },
        {
            'url':get_workout_default_page(request,encoder.encode_hex(row.id)),
            'name': row.name
        },
        {
            'url':reverse('workout_summary_edit_view',kwargs={'id':id}),
            'name': 'Edit Intervals'
        }
        
    ]

    s = ""
    # still here - this is a workout we may edit
    f1 = row.csvfilename
    u = row.user.user
    r = getrower(u)
    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 row.workouttype in mytypes.otwtypes:
        ftp = ftp*(100.-r.otwslack)/100.
        
    rr = rrower(hrmax=r.max,hrut2=r.ut2,
                hrut1=r.ut1,hrat=r.at,
                hrtr=r.tr,hran=r.an,ftp=ftp,
                powerperc=powerperc,powerzones=r.powerzones)
    rowdata = rdata(f1,rower=rr)
    if rowdata == 0:
        return HttpResponse("Error: CSV Data File Not Found")
    intervalstats = rowdata.allstats()
    try:
        itime,idist,itype = rowdata.intervalstats_values()
    except TypeError:
        return HttpResponse("Error: CSV Data File Not Found")
    nrintervals = len(idist)

    
    savebutton = 'nosavebutton'
    formvalues = {}
    form = SummaryStringForm()

    tss,normp = dataprep.workout_rscore(row)

    normv,normw = dataprep.workout_normv(row,pp=8.0)

    work = int(normw)
    power = int(normp)
    try:
        pace_secs = int(500./normv)
    except (OverflowError, ZeroDivisionError):
        pace_secs = 140.

    try:
        avpace = datetime.timedelta(seconds=int(500./normv))
    except (OverflowError, ZeroDivisionError):
        avpace = datetime.timedelta(seconds=130)

    data = {
        'power': int(normp),
        'pace': avpace,
        'selector': 'power',
        'work': int(normw)
        }

    powerorpace = 'power'

    if normp == 0:
        data['selector'] = 'pace'
        powerorpace = 'pace'

        
    
    powerupdateform = PowerIntervalUpdateForm(initial=data)
    
    # We have submitted the mini language interpreter
    if request.method == 'POST' and "intervalstring" in request.POST:
        form = SummaryStringForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            s = cd["intervalstring"]
            try:
                rowdata.updateinterval_string(s)
            except:
                messages.error(request,'Parsing error')
            intervalstats = rowdata.allstats()
            itime,idist,itype = rowdata.intervalstats_values()
            nrintervals = len(idist)
            savebutton = 'savestringform'
        powerupdateform = PowerIntervalUpdateForm(initial=data)

    # we are saving the results obtained from the split by power/pace interpreter
    elif request.method == 'POST' and "savepowerpaceform" in request.POST:
        powerorpace = request.POST['powerorpace']
        value_pace = request.POST['value_pace']
        value_power = request.POST['value_power']
        value_work = request.POST['value_work']
        if powerorpace == 'power':
            try:
                power = int(value_power)
            except ValueError:
                int(normp)
        elif powerorpace == 'pace':
            try:
                pace_secs = float(value_pace)
            except ValueError:
                try:
                    pace_secs = float(value_pace.replace(',','.'))
                except ValueError:
                    pace_secs  = int(500./normv)
        elif powerorpace == 'work':
            try:
                work = int(value_work)
            except ValueError:
                work = int(normw)

        if powerorpace == 'power' and power is not None:
            try:
                rowdata.updateinterval_metric(
                    ' Power (watts)',power,mode='larger',
                    debug=False,smoothwindow=15.)
            except:
                messages.error(request,'Error updating power')
        elif powerorpace == 'pace':
            try:
                velo = 500./pace_secs
                rowdata.updateinterval_metric(
                    ' AverageBoatSpeed (m/s)',velo,mode='larger',
                    debug=False,smoothwindow=15.)
            except:
                messages.error(request,'Error updating pace')
        elif powerorpace == 'work':
            try:
                rowdata.updateinterval_metric(
                    'driveenergy',work,mode='larger',
                    debug=False,smoothwindow=15.)
            except:
                messages.error(request,'Error updating Work per Stroke')

        intervalstats = rowdata.allstats()
        itime,idist,itype = rowdata.intervalstats_values()
        nrintervals = len(idist)

        row.summary = intervalstats
        row.save()

        rowdata.write_csv(f1,gzip=True)

        dataprep.update_strokedata(encoder.decode_hex(id),rowdata.df)
        
        messages.info(request,"Updated interval data saved")
        data = {
            'power': power,
            'pace': datetime.timedelta(seconds=int(pace_secs)),
            'work': work,
            'selector': powerorpace
        }
        form = SummaryStringForm()
        powerupdateform = PowerIntervalUpdateForm(initial=data)
        savebutton = 'savepowerpaceform'
        formvalues = {
            'powerorpace': powerorpace,
            'value_power': power,
            'value_pace': pace_secs,
            'value_work':work,
            }

            
    # we are saving the results obtained from the mini language interpreter
    elif request.method == 'POST' and "savestringform" in request.POST:
        s = request.POST["savestringform"]
        try:
            rowdata.updateinterval_string(s)
        except (ParseException,err):
            messages.error(request,'Parsing error in column '+str(err.col))
            
        intervalstats = rowdata.allstats()
        itime,idist,itype = rowdata.intervalstats_values()
        nrintervals = len(idist)
        row.summary = intervalstats
        #intervalstats = rowdata.allstats()
        if s:
            try:
                row.notes = u'{n} \n {s}'.format(
                    n = row.notes,
                    s = s
                )
            except TypeError:
                pass
            
        row.save()
        rowdata.write_csv(f1,gzip=True)
        dataprep.update_strokedata(encoder.decode_hex(id),rowdata.df)
        messages.info(request,"Updated interval data saved")
        data = {'intervalstring':s}
        form = SummaryStringForm(initial=data)
        powerupdateform = PowerIntervalUpdateForm(initial={
            'power': int(normp),
            'pace': avpace,
            'selector': 'power',
            'work': int(normw)
        })
        savebutton = 'savestringform'

    # we are saving the results obtained from the power update form
    elif request.method == 'POST' and 'selector' in request.POST:
        powerupdateform = PowerIntervalUpdateForm(request.POST)
        if powerupdateform.is_valid():
            cd = powerupdateform.cleaned_data
            powerorpace = cd['selector']
            power = cd['power']
            pace = cd['pace']
            work = cd['work']
            try:
                pace_secs = pace.seconds+pace.microseconds/1.0e6
            except AttributeError:
                pace_secs = 120.

            if powerorpace == 'power' and power is not None:
                try:
                    rowdata.updateinterval_metric(' Power (watts)',power,mode='larger',
                                                  debug=False,smoothwindow=15)
                except:
                    messages.error(request,'Error updating power')
            elif powerorpace == 'pace':
                try:
                    velo = 500./pace_secs
                    rowdata.updateinterval_metric(' AverageBoatSpeed (m/s)',velo,mode='larger',
                                                  debug=False,smoothwindow=15)
                except:
                    messages.error(request,'Error updating pace')
            elif powerorpace == 'work':
                try:
                    rowdata.updateinterval_metric(
                        'driveenergy',work,mode='larger',
                        debug=False,smoothwindow=15.)
                except:
                    messages.error(request,'Error updating Work per Stroke')
                    

            intervalstats = rowdata.allstats()
            itime,idist,itype = rowdata.intervalstats_values()
            nrintervals = len(idist)
            savebutton = 'savepowerpaceform'
            formvalues = {
                'powerorpace': powerorpace,
                'value_power': power,
                'value_pace': pace_secs,
                'value_work': work,
                }
            powerupdateform = PowerIntervalUpdateForm(initial=cd)
            form = SummaryStringForm()
                

        form = SummaryStringForm()
                    
    # we are saving the results obtained from the detailed form
    elif request.method == 'POST' and "savedetailform" in request.POST:
        savebutton = 'savedetailform'
        form = SummaryStringForm()
        nrintervals = int(request.POST['nrintervals'])
        detailform = IntervalUpdateForm(request.POST,aantal=nrintervals)
        itime = []
        idist = []
        itype = []
        ivalues = []
        iunits = []
        itypes = []
        iresults = []
        for i in range(nrintervals):
            try:
                t = datetime.datetime.strptime(request.POST['intervalt_%s' % i],"%H:%M:%S.%f")
            except ValueError:
                t = datetime.datetime.strptime(request.POST['intervalt_%s' % i],"%H:%M:%S")
                
            timesecs = 3600*t.hour+60*t.minute+t.second+t.microsecond/1.e6
            itime += [timesecs]
            idist += [int(request.POST['intervald_%s' % i])]
            itype += [int(request.POST['type_%s' % i])]

            if itype[i] == 3: # rest
                itypes += ['rest']
                ivalues += [timesecs]
                iresults += [idist[i]]
                iunits += ['seconds']
            if itype[i] == 5 or itype[i] == 2:  # distance based work
                itypes += ['work']
                ivalues += [idist[i]]
                iresults += [timesecs]
                iunits += ['meters']
            if itype[i] == 4 or itype[i] == 1:  # time based work
                itypes += ['work']
                ivalues += [timesecs]
                iresults += [idist[i]]
                iunits += ['seconds']


        rowdata.updateintervaldata(ivalues,iunits,itypes,iresults=iresults)
        intervalstats = rowdata.allstats()
        row.summary = intervalstats
        try:
            row.notes += "\n"+s
        except TypeError:
            pass
        
        row.save()
        rowdata.write_csv(f1,gzip=True)
        dataprep.update_strokedata(encoder.decode_hex(id),rowdata.df)
        messages.info(request,"Updated interval data saved")

        form = SummaryStringForm()
        powerupdateform = PowerIntervalUpdateForm(initial={
            'power': int(normp),
            'pace': avpace,
            'selector': 'power',
            'work': int(normw)
        })


    # we are processing the details form
    elif request.method == 'POST' and "nrintervals" in request.POST:
        savebutton = 'savedetailform'
        nrintervals = int(request.POST['nrintervals'])
        detailform = IntervalUpdateForm(request.POST,aantal=nrintervals)
        if detailform.is_valid():
            cd = detailform.cleaned_data
            itime = []
            idist = []
            itype = []
            ivalues = []
            iunits = []
            itypes = []
            iresults = []
            for i in range(nrintervals):
                t = cd['intervalt_%s' % i]
                timesecs = t.total_seconds()
                itime += [timesecs]
                idist += [cd['intervald_%s' % i]]
                itype += [cd['type_%s' % i]]

                if itype[i] == '3': # rest
                    itypes += ['rest']
                    ivalues += [timesecs]
                    iresults += [idist[i]]
                    iunits += ['seconds']
                if itype[i] == '5' or itype[i] == '2':  # distance based work
                    itypes += ['work']
                    ivalues += [idist[i]]
                    iresults += [timesecs]
                    iunits += ['meters']
                if itype[i] == '4' or itype[i] == '1':  # time based work
                    itypes += ['work']
                    ivalues += [timesecs]
                    iresults += [idist[i]]
                    iunits += ['seconds']

            rowdata.updateintervaldata(ivalues,iunits,
                                       itypes,iresults=iresults)
            intervalstats = rowdata.allstats()


        form = SummaryStringForm()
        powerupdateform = PowerIntervalUpdateForm()



    initial = {}
    for i in range(nrintervals):
        try:
            initial['intervald_%s' % i] = idist[i]
            initial['intervalt_%s' % i] = get_time(itime[i])
            initial['type_%s' % i] = itype[i]
        except IndexError:
            pass


    detailform = IntervalUpdateForm(aantal=nrintervals,initial=initial)

    # create interactive plot
    try:
        intervaldata = {
            'itime':itime,
            'idist':idist,
            'itype':itype,
            'selector': powerorpace,
            'normp': normp,
            'normv': normv,
            }
        res = interactive_chart(encoder.decode_hex(id),promember=1,intervaldata=intervaldata)
        script = res[0]
        div = res[1]
    except ValueError:
        script = ''
        div = ''

    # render page

    return render(request, 'summary_edit.html',
                  {'form':form,
                   'detailform':detailform,
                   'powerupdateform':powerupdateform,
                   'workout':row,
                   'rower':r,
                   'breadcrumbs':breadcrumbs,
                   'active':'nav-workouts',
                   'teams':get_my_teams(request.user),
                   'intervalstats':intervalstats,
                   'nrintervals':nrintervals,
                   'interactiveplot':script,
                   'the_div':div,
                   'intervalstring':s,
                   'savebutton':savebutton,
                   'formvalues':formvalues,
                   })


class GraphDelete(DeleteView):
    login_required = True
    model = GraphImage
    template_name = 'graphimage_delete_confirm.html'

    # extra parameters
    def get_context_data(self, **kwargs):
        context = super(GraphDelete, self).get_context_data(**kwargs)

        breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(
                    self.request,
                    encoder.encode_hex(self.object.workout.id)),
                'name': self.object.workout.name
                },
            {
                'url':reverse('graph_show_view',kwargs={'id':self.object.pk}),
                'name': 'Chart'
                },
            { 'url':reverse('graph_delete',kwargs={'pk':str(self.object.pk)}),
              'name': 'Delete'
              }
            
            ]
        
        context['active'] = 'nav-workouts'
        context['rower'] = getrower(self.request.user)
        context['breadcrumbs'] = breadcrumbs

        return context
        
    
    def get_success_url(self):
        w = self.object.workout
        try:
            w = Workout.objects.get(id=w.id)
        except Workout.DoesNotExist:
            return reverse('workouts_view')
        
        return reverse('workout_edit_view',kwargs={'id':encoder.encode_hex(w.id)})

    def get_object(self, *args, **kwargs):
        obj = super(GraphDelete, self).get_object(*args, **kwargs)
        if not checkaccessuser(self.request.user,obj.workout.user):
            raise PermissionDenied('You are not allowed to delete this chart')

        return obj

def workout_code_delete_view(request,id=0):
    pk = encoder.decode_hex(id)

    url = reverse('workout_delete',kwargs={'pk':pk})

    return HttpResponseRedirect(url)
    
class WorkoutDelete(DeleteView):
    login_required = True
    model = Workout
    template_name = 'workout_delete_confirm.html'

    # extra parameters
    def get_context_data(self, **kwargs):
        context = super(WorkoutDelete, self).get_context_data(**kwargs)

        breadcrumbs = [
            {
                'url':'/rowers/list-workouts/',
                'name':'Workouts'
                },
            {
                'url':get_workout_default_page(self.request,encoder.encode_hex(self.object.id)),
                'name': encoder.encode_hex(self.object.id)
                },
            { 'url':reverse('workout_delete',kwargs={'pk':str(self.object.pk)}),
              'name': 'Delete'
              }
            
            ]

        mayedit=0
        promember=0
        if not self.request.user.is_anonymous:
            r = getrower(self.request.user)
            result = self.request.user.is_authenticated and ispromember(self.request.user)
            if result:
                promember=1
            if self.request.user == self.object.user.user:
                mayedit=1
        
        context['active'] = 'nav-workouts'
        context['rower'] = getrower(self.request.user)
        context['breadcrumbs'] = breadcrumbs
        context['workout'] = self.object
        context['mayedit'] = mayedit
        context['promember'] = promember
        
        return context
        
    
    def get_success_url(self):
        return reverse('workouts_view')

    def get_object(self, *args, **kwargs):
        obj = super(WorkoutDelete, self).get_object(*args, **kwargs)
        if not checkaccessuser(self.request.user,obj.user):
            raise PermissionDenied('You are not allowed to delete this workout')

        return obj