From 3420da47d7bad579b670a32f39a5a6f74a1c4716 Mon Sep 17 00:00:00 2001 From: Sander Roosendaal Date: Sat, 18 Feb 2023 17:16:54 +0100 Subject: [PATCH] polar passing tests --- rowers/integrations/__init__.py | 3 +- rowers/integrations/polar.py | 521 +++++++++++++++++++++ rowers/integrations/sporttracks.py | 8 +- rowers/management/commands/processemail.py | 8 +- rowers/tests/test_imports.py | 32 +- rowers/tests/testdata/testdata.tcx.gz | Bin 4000 -> 4000 bytes rowers/urls.py | 4 - rowers/views/importviews.py | 98 +--- rowers/views/statements.py | 1 - 9 files changed, 565 insertions(+), 110 deletions(-) create mode 100644 rowers/integrations/polar.py diff --git a/rowers/integrations/__init__.py b/rowers/integrations/__init__.py index 4e34497e..f68aed3e 100644 --- a/rowers/integrations/__init__.py +++ b/rowers/integrations/__init__.py @@ -4,7 +4,7 @@ from .nk import NKIntegration from .sporttracks import SportTracksIntegration from .rp3 import RP3Integration from .trainingpeaks import TPIntegration - +from .polar import PolarIntegration importsources = { 'c2': C2Integration, @@ -14,5 +14,6 @@ importsources = { 'nk': NKIntegration, 'tp':TPIntegration, 'rp3':RP3Integration, + 'polar': PolarIntegration } diff --git a/rowers/integrations/polar.py b/rowers/integrations/polar.py new file mode 100644 index 00000000..8b0b9768 --- /dev/null +++ b/rowers/integrations/polar.py @@ -0,0 +1,521 @@ +from rowers.rower_rules import ispromember +from .integrations import SyncIntegration +from rowers.models import User, Rower, Workout +from rowsandall_app.settings import ( + POLAR_CLIENT_ID, POLAR_REDIRECT_URI, POLAR_CLIENT_SECRET, UPLOAD_SERVICE_URL +) + +import urllib +import requests + +from rowers.utils import dologging, myqueue, NoTokenError +from django.utils import timezone + +from uuid import uuid4 +import base64 +from rowers.tasks import handle_request_post +from json.decoder import JSONDecodeError + +from rowers.opaque import encoder +import rowers.mytypes as mytypes + +from django.conf import settings + +import django_rq +queue = django_rq.get_queue('default') +queuelow = django_rq.get_queue('low') +queuehigh = django_rq.get_queue('high') + +baseurl = 'https://polaraccesslink.com/v3' + + +class PolarIntegration(SyncIntegration): + def __init__(self, *args, **kwargs): + if args[0] is not None: + super(PolarIntegration, self).__init__(*args, **kwargs) + + def get_notifications(self): + url = baseurl+'/notifications' + # state = str(uuid4()) + auth_string = '{id}:{secret}'.format( + id=POLAR_CLIENT_ID, + secret=POLAR_CLIENT_SECRET + ) + + try: + headers = {'Authorization': 'Basic %s' % base64.b64encode(auth_string)} + except TypeError: + headers = {'Authorization': 'Basic %s' % base64.b64encode( + bytes(auth_string, 'utf-8')).decode('utf-8')} + + try: + response = requests.get(url, headers=headers) + except ConnectionError: # pragma: no cover + response = { + 'status_code': 400, + } + + available_data = [] + + try: + if response.status_code == 200: + available_data = response.json()['available-user-data'] + dologging('polar.log', available_data) + else: # pragma: no cover + dologging('polar.log', response.status_code) + dologging('polar.log', response.text) + except AttributeError: # pragma: no cover + try: + dologging('polar.log', response.text) + except AttributeError: + pass + pass + + return available_data + + + def get_name(self): + return "Polar Flow" + + def get_shortname(self): + raise "polar" + + def createworkoutdata(self, w, *args, **kwargs): + raise NotImplementedError + + + def workout_export(self, workout, *args, **kwargs) -> str: + raise NotImplementedError + + def revoke_access(self): # pragma: no cover + user = self.user + headers = { + 'Authorization': 'Bearer {token}'.format(token=user.rower.polartoken) + } + + response = requests.delete('https://www.polaraccesslink.com/v3/users/{userid}'.format( + userid=user.rower.polaruserid + ), headers=headers) + + dologging('polar.log', response.text) + dologging('polar.log', response.reason) + + return 1 + + def get_polar_workouts(self, user): + r = Rower.objects.get(user=user) + + exercise_list = [] + + if (r.polartoken == '') or (r.polartoken is None): + s = "Token doesn't exist. Need to authorize" + return [] + elif (timezone.now() > r.polartokenexpirydate): # pragma: no cover + s = "Token expired. Needs to refresh" + dologging('polar.log', s) + return [] + + authorizationstring = str('Bearer ' + r.polartoken) + headers = {'Authorization': authorizationstring, + 'Accept': 'application/json'} + + headers2 = { + 'Authorization': authorizationstring, + } + + url = baseurl+'/users/{userid}/exercise-transactions'.format( + userid=r.polaruserid + ) + + response = requests.post(url, headers=headers) + dologging('polar.log', url) + dologging('polar.log', authorizationstring) + dologging('polar.log', str(response.status_code)) + + if response.status_code == 201: + transactionid = response.json()['transaction-id'] + url = baseurl+'/users/{userid}/exercise-transactions/{transactionid}'.format( + transactionid=transactionid, + userid=r.polaruserid + ) + + dologging('polar.log', url) + + response = requests.get(url, headers=headers) + if response.status_code == 200: + exerciseurls = response.json()['exercises'] + dologging('polar.log', exerciseurls) + for exerciseurl in exerciseurls: + response = requests.get(exerciseurl, headers=headers) + if response.status_code == 200: + exercise_dict = response.json() + tcxuri = exerciseurl+'/tcx' + response = requests.get(tcxuri, headers=headers2) + + if response.status_code == 200: + filename = 'media/mailbox_attachments/{code}_{id}.tcx'.format( + id=exercise_dict['id'], + code=uuid4().hex[:16] + ) + dologging('polar.log', filename) + + with open(filename, 'wb') as fop: + fop.write(response.content) + + workouttype = 'other' + try: + workouttype = mytypes.polaraccesslink_sports[ + exercise_dict['detailed-sport-info']] + except KeyError: # pragma: no cover + dologging( + 'polar.log', exercise_dict['detailed-sport-info']) + dologging('polar.log', workouttype) + try: + workouttype = mytypes.polarmappinginv[exercise_dict['sport'].lower( + )] + except KeyError: + dologging('polar.log', workouttype) + pass + + dologging('polar.log', workouttype) + + # post file to upload api + # TODO: add workouttype + uploadoptions = { + 'title': '', + 'workouttype': workouttype, + 'boattype': '1x', + 'user': user.id, + 'secret': settings.UPLOAD_SERVICE_SECRET, + 'file': filename, + 'title': '', + } + + url = settings.UPLOAD_SERVICE_URL + + dologging('polar.log', uploadoptions) + dologging('polar.log', url) + + _ = myqueue( + queuehigh, + handle_request_post, + url, + uploadoptions + ) + + dologging('polar.log', response.status_code) + if response.status_code != 200: # pragma: no cover + try: + dologging('polar.log', response.text) + except: + pass + try: + dologging('polar.log', response.json()) + except: + pass + + exercise_dict['filename'] = filename + else: # pragma: no cover + exercise_dict['filename'] = '' + + exercise_list.append(exercise_dict) + dologging('polar.log', str(exercise_dict)) + + # commit transaction + url = baseurl+'/users/{userid}/exercise-transactions/{transactionid}'.format( + transactionid=transactionid, + userid=r.polaruserid + ) + requests.put(url, headers=headers) + dologging( + 'polar.log', 'Committed transation at {url}'.format(url=url)) + + return exercise_list + + + def get_workouts(self, *args, **kwargs) -> int: + available_data = self.get_notifications() + polaruserid = self.rower.polaruserid + for record in available_data: + dologging('polar.log', str(record)) + + if record['data-type'] == 'EXERCISE': + try: + r = Rower.objects.get(polaruserid=record['user-id']) + u = r.user + if r.polar_auto_import and ispromember(u): + exercise_list = self.get_polar_workouts(u) + dologging('polar.log', exercise_list) + elif record['user-id'] == polaruserid: + exercise_list = self.get_polar_workouts(u) + except Rower.DoesNotExist: # pragma: no cover + pass + + return 1 + + def register_user(self, token): + _ = self.open() + + authorizationstring = 'Bearer {token}'.format(token=token) + headers = { + 'Content-Type': 'application/xml', + 'Authorization': authorizationstring, + 'Accept': 'application/json' + } + + payload = { + "member-id": encoder.encode_hex(self.user.id) + } + + headers = { + 'Content-Type': 'application/json', + 'Accept': 'application/json', + 'Authorization': 'Bearer {token}'.format(token=token) + } + + dologging('polar.log', 'Registering user') + + response = requests.post( + 'https://www.polaraccesslink.com/v3/users', + json=payload, + headers=headers + ) + + + + if response.status_code not in [200, 201]: # pragma: no cover + # dologging('polar.log',url) + dologging('polar.log', headers) + dologging('polar.log', payload) + dologging('polar.log', response.status_code) + dologging('polar.log', response.content) + try: + dologging('polar.log', response.reason) + dologging('polar.log', response.text) + except KeyError: + pass + + try: + jsondata = response.json() + if jsondata['error']['error_type'] == 'user_already_registered': + return jsondata + except: + pass + + return {} + + polar_user_data = response.json() + + return polar_user_data + + def get_polar_user_info(self, physical=False): # pragma: no cover + r = self.rower + _ = self.open() + + authorizationstring = str('Bearer ' + r.polartoken) + headers = { + 'Authorization': authorizationstring, + 'Accept': 'application/json' + } + + if not physical: + url = baseurl+'/users/{userid}'.format( + userid=r.polaruserid + ) + else: + url = 'https://www.polaraccesslink.com/v3/users/{userid}/physical-information-transactions/'.format( + userid=r.polaruserid + ) + + if physical: + response = requests.post(url, headers=headers) + else: + response = requests.get(url, headers=headers) + + return response + + + def get_workout(self, id, transaction_id) -> int: + r = self.rower + _ = self.open() + authorizationstring = str('Bearer ' + r.polartoken) + headers = { + 'Authorization': authorizationstring, + 'Accept': 'application/json' + } + + url = baseurl+'/users/{userid}/exercise-transactions'.format( + userid=r.polaruserid + ) + + response = requests.post(url, headers=headers) + + if response.status_code == 201: + transactionid = response.json()['transaction-id'] + url = baseurl+'/users/{userid}/exercise-transactions/{transactionid}'.format( + transactionid=transactionid, + userid=r.polaruserid + ) + + response = requests.get(url, headers=headers) + if response.status_code == 200: + exerciseurls = response.json()['exercises'] + for exerciseurl in exerciseurls: + response = requests.get(exerciseurl, headers=headers) + if response.status_code == 200: + exercise_dict = response.json() + thisid = exercise_dict['id'] + if thisid == id: + url = baseurl+'/users/{userid}/exercise-transactions/{transactionid}' \ + '/exercises/{exerciseid}/tcx'.format( + userid=r.polaruserid, + transactionid=transactionid, + exerciseid=id) + authorizationstring = str('Bearer ' + r.polartoken) + headers2 = { + 'Authorization': authorizationstring, + } + + response = requests.get(url, headers=headers2) + + if response.status_code == 200: + result = response.content + # commit transaction + url = baseurl+'/users/{userid}/exercise-transactions/{transactionid}'.format( + transactionid=transactionid, + userid=r.polaruserid + ) + response = requests.put(url, headers=headers) + dologging( + 'polar.log', 'Committing transaction on {url}'.format(url=url)) + else: # pragma: no cover + result = None + + return result + + + def get_workout_list(self, *args, **kwargs) -> list: + exercises = self.get_polar_workouts(self.user) + workouts = [] + try: + a = exercises.status_code + return [] + except: + return [] + + for exercise in exercises: + try: + d = exercise['distance'] + except KeyError: + d = 0 + + i = exercise['id'] + transactionid = exercise['transaction-id'] + starttime = exercise['start-time'] + rowtype = exercise['sport'] + durationstring = exercise['duration'] + duration = isodate.parse_duration(durationstring) + keys = ['id', 'distance', 'duration', + 'starttime', 'rowtype', 'source', 'name', 'new'] + values = [i, d, duration, starttime, rowtype, transactionid, '', ''] + res = dict(zip(keys, values)) + workouts.append(res) + + return workouts + + + def make_authorization_url(self, *args, **kwargs) -> str: # pragma: no cover + + state = str(uuid4()) + + params = {"client_id": POLAR_CLIENT_ID, + "response_type": "code", + # "redirect_uri": POLAR_REDIRECT_URI, + "state": state, + # "scope":"accesslink.read_all" + } + url = "https://flow.polar.com/oauth2/authorization?" + \ + urllib.parse.urlencode(params) + dologging('polar.log', 'Authorizing') + dologging('polar.log', url) + dologging('polar.log', params) + + return url + + def get_token(self, code, *args, **kwargs) -> (str, int, str): + post_data = {"grant_type": "authorization_code", + "code": code, + # "redirect_uri": POLAR_REDIRECT_URI, + } + + auth_string = '{id}:{secret}'.format( + id=POLAR_CLIENT_ID, + secret=POLAR_CLIENT_SECRET + ) + + try: + headers = {'Authorization': 'Basic %s' % base64.b64encode(auth_string)} + except TypeError: + headers = {'Authorization': 'Basic %s' % base64.b64encode( + bytes(auth_string, 'utf-8')).decode('utf-8')} + + dologging('polar.log', 'Getting token') + dologging('polar.log', post_data) + dologging('polar.log', auth_string) + + response = requests.post("https://polarremote.com/v2/oauth2/token", + data=post_data, + headers=headers) + + if response.status_code != 200: # pragma: no cover + dologging('polar.log', 'Getting token, got:') + dologging('polar.log', response.status_code) + dologging('polar.log', response.reason) + dologging('polar.log', response.text) + + try: + token_json = response.json() + thetoken = token_json['access_token'] + expires_in = token_json['expires_in'] + user_id = token_json['x_user_id'] + dologging('polar.log', response.status_code) + try: + dologging('polar.log', response.text) + except AttributeError: + pass + dologging('polar.log', token_json) + except (KeyError, JSONDecodeError) as e: # pragma: no cover + dologging('polar.log', e) + try: + dologging('polar.log', response.text) + except AttributeError: + pass + thetoken = 0 + expires_in = 0 + user_id = 0 + + return [thetoken, expires_in, user_id] + + + def open(self, *args, **kwargs) -> str: + r = self.rower + if (r.polartoken == '') or (r.polartoken is None): + s = "Token doesn't exist. Need to authorize" + raise NoTokenError(s) + elif (timezone.now() > r.polartokenexpirydate): + s = "Token expired. Needs to refresh" + raise NoTokenError(s) + + token = self.rower.polartoken + + return token + + + def token_refresh(self, *args, **kwargs) -> str: + raise NotImplementedError + +# just as a quick test during development +u = User.objects.get(id=1) + +nk_integration_1 = PolarIntegration(u) + diff --git a/rowers/integrations/sporttracks.py b/rowers/integrations/sporttracks.py index 1c65b4da..199f95a9 100644 --- a/rowers/integrations/sporttracks.py +++ b/rowers/integrations/sporttracks.py @@ -322,10 +322,4 @@ class SportTracksIntegration(SyncIntegration): def token_refresh(self, *args, **kwargs) -> str: return super(SportTracksIntegration, self).token_refresh(*args, **kwargs) - - -# just as a quick test during development -u = User.objects.get(id=1) - -nk_integration_1 = SportTracksIntegration(u) - + diff --git a/rowers/management/commands/processemail.py b/rowers/management/commands/processemail.py index 13e9dba9..593a4e9c 100644 --- a/rowers/management/commands/processemail.py +++ b/rowers/management/commands/processemail.py @@ -27,9 +27,6 @@ from rowingdata import rowingdata as rrdata import rowers.uploads as uploads -import rowers.polarstuff as polarstuff - - from rowers.opaque import encoder from rowers.integrations import * from rowers.rower_rules import user_is_not_basic, user_is_coachee @@ -77,8 +74,9 @@ class Command(BaseCommand): def handle(self, *args, **options): # Polar try: - polar_available = polarstuff.get_polar_notifications() - _ = polarstuff.get_all_new_workouts(polar_available) + polarintegration = PolarIntegration(None) + + _ = polarintegration.get_workouts() except: # pragma: no cover exc_type, exc_value, exc_traceback = sys.exc_info() lines = traceback.format_exception(exc_type, exc_value, exc_traceback) diff --git a/rowers/tests/test_imports.py b/rowers/tests/test_imports.py index e84c7404..e4baa269 100644 --- a/rowers/tests/test_imports.py +++ b/rowers/tests/test_imports.py @@ -15,7 +15,6 @@ import rowers from rowers import dataprep from rowers import tasks -from rowers import polarstuff import urllib import json @@ -875,39 +874,40 @@ class PolarObjects(DjangoTestCase): csvfilename=filename ) - @patch('rowers.polarstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.polarstuff.requests.get', side_effect=mocked_requests) + @patch('rowers.integrations.polar.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.polar.requests.get', side_effect=mocked_requests) def test_polar_auto_import(self, mock_get, mock_post): self.r.polar_auto_import = True self.r.save() + integration = PolarIntegration(self.r.user) + res = integration.get_workouts(self.r.user) + self.assertEqual(res,1) - res = polarstuff.get_polar_workouts(self.r.user) - self.assertEqual(len(res),2) - - @patch('rowers.polarstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.polarstuff.requests.get', side_effect=mocked_requests) + @patch('rowers.integrations.polar.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.polar.requests.get', side_effect=mocked_requests) def test_polar_callback(self, mock_get, mock_post): response = self.c.get('/polarflowcallback?code=abcdef&state=12sdss',follow=True) self.assertEqual(response.status_code,200) - @patch('rowers.polarstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.polarstuff.requests.get', side_effect=mocked_requests) + @patch('rowers.integrations.polar.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.polar.requests.get', side_effect=mocked_requests) def test_polar_notifications(self, mock_get, mock_post): - data = polarstuff.get_polar_notifications() + integration = PolarIntegration(self.r.user) + data = integration.get_notifications() self.assertEqual(data[0]['user-id'],475) - response = polarstuff.get_all_new_workouts(data) + response = integration.get_workouts() self.assertEqual(response,1) - @patch('rowers.polarstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.polarstuff.requests.get', side_effect=mocked_requests) + @patch('rowers.integrations.polar.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.polar.requests.get', side_effect=mocked_requests) def test_polar_get_workout(self, mock_get, mock_post): transaction_id = 240522162 id = 1937529874 - - response = polarstuff.get_polar_workout(self.u, id, transaction_id) + integration = PolarIntegration(self.u) + response = integration.get_workout(id, transaction_id) self.assertEqual(len(response),14836) diff --git a/rowers/tests/testdata/testdata.tcx.gz b/rowers/tests/testdata/testdata.tcx.gz index d33bfac882a7ba205c60b1f4120ffb56d654651d..8f8a0dc99dca2b5c97c3e1000a87574c6737bf2f 100644 GIT binary patch delta 3905 zcmV-H55DlAAD|xxABzYG<@xZD2OkxRnscdB7sogvkkujq8wHfj+p1$GkvkzUAK#sx z?7dlDY*uIM`*+d6-Mt?V?;O0i=vM31`uO2;-7ha5b$$0ow^{C`o!6WDk&G={2S@$t z&8mO@^Sgez&Nq1F1n)Mh&(83c&Dq8Af&g&w`_m`Sx2L$bT5tMpeY8wRZC3lc^FBE{ z>iX@kz0nQq>5qCt=H2GyUmy7Qu7B8_oL#Jzo5dUa>;3(Z@8A7r|7v-0 zclTxb`ti#{0(AF4?h(8|-nY0<&O}EX;co!@00)b-)5ravbmx1|`|hHDu{vGezx!9m zUS232`r@qbPV!;Tmq%yomzzUjf3Wy!>!$-At#)tF(`EXxn{=P~UcT7)Y44Bt4iUq_ z;_}m{9Udf6>yDRy|5&EG|F!FvKb@a$U(NpgdHN-nn;)-#T6X>Bm*vIN)%tb6{C9ul zN2JsI)}6dw9->Vb+5P$H3X5wlapmi$-MiK4>(l?!4T!tu2Clipm9HPKx36md{&4$N zEECzwEmt4p%Vm1NhlKet?*6_)@nUs+oNjH|zdCz)__SMpzwS;F#m}~0-Mc&b?`LDI=ouy3?@mt zSOs-tgVVr&o*#5Y+{snMJwZfpLBXAp-c*o#xH)&KOWv(i#N8QURE_d!h~R?U<7~J) zTM_q|I+_5U|0V?7yiF*<%jW+L%n+W&1 z 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 P&i?@Im=Xa5#DD<+Gyn3; delta 3905 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 diff --git a/rowers/urls.py b/rowers/urls.py index d448a193..6baf4b8d 100644 --- a/rowers/urls.py +++ b/rowers/urls.py @@ -624,10 +624,6 @@ urlpatterns = [ views.workout_import_view, name='workout_import_view'), re_path(r'^workout/(?P\w+.*)import/(?P\d+)/$', views.workout_getimportview, name='workout_getimportview'), - re_path(r'^workout/polarimport/$', views.workout_polarimport_view, - name='workout_polarimport_view'), - re_path(r'^workout/polarimport/user/(?P\d+)/', - views.workout_polarimport_view, name='workout_polarimport_view'), re_path(r'^workout/(?P[0-9A-Fa-f]+)/(?P[0-9A-za-z]+)uploadw/$', views.workout_export_view, name='workout_export_view'), re_path(r'^workout/(?P\b[0-9A-Fa-f]+\b)/recalcsummary/$', diff --git a/rowers/views/importviews.py b/rowers/views/importviews.py index 99dae081..06275ff1 100644 --- a/rowers/views/importviews.py +++ b/rowers/views/importviews.py @@ -76,21 +76,8 @@ def rower_garmin_authorize(request): # pragma: no cover # Polar Authorization @login_required() def rower_polar_authorize(request): # pragma: no cover - - state = str(uuid4()) - - params = {"client_id": POLAR_CLIENT_ID, - "response_type": "code", - # "redirect_uri": POLAR_REDIRECT_URI, - "state": state, - # "scope":"accesslink.read_all" - } - url = "https://flow.polar.com/oauth2/authorization?" + \ - urllib.parse.urlencode(params) - dologging('polar.log', 'Authorizing') - dologging('polar.log', url) - dologging('polar.log', params) - + integration = importsources['polar'](request.user) + url = integration.make_authorization_url() return HttpResponseRedirect(url) @login_required() @@ -166,8 +153,9 @@ def rower_process_twittercallback(request): # pragma: no cover @login_required() def rower_process_polarcallback(request): - + integration = importsources['polar'](request.user) error = request.GET.get('error', 'no error') + dologging('polar.log', 'Callback: {error}'.format(error=error)) if error != 'no error': # pragma: no cover messages.error(request, error) @@ -188,7 +176,7 @@ def rower_process_polarcallback(request): return HttpResponseRedirect(url) - access_token, expires_in, user_id = polarstuff.get_token(code) + access_token, expires_in, user_id = integration.get_token(code) expirydatetime = timezone.now()+datetime.timedelta(seconds=expires_in) r = getrower(request.user) r.polartoken = access_token @@ -198,12 +186,28 @@ def rower_process_polarcallback(request): r.save() if user_id: - polar_user_data = polarstuff.register_user(request.user, access_token) + polar_user_data = integration.register_user(access_token) else: # pragma: no cover messages.error(request, 'Polar Flow Authorization Failed') url = reverse('rower_exportsettings_view') return HttpResponseRedirect(url) + try: + error = polar_user_data['error'] + if error['error_type'] == 'user_already_registered': + s = error['message'] + tester = re.compile(r'.*userid:(?P\d+)') + testresult = tester.match(s) + if testresult: + user_id2 = testresult.group('id') + if user_id2 == str(user_id): + messages.info(request, + "Tokens stored. Good to go. Please check your import/export settings") + url = reverse('rower_exportsettings_view') + return HttpResponseRedirect(url) + + except KeyError: + pass try: user_id2 = polar_user_data['polar-user-id'] except KeyError: # pragma: no cover @@ -942,64 +946,6 @@ def garmin_details_view(request): return HttpResponse(status=200) -# the page where you select which Polar workout to Import -@login_required() -@permission_required('rower.is_coach', fn=get_user_by_userid, raise_exception=True) -@permission_required('rower.is_not_freecoach', fn=get_user_by_userid, raise_exception=True) -def workout_polarimport_view(request, userid=0): # pragma: no cover - exercises = polarstuff.get_polar_workouts(request.user) - workouts = [] - - try: - a = exercises.status_code - if a == 401: - messages.error( - request, 'Not authorized. You need to connect to Polar first') - url = reverse('workouts_view') - return HttpResponseRedirect(url) - except: # pragma: no cover - exercises = [] - pass - - for exercise in exercises: - try: - d = exercise['distance'] - except KeyError: - d = 0 - - i = exercise['id'] - transactionid = exercise['transaction-id'] - starttime = exercise['start-time'] - rowtype = exercise['sport'] - durationstring = exercise['duration'] - duration = isodate.parse_duration(durationstring) - keys = ['id', 'distance', 'duration', - 'starttime', 'type', 'transactionid'] - values = [i, d, duration, starttime, rowtype, transactionid] - res = dict(zip(keys, values)) - workouts.append(res) - - breadcrumbs = [ - { - 'url': '/rowers/list-workouts/', - 'name': 'Workouts' - }, - { - 'url': reverse('workout_polarimport_view'), - 'name': 'Polar' - }, - ] - - r = getrower(request.user) - - return render(request, 'polar_list_import.html', - { - 'workouts': workouts, - 'active': 'nav-workouts', - 'rower': r, - 'breadcrumbs': breadcrumbs, - 'teams': get_my_teams(request.user), - }) importauthorizeviews = { 'c2': 'rower_integration_authorize', diff --git a/rowers/views/statements.py b/rowers/views/statements.py index d0526ca8..a0ef5835 100644 --- a/rowers/views/statements.py +++ b/rowers/views/statements.py @@ -200,7 +200,6 @@ import rowers.rojabo_stuff as rojabo_stuff import rowers.garmin_stuff as garmin_stuff from rowers.rojabo_stuff import rojabo_open -import rowers.polarstuff as polarstuff from rowers.integrations import *