nk, not fully tested

rowers/integrations/__init__.py

@@ -1,2 +1,3 @@
 from .c2 import C2Integration
 from .strava import StravaIntegration
+from .nk import NKIntegration

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':

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
 

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)

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)

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)

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,
     }

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')

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,
 }
 
 

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