diff --git a/rowers/integrations/__init__.py b/rowers/integrations/__init__.py index 89ea5f85..6677bbaa 100644 --- a/rowers/integrations/__init__.py +++ b/rowers/integrations/__init__.py @@ -1,2 +1,3 @@ from .c2 import C2Integration from .strava import StravaIntegration +from .nk import NKIntegration diff --git a/rowers/integrations/c2.py b/rowers/integrations/c2.py index 1d5d3ea4..69774d33 100644 --- a/rowers/integrations/c2.py +++ b/rowers/integrations/c2.py @@ -369,7 +369,6 @@ class C2Integration(SyncIntegration): # this part to get_workout_list workouts = self.get_workout_list(page=page) - counter = 0 for workout in workouts: c2id = workout['id'] if workout['new'] == 'NEW': diff --git a/rowers/integrations/integrations.py b/rowers/integrations/integrations.py index 4857f80f..03fb2a3a 100644 --- a/rowers/integrations/integrations.py +++ b/rowers/integrations/integrations.py @@ -38,24 +38,24 @@ class SyncIntegration(metaclass=ABCMeta): @abstractmethod - def createworkoutdata(w, *args, **kwargs): + def createworkoutdata(self, w, *args, **kwargs): return None @abstractmethod - def workout_export(workout, *args, **kwargs) -> str: + def workout_export(self, workout, *args, **kwargs) -> str: pass @abstractmethod - def get_workouts(*args, **kwargs) -> int: + def get_workouts(self, *args, **kwargs) -> int: pass @abstractmethod - def get_workout(id) -> int: + def get_workout(self, id) -> int: return 0 # need to unify workout list @abstractmethod - def get_workout_list(*args, **kwargs) -> list: + def get_workout_list(self, *args, **kwargs) -> list: return [] @abstractmethod @@ -71,7 +71,7 @@ class SyncIntegration(metaclass=ABCMeta): "scope": self.oauth_data['scope'], "state": state} - url = oauth_data['authorizaton_uri']+urllib.parse.urlencode(params) + url = self.oauth_data['authorizaton_uri']+urllib.parse.urlencode(params) return url diff --git a/rowers/integrations/nk.py b/rowers/integrations/nk.py new file mode 100644 index 00000000..80f73df6 --- /dev/null +++ b/rowers/integrations/nk.py @@ -0,0 +1,316 @@ +from .integrations import SyncIntegration, NoTokenError +from rowers.models import User, Rower, Workout, TombStone + +from rowingdata import rowingdata + +from rowers import mytypes +from rowers.nkimportutils import * +from rowers.tasks import handle_nk_async_workout +from rowsandall_app.settings import ( + NK_CLIENT_ID, NK_REDIRECT_URI, NK_CLIENT_SECRET, + SITE_URL, NK_API_LOCATION, NK_OAUTH_LOCATION, + UPLOAD_SERVICE_URL, UPLOAD_SERVICE_SECRET, +) + +import time +from time import strftime +import urllib +import requests +import arrow +from json.decoder import JSONDecodeError +from django.utils import timezone +from rowers.utils import dologging, uniqify, custom_exception_handler, myqueue + +from requests_oauthlib import OAuth2Session +from requests.auth import HTTPBasicAuth + +import django_rq +queue = django_rq.get_queue('default') +queuelow = django_rq.get_queue('low') +queuehigh = django_rq.get_queue('low') + +class NKIntegration(SyncIntegration): + def __init__(self, *args, **kwargs): + super(NKIntegration, self).__init__(self, *args, **kwargs) + self.oauth_data = { + 'client_id': NK_CLIENT_ID, + 'client_secret': NK_CLIENT_SECRET, + 'redirect_uri': NK_REDIRECT_URI, + 'autorization_uri': NK_OAUTH_LOCATION+"/oauth/authorize", + 'content_type': 'application/json', + 'tokenname': 'nktoken', + 'refreshtokenname': 'nkrefreshtoken', + 'expirydatename': 'nktokenexpirydate', + 'bearer_auth': True, + 'base_url': NK_OAUTH_LOCATION+"/oauth/token", + 'scope': 'read', + } + + def createworkoutdata(self, w, *args, **kwargs): + return None + + def workout_export(self, workout, *args, **kwargs) -> str: + return "" # there is no export + + def get_workouts(*args, **kwargs) -> int: + before = kwargs.get('before',0) + after = kwargs.get('after',0) + try: + _ = self.open() + except NoTokenError: # pragma: no cover + dologging("nklog.log","NK Token error for user {id}".format(id=rower.user.id)) + return 0 + + workouts = self.get_workout_list(before=before, after=after) + + for workout in workuots: + nkid = workout['id'] + if workout['new'] == 'NEW': + dologging('nklog.log','Queueing {id}'.format(id=nkid)) + self.get_workout(nkid) + + return 1 + + + def get_workout(self, id, *args, **kwargs) -> int: + startdate = kwargs.get('startdate','') + enddate = kwargs.get('enddate','') + _ = self.open() + r = self.rower + + before = 0 + after = 0 + if startdate: # pragma: no cover + startdate = arrow.get(startdate) + after = str(int(startdate.timestamp())*1000) + if enddate: # pragma: no cover + enddate = arrow.get(enddate) + before = str(int(enddate.timestamp())*1000) + + jsondata = self.get_workout_list_json(before=before, after=after) + + alldata = {} + + for item in jsondata: + alldata[item['id']] = item + + res = myqueue( + queuehigh, + handle_nk_async_workout, + alldata, + r.user.id, + r.nktoken, + id, + 0, + r.defaulttimezone, + ) + + return 1 + + + def get_workout_list_json(self, *args, **kwargs) -> dict: + before = kwargs.get('before',0) + after = kwargs.get('after',0) + + # For debugging + startdate = '2021-01-01' + enddate = '2021-06-01' + before = arrow.get(enddate) + before = str(int(before.timestamp()*1000)) + + after = arrow.get(startdate) + after = str(int(after.timestamp()*1000)) + + r = self.rower + authorizationstring = str('Bearer ' + r.nktoken) + headers = {'Authorization': authorizationstring, + 'user-agent': 'sanderroosendaal', + 'Content-Type': 'application/json', + } + + url = NK_API_LOCATION+"api/v1/sessions" + + params = { + 'after': after, + 'before': before, + } # start / end time + + res = requests.get(url, headers=headers, params=params) + if (res.status_code != 200): # pragma: no cover + raise NoTokenError("No NK Token") + + + return res.json() + + # need to unify workout list + def get_workout_list(self, *args, **kwargs) -> list: + _ = self.open() + r = self.rower + + before = kwargs.get('before',0) + after = kwargs.get('after',0) + + # ready to fetch. Hurray + if not before: # pragma: no cover + before = arrow.now()+timedelta(days=1) + before = str(int(before.timestamp())*1000) + if not after: # pragma: no cover + after = arrow.now()-timedelta(days=7) + after = str(int(after.timestamp())*1000) + + jsondata = self.get_workout_list_json(before=before,after=after) + + + # get NK IDs + nkids = [item['id'] for item in jsondata] + knownnkids = uniqify([ + w.uploadedtonk for w in Workout.objects.filter(user=r) + ]) + tombstones = [ + t.uploadedtonk for t in TombStone.objects.filter(user=r) + ] + parkedids = [] + try: + with open('nkblocked.json', 'r') as nkblocked: + try: + jsondatal = json.load(nkblocked) + except: + jsondatal = { + 'ids':[] + } + parkedids = jsondatal['ids'] + except FileNotFoundError: # pragma: no cover + pass + + knownnkids = uniqify(knownnkids+tombstones+parkedids) + workouts = [] + + + for item in jsondata: + d = int(float(item['totalDistanceGps'])) # could also be Impeller + i = item['id'] + n = item['name'] + if i in knownnkids: + nnn = '' + else: # pragma: no cover + nnn = 'NEW' + ttot = str(datetime.timedelta( + seconds=int(float(item['elapsedTime'])/1000.))) + s = arrow.get(item['startTime'], tzinfo=r.defaulttimezone).format( + arrow.FORMAT_RFC850) + keys = ['id', 'distance', 'duration', 'starttime', + 'rowtype', 'source', 'name','new'] + values = [i, d, ttot, s, None, None, n, nnn] + rs = dict(zip(keys, values)) + workouts.append(rs) + + workouts = workouts[::-1] + + return workouts + + + def make_authorization_url(self, *args, **kwargs) -> str: # pragma: no cover + state = str(uuid4()) + scope = "read" + params = { + "grant_type": "authorization_code", + "response_type": "code", + "client_id": NK_CLIENT_ID, + "scope": scope, + "state": state, + "redirect_uri": NK_REDIRECT_URI, + } + + url = NK_OAUTH_LOCATION+"/oauth/authorize?"+urllib.parse.urlencode(params) + return url + + + def get_token(self, code, *args, **kwargs) -> (str, int, str): + url = self.oauth_data['base_url'] + + post_data = {"client_id": self.oauth_data['client_id'], + "grant_type": "authorization_code", + "redirect_uri": self.oauth_data['redirect_uri'], + "code": code, + } + + response = requests.post( + url, + auth=HTTPBasicAuth(self.oauth_data['client_id'], + self.oauth_data['client_secret']), + data=post_data + ) + + if response.status_code != 200: + raise NoTokenError("Failed to obtain token") + + token_json = response.json() + + access_token = token_json['access_token'] + refresh_token = token_json['refresh_token'] + expires_in = token_json['expires_in'] + nk_owner_id = token_json['user_id'] + + return [access_token, expires_in, refresh_token] #, nk_owner_id] + + def open(self, *args, **kwargs) -> str: + r = self.rower + if (r.nktoken == '') or (r.nktoken is None): # pragma: no cover + raise NoTokenError("User has no token") + else: + if (timezone.now() > r.nktokenexpirydate): + thetoken = self.token_refresh() + if thetoken is None: # pragma: no cover + raise NoTokenError("User has no token") + return thetoken + else: + thetoken = r.nktoken + + return thetoken + + def do_refresh_token(self, *args, **kwargs): + post_data = {"grant_type": "refresh_token", + # "client_id":NK_CLIENT_ID, + "refresh_token": self.rower.nkrefreshtoken, + } + + url = self.oauth_data['base_url'] + + response = requests.post( + url, + data=post_data, + auth=HTTPBasicAuth( + self.oauth_data['client_id'], + self.oauth_data['client_secret'] + ) + ) + + if response.status_code != 200: # pragma: no cover + return [0, 0, 0] + + token_json = response.json() + + access_token = token_json['access_token'] + refresh_token = token_json['refresh_token'] + expires_in = token_json['expires_in'] + + return access_token, expires_in, refresh_token + + + def token_refresh(self, *args, **kwargs) -> str: + r = self.rower + access_token, expires_in, refresh_token = self.do_refresh_token() + + expirydatetime = timezone.now()+timedelta(seconds=expires_in) + + r.nktoken = access_token + r.nktokenexpirydate = expirydatetime + r.nkrefreshtoken = refresh_token + r.save() + + return r.nktoken + +# just as a quick test during development +u = User.objects.get(id=1) + +nk_integration_1 = NKIntegration(u) diff --git a/rowers/integrations/strava.py b/rowers/integrations/strava.py index 82cb0561..079bab33 100644 --- a/rowers/integrations/strava.py +++ b/rowers/integrations/strava.py @@ -338,7 +338,3 @@ class StravaIntegration(SyncIntegration): -# just as a quick test during development -u = User.objects.get(id=1) - -strava_integration_1 = StravaIntegration(u) diff --git a/rowers/management/commands/processemail.py b/rowers/management/commands/processemail.py index a89c1eb9..6769ae74 100644 --- a/rowers/management/commands/processemail.py +++ b/rowers/management/commands/processemail.py @@ -31,7 +31,6 @@ import rowers.polarstuff as polarstuff import rowers.rp3stuff as rp3stuff -import rowers.nkstuff as nkstuff from rowers.opaque import encoder from rowers.integrations import * from rowers.rower_rules import user_is_not_basic, user_is_coachee @@ -114,7 +113,8 @@ class Command(BaseCommand): for r in rowers: # pragma: no cover dologging("nklog.log","NK Auto import set for rower {id}".format(id=r.user.id)) if user_is_not_basic(r.user) or user_is_coachee(r.user): - _ = nkstuff.get_nk_workouts(r) + nk_integration = NKIntegration(r.user) + _ = nk_integration.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/tasks.py b/rowers/tasks.py index 5c318741..73e8e773 100644 --- a/rowers/tasks.py +++ b/rowers/tasks.py @@ -3086,7 +3086,6 @@ def handle_nk_async_workout(alldata, userid, nktoken, nkid, delaysec, defaulttim data = alldata[int(nkid)] except KeyError: return 0 - params = { 'sessionIds': nkid, } diff --git a/rowers/tests/test_imports.py b/rowers/tests/test_imports.py index 1d5a383a..8426aee5 100644 --- a/rowers/tests/test_imports.py +++ b/rowers/tests/test_imports.py @@ -716,10 +716,12 @@ class NKObjects(DjangoTestCase): csvfilename=filename ) - @patch('rowers.nkstuff.requests.get', side_effect=mocked_requests) - @patch('rowers.nkstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.get', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.post', side_effect=mocked_requests) def test_nk_list(self, mock_get, mockpost): - result = rowers.nkstuff.rower_nk_token_refresh(self.u) + integration = NKIntegration(self.u) + result = integration.token_refresh() + self.assertEqual(result,"TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq") response = self.c.get('/rowers/workout/nkimport/') @@ -742,16 +744,18 @@ class NKObjects(DjangoTestCase): ) self.assertTrue(res>0) - @patch('rowers.nkstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.post', side_effect=mocked_requests) def notest_nk_callback(self, mock_post): response = self.c.get('/nk_callback?code=absdef23&scope=read',follow=True) self.assertEqual(response.status_code, 200) - @patch('rowers.nkstuff.requests.get', side_effect=mocked_requests) - @patch('rowers.nkstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.get', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.post', side_effect=mocked_requests) def test_nk_get_workouts(self, mock_get, mockpost): - result = rowers.nkstuff.nk_open(self.u) + integration = NKIntegration(self.u) + result = integration.open() + self.assertEqual(result,"TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq") response = self.c.get('/rowers/workout/nkimport/all/',follow=True) @@ -763,15 +767,17 @@ class NKObjects(DjangoTestCase): self.assertEqual(response.status_code, 200) - @patch('rowers.nkstuff.requests.get', side_effect=mocked_requests) - @patch('rowers.nkstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.get', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.post', side_effect=mocked_requests) @patch('rowers.nkimportutils.requests.session', side_effect=mocked_session) @patch('rowers.dataprep.getsmallrowdata_db', side_effect=mocked_getsmallrowdata_db) def test_nk_import(self, mock_get, mock_post, mocked_session, mocked_getsmallrowdata_db): - result = rowers.nkstuff.rower_nk_token_refresh(self.u) + integration = NKIntegration(self.u) + result = integration.token_refresh() + response = self.c.get('/rowers/workout/nkimport/469',follow=True) expected_url = reverse('workout_nkimport_view') @@ -786,15 +792,16 @@ class NKObjects(DjangoTestCase): #self.assertEqual(w.inboard,0.89) #self.assertEqual(w.oarlength,2.87) - @patch('rowers.nkstuff.requests.get', side_effect=mocked_requests) - @patch('rowers.nkstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.get', side_effect=mocked_requests) + @patch('rowers.integrations.nk.requests.post', side_effect=mocked_requests) @patch('rowers.nkimportutils.requests.session', side_effect=mocked_session) @patch('rowers.dataprep.getsmallrowdata_db', side_effect=mocked_getsmallrowdata_db) def test_nk_import_impeller(self, mock_get, mock_post, mocked_session, mocked_getsmallrowdata_db): - result = rowers.nkstuff.rower_nk_token_refresh(self.u) + integration = NKIntegration(self.u) + result = integration.token_refresh() response = self.c.get('/rowers/workout/nkimport/404',follow=True) expected_url = reverse('workout_nkimport_view') diff --git a/rowers/tests/testdata/testdata.tcx.gz b/rowers/tests/testdata/testdata.tcx.gz index f5a12aad..8a8e14fa 100644 Binary files a/rowers/tests/testdata/testdata.tcx.gz and b/rowers/tests/testdata/testdata.tcx.gz differ diff --git a/rowers/views/importviews.py b/rowers/views/importviews.py index b454e031..953169bb 100644 --- a/rowers/views/importviews.py +++ b/rowers/views/importviews.py @@ -7,7 +7,7 @@ from rowers.views.statements import * from rowers.plannedsessions import get_dates_timeperiod from rowers.tasks import fetch_strava_workout -from rowers.integrations import C2Integration, StravaIntegration +from rowers.integrations import C2Integration, StravaIntegration, NKIntegration import rowers.integrations.strava as strava @@ -177,19 +177,9 @@ def rower_rojabo_authorize(request): # pragma: no cover # NK Logbook authorization @login_required() def rower_nk_authorize(request): # pragma: no cover - state = str(uuid4()) - scope = "read" - params = { - "grant_type": "authorization_code", - "response_type": "code", - "client_id": NK_CLIENT_ID, - "scope": scope, - "state": state, - "redirect_uri": NK_REDIRECT_URI, - } - - url = NK_OAUTH_LOCATION+"/oauth/authorize?"+urllib.parse.urlencode(params) - + nk_integration = NKIntegration(request.user) + url = nk_integration.make_authorization_url() + return HttpResponseRedirect(url) @@ -545,7 +535,8 @@ def rower_process_nkcallback(request): # pragma: no cover # do stuff try: code = request.GET.get('code', None) - res = nkstuff.get_token(code) + nk_integration = NKIntegration(request.user) + access_token, expires_in, refresh_token = nk_integration.get_token(code) except MultiValueDictKeyError: message = "The resource owner or authorization server denied the request" messages.error(request, message) @@ -553,7 +544,6 @@ def rower_process_nkcallback(request): # pragma: no cover url = reverse('rower_exportsettings_view') return HttpResponseRedirect(url) - access_token = res[0] if access_token == 0: message = res[1] message += ' Contact support@rowsandall.com if this behavior persists' @@ -563,16 +553,14 @@ def rower_process_nkcallback(request): # pragma: no cover return HttpResponseRedirect(url) - expires_in = res[1] - refresh_token = res[2] - nk_owner_id = res[3] + # nk_owner_id = res[3] expirydatetime = timezone.now()+datetime.timedelta(seconds=expires_in) r = getrower(request.user) r.nktoken = access_token r.nktokenexpirydate = expirydatetime r.nkrefreshtoken = refresh_token - r.nk_owner_id = nk_owner_id + # r.nk_owner_id = nk_owner_id r.save() @@ -594,16 +582,16 @@ def workout_getnkworkout_all(request, startdatestring='', enddatestring=''): after = arrow.get(startdate) after = str(int(after.timestamp()*1000)) + nk_integration = NKIntegration(request.user) try: - _ = nk_open(request.user) + _ = nk_integration.open() except NoTokenError: # pragma: no cover return HttpResponseRedirect("rower_nk_authorize") r = getrequestrower(request) - result = nkstuff.get_nk_workouts( - r, do_async=True, before=before, after=after) + result = nk_integration.get_workouts(before=before, after=after) if result: messages.info( @@ -624,125 +612,25 @@ def workout_nkimport_view(request, userid=0, after=0, before=0): startdate = startdate.date() enddate = enddate.date() r = getrequestrower(request, userid=userid) - #if r.user != request.user: # pragma: no cover - # messages.error( - # request, 'You can only access your own workouts on the NK Logbook, not those of your athletes') - # url = reverse('workout_nkimport_view', kwargs={ - # 'userid': request.user.id}) - # return HttpResponseRedirect(url) + nk_integration = NKIntegration(request.user) try: - _ = nk_open(r.user) + _ = nk_integration.open() except NoTokenError: # pragma: no cover return HttpResponseRedirect("/rowers/me/nkauthorize/") - if request.method == 'POST': # pragma: no cover - dateform = DateRangeForm(request.POST) - if dateform.is_valid(): - startdate = dateform.cleaned_data['startdate'] - enddate = dateform.cleaned_data['enddate'] + \ - datetime.timedelta(days=1) - else: - dateform = DateRangeForm(initial={ - 'startdate': startdate, - 'enddate': enddate, - }) - if enddate < startdate: # pragma: no cover - s = enddate - enddate = startdate - startdate = s - startdatestring = startdate.strftime('%Y-%m-%d') - enddatestring = enddate.strftime('%Y-%m-%d') + workouts = nk_integration.get_workout_list(before=0, after=0) - request.session['startdate'] = startdatestring - request.session['enddate'] = enddatestring - - before = arrow.get(enddate) - before = str(int(before.timestamp()*1000)) - - after = arrow.get(startdate) - after = str(int(after.timestamp()*1000)) - - res = nkstuff.get_nk_workout_list(r.user, before=before, after=after) - - if (res.status_code != 200): # pragma: no cover - if (res.status_code == 401): - r = getrower(request.user) - if (r.nktoken == '') or (r.nktoken is None): - s = "Token doesn't exist. Need to authorize" - return HttpResponseRedirect("/rowers/me/nkauthorize/") - message = "Something went wrong in workout_nkimport_view" - messages.error(request, message) - url = reverse('workouts_view') - return HttpResponseRedirect(url) - - # get NK IDs - nkids = [item['id'] for item in res.json()] - knownnkids = uniqify([ - w.uploadedtonk for w in Workout.objects.filter(user=r) - ]) - tombstones = [ - t.uploadedtonk for t in TombStone.objects.filter(user=r) - ] - parkedids = [] - try: - with open('nkblocked.json', 'r') as nkblocked: - try: - jsondata = json.load(nkblocked) - except: - jsondata = { - 'ids':[] - } - parkedids = jsondata['ids'] - except FileNotFoundError: # pragma: no cover - pass - - knownnkids = uniqify(knownnkids+tombstones+parkedids) - workouts = [] - - for item in res.json(): - d = int(float(item['totalDistanceGps'])) # could also be Impeller - i = item['id'] - n = item['name'] - if i in knownnkids: - nnn = '' - else: # pragma: no cover - nnn = 'NEW' - ttot = str(datetime.timedelta( - seconds=int(float(item['elapsedTime'])/1000.))) - s = arrow.get(item['startTime'], tzinfo=r.defaulttimezone).format( - arrow.FORMAT_RFC850) - keys = ['id', 'distance', 'duration', 'starttime', 'name', 'new'] - values = [i, d, ttot, s, n, nnn] - rs = dict(zip(keys, values)) - workouts.append(rs) - - workouts = workouts[::-1] if request.method == 'POST': # pragma: no cover try: tdict = dict(request.POST.lists()) ids = tdict['workoutid'] nkids = [int(id) for id in ids] - alldata = {} - - for item in res.json(): - alldata[item['id']] = item - counter = 0 for nkid in nkids: - _ = myqueue( - queue, - handle_nk_async_workout, - alldata, - r.user.id, - r.nktoken, - nkid, - counter, - r.defaulttimezone - ) - counter = counter+1 + _ = nk_integration.get_workout(nkid) messages.info( request, 'Your NK logbook workouts will be imported in the background.' @@ -765,17 +653,17 @@ def workout_nkimport_view(request, userid=0, after=0, before=0): checknew = request.GET.get('selectallnew', False) - return render(request, 'nk_list_import.html', + return render(request, 'list_import.html', { 'workouts': workouts, 'rower': r, - 'dateform': dateform, 'startdate': startdate, 'enddate': enddate, 'active': 'nav-workouts', 'breadcrumbs': breadcrumbs, 'teams': get_my_teams(request.user), 'checknew': checknew, + 'integration': 'NK Logbook' }) # Process Strava Callback @@ -1744,7 +1632,7 @@ importsources = { 'ownapi': ownapistuff, 'sporttracks': sporttracksstuff, 'trainingpeaks': tpstuff, - 'nk': nkstuff, + 'nk': NKIntegration, } diff --git a/rowers/views/statements.py b/rowers/views/statements.py index b56e8dfa..c5004b2d 100644 --- a/rowers/views/statements.py +++ b/rowers/views/statements.py @@ -192,9 +192,7 @@ import os import sys import datetime import iso8601 -import rowers.nkstuff as nkstuff import rowers.rojabo_stuff as rojabo_stuff -from rowers.nkstuff import nk_open from rowers.rp3stuff import rp3_open from rowers.sporttracksstuff import sporttracks_open from rowers.tpstuff import tp_open