def login():
client = Client()
authorize_url = client.authorization_url(
client_id=CONSTANTS.CLIENT_ID, redirect_uri=CONSTANTS.CALLBACK_URL)
# Have the user click the authorization URL,
# a 'code' param will be added to the redirect_uris
return jsonify({"status": "success", "url": authorize_url})
def __fetch_token(self):
host = '127.0.0.1'
port = 5000
client = Client()
url = client.authorization_url(
client_id=self.__client_id,
redirect_uri='http://127.0.0.1:5000/authorization')
print("follow this link (ctrl-c to cancel): {}".format(url))
client_id = self.__client_id
secret = self.__secret
class Handler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
code = urllib.parse.parse_qs(
urllib.parse.urlparse(self.path).query).get('code',
None)[0]
token = client.exchange_code_for_token(client_id=client_id,
client_secret=secret,
code=code)
keyring.set_password('bike2cern', 'strava', token)
s = http.server.HTTPServer((host, port), Handler)
try:
s.handle_request()
except KeyboardInterrupt:
pass
s.server_close()
def login():
c = Client()
url = c.authorization_url(client_id=app.config['STRAVA_CLIENT_ID'],
redirect_uri=url_for('.logged_in',
_external=True),
approval_prompt='auto')
return render_template('login.html', authorize_url=url)
def authenticate():
## Strava API uses OAuth2, which requires users to manually allow permission, which generates
## a token only valid for a number of hours.
## get API client id and secret from config file
config = configparser.ConfigParser()
config.read("credentials.cfg")
client_id = config.get('credentials', 'client_id')
client_secret = config.get('credentials', 'client_secret')
client = Client(rate_limiter=limiter.DefaultRateLimiter())
authorize_url = client.authorization_url(
client_id=client_id, redirect_uri='http://localhost:8282/authorized')
## getting token -- pretty manual process for now
webbrowser.open_new_tab(authorize_url)
code = input('Enter Temporary Code: ')
code = str(code)
## authenticate using API credntials + token
token_response = client.exchange_code_for_token(
client_id=client_id, client_secret=client_secret, code=code)
return client
def strava_authorize_url(page=None):
client = Client()
url = url_for('query.authorized', _external=True, page=page)
return client.authorization_url(
scope=['profile:read_all', 'activity:read_all'],
client_id=CLIENT_ID,
redirect_uri=url)
def make_authorization_url():
client = Client()
authorize_url = client.authorization_url(client_id=CLIENT_ID,
redirect_uri=REDIRECT_URI,
scope='view_private,write')
print(authorize_url)
return authorize_url
def get_authorization_url():
client = Client()
return client.authorization_url(
client_id=STRAVA_CLIENT_ID,
redirect_uri=url_for("authenticate", _external=True),
scope=["activity:write", "activity:read_all"],
)
def get_code(client_id: int) -> None:
"""Build an authorization URL"""
client = Client()
url = client.authorization_url(client_id = client_id, redirect_uri="http://localhost/get_the_code_parameter", scope=["read", "read_all", "profile:read_all", "profile:write", "activity:read","activity:read_all", "activity:write"])
print("[+] Authorization URL is: {}".format(url))
def login():
params = {
'client_id': CLIENT_ID,
'redirect_uri': HOSTNAME + '/oauth_authorized/'
}
client = Client()
url = client.authorization_url(**params)
return redirect(url)
def login():
params = {
'client_id': CLIENT_ID,
'redirect_uri': HOSTNAME + '/oauth_authorized/'
}
client = Client()
url = client.authorization_url(**params)
return redirect(url)
def auth(request):
client = Client()
auth_link = client.authorization_url(
5928, 'https://elevation-challenge.herokuapp.com/auth_success/')
return render(request, 'auth.html', {
'leaderboard': get_leaderboard(),
'auth_link': auth_link
})
def __init__(self, token):
if not token:
client = Client()
url = client.authorization_url(client_id=STRAVA_APP_ID, redirect_uri='http://localhost:8000/')
code = input(f"Open {url}, copy code once redirected: ")
token_response = client.exchange_code_for_token(client_id=STRAVA_APP_ID, client_secret=STRAVA_CLIENT_SECRET, code=code)
self.STRAVA_ACCESS_TOKEN = token_response['access_token']
else:
self.STRAVA_ACCESS_TOKEN = token
def create_authentication_token():
logger = logging.getLogger("authenticator.create_authentication_token")
client = Client()
logger.info(
"This is a one-time operation to generate the required authentication tokens for the app. Please follow the steps carefully"
)
logger.info("")
logger.info(
"Follow the instructions here: https://developers.strava.com/docs/getting-started/#account to create an 'API Application'"
)
logger.info(
"The important bits: Set the 'authorization callback domain' to 'localhost'"
)
logger.info(
"Make a note of the 'Client ID' and 'Client Secret' values (you may have to click 'show' to see the value of the secret"
)
logger.info("")
logger.info(
"Create a file called 'client.secret' and place it in the strava_data directory"
)
input("Once you have performed the above steps, hit enter")
MY_STRAVA_CLIENT_ID, MY_STRAVA_CLIENT_SECRET = open(
'/opt/strava_data/client.secret').read().strip().split(',')
logger.info(
'Client ID ({}) and secret read from file'.format(MY_STRAVA_CLIENT_ID))
url = client.authorization_url(
client_id=MY_STRAVA_CLIENT_ID,
redirect_uri='http://127.0.0.1:5000/authorization',
scope=[
'read_all', 'profile:read_all', 'activity:read_all',
'profile:write', 'activity:write'
])
logger.info("Open the following URL in a browser and approve access:")
logger.info(url)
auth_url_eg = "http://127.0.0.1:5000/authorization?state=&code=1e6878eb4b0175123e87bd8d708c40717448ac33&scope=read,activity:read_all,profile:read_all,read_all"
code_eg = "1e6878eb4b0175123e87bd8d708c40717448ac33"
logger.info(
"The re-directed URL will look something like this: {}, please enter just the 'code' value now e.g. {}"
.format(auth_url_eg, code_eg))
CODE = input()
access_token = client.exchange_code_for_token(
client_id=MY_STRAVA_CLIENT_ID,
client_secret=MY_STRAVA_CLIENT_SECRET,
code=CODE)
logger.info(
"Access_token: {}, outputting to local file".format(access_token))
with open('/opt/strava_data/access_token.pickle', 'wb') as f:
pickle.dump(access_token, f)
def auth():
access_token = request.cookies.get('access_token')
if access_token:
# Success!
return show_images_demo()
else:
client = Client()
url = client.authorization_url(client_id=MY_STRAVA_CLIENT_ID, redirect_uri=DOMAIN + '/authorization')
print("DEBUG: auth url :" + url)
return redirect(url, code=302)
def login():
c = Client()
url = c.authorization_url(
client_id=config['client_id'],
redirect_uri=url_for('.logged_in', _external=True),
approval_prompt='auto',
# Change to None if you don't want private activities included
# scope=['read', 'read_all', 'profile:read_all', 'profile:write', 'activity:read','activity:read_all', 'activity:write']
scope=['activity:read', 'activity:read_all', 'activity:write'])
return render_template('login.html', authorize_url=url)
def parse_args(args):
access_token_file_name = args.output_file
client = Client()
access_token_does_exist = os.path.isfile(access_token_file_name)
access_token_doesnt_exist = not (access_token_does_exist)
access_token_expired = True
if access_token_does_exist:
with open(access_token_file_name, "r") as f:
token_response = json.load(f)
token_response = json.loads(token_response)
token_expiry_time = token_response["expires_at"]
current_time = time.time()
access_token_expired = current_time > token_expiry_time
if access_token_doesnt_exist or access_token_expired:
client_id = args.client_id
client_secret = args.client_secret
scope = [
"read",
"read_all",
"profile:read_all",
"activity:read",
"activity:read_all",
]
authorize_url = client.authorization_url(
client_id=client_id,
redirect_uri="http://localhost:5000/authorized",
scope=scope,
)
# Open the authorization url
print("Opening: " + authorize_url)
webbrowser.open(authorize_url)
# Get code
entered_code = str(input("Please enter code: "))
# Exchange code for token:
token_response = client.exchange_code_for_token(
client_id=client_id, client_secret=client_secret, code=entered_code
)
# Save it to file so we can use it until it expires.
access_token_string = json.dumps(token_response)
with open(access_token_file_name, "w+") as f:
json.dump(access_token_string, f)
# Now we have a token_response dict either from file or from the
# Strava API
access_token = token_response["access_token"]
refresh_token = token_response["refresh_token"]
print("access_token:", access_token)
print("refresh_token", refresh_token)
def authenticate(self, host_url, state):
client = Client(requests_session=self.session)
# chop last character of host url to avoid double slash in middle of url
authorize_url = client.authorization_url(
client_id=self.CLIENT_ID,
redirect_uri=host_url[:-1] +
url_for('handle_strava_auth_response'),
state=state)
self.logger.info(
'Redirect: %s',
host_url[:-1] + url_for('handle_strava_auth_response'))
return redirect(authorize_url)
def index():
"""Home authentication page
"""
conn = get_conn()
client_id, client_secret = get_app_credentials(conn)
client = Client() # stravalib v3
auth_link = client.authorization_url(client_id, REDIRECT_URI, scope=AUTH_SCOPE)
title = "STRAVA buddies | Please log in to STRAVA"
conn.close()
return render_template("index.html", title=title, auth_link=auth_link,
tab="authenticate", examples=cached_athletes)
def get(self):
client = Client()
authorize_url = client.authorization_url(client_id=conf.SV_CLIENT_ID, redirect_uri=conf.SV_AUTH_URL)
template_values = {
'url': authorize_url,
'url_linktext': 'Connect with STAVA'
}
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
def get_stravauth_url(approval_prompt="auto", scope="write"):
from django.conf import settings
logger.info('get_stravauth_url begging')
client = Client()
authorize_url = client.authorization_url(
client_id=settings.CLIENT_ID,
redirect_uri=settings.STRAVA_REDIRECT,
approval_prompt=approval_prompt,
scope=scope)
# TODO: check scope and approval_prompt are reasonable
return authorize_url
def get_client():
client = Client()
authorize_url = client.authorization_url(
client_id=26273,
redirect_uri='https://localhost:8080',
scope=['read', 'read_all', 'activity:read_all'])
code = '299ad7943b6eb478247684620d87e341cfdcb6a2'
access_token = client.exchange_code_for_token(
client_id=26273,
client_secret='80f4236b6e958701dbeebb8c09c99e9d2fb71d1a',
code=code)
client.access_token = access_token['access_token']
return client
def get(request):
""" Request oauth via strava. """
client = Client()
return_uri = 'http://{}{}?start_date={}&end_date={}'.format(
request.META['HTTP_HOST'],
reverse_lazy('strava-authorized'),
request.GET.get('start_date'),
request.GET.get('end_date'),
)
authorize_url = client.authorization_url(
client_id=settings.STRAVA_CLIENT_ID,
redirect_uri=return_uri
)
return HttpResponseRedirect(authorize_url)
def index(request):
user = None
if (request.user.is_authenticated):
user = AuthUser.objects.get(user_id=request.user.id)
client = Client()
authorize_url = client.authorization_url(client_id=24429, redirect_uri="http://localhost:8000/main")
#get code from get
#Get Code from webapp response
code = request.GET.get('code') if (request.GET.get('code') != None) else ''
start_pos, end_pos, a_polyline = '', '', ''
if (code != '' and request.user.is_authenticated):
access_token = client.exchange_code_for_token(client_id=24429, client_secret=config_vars.STRAVA_CLIENT_SECRET, code=code)
user_model = AuthUser.objects.get(user_id=request.user.id)
# Store User Access Token in DB
if (user_model is not None):
user_model.auth_code = access_token
user_model.save()
# Set Access Token On Client
if (request.user.is_authenticated and user.auth_code != ''):
pprint("User Logged in and has an auth code")
client.access_token = user.auth_code
athlete = client.get_athlete()
full_activity = client.get_activity(1486441471, True)
a_polyline = full_activity.map.polyline
start_pos = full_activity.start_latlng
end_pos = full_activity.end_latlng
return render(request, "index.html", {
"auth_url": authorize_url,
"start_pos": start_pos,
"end_pos": end_pos,
"polyline": a_polyline,
"user_is_authenticated": request.user.is_authenticated
})
def authorize(self):
client = Client()
authorize_url = client.authorization_url(
client_id=9531, redirect_uri='http://127.0.0.1:5000/authorization')
# Have the user click the authorization URL, a 'code' param will be added to the redirect_uri
# .....
# Extract the code from your webapp response
# code = request.args.get('code') # or whatever your framework does
# access_token = client.exchange_code_for_token(client_id=9531, client_secret='111b5017534c4bd4049f8ff941790b0762b63701', code=code)
access_token = "990aa3bd5897c731ee759794edeecd7c058939de"
# Now store that access token somewhere (a database?)
client.access_token = access_token
athlete = client.get_athlete()
print("For {id}, I now have an access token {token}".format(
id=athlete.id, token=access_token))
athlete = client.get_athlete(227615)
print("Hello, {}".format(athlete.firstname))
def strava_client(client_id=None,
client_secret=None,
refresh_token=None,
access_token=None):
client = Client()
if access_token is None:
authorize_url = client.authorization_url(
client_id=client_id,
redirect_uri='http://localhost:8282/authorized',
scope='view_private,write')
logging.info("Go to %s" % (authorize_url))
code = raw_input("Code: ")
client.access_token = client.exchange_code_for_token(
client_id=client_id, client_secret=client_secret, code=code)
logging.info("Access Token = %s" % (client.access_token))
else:
client.access_token = access_token
return client
def main():
global leader_list
client = Client()
authorize_url = client.authorization_url(
client_id=16694, redirect_uri='http://localhost:8282/authorized')
access_token = '1a424f23c2b57360dab45e720a9a45bd0868f299'
client.access_token = access_token
rex = client.get_athlete(168768)
abdul = client.get_athlete(9954274)
addison = client.get_athlete(3070847)
jd = client.get_athlete(2903427)
leaders = client.get_segment_leaderboard(7769406)
for leader in leaders:
name = (str(leader.athlete_name))
leader_list.append(name)
print(leader_list)
def main():
user_id = input("user id: ")
access_token = input("access token: ")
client = Client(access_token)
#Build url or authorizing app
url = client.authorization_url(
client_id=user_id,
redirect_uri='http://127.0.0.1:5000/authorization',
approval_prompt='auto',
scope='activity:read_all')
print(url)
#Extract access code from url response
access_code = input("access code: ")
client_secret = input("client secret: ")
#Get permanent access token
permanent_access_token = client.exchange_code_for_token(
user_id, client_secret, access_code)
print(permanent_access_token)
class StrvaSignIn(StravaAuthSignIn):
def __init__(self):
super(StrvaSignIn, self).__init__('Strava')
self.StravaClient = Client()
def authorize(self):
return redirect(
self.StravaClient.authorization_url(
client_id=self.consumer_id,
redirect_uri=self.get_callback_url()))
def callback(self):
if 'code' not in request.args:
return None
access_token = self.StravaClient.exchange_code_for_token(
client_id=self.consumer_id,
client_secret=self.consumer_secret,
code=request.args['code'])
social_id = session['social_id']
user = User.query.filter_by(social_id=social_id).first()
user.stravatoken = access_token
self.StravaClient.access_token = access_token
user.athlete_id = self.StravaClient.get_athlete().id
db.session.commit()
a = Athlete.query.get(user.athlete_id)
if a is None:
dbathlete = Athlete(
id=user.athlete_id,
stravatoken=access_token,
firstname=self.StravaClient.get_athlete().firstname,
lastname=self.StravaClient.get_athlete().lastname)
db.session.add(dbathlete)
else:
dbathlete = Athlete.query.filter_by(id=user.athlete_id).first()
dbathlete.stravatoken = access_token
dbathlete.firstname = self.StravaClient.get_athlete().firstname
dbathlete.lastname = self.StravaClient.get_athlete().lastname
db.session.add(dbathlete)
db.session.commit()
return (user, self.StravaClient.get_athlete())
i += 1
print('{} activities written to mongodb'.format(i))
# id and port info
client_id = open('client.id')
client_secret = os.environ['STRAVA_CLIENT_SECRET']
access_token = os.environ['STRAVA_ACCESS_TOKEN']
port = 5000
url = 'http://localhost:%d/authorized' % port
if __name__ == '__main__':
# initialize stravalib client
client = Client()
authorize_url = client.authorization_url(client_id=client_id,
redirect_uri=url)
# get athlete
client.access_token = access_token
athlete = get_athlete(client)
# get activities for athlete
activities = get_activities(client, limit=10)
# initiate mongo database, connect, make collection
db_client = MongoClient(
'localhost', 27017) # Establish connection to persistent storage
db = db_client.Strava # Access/Initiate Database
coll_name = '{}_{}_user'.format(athlete.firstname, athlete.lastname)
collection = db[coll_name]
if "code" in q:
# Add the resulting code to global array
# checked by the while loop below.
code.extend(q["code"])
self.send_response(200)
self.end_headers()
self.wfile.write("Thanks! Now go back to your terminal. :-)")
else:
self.send_error(404)
# Port doesn't matter so let the kernel pick one.
httpd = SocketServer.TCPServer(("", 0), Handler)
port = httpd.server_address[1]
authorize_url = client.authorization_url(
client_id=APP["id"],
redirect_uri="http://localhost:%d/authorized" % port,
scope="write")
print "Now open the following URL and authorise this application."
print "Then Strava should send you to a localhost:%d URL handled by this script." % port
print "If that fails, rerun this script passing the code= value as an argument."
print
print authorize_url
# "code" gets updated once Strava calls us back.
while not code:
httpd.handle_request()
access_token = client.exchange_code_for_token(
client_id=APP["id"],
client_secret=APP["client_secret"], code=code)
class Strava(object):
def __init__(self):
self.client_id = current_app.config['STRAVA_CLIENT_ID']
self.client_secret = current_app.config['STRAVA_CLIENT_SECRET']
self.redirect_uri = url_for('strava.confirm_auth', _external=True)
self.client = StravaClient()
self._activity_type = 'ride' # rides or runs
self._activities = None
@property
def activity_type(self):
return self._activity_type
@activity_type.setter
def activity_type(self, value):
self._activity_type = value
self._activities = None
@property
def athlete(self):
return self.client.get_athlete()
@property
def activities(self):
if not self._activities:
# current_year = datetime.datetime.now().year
# after = datetime.datetime(current_year - 2, 12, 25)
self._activities = Activities(self.client.get_activities(),
self.activity_type)
return self._activities
@classmethod
def authorization_url(cls):
self = cls()
return self.client.authorization_url(client_id=self.client_id,
redirect_uri=self.redirect_uri)
def get_access_token(self, code):
return self.client.exchange_code_for_token(
client_id=self.client_id,
client_secret=self.client_secret,
code=code)
@classmethod
def athlete_by_code(cls, code):
self = cls()
self.client.access_token = self.get_access_token(code)
return self.athlete
@classmethod
def athlete_by_token(cls, token):
self = cls()
self.client.access_token = token
return self.athlete
@classmethod
def activities_by_token(cls, token):
self = cls()
self.client.access_token = token
return self.activities
@classmethod
def by_token(cls, token):
self = cls()
self.client.access_token = token
return self
def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Authenticate to the Strava API."""
from stravalib.client import Client
hass.http.register_view(StravaAuthCallbackView())
client_id = config.get(CONF_CLIENT_ID)
client_secret = config.get(CONF_CLIENT_SECRET)
client = Client()
config_path = hass.config.path(STRAVA_CONFIG_PATH)
@asyncio.coroutine
def _read_config():
if not os.path.isfile(config_path):
return None
with open(config_path, 'r') as auth_file:
config = json.load(auth_file)
if config['client_id'] == client_id:
return config['access_token']
@asyncio.coroutine
def _write_config():
with open(config_path, 'w') as auth_file:
json.dump(
{
'client_id': client_id,
'access_token': client.access_token,
}, auth_file)
@asyncio.coroutine
def _add_device():
strava = StravaSensor(hass, client)
yield from strava.async_update()
return async_add_devices([strava])
access_token = yield from _read_config()
if access_token is not None:
client.access_token = access_token
yield from _add_device()
else:
callback_url = '{}{}'.format(hass.config.api.base_url,
StravaAuthCallbackView.url)
authorize_url = client.authorization_url(client_id=client_id,
redirect_uri=callback_url)
configurator = hass.components.configurator
request_id = configurator.async_request_config(
'Strava',
description='Authorization required for Strava account.',
link_name='Authorize Home Assistant',
link_url=authorize_url,
entity_picture='/local/images/logo_strava.png')
@asyncio.coroutine
def initialize_callback(code):
"""Handle OAuth callback from Strava authorization flow."""
client.access_token = client.exchange_code_for_token(
client_id=client_id, client_secret=client_secret, code=code)
yield from _write_config()
yield from _add_device()
configurator.async_request_done(request_id)
hass.data[DATA_CALLBACK] = initialize_callback
return True
def get_strava_url():
client = Client()
cid = app.config['STRAVA_CLIENT_ID']
redirect = app.config['STRAVA_REDIRECT']
url = client.authorization_url(client_id=cid, redirect_uri=redirect)
print(url)
from stravalib.client import Client
client_id = 26296 # Replace this ID
client = Client()
url = client.authorization_url(
client_id=client_id,
redirect_uri='http://127.0.0.1:8000/authorization',
scope='view_private')
print(url)
import configparser
from stravalib.client import Client
cfg = configparser.ConfigParser()
cfg._interpolation = configparser.ExtendedInterpolation()
cfg.read("token_id.ini")
cfg.sections()
cfg.items('strava')
token_entry = cfg.get('strava', 'token_entry')
clientid = cfg.get('strava', 'clientid')
activity = cfg.get('strava', 'activity')
client = Client()
authorize_url = client.authorization_url(
clientid, redirect_uri='http://127.0.0.0.0:8100/authorized')
# Have the user click the authorization URL, a 'code' param will be added to the redirect_uri
client = Client(access_token=token_entry)
# Currently-authenticated (based on provided token) athlete
curr_athlete = client.get_athlete() # This is now me
# Saying hello
athlete = client.get_athlete()
print("Hello, {}".format(athlete.firstname))
# Showing the friends
athlete = client.get_athlete_clubs()
for a in athlete:
print("{} is your club.".format(a))
''' Script to grab activities from strava '''
import sys
import stravalib
from stravalib.client import Client
from configparser import SafeConfigParser
config = SafeConfigParser()
config.read('config.yaml')
client = Client()
authorize_url = client.authorization_url(
client_id=config.get('strava', 'client_id'),
redirect_uri='http://localhost:8282/authorized')
# Extract the code from your webapp response
# access_token = client.exchange_code_for_token(client_id=config.get('strava', 'client_id'), client_secret=config.get('strava', 'client_secret'), code=config.get('strava', 'code'))
# Now store that access token somewhere (a database?)
client.access_token = config.get('strava', 'Bearer')
athlete = client.get_athlete()
activities = client.get_activities(after="2017-11-17T00:00:00Z", limit=15)
activity_data = []
for activity in activities:
activity_stream = client.get_activity_streams(activity.id,
types=['latlng', 'distance'])
activity_data.append(activity_stream['latlng'].data)
# get a strava client
client = StravaClient()
# if we haven't authorized yet, let's do it:
if not token:
# get token from strava
client_id = cfg.get("StravaClient", "ClientId")
client_secret = cfg.get("StravaClient", "ClientSecret")
port = int(cfg.get("Application", "Port"))
# setup webserver for authentication redirect
httpd = http.server.HTTPServer(('127.0.0.1', port), AuthHandler)
# The url to authorize from
authorize_url = client.authorization_url(client_id=client_id, redirect_uri='http://localhost:{port}/authorized'.format(port=port), scope='view_private,write')
# Open the url in your browser
webbrowser.open(authorize_url, new=0, autoraise=True)
# wait until you click the authorize link in the browser
httpd.handle_request()
code = httpd.code
# Get the token
token = client.exchange_code_for_token(client_id=client_id, client_secret=client_secret, code=code)
# Now store that access token in the config
cfg.set("UserAcct", "Token", token)
with open("stravamng.cfg", "w") as cfg_file:
cfg.write(cfg_file)
# client_secret=MY_STRAVA_CLIENT_SECRET,
# code=code)
from stravalib.client import Client
# test = np.load('/home/lgum/BitBucket/STRONZO/efforts.npz')
with open('/home/lgum/BitBucket/STRONZO/credentials.json', 'r') as credentials_file:
credentials = json.load(credentials_file)
client = Client()
# authorize_url = client.authorization_url(client_id=10889082,
# redirect_uri='http://localhost:8282/authorized')
authorize_url = client.authorization_url(client_id=credentials['client_id'],
redirect_uri='http://localhost:8282/authorized')
# Have the user click the authorization URL, a 'code' param will be added to the redirect_uri
# .....
# Extract the code from your webapp response
# code = requests.get('code') # or whatever your framework does
access_token = str(credentials['access_token'])
# Now store that access token somewhere (a database?)
client.access_token = access_token
athlete = client.get_athlete()
# datetime.datetime(2005, 7, 14, 12, 30)
# start = datetime.datetime(2015, 10, 1, 0, 0)
# end = datetime.datetime(2015, 11, 20, 0, 0)
class Strava(object):
def __init__(self):
self.client_id = current_app.config['STRAVA_CLIENT_ID']
self.client_secret = current_app.config['STRAVA_CLIENT_SECRET']
self.redirect_uri = url_for('strava.confirm_auth', _external=True)
self.client = StravaClient()
self._activity_type = 'ride' # rides or runs
self._activities = None
@property
def activity_type(self):
return self._activity_type
@activity_type.setter
def activity_type(self, value):
self._activity_type = value
self._activities = None
@property
def athlete(self):
return self.client.get_athlete()
@property
def activities(self):
if not self._activities:
# current_year = datetime.datetime.now().year
# after = datetime.datetime(current_year - 2, 12, 25)
self._activities = Activities(self.client.get_activities(), self.activity_type)
return self._activities
@classmethod
def authorization_url(cls):
self = cls()
return self.client.authorization_url(client_id=self.client_id,
redirect_uri=self.redirect_uri)
def get_access_token(self, code):
return self.client.exchange_code_for_token(client_id=self.client_id,
client_secret=self.client_secret,
code=code)
@classmethod
def athlete_by_code(cls, code):
self = cls()
self.client.access_token = self.get_access_token(code)
return self.athlete
@classmethod
def athlete_by_token(cls, token):
self = cls()
self.client.access_token = token
return self.athlete
@classmethod
def activities_by_token(cls, token):
self = cls()
self.client.access_token = token
return self.activities
@classmethod
def by_token(cls, token):
self = cls()
self.client.access_token = token
return self
def auth(request):
client = Client()
auth_link = client.authorization_url(5928,'https://elevation-challenge.herokuapp.com/auth_success/')
return render(request, 'auth.html', {'leaderboard':get_leaderboard(), 'auth_link':auth_link})
