sander/rowsandall
Private
Public Access
1
0
Fork 0
Code Activity

flow flush manual upload - still saving as private

Browse Source
This commit is contained in:
Sander Roosendaal
2025-10-21 22:41:52 +02:00
parent f8f4552355
commit fd9c00dcfe
4 changed files with 872 additions and 426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

438
rowers/views/workoutviews.py
View File

@@ -5264,16 +5264,10 @@ def workout_upload_view(request,
'upload_to_C2': False,
'plottype': 'timeplot',
'landingpage': 'workout_edit_view',
},
docformoptions={
'workouttype': 'rower',
},
raceid=0):
is_ajax = request.META.get('HTTP_X_REQUESTED_WITH') == 'XMLHttpRequest'
if settings.TESTING:
is_ajax = False
r = getrower(request.user)
if r.imports_are_private:
uploadoptions['makeprivate'] = True
@@ -5289,420 +5283,44 @@ def workout_upload_view(request,
}
]
if 'uploadoptions' in request.session:
uploadoptions = request.session['uploadoptions']
try:
_ = uploadoptions['landingpage']
except KeyError: # pragma: no cover
uploadoptions['landingpage'] = r.defaultlandingpage
else:
request.session['uploadoptions'] = uploadoptions
form = DocumentsForm(initial=uploadoptions)
optionsform = UploadOptionsForm(initial=uploadoptions,
request=request, raceid=raceid)
if 'docformoptions' in request.session:
docformoptions = request.session['docformoptions']
else:
request.session['docformoptions'] = docformoptions
makeprivate = uploadoptions.get('makeprivate', False)
make_plot = uploadoptions.get('make_plot', False)
workouttype = uploadoptions.get('WorkoutType', 'rower')
boattype = docformoptions.get('boattype', '1x')
try:
rpe = docformoptions['rpe']
try: # pragma: no cover
rpe = int(rpe)
except ValueError: # pragma: no cover
rpe = 0
if not rpe: # pragma: no cover
rpe = -1
except KeyError:
rpe = -1
notes = docformoptions.get('notes', '')
workoutsource = uploadoptions.get('workoutsource', None)
plottype = uploadoptions.get('plottype', 'timeplot')
landingpage = uploadoptions.get('landingpage', r.defaultlandingpage)
upload_to_c2 = uploadoptions.get('upload_to_C2', False)
upload_to_strava = uploadoptions.get('upload_to_Strava', False)
upload_to_st = uploadoptions.get('upload_to_SportTracks', False)
upload_to_tp = uploadoptions.get('upload_to_TrainingPeaks', False)
upload_to_intervals = uploadoptions.get('upload_to_Intervals', 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 form.is_valid() and optionsform.is_valid():
uploadoptions = form.cleaned_data.copy()
uploadoptions.update(optionsform.cleaned_data)
uploadoptions['secret'] = settings.UPLOAD_SERVICE_SECRET
uploadoptions['user'] = r.user.id
if request.FILES['file'] is not None:
filename, file_path = handle_uploaded_file(request.FILES['file'])
uploadoptions['file'] = file_path
if f is not None:
res = handle_uploaded_file(f)
else: # pragma: no cover
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']
try:
rpe = form.cleaned_data['rpe']
try:
rpe = int(rpe)
except ValueError:
rpe = 0
except KeyError: # pragma: no cover
rpe = -1
request.session['docformoptions'] = {
'workouttype': workouttype,
'boattype': boattype,
}
notes = form.cleaned_data['notes']
offline = form.cleaned_data['offline']
registrationid = 0
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_tp = optionsform.cleaned_data['upload_to_TrainingPeaks']
upload_to_intervals = optionsform.cleaned_data['upload_to_Intervals']
makeprivate = optionsform.cleaned_data['makeprivate']
landingpage = optionsform.cleaned_data['landingpage']
raceid = optionsform.cleaned_data['raceid']
try:
registrationid = optionsform.cleaned_data['submitrace']
except KeyError:
registrationid = 0
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_TrainingPeaks': upload_to_tp,
'upload_to_Intervals': upload_to_intervals,
'landingpage': landingpage,
'boattype': boattype,
'rpe': rpe,
'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,
rpe=rpe,
makeprivate=makeprivate,
title=t,
notes=notes,
)
response = upload_handler(uploadoptions, file_path)
if response["status"] not in ["processing"]:
messages.error(request, response["message"])
else:
uploadoptions['secret'] = settings.UPLOAD_SERVICE_SECRET
uploadoptions['user'] = r.user.id
uploadoptions['title'] = t
uploadoptions['file'] = f2
messages.info(request, response["message"])
url = settings.UPLOAD_SERVICE_URL
_ = myqueue(queuehigh,
handle_request_post,
url,
uploadoptions
)
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: # pragma: no cover
return JSONResponse({'result': 1, 'url': url})
else:
response = HttpResponseRedirect(url)
return response
if not id: # pragma: no cover
messages.error(request, message)
url = reverse('workout_upload_view')
if is_ajax: # pragma: no cover
return JSONResponse({'result': 0, 'url': url})
else:
response = HttpResponseRedirect(url)
return response
elif id == -1: # pragma: no cover
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: # pragma: no cover
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: # pragma: no cover
response = {'result': 1, 'url': url}
else:
response = HttpResponseRedirect(url)
r = getrower(request.user)
if (make_plot): # pragma: no cover
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')]
elif r.staticchartonupload is not None:
plottype = r.staticchartonupload
res, jobid = uploads.make_plot(r, w, f1, f2, plottype, t)
# upload to C2
if (upload_to_c2): # pragma: no cover
try:
c2integration = C2Integration(request.user)
id = c2integration.workout_export(w)
except NoTokenError:
id = 0
message = "Something went wrong with the Concept2 sync"
messages.error(request, message)
if (upload_to_strava): # pragma: no cover
strava_integration = StravaIntegration(request.user)
try:
id = strava_integration.workout_export(w)
except NoTokenError:
id = 0
message = "Please connect to Strava first"
messages.error(request, message)
if (upload_to_st): # pragma: no cover
st_integration = SportTracksIntegration(request.user)
try:
id = st_integration.workout_export(w)
except NoTokenError:
message = "Please connect to SportTracks first"
id = 0
messages.error(request, message)
if (upload_to_tp): # pragma: no cover
tp_integration = TPIntegration(request.user)
try:
id = tp_integration.workout_export(w)
except NoTokenError:
message = "Please connect to TrainingPeaks first"
messages.error(request, message)
if (upload_to_intervals):
intervals_integration = IntervalsIntegration(request.user)
try:
id = intervals_integration.workout_export(w)
except NoTokenError:
message = "Please connect to Intervals.icu first"
messages.error(request, message)
if int(registrationid) < 0: # pragma: no cover
race = VirtualRace.objects.get(id=-int(registrationid))
if race.sessiontype == 'race':
result, comments, errors, jobid = add_workout_race(
[w], race, r, doregister=True,
)
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)
elif race.sessiontype == 'indoorrace':
result, comments, errors, jobid = add_workout_indoorrace(
[w], race, r, doregister=True,
)
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)
elif race.sessiontype in ['fastest_time', 'fastest_distance']:
result, comments, errors, jobid = add_workout_fastestrace(
[w], race, r, doregister=True,
)
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 int(registrationid) > 0: # pragma: no cover
races = VirtualRace.objects.filter(
registration_closure__gt=timezone.now()
)
if raceid != 0:
races = VirtualRace.objects.filter(
registration_closure__gt=timezone.now(),
id=raceid,
)
registrations = IndoorVirtualRaceResult.objects.filter(
race__in=races,
id=registrationid,
userid=r.id,
)
registrations2 = VirtualRaceResult.objects.filter(
race__in=races,
id=registrationid,
userid=r.id,
)
if int(registrationid) in [r.id for r in registrations]: # pragma: no cover
# indoor race
registrations = registrations.filter(id=registrationid)
if registrations:
race = registrations[0].race
if race.sessiontype == 'indoorrace':
result, comments, errors, jobid = add_workout_indoorrace(
[w], race, r, recordid=registrations[0].id
)
elif race.sessiontype in ['fastest_time', 'fastest_distance']:
result, comments, errors, jobid = add_workout_fastestrace(
[w], race, r, recordid=registrations[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 int(registrationid) in [r.id for r in registrations2]: # pragma: no cover
# race
registrations = registrations2.filter(id=registrationid)
if registrations:
race = registrations[0].race
if race.sessiontype == 'race':
result, comments, errors, jobid = add_workout_race(
[w], race, r, recordid=registrations[0].id
)
elif race.sessiontype in ['fastest_time', 'fastest_distance']:
result, comments, errors, jobid = add_workout_fastestrace(
[w], race, r, recordid=registrations[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 registrationid != 0: # pragma: no cover
try:
url = reverse('virtualevent_view',
kwargs={
'id': race.id,
})
except UnboundLocalError:
if landingpage != 'workout_upload_view':
url = reverse(landingpage,
kwargs={
'id': encoder.encode_hex(w.id),
})
else: # pragma: no cover
url = reverse(landingpage)
elif landingpage != 'workout_upload_view': # pragma: no cover
url = reverse(landingpage,
kwargs={
'id': encoder.encode_hex(w.id),
})
else: # pragma: no cover
url = reverse(landingpage)
if is_ajax: # pragma: no cover
response = {'result': 1, 'url': url}
else:
response = HttpResponseRedirect(url)
# redirect to workouts_view
url = reverse('workouts_view')
return HttpResponseRedirect(url)
else:
if not is_ajax: # pragma: no cover
response = render(request,
'document_form.html',
{'form': form,
'teams': get_my_teams(request.user),
'optionsform': optionsform,
})
if is_ajax: # pragma: no cover
return JSONResponse(response)
else:
return response
else:
if not is_ajax:
form = DocumentsForm(initial=docformoptions)
optionsform = UploadOptionsForm(initial=uploadoptions,
request=request, raceid=raceid)
return render(request, 'document_form.html',
{'form': form,
'active': 'nav-workouts',
'breadcrumbs': breadcrumbs,
'teams': get_my_teams(request.user),
'optionsform': optionsform,
})
else: # pragma: no cover
return {'result': 0}
messages.error(request, "error")
return render(request, 'file_upload.html',
{'form': form,
'active': 'nav-workouts',
'breadcrumbs': breadcrumbs,
'teams': get_my_teams(request.user),
'optionsform': optionsform,
})
# This is the main view for processing uploaded files
@user_passes_test(ispromember, login_url="/rowers/paidplans", redirect_field_name=None,