using imports.py on all external APIs

rowers/tpstuff.py

@@ -1,40 +1,12 @@
 # All the functionality needed to connect to Runkeeper
+from rowers.imports import *
 
 # Python
-import oauth2 as oauth
-import cgi
-import requests
-import requests.auth
-import json
-from django.utils import timezone
-from datetime import datetime
-from datetime import timedelta
-import numpy as np
-from dateutil import parser
-import time
-import pytz
-import math
 import gzip
-from math import sin,cos,atan2,sqrt
-import os,sys
-import urllib
+
 import base64
 from io import BytesIO
-from time import strftime
-# Django
-from django.shortcuts import render_to_response
-from django.http import HttpResponseRedirect, HttpResponse,JsonResponse
-from django.conf import settings
-from django.contrib.auth import authenticate, login, logout
-from django.contrib.auth.models import User
-from django.contrib.auth.decorators import login_required
-#from django.contrib import messages
 
-# Project
-# from .models import Profile
-from rowingdata import rowingdata
-import pandas as pd
-from rowers.models import Rower,Workout,checkworkoutuser
 
 from rowsandall_app.settings import (
     C2_CLIENT_ID, C2_REDIRECT_URI, C2_CLIENT_SECRET,
@@ -50,116 +22,35 @@ from django_rq import job
 import time
 from async_messages import message_user,messages
 
-
-
-
-from utils import geo_distance, NoTokenError,ewmovingaverage, custom_exception_handler
-
+oauth_data = {
+    'client_id': TP_CLIENT_ID,
+    'client_secret': TP_CLIENT_SECRET,
+    'redirect_uri': TP_REDIRECT_URI,
+    'autorization_uri': "https://oauth.trainingpeaks.com/oauth/authorize?",
+    'content_type': 'application/x-www-form-urlencoded',
+    'tokenname': 'tptoken',
+    'refreshtokenname': 'tprefreshtoken',
+    'expirydatename': 'tptokenexpirydate',
+    'bearer_auth': False,
+    'base_url': "https://oauth.trainingpeaks.com/oauth/token",
+    }
 
 
 # Checks if user has UnderArmour token, renews them if they are expired
 def tp_open(user):
-    r = Rower.objects.get(user=user)
-    if (r.tptoken == '') or (r.tptoken is None):
-	s = "Token doesn't exist. Need to authorize"
-	raise NoTokenError("User has no token")
-    else:
-	if (timezone.now()>r.tptokenexpirydate):
-	    res = do_refresh_token(r.tprefreshtoken)
-            if res[0] != 0:
-                r.tptoken = res[0]
-                r.tprefreshtoken = res[2]
-                expirydatetime = timezone.now()+timedelta(seconds=res[1])
-                r.tptokenexpirydate = expirydatetime
-                r.save()
-                thetoken = r.tptoken
-            else:
-                raise NoTokenError("Refresh token invalid")
-	else:
-	    thetoken = r.tptoken
-
-    return thetoken
+    return imports_open(user, oauth_data)
 
 # Refresh ST token using refresh token
 def do_refresh_token(refreshtoken):
-    client_auth = requests.auth.HTTPBasicAuth(TP_CLIENT_KEY, TP_CLIENT_SECRET)
-    post_data = {"grant_type": "refresh_token",
-		 "client_secret": TP_CLIENT_SECRET,
-		 "client_id":TP_CLIENT_KEY,
-		 "refresh_token": refreshtoken,
-		 }
-    headers = {'user-agent': 'sanderroosendaal',
-	       'Accept': 'application/json',
-	       'Content-Type': 'application/x-www-form-urlencoded',
-    }
-    
-
-    url = "https://oauth.trainingpeaks.com/oauth/token"
-    
-    response = requests.post(url,
-                             data=post_data,
-			     headers=headers)
-
-    if response.status_code == 200 or response.status_code == 201:
-        token_json = response.json()
-        thetoken = token_json['access_token']
-        expires_in = token_json['expires_in']
-        try:
-	    refresh_token = token_json['refresh_token']
-        except KeyError:
-	    refresh_token = refreshtoken
-    else:
-        return [0,0,0]
-
-            
-    return [thetoken,expires_in,refresh_token]
+    return imports_do_refresh_token(refreshtoken, oauth_data)
 
 # Exchange access code for long-lived access token
 def get_token(code):
-    client_auth = requests.auth.HTTPBasicAuth(TP_CLIENT_KEY, TP_CLIENT_SECRET)
-    post_data = {
-	"client_id":TP_CLIENT_KEY,
-        "grant_type": "authorization_code",
-        "code": code,
-        "redirect_uri":TP_REDIRECT_URI,
-	"client_secret": TP_CLIENT_SECRET,
-    }
-    headers = {
-	'Content-Type': 'application/x-www-form-urlencoded',
-    }
-    
-    response = requests.post("https://oauth.trainingpeaks.com/oauth/token",
-                             data=post_data)
-
-
-    try:
-        token_json = response.json()
-        thetoken = token_json['access_token']
-        expires_in = token_json['expires_in']
-        refresh_token = token_json['refresh_token']
-    except KeyError:
-        thetoken = 0
-        expires_in = 0
-        refresh_token = 0
-        
-    return thetoken,expires_in,refresh_token
+    return imports_get_token(code, oauth_data)
 
 # Make authorization URL including random string
 def make_authorization_url(request):
-    # Generate a random string for the state parameter
-    # Save it for use later to prevent xsrf attacks
-    from uuid import uuid4
-    state = str(uuid4())
-
-    params = {"client_id": TP_CLIENT_KEY,
-              "response_type": "code",
-              "redirect_uri": TP_REDIRECT_URI,
-              "scope": "file:write",
-	      }
-    url = "https://oauth.trainingpeaks.com/oauth/authorize?" +urllib.urlencode(params)
-
-    return HttpResponseRedirect(url)
-
+    return imports_make_authorization_url(oauth_data)
 
 
 def getidfromresponse(response):