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

Merge branch 'release/v18.5.0'

Browse Source
This commit is contained in:
Sander Roosendaal
2022-04-28 15:22:34 +02:00
parent 2089901f71 9597cff5f5
commit 0d0128b766
14 changed files with 502 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
rowers/admin.py
View File

@@ -49,7 +49,9 @@ class RowerInline(admin.StackedInline):
'stravatoken', 'stravatokenexpirydate', 'stravarefreshtoken',
'stravaexportas', 'strava_auto_export',
'strava_auto_import',
'garmintoken', 'garminrefreshtoken')}),
'garmintoken', 'garminrefreshtoken',
'nktoken','nkrefreshtoken','nktokenexpirydate',
'rojabo_token','rojabo_refreshtoken','rojabo_tokenexpirydate')}),
('Team',
{'fields': ('friends', 'privacy', 'team')}),
)

18
rowers/c2stuff.py
View File

@@ -845,16 +845,16 @@ def get_c2_workout_list(user, page=1):
s = "Token expired. Needs to refresh."
return custom_exception_handler(401, s)
else:
# ready to fetch. Hurray
authorizationstring = str('Bearer ' + r.c2token)
headers = {'Authorization': authorizationstring,
'user-agent': 'sanderroosendaal',
'Content-Type': 'application/json'}
url = "https://log.concept2.com/api/users/me/results"
url += "?page={page}".format(page=page)
s = requests.get(url, headers=headers)
# ready to fetch. Hurray
authorizationstring = str('Bearer ' + r.c2token)
headers = {'Authorization': authorizationstring,
'user-agent': 'sanderroosendaal',
'Content-Type': 'application/json'}
url = "https://log.concept2.com/api/users/me/results"
url += "?page={page}".format(page=page)
s = requests.get(url, headers=headers)
return s

7
rowers/models.py
View File

@@ -1048,6 +1048,12 @@ class Rower(models.Model):
rp3_auto_import = models.BooleanField(default=False)
rojabo_token = models.CharField(
default='', max_length=200, blank=True, null=True)
rojabo_refreshtoken = models.CharField(
default='', max_length=200, blank=True, null=True)
rojabo_tokenexpirydate = models.DateTimeField(blank=True, null=True)
nktoken = models.TextField(
default='', max_length=1000, blank=True, null=True)
nktokenexpirydate = models.DateTimeField(blank=True, null=True)
@@ -2568,6 +2574,7 @@ class PlannedSession(models.Model):
)
manager = models.ForeignKey(User, on_delete=models.PROTECT)
rojabo_id = models.BigIntegerField(default=0,blank=True)
course = models.ForeignKey(GeoCourse, blank=True, null=True,
verbose_name='OTW Course', on_delete=models.SET_NULL)

197
rowers/rojabo_stuff.py Normal file
View File

@@ -0,0 +1,197 @@
from rowers.models import Rower, Workout, TombStone
from rowers import utils
import datetime
from rowers.imports import *
from rowsandall_app.settings import (
ROJABO_CLIENT_ID, ROJABO_REDIRECT_URI, ROJABO_CLIENT_SECRET,
SITE_URL, ROJABO_OAUTH_LOCATION,
UPLOAD_SERVICE_URL, UPLOAD_SERVICE_SECRET,
)
import gzip
import rowers.mytypes as mytypes
from rowers.utils import myqueue
import requests
import base64
from rowers.utils import dologging
from json.decoder import JSONDecodeError
import django_rq
queue = django_rq.get_queue('default')
queuelow = django_rq.get_queue('low')
queuehigh = django_rq.get_queue('low')
requests.packages.urllib3.disable_warnings()
oauth_data = {
'client_id': ROJABO_CLIENT_ID,
'client_secret': ROJABO_CLIENT_SECRET,
'redirect_uri': ROJABO_REDIRECT_URI,
'autorization_uri': ROJABO_OAUTH_LOCATION+"oauth/authorize",
'content_type': 'application/json',
'tokenname': 'nktoken',
'refreshtokenname': 'nkrefreshtoken',
'expirydatename': 'nktokenexpirydate',
'bearer_auth': True,
'base_url': ROJABO_OAUTH_LOCATION+"oauth/token",
'scope': 'read',
}
def get_token(code): # pragma: no cover
post_data = {
"grant_type": "authorization_code",
"code": code,
"redirect_uri": oauth_data['redirect_uri'],
}
auth_string = '{id}:{secret}'.format(
id=ROJABO_CLIENT_ID,
secret=ROJABO_CLIENT_SECRET
)
try:
headers = {'Authorization': 'Basic %s' % base64.b64encode(auth_string),
'Content-Type': 'application/x-www-form-urlencoded'}
except TypeError:
headers = {'Authorization': 'Basic %s' % base64.b64encode(
bytes(auth_string, 'utf-8')).decode('utf-8'),
'Content-Type': 'application/x-www-form-urlencoded'}
response = requests.post(oauth_data['base_url'],
data=post_data,
headers=headers)
if response.status_code != 200:
return (0,response.reason)
try:
token_json = response.json()
thetoken = token_json['access_token']
expires_in = token_json['expires_in']
refresh_token = token_json['refresh_token']
except (KeyError, JSONDecodeError) as e: # pragma: no cover
thetoken = 0
expires_in = 0
refresh_token = 0
return [thetoken, expires_in, refresh_token]
def rojabo_open(user):
r = Rower.objects.get(user=user)
if (r.rojabo_token == '') or (r.rojabo_token is None):
raise NoTokenError("User has no token")
else:
if (timezone.now() > r.rojabo_tokenexpirydate):
res = rower_rojabo_token_refresh(user)
if res is None: # pragma: no cover
raise NoTokenError("User has no token")
if res[0] is not None:
thetoken = res[0]
else: # pragma: no cover
raise NoTokenError("User has no token")
else:
thetoken = r.rojabo_token
return thetoken
def rower_rojabo_token_refresh(user):
r = Rower.objects.get(user=user)
res = do_refresh_token(r.rojabo_refreshtoken)
if res[0]:
access_token = res[0]
expires_in = res[1]
refresh_token = res[2]
expirydatetime = timezone.now()+timedelta(seconds=expires_in)
r = Rower.objects.get(user=user)
r.rojabo_token = access_token
r.rojabo_tokenexpirydate = expirydatetime
r.rojabo_refreshtoken = refresh_token
r.save()
return r.rojabo_token
else: # pragma: no cover
return None
def do_refresh_token(refreshtoken):
post_data = {
"grant_type": "refresh_token",
"refresh_token": refreshtoken,
"redirect_uri": oauth_data['redirect_uri'],
}
auth_string = '{id}:{secret}'.format(
id=ROJABO_CLIENT_ID,
secret=ROJABO_CLIENT_SECRET
)
try:
headers = {'Authorization': 'Basic %s' % base64.b64encode(auth_string),
'Content-Type': 'application/x-www-form-urlencoded'}
except TypeError:
headers = {'Authorization': 'Basic %s' % base64.b64encode(
bytes(auth_string, 'utf-8')).decode('utf-8'),
'Content-Type': 'application/x-www-form-urlencoded'}
response = requests.post(oauth_data['base_url'],
data=post_data,
headers=headers,
verify=False)
if response.status_code != 200:
return (0,response.reason)
try:
token_json = response.json()
thetoken = token_json['access_token']
expires_in = token_json['expires_in']
refresh_token = token_json['refresh_token']
except (KeyError, JSONDecodeError) as e: # pragma: no cover
thetoken = 0
expires_in = 0
refresh_token = 0
return [thetoken, expires_in, refresh_token]
aweekago = timezone.now()-timedelta(days=7)
today = timezone.now()
a_week_from_now = timezone.now()+timedelta(days=7)
def get_rojabo_workout_list(user,startdate=aweekago,enddate=a_week_from_now):
r = Rower.objects.get(user=user)
if (r.rojabo_token == '') or (r.rojabo_token is None): # pragma: no cover
s = "Token doesn't exist. Need to authorize"
return custom_exception_handler(401, s)
elif (timezone.now() > r.rojabo_tokenexpirydate): # pragma: no cover
s = "Token expired. Needs to refresh."
return custom_exception_handler(401, s)
_ = rojabo_open(user)
authorizationstring = str('Bearer ' + r.rojabo_token)
headers = {'Authorization': authorizationstring,
'Content-Type': 'application/json'}
date1 = startdate.strftime('%Y-%m-%d')
date2 = enddate.strftime('%Y-%m-%d')
url = ROJABO_OAUTH_LOCATION+'api/v1/training_sessions?from={date1}&to={date2}'.format(date1=date1,date2=date2)
response = requests.get(url, headers=headers)
return response

12
rowers/tasks.py
View File

@@ -3377,6 +3377,16 @@ def handle_c2_async_workout(alldata, userid, c2token, c2id, delaysec, defaulttim
return workoutid
@app.task
def fetch_rojabo_session(id,alldata,userid,rowerid,debug=False, **kwargs):
try:
item = alldata[id]
except KeyError:
return 0
return 1
@app.task
def fetch_strava_workout(stravatoken, oauth_data, stravaid, csvfilename, userid, debug=False, **kwargs):
@@ -3390,7 +3400,7 @@ def fetch_strava_workout(stravatoken, oauth_data, stravaid, csvfilename, userid,
if response.status_code != 200: # pragma: no cover
tstamp = time.localtime()
timestamp = time.strftime('%b-%d-%Y_%H%M', tstamp)
with open('strava_webhooks.log', 'a') as f:
with open('stravalog.log', 'a') as f:
f.write('\n')
f.write(timestamp)
f.write(' ')

5
rowers/templates/menu_plan.html
View File

@@ -66,6 +66,11 @@
<i class="far fa-calendar-plus fa-fw"></i>&nbsp;Add Session
</a>
</li>
<li id="import-rojabo">
<a href="/rowers/session/rojaboimport/">
<i class="fas fa-cloud-download fa-fw"></i>&nbsp;Import from Rojabo
</a>
</li>
<li id="plan-microcycle">
<a href="/rowers/sessions/multicreate/?when={{ timeperiod }}">
<i class="fas fa-expand fa-fw"></i>Plan Microcycle

59
rowers/templates/rojabo_list_import.html Normal file
View File

@@ -0,0 +1,59 @@
{% extends "newbase.html" %}
{% load static %}
{% load rowerfilters %}
{% block title %}sessions{% endblock %}
{% block main %}
<h1>Available on Rojabo</h1>
{% if sessions %}
<ul class="main-content">
<li class="grid_4">
<form enctype="multipart/form-data" method="post">
{% csrf_token %}
<input name='sessions' type="submit" value="Import selected sessions">
<a href="/rowers/session/rojaboimport/?selectallnew=true">Select All New</a>
<table width="70%" class="listtable">
<thead>
<tr>
<th> Import </th>
<th> Session</th>
<th> SPM</th>
<th> Points</th>
<th> Planned Date </th>
<th> New </th>
</tr>
</thead>
<tbody>
{% for session in sessions %}
<tr>
<td>
{% if session|lookuplong:'new' == 'NEW' and checknew == 'true' %}
<input checked type="checkbox" value={{ session|lookuplong:'id' }} name="sessionid">
{% else %}
<input type="checkbox" value={{ session|lookuplong:'id' }} name="sessionid">
{% endif %}
</td>
<td>{{ session|lookuplong:'name' }}</td>
<td>{{ session|lookuplong:'spm' }}</td>
<td>{{ session|lookuplong:'points' }}</td>
<td>{{ session|lookuplong:'date' }} </td>
<td>{{ session|lookuplong:'new' }} </td>
</tr>
{% endfor %}
</tbody>
</table>
</form>
</li>
</ul>
{% else %}
<p>
No sessions found
</p>
{% endif %}
{% endblock %}
{% block sidebar %}
{% include 'menu_plan.html' %}
{% endblock %}

10
rowers/templates/rower_exportsettings.html
View File

@@ -32,6 +32,10 @@
{% if rower.rp3token is not None and rower.rp3token != '' %}
RP3
{% endif %}
{% if rower.rojabo_token is not None and rower.rojabo_token != '' %}
Rojabo
{% endif %}
</p>
{% if form.errors %}
@@ -80,8 +84,10 @@
<p><a href="/rowers/me/garminauthorize"><img src="/static/img/garmin_badge_130.png"
alt="connect with Garmin" width="130"></a></p>
<p><a href="/rowers/me/rp3authorize"><img src="/static/img/logo-rp3-full-black.png"
alt="connect with RP3" width="130"></a></p>
<p><a href="/rowers/me/rp3authorize"><img src="/static/img/logo-rp3-full-black.png"
alt="connect with RP3" width="130"></a></p>
<p><a href="/rowers/me/rojaboauthorize"><img src="/static/img/rojabo.png"
alt="connect with Rojabo" width="130"></a></p>
{% endblock %}

4
rowers/urls.py
View File

@@ -598,6 +598,8 @@ urlpatterns = [
views.workout_rp3import_view, name='workout_rp3import_view'),
re_path(r'^workout/stravaimport/$', views.workout_stravaimport_view,
name='workout_stravaimport_view'),
re_path(r'^session/rojaboimport/$', views.workout_rojaboimport_view,
name='workout_rojaboimport_view'),
re_path(r'^workout/stravaimport/user/(?P<userid>\d+)/$',
views.workout_stravaimport_view, name='workout_stravaimport_view'),
re_path(r'^workout/c2import/all/$', views.workout_getc2workout_all,
@@ -757,6 +759,8 @@ urlpatterns = [
name='rower_c2_authorize'),
re_path(r'^me/nkauthorize/$', views.rower_nk_authorize,
name='rower_nk_authorize'),
re_path(r'^me/rojaboauthorize/$', views.rower_rojabo_authorize,
name='rower_rojabo_authorize'),
re_path(r'^me/polarauthorize/$', views.rower_polar_authorize,
name='rower_polar_authorize'),
re_path(r'^me/revokeapp/(?P<id>\d+)/$',

190
rowers/views/importviews.py
View File

@@ -1,4 +1,4 @@
from rowsandall_app.settings import NK_OAUTH_LOCATION
from rowsandall_app.settings import NK_OAUTH_LOCATION, ROJABO_OAUTH_LOCATION
from rowers.views.statements import *
from rowers.plannedsessions import get_dates_timeperiod
@@ -139,6 +139,23 @@ def workout_sporttracks_upload_view(request, id=0):
return HttpResponseRedirect(url) # pragma: no cover
# ROJABO authorization
def rower_rojabo_authorize(request): # pragma: no cover
state = str(uuid4())
scope = "read"
params = {
# "grant_type": "authorization_code",
# "response_type": "code",
"client_id": ROJABO_CLIENT_ID,
#"client_secret": ROJABO_CLIENT_SECRET,
# "scope": scope,
#"state": state,
"redirect_uri": ROJABO_REDIRECT_URI,
}
url = ROJABO_OAUTH_LOCATION+'oauth/authorize?'+urllib.parse.urlencode(params)
return HttpResponseRedirect(url)
# NK Logbook authorization
@login_required()
@@ -496,9 +513,47 @@ def rower_process_garmincallback(request): # pragma: no cover
url = reverse('rower_exportsettings_view')
return HttpResponseRedirect(url)
# Process Rojabo callback
@login_required()
def rower_process_rojabocallback(request): # prgrma: no cover
# do stuff
try:
code = request.GET.get('code', None)
res = rojabo_stuff.get_token(code)
except MultiValueDictKeyError:
message = "The resource owner or authorization server denied the request"
messages.error(request, message)
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'
messages.error(request, message)
url = reverse('rower_exportsettings_view')
return HttpResponseRedirect(url)
expires_in = res[1]
refresh_token = res[2]
expirydatetime = timezone.now()+datetime.timedelta(seconds=expires_in)
r = getrower(request.user)
r.rojabo_token = access_token
r.rojabo_tokenexpirydate = expirydatetime
r.rojabo_refreshtoken = refresh_token
r.save()
successmessage = "Tokens stored. Good to go. Please check your import/export settings"
messages.info(request, successmessage)
url = reverse('rower_exportsettings_view')
return HttpResponseRedirect(url)
# Process NK Callback
@login_required()
def rower_process_nkcallback(request): # pragma: no cover
# do stuff
@@ -974,6 +1029,133 @@ def workout_rp3import_view(request, userid=0):
'teams': get_my_teams(request.user)
})
# The page where you select which Strava workout to import
@login_required()
@user_passes_test(ispromember, login_url="/rowers/paidplans/",
message="This functionality requires a Pro plan or higher",
redirect_field_name=None)
@permission_required('rower.is_coach', fn=get_user_by_userid, raise_exception=True)
def workout_rojaboimport_view(request, message="", userid=0):
r = getrequestrower(request, userid=userid)
if r.user != request.user:
messages.error(
request, 'You can only access your own workouts on Rojabo, not those of your athletes')
url = reverse('workout_rojaboimport_view',
kwargs={'userid': request.user.id})
return HttpResponseRedirect(url)
try:
_ = rojabo_open(request.user)
except NoTokenError: # pragma: no cover
return HttpResponseRedirect("/rowers/me/rojaboauthorize/")
res = rojabo_stuff.get_rojabo_workout_list(request.user)
if (res.status_code != 200): # pragma: no cover
if (res.status_code == 401):
r = getrower(request.user)
if (r.stravatoken == '') or (r.stravatoken is None):
s = "Token doesn't exist. Need to authorize"
return HttpResponseRedirect("/rowers/me/rojaboauthorize/")
message = "Something went wrong in workout_rojaboimport_view"
messages.error(request, message)
url = reverse('workouts_view')
return HttpResponseRedirect(url)
sessions = []
r = getrower(request.user)
if request.method == "POST":
try:
tdict = dict(request.POST.lists())
ids = tdict['sessionid']
rojaboids = [int(id) for id in ids]
alldata = {}
for item in res.json():
alldata[item['training_session']['id']] = item['training_session']
for rojaboid in rojaboids:
try:
item = alldata[rojaboid]
name = item['workout']
spm = item['stroke']
points = item['points']
manager = userid
comment = 'ROJABO {name}, SPM: {spm}. Points: {points}'.format(
name = name,
points = points,
spm = spm,
)
preferreddate = datetime.datetime.strptime(item['training_date'],"%Y-%m-%d")
startdate = preferreddate
enddate = preferreddate
ps = PlannedSession(
name = item['workout'],
comment = comment,
startdate = startdate,
enddate = enddate,
preferreddate = preferreddate,
sessionsport = 'rower',
manager = request.user,
rojabo_id = rojaboid,
)
ps.save()
ps.rower.add(r)
ps.tags.add('ROJABO')
ps.save()
messages.info(request,'Saved planned session {id}'.format(id=ps.id))
except KeyError:
pass
except KeyError:
pass
rojabo_ids = [int(item['training_session']['id']) for item in res.json()]
knownrojaboids = uniqify([
ps.rojabo_id for ps in PlannedSession.objects.filter(manager=request.user)
])
for item in res.json():
i = item['training_session']['id']
if i in knownrojaboids:
nnn = ''
else:
nnn = 'NEW'
n = item['training_session']['workout']
spm = item['training_session']['stroke']
d = item['training_session']['training_date']
p = item['training_session']['points']
sessions.append({
'id':i,
'name':n,
'spm':spm,
'new':nnn,
'date': d,
'points': p,
})
breadcrumbs = [
{
'url': '/rowers/list-workouts/',
'name': 'Workouts'
},
{
'url': reverse('workout_rojaboimport_view'),
'name': 'Strava'
},
]
checknew = request.GET.get('selectallnew', False)
return render(request, 'rojabo_list_import.html',
{'sessions': sessions,
'rower': r,
'active': 'nav-plans',
'breadcrumbs': breadcrumbs,
'teams': get_my_teams(request.user),
'checknew': checknew,
})
# The page where you select which Strava workout to import
@login_required()
@@ -1566,8 +1748,6 @@ def workout_getrp3workout_all(request): # pragma: no cover
return HttpResponseRedirect(url)
# List of workouts available on Concept2 logbook - for 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)

7
rowers/views/statements.py
View File

@@ -190,6 +190,7 @@ import datetime
import iso8601
import rowers.c2stuff as c2stuff
import rowers.nkstuff as nkstuff
import rowers.rojabo_stuff as rojabo_stuff
from rowers.c2stuff import c2_open
from rowers.nkstuff import nk_open
from rowers.rp3stuff import rp3_open
@@ -197,8 +198,10 @@ from rowers.sporttracksstuff import sporttracks_open
from rowers.tpstuff import tp_open
from iso8601 import ParseError
import rowers.stravastuff as stravastuff
import rowers.rojabo_stuff as rojabo_stuff
import rowers.garmin_stuff as garmin_stuff
from rowers.stravastuff import strava_open
from rowers.rojabo_stuff import rojabo_open
import rowers.polarstuff as polarstuff
import rowers.sporttracksstuff as sporttracksstuff
@@ -218,7 +221,8 @@ from rowsandall_app.settings import (
BRAINTREE_MERCHANT_ID, BRAINTREE_PUBLIC_KEY, BRAINTREE_PRIVATE_KEY,
PAYMENT_PROCESSING_ON,
RECAPTCHA_SITE_KEY, RECAPTCHA_SITE_SECRET,
NK_REDIRECT_URI, NK_CLIENT_ID, NK_CLIENT_SECRET
NK_REDIRECT_URI, NK_CLIENT_ID, NK_CLIENT_SECRET,
ROJABO_REDIRECT_URI, ROJABO_CLIENT_ID, ROJABO_CLIENT_SECRET,
)
from django.contrib import messages
@@ -235,6 +239,7 @@ from rowers.rows import handle_uploaded_file, handle_uploaded_image
from rowers.plannedsessions import *
from rowers.tasks import handle_makeplot, handle_otwsetpower, handle_sendemailtcx, handle_sendemailcsv
from rowers.tasks import (
fetch_rojabo_session,
handle_sendemail_unrecognized, handle_sendemailnewcomment,
handle_request_post,
handle_sendemailsummary,

7
rowsandall_app/settings.py
View File

@@ -281,6 +281,13 @@ STRAVA_CLIENT_ID = CFG['strava_client_id']
STRAVA_CLIENT_SECRET = CFG['strava_client_secret']
STRAVA_REDIRECT_URI = CFG['strava_callback']
# ROJABO
ROJABO_CLIENT_ID = CFG['rojabo_client_id']
ROJABO_CLIENT_SECRET = CFG['rojabo_client_secret']
ROJABO_REDIRECT_URI = CFG['rojabo_callback']
ROJABO_OAUTH_LOCATION = CFG['rojabo_oauth_location']
# Garmin
GARMIN_CLIENT_KEY = CFG["garmin_client_key"]
GARMIN_CLIENT_SECRET = CFG['garmin_client_secret']

1
rowsandall_app/urls.py
View File

@@ -84,6 +84,7 @@ urlpatterns += [
# re_path(r'^admin/rq/',include('django_rq_dashboard.urls')),
re_path(r'^call\_back', rowersviews.rower_process_callback),
re_path(r'^nk\_callback', rowersviews.rower_process_nkcallback),
re_path(r'^rojabo\_callback', rowersviews.rower_process_rojabocallback),
re_path(r'^stravacall\_back', rowersviews.rower_process_stravacallback),
re_path(r'^garmin\_callback', rowersviews.rower_process_garmincallback),
re_path(r'^sporttracks\_callback', rowersviews.rower_process_sporttrackscallback),

BIN
static/img/rojabo.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 37 KiB