def authorization():
code = request.args.get('code')
client = Client()
token_response = client.exchange_code_for_token(
client_id=os.environ.get('CLIENT_ID'),
client_secret=os.environ.get('CLIENT_SECRET'),
code=code)
access_token = token_response['access_token']
client = Client(access_token=access_token)
athlete = client.get_athlete()
r_out = requests.get(API_BASE_URL + '/segments/' + LEGENDS_OUT +
'/all_efforts' + '?access_token=' + access_token)
legends_out_data = r_out.json()
r_back = requests.get(API_BASE_URL + '/segments/' + LEGENDS_BACK +
'/all_efforts' + '?access_token=' + access_token)
legends_back_data = r_back.json()
if (len(legends_out_data) == 0 or len(legends_back_data) == 0) and \
(int(athlete.id) != 13260725 and int(athlete.id) != 18685549):
return redirect(url_for('not_legend'))
# user is authorized at this point
response = redirect(url_for('chat'))
response.set_cookie('name', athlete.firstname + ' ' + athlete.lastname)
response.set_cookie('authcookie', os.environ.get('VERIFICATION_KEY'))
return response
def authorization():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
state = request.args.get('state')
if error:
return render_template('authorization_error.html', error=error)
else:
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id=app.config['STRAVA_CLIENT_ID'],
client_secret=app.config['STRAVA_CLIENT_SECRET'],
code=code)
# Use the now-authenticated client to get the current athlete
strava_athlete = client.get_athlete()
athlete_model = data.register_athlete(strava_athlete, access_token)
multiple_teams = None
no_teams = False
team = None
try:
team = data.register_athlete_team(strava_athlete=strava_athlete, athlete_model=athlete_model)
except bafs.exc.MultipleTeamsError as multx:
multiple_teams = multx.teams
except bafs.exc.NoTeamsError:
no_teams = True
return render_template('authorization_success.html', athlete=strava_athlete,
team=team, multiple_teams=multiple_teams,
no_teams=no_teams)
def do_GET(self):
request_path = self.path
parsed_path = urlparse.urlparse(request_path)
client = Client()
if request_path.startswith('/authorization'):
self.send_response(200)
self.send_header(six.b("Content-type"), six.b("text/plain"))
self.end_headers()
self.wfile.write(six.b("Authorization Handler\n\n"))
code = urlparse.parse_qs(parsed_path.query).get('code')
if code:
code = code[0]
token_response = client.exchange_code_for_token(client_id=self.server.client_id,
client_secret=self.server.client_secret,
code=code)
access_token = token_response['access_token']
self.server.logger.info("Exchanged code {} for access token {}".format(code, access_token))
self.wfile.write(six.b("Access Token: {}\n".format(access_token)))
else:
self.server.logger.error("No code param received.")
self.wfile.write(six.b("ERROR: No code param recevied.\n"))
else:
url = client.authorization_url(client_id=self.server.client_id,
redirect_uri='http://localhost:{}/authorization'.format(self.server.server_port))
self.send_response(302)
self.send_header(six.b("Content-type"), six.b("text/plain"))
self.send_header(six.b('Location'), six.b(url))
self.end_headers()
self.wfile.write(six.b("Redirect to URL: {}\n".format(url)))
def logged_in():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
state = request.args.get('state')
if error:
return render_template('login_error.html', error=error)
else:
#Requesting the authorization code to STRAVA
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(
client_id='30922',
client_secret='2791ad32fb846e9f5b567f0a0deba5bb168fe533',
code=code)
logger.info(access_token)
extractDataClub(client)
return render_template('segment_results.html',
segmentsPara=[],
segmentsNort=[],
segmentsCAM=[],
segmentsCAS=[])
def get_login_token():
last_activity = None
# auth_token = ""
if not os.path.exists(STRAVA_ACCESS_TOKEN_STRING_FNAME):
print '* Obtain a request token ...'
strava_client = Client()
# auth_url = strava_client.authorization_url(client_id='601', redirect_uri='http://127.0.0.1:5000/authorisation')
client_secret = open(STRAVA_CLIENT_SECRET_STRING_FNAME).read().strip()
print client_secret
client_code = open(STRAVA_CLIENT_CODE_STRING_NAME).read().strip()
print client_code
auth_token = strava_client.exchange_code_for_token(client_id='601',
client_secret= client_secret,
code = client_code)
print auth_token
f = open(STRAVA_ACCESS_TOKEN_STRING_FNAME, 'w')
f.write(auth_token)
else:
print '* Reading request token from file ...'
f = open(STRAVA_ACCESS_TOKEN_STRING_FNAME)
auth_token = f.read()
f.close()
print auth_token
return auth_token
def authorization():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
state = request.args.get('state')
if error:
return render_template('authorization_error.html', error=error)
else:
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id=app.config['STRAVA_CLIENT_ID'],
client_secret=app.config['STRAVA_CLIENT_SECRET'],
code=code)
# Use the now-authenticated client to get the current athlete
strava_athlete = client.get_athlete()
athlete_model = data.register_athlete(strava_athlete, access_token)
multiple_teams = None
no_teams = False
team = None
try:
team = data.register_athlete_team(strava_athlete=strava_athlete, athlete_model=athlete_model)
except bafs.exc.MultipleTeamsError as multx:
multiple_teams = multx.teams
except bafs.exc.NoTeamsError:
no_teams = True
return render_template('authorization_success.html', athlete=strava_athlete,
team=team, multiple_teams=multiple_teams,
no_teams=no_teams)
async def strava_callback(background_task: BackgroundTasks, code: str, scope: str, state: str = None):
client = Client()
token_response = client.exchange_code_for_token(
client_id=STRAVA_CLIENT_ID, client_secret=STRAVA_CLIENT_SECRET,
code=code)
client = Client(access_token=token_response['access_token'])
athlete = client.get_athlete()
try:
strava_athlete = await StravaAthlete.objects.get(id=athlete.id)
except orm_exceptions.NoMatch:
strava_athlete = await StravaAthlete.objects.create(
id=athlete.id,
access_token=token_response['access_token'],
refresh_token=token_response['refresh_token'],
token_expiration_datetime=datetime.utcfromtimestamp(token_response['expires_at']).isoformat())
background_task.add_task(new_athlete, strava_athlete)
response = RedirectResponse('/reports')
jwt_token = create_jwt_token(sub=strava_athlete.id)
response.set_cookie(
key="jwt_token",
value=jwt_token,
httponly=True)
return response
class Strava():
def __init__(self):
self.client = Client()
self.url = self.client.authorization_url(client_id=41952,
redirect_uri='https://strava2toggl.herokuapp.com/authorization')
def get_access_token(self, code):
self.code = code
s3 = S3Connection(os.environ['client_id'], os.environ['client_secret'])
self.access_token = self.client.exchange_code_for_token(client_id=os.environ['client_id'],
client_secret=os.environ['client_secret'],
code=self.code)
self.access_token = self.access_token['access_token']
self.client = Client(access_token=self.access_token)
return self.access_token
def get_activities(self, days, code):
dt1 = datetime.now()
dt2 = timedelta(days=days)
dt3 = dt1 - dt2
dt3 = dt3.strftime("%Y-%m-%dT%H:%M:%SZ")
client = Client(access_token=code)
activities = client.get_activities(after=dt3)
return activities
class strava_class(object):
def __init__(self):
self.client = Client()
def login_vegard(self):
MY_STRAVA_CLIENT_ID = 14139
MY_STRAVA_CLIENT_SECRET = 'd753993b6646b15440914a6477e0d0e594b6a5b5'
code = '3436d2f7d6b3926667097f39cb9d07eeb8fdc9d2'
access_token = self.client.exchange_code_for_token(
client_id=MY_STRAVA_CLIENT_ID,
client_secret=MY_STRAVA_CLIENT_SECRET,
code=code)
self.client.access_token = access_token
def login_other():
MY_Url = 'http://127.0.0.1:5000'
url = client.authorization_url(client_id=MY_STRAVA_CLIENT_ID,
redirect_uri=self.MY_Url)
#Start web server
#Get the user to click the link
#read out the code from web server
#stop web server
return 0
def get_last_week(self, lim):
for activity in self.client.get_activities(
after="2016-08-01T00:00:00Z", limit=lim):
print("{0.name} {0.moving_time}".format(activity))
def request_user_login():
print("Requesting user login")
client_id = get_string_from_file('client_id')
client_secret = get_string_from_file('client_secret')
client=Client()
LOGIN_URL = client.authorization_url(client_id=client_id, redirect_uri='http://localhost')
print(LOGIN_URL)
webbrowser.open(LOGIN_URL)
try:
auth_code = input("Enter the auth_code from the redirected URL: ")
write_string_to_file("auth_code", auth_code)
except EOFError:
print("Unable to read code from stdin. Assuming `auth_code` file is manually populated")
auth_code = get_string_from_file('auth_code')
token_response = client.exchange_code_for_token(client_id=client_id, client_secret=client_secret, code=auth_code)
write_string_to_file("access_token", token_response['access_token'])
write_string_to_file("refresh_token", token_response['refresh_token'])
print("Token expires at " + str(token_response['expires_at']))
check_if_access_token_valid()
def authenticate(self, code):
logger.info('StravaV3Backend.authenticate begging')
client_id = settings.CLIENT_ID
client_secret = settings.CLIENT_SECRET
# Make the request to the API
client = Client()
access_token = client.exchange_code_for_token(client_id=client_id, client_secret=client_secret, code=code)
athlete = client.get_athlete()
# username must be unique hence use id
username = "******" % (athlete.id , athlete.firstname, athlete.lastname)
# Get or create the user (returns tuple)
try:
user = User.objects.get(id=athlete.id)
except:
logger.error('User.objects.get failed')
user = User(id=athlete.id)
# Update username
logger.info('Update username: '******'Update token: '+access_token)
token_model.token = access_token
token_model.code = code
token_model.save()
logger.info(user)
# Return the user
return user
def logged_in():
error = request.args.get('error')
state = request.args.get('state')
try:
if error:
return render_template('login_error.html', error=error)
else:
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(
client_id=current_app.config['STRAVA_CLIENT_ID'],
client_secret=current_app.config['STRAVA_CLIENT_SECRET'],
code=code)
strava_athlete = client.get_athlete()
session.parmanent = True
session['access_token'] = access_token
return render_template('login_results.html',
athlete=strava_athlete,
access_token=access_token)
except Exception as e:
return render_template('login_error.html', error=str(e))
def authorize():
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id=STRAVA_CLIENT_ID,
client_secret=STRAVA_CLIENT_SECRET,
code=code)
tokens.insert_one({'token': access_token})
return render_template('success.html', token=access_token)
def authorize(request):
code = request.GET.get('code')
print("Code", code)
print(settings.STATIC_URL)
client = Client()
access_token = client.exchange_code_for_token(client_id=11103,
client_secret=settings.MYSECRETKEY,
code=code)
return HttpResponse('Your access token is {0}'.format(access_token))
def get_strava_token_from_code_id(config: ConfigParser) -> str:
""" Method that interchange the temporary authentication code obtained
when `src/request_auth.py` is executed. The method reads the file
`config/code_id.txt` that contains the temporal authentication and generates
the POST request to obtain the final access token which is saved in
`config/token.json`.
This method requires the Strava application `client_id` and `secret` that
has to be set in the configuration file (`config/config.ini`).
Args:
config (ConfigParser): app configuration.
Returns:
str: Strava access token.
Raises:
ValueError: If no token is found in the configuration.
"""
code_id_path = Path(CONFIG_PATH, CODE_ID_FILE_NAME)
if not code_id_path.is_file():
raise ValueError(
'The file with the temporal authentication code (`config/code_id.txt`)'
'was NOT found. Execute `request_auth.py` to obtain the temporal access.'
)
with open(code_id_path, 'r') as file:
logger.debug(
'The file with the temporal authentication code (`config/code_id.txt`)'
'was found.')
code_id = file.read()
if not code_id:
raise ValueError(
'No valid temporal code access found. Rerun `request_auth.py` '
'to obtain the temporal access.')
client = Client()
token = client.exchange_code_for_token(client_id=get_client_id(config),
client_secret=get_secret(config),
code=code_id)
logger.debug(
'Obtained access until {}:\n'
'- token: {}.'
'- refresh token: {}.',
datetime.utcfromtimestamp(int(
token['expires_at'])).strftime('%d-%m-%Y %H:%M:%S'),
token['access_token'], token['refresh_token'])
# Save JSON with the response
save_path = Path(check_folder(CONFIG_PATH), TOKEN_FILE_NAME)
with open(save_path, 'w') as file:
logger.info('Writing token information to `{}`.', save_path)
json.dump(token, file, indent=4)
return token['access_token']
def main():
""" Get access token from stravaupload.cfg """
config = ConfigParser()
config.read('./scripts/.stravaupload.cfg')
if config.has_option('access', 'clientid'):
client_id = config.get('access', 'clientid')
else:
print('No access/clientid found in .stravaupload.cfg')
sys.exit(0)
if config.has_option('access', 'token'):
access_token = config.get('access', 'token')
else:
print('No access/token found in .stravaupload.cfg')
sys.exit(0)
if config.has_option('access', 'clientsecret'):
client_secret = config.get('access', 'clientsecret')
else:
print('No access/clientsecret found in .stravaupload.cfg')
sys.exit(0)
""" Exchange code for token """
stravaClient = Client()
stravaClient.exchange_code_for_token(client_id=client_id,
client_secret=str(client_secret),
code=str(access_token))
""" Check if input is a single file or a directory """
if len(sys.argv) == 1:
''' Find directory where are stored TCX converted files '''
tcxDir = os.path.join(os.getcwd(), 'TCX_exports')
''' Set TCX pattern to finf files ending with .tcx '''
tcxPattern = os.path.join(tcxDir, '*.tcx')
filenames = glob.glob(tcxPattern)
if len(filenames) == 0:
sys.exit('No .tcx found in ' + str(sys.argv[1]) + ' directory')
else:
for idx, filename in enumerate(filenames):
uploadFile(stravaClient, filename)
elif os.path.isfile(sys.argv[1]):
uploadFile(stravaClient, sys.argv[1])
else:
sys.exit('usage: stravaupload.py <filename.tcx>')
def logged_in():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
state = request.args.get('state')
if error:
return render_template('login_error.html',
error=error,
competition_title=config.COMPETITION_TITLE)
else:
code = request.args.get('code')
client = Client()
token_dict = client.exchange_code_for_token(client_id=config.STRAVA_CLIENT_ID,
client_secret=config.STRAVA_CLIENT_SECRET,
code=code)
# Use the now-authenticated client to get the current athlete
strava_athlete = client.get_athlete()
athlete_model = data.update_athlete_auth(strava_athlete, token_dict)
if not athlete_model:
return render_template('login_error.html',
error="ATHLETE_NOT_FOUND",
competition_title=config.COMPETITION_TITLE)
multiple_teams = None
no_teams = False
team = None
message = None
try:
team = data.register_athlete_team(
strava_athlete=strava_athlete,
athlete_model=athlete_model,
)
except MultipleTeamsError as multx:
multiple_teams = multx.teams
message = multx
except NoTeamsError as noteamsx:
no_teams = True
message = noteamsx
if not no_teams:
auth.login_athlete(strava_athlete)
return redirect(url_for('user.rides'))
else:
return render_template(
'login_results.html',
athlete=strava_athlete,
team=team,
multiple_teams=multiple_teams,
no_teams=no_teams,
message=message,
competition_title=config.COMPETITION_TITLE,
)
def authorization():
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(
client_id=STRAVA_CLIENT_ID,
client_secret=STRAVA_CLIENT_SECRET,
code=code
)
bridge.token_got.emit(access_token)
return access_token
def strava_authorisation_view(request):
code = request.GET.get("code")
client = Client()
client_id = request.user.profile[0].strava_client_id
client_secret = request.registry.settings.get("strava.client_secret")
access_token = client.exchange_code_for_token(client_id=client_id,
client_secret=client_secret,
code=code)
request.user.profile[0].strava_access_key = access_token
request.session.flash("Authorized client", "success")
return HTTPFound(request.route_path("home"))
def add_user(code: str):
"""
Takes a temporary access code returned from Strava and retrieves the
associated user and access token. Then it checks for the user in the
database. If they're not found, then the new user is recorded. If they are
found, then just the access token is recorded in case it has changed.
"""
client = Client()
if not Config.TESTING:
response = client.exchange_code_for_token(
client_id=Config.CLIENT_ID,
client_secret=Config.CLIENT_SECRET,
code=code,
)
current_app.logger.debug("Response: " + str(response))
client.access_token = response["access_token"]
access_token = response["access_token"]
refresh_token = response["refresh_token"]
access_expr = datetime.fromtimestamp(response["expires_at"])
athlete = client.get_athlete()
user_id = athlete.id
first_name = athlete.firstname
else:
access_token = "access"
refresh_token = "refresh"
access_expr = datetime.now() - timedelta(hours=5)
user_id = 1
first_name = "joe"
# noinspection PyArgumentList
# Check if the user is already in the db
if User.query.get(user_id) is None:
u = User(
id=user_id,
first_name=first_name,
access_token=access_token,
refresh_token=refresh_token,
access_expr=access_expr,
)
db.session.add(u)
db.session.commit()
current_app.logger.info(f"New user added: {user_id}")
else:
u = User.query.get(user_id)
u.access_token = access_token
u.refresh_token = refresh_token
u.access_expr = access_expr
db.session.commit()
current_app.logger.info(
f"User {user_id} already found; updating token, logging in,"
" and redirecting to dashboard"
)
return u
def do_GET(self):
request_path = self.path
parsed_path = urlparse.urlparse(request_path)
client = Client()
if request_path.startswith('/authorization'):
self.send_response(200)
self.send_header(six.b("Content-type"), six.b("text/plain"))
self.end_headers()
self.wfile.write(six.b("Authorization Handler\n\n"))
code = urlparse.parse_qs(parsed_path.query).get('code')
if code:
code = code[0]
token_response = client.exchange_code_for_token(
client_id=self.server.client_id,
client_secret=self.server.client_secret,
code=code)
access_token = token_response['access_token']
refresh_token = token_response['refresh_token']
expires_at = token_response['expires_at']
self.server.logger.info(
"Exchanged code {} for access token {}".format(
code, access_token))
self.wfile.write(
six.b("Access Token: {}\n".format(access_token)))
self.wfile.write(
six.b("Refresh Token: {}\n".format(refresh_token)))
self.wfile.write(six.b("Expires at: {}\n".format(expires_at)))
with open('strava_token.txt', 'w') as f:
f.write(self.server.client_id + '\n')
f.write(self.server.client_secret + '\n')
f.write(access_token + '\n')
f.write(refresh_token + '\n')
f.write(str(expires_at) + '\n')
else:
self.server.logger.error("No code param received.")
self.wfile.write(six.b("ERROR: No code param recevied.\n"))
else:
url = client.authorization_url(
client_id=self.server.client_id,
redirect_uri='http://localhost:{}/authorization'.format(
self.server.server_port),
scope='activity:write')
self.send_response(302)
self.send_header(six.b("Content-type"), six.b("text/plain"))
self.send_header(six.b('Location'), six.b(url))
self.end_headers()
self.wfile.write(six.b("Redirect to URL: {}\n".format(url)))
def getToken(MY_STRAVA_CLIENT_ID, MY_STRAVA_CLIENT_SECRET):
access_token = session.get('access_token')
if access_token != None:
return access_token
# the code is in the results thingy!
code = request.args.get('code')
if code == None:
return None
client = Client()
access_token = client.exchange_code_for_token(client_id=MY_STRAVA_CLIENT_ID,\
client_secret=MY_STRAVA_CLIENT_SECRET,\
code=code)
session['access_token'] = access_token
return access_token
def getToken():
access_token = session.get('access_token')
if access_token != None:
return access_token
# the code is in the results thingy!
code = request.args.get('code')
if code == None:
return None
client = Client()
access_token = client.exchange_code_for_token(client_id=MY_STRAVA_CLIENT_ID,\
client_secret=MY_STRAVA_CLIENT_SECRET,\
code=code)
session['access_token'] = access_token
return access_token
def authorization():
my_client_id = app.vars['client_id']
my_client_secret = app.vars['client_secret']
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id = my_client_id, \
client_secret = my_client_secret, code = code)
app.vars['access_token'] = access_token
my_client = StravaClient()
app.vars['athlete'] = my_client.get_athlete()
return redirect('power_profile')
def lambda_handler(event, context):
code = event['code']
exchange_mode, exchange_opt = event['state'].split('-')
client = Client()
access_token = client.exchange_code_for_token(
client_id=os.environ.get('STRAVA_CLIENT_ID'),
client_secret=os.environ.get('STRAVA_CLIENT_SECRET'),
code=code)
if exchange_mode == 'REDIRECT':
return {
'location':
f'http://127.0.0.1:{exchange_opt}?access_token={access_token}'
}
def strava_authorize(request):
code = request.GET.get('code')
scopes = request.GET.get('scope', '').split(',')
if not code or 'activity:read_all' not in scopes or 'activity:write' not in scopes:
return HttpResponseRedirect(settings.URL_FRONT+'/new')
client = StravaClient()
access_token = client.exchange_code_for_token(
client_id=settings.MY_STRAVA_CLIENT_ID,
client_secret=settings.MY_STRAVA_CLIENT_SECRET,
code=code
)
user_settings = request.user.settings
user_settings.strava_access_token = json.dumps(access_token)
user_settings.save()
return HttpResponseRedirect(settings.URL_FRONT + '/new')
def authorization():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
if error:
return render_template('authorization_error.html',
error=error,
competition_title=config.COMPETITION_TITLE)
else:
code = request.args.get('code')
client = Client()
token_dict = client.exchange_code_for_token(
client_id=config.STRAVA_CLIENT_ID,
client_secret=config.STRAVA_CLIENT_SECRET,
code=code,
)
# Use the now-authenticated client to get the current athlete
strava_athlete = client.get_athlete()
athlete_model = data.register_athlete(strava_athlete, token_dict)
multiple_teams = None
no_teams = False
team = None
message = None
try:
team = data.register_athlete_team(
strava_athlete=strava_athlete,
athlete_model=athlete_model,
)
except MultipleTeamsError as multx:
multiple_teams = multx.teams
message = multx
except NoTeamsError as noteamx:
no_teams = True
message = noteamx
return render_template(
'authorization_success.html',
athlete=strava_athlete,
team=team,
multiple_teams=multiple_teams,
no_teams=no_teams,
message=message,
competition_title=config.COMPETITION_TITLE,
)
def get_activities_from_strava():
last_activity = None
if not os.path.exists(STRAVA_ACCESS_TOKEN_STRING_FNAME):
print '* Obtain a request token ...'
strava_client = Client()
auth_url = strava_client.authorization_url(client_id='601', redirect_uri='http://127.0.0.1:5000/authorisation')
print auth_url
auth_token = strava_client.exchange_code_for_token(client_id='601', client_secret='600580e02b4814c75c93d3a60e15077147895776', code = '74cc257e6bc370d9da44cabc8852f3667ad95515')
print auth_token
# write the access token to file; next time we just read it from file
if DEBUG:
print 'Writing file', STRAVA_ACCESS_TOKEN_STRING_FNAME
fobj = open(STRAVA_ACCESS_TOKEN_STRING_FNAME, 'w')
fobj.write(auth_token)
fobj.close()
else:
if DEBUG:
print 'Reading file', STRAVA_ACCESS_TOKEN_STRING_FNAME
fobj = open(STRAVA_ACCESS_TOKEN_STRING_FNAME)
access_token_string = fobj.read()
print access_token_string
#access_token = oauth.OAuthToken.from_string(access_token_string)
strava_client = Client(access_token=access_token_string)
activities = strava_client.get_activities(limit=10)
# for activity in activities:
# details = strava_client.get_activity(activity_id=activity.id)
# print details.name
# print unithelper.kilometers(details.distance)
# print details.start_date_local
# print details.elapsed_time
# print details.calories
# print details.type
# print "------"
# fobj.close()
for activity in activities:
last_activity = activity
return strava_client.get_activity(activity_id=activity.id)
def authorization(request):
'''
Trades in the `code` sent from Strava for an `access_token`.
Ties that `access_token` to a users session.
'''
code = request.GET.get('code', None)
client = Client()
access_token = client.exchange_code_for_token(
client_id=os.environ.get('STRAVA_CLIENT_ID', None),
client_secret=os.environ.get('STRAVA_CLIENT_SECRET', None),
code=code
)
request.session['access_token'] = access_token
return redirect(index)
def logged_in():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
state = request.args.get('state')
if error:
return render_template('login_error.html', error=error)
else:
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(
client_id=app.config['STRAVA_CLIENT_ID'],
client_secret=app.config['STRAVA_CLIENT_SECRET'],
code=code)
# Use the now-authenticated client to get the current athlete
strava_athlete = client.get_athlete()
athlete_model = meta.session_factory().query(Athlete).get(
strava_athlete.id)
if not athlete_model:
return render_template('login_error.html',
error="ATHLETE_NOT_FOUND")
multiple_teams = None
no_teams = False
team = None
try:
team = data.register_athlete_team(strava_athlete=strava_athlete,
athlete_model=athlete_model)
except MultipleTeamsError as multx:
multiple_teams = multx.teams
except NoTeamsError:
no_teams = True
if not no_teams:
auth.login_athlete(strava_athlete)
return redirect(url_for('user.rides'))
else:
return render_template('login_results.html',
athlete=strava_athlete,
team=team,
multiple_teams=multiple_teams,
no_teams=no_teams)
def authorize_strava():
if request.args.get('state') and request.args.get('code'):
id = request.args.get('state')
strava_code = request.args.get('code')
strava_client_id = current_app.config['STRAVA_CLIENT_ID']
strava_client_secret = current_app.config['STRAVA_CLIENT_SECRET']
strava_client = Client()
try:
access_token = (
strava_client.exchange_code_for_token(
client_id=strava_client_id,
client_secret=strava_client_secret,
code=strava_code))
except Exception:
return redirect(url_for('racer.index'))
else:
racer = Racer.query.get_or_404(id)
strava_client = Client(access_token)
strava_athlete = strava_client.get_athlete()
existing_racer = Racer.query\
.filter_by(strava_id=strava_athlete.id)\
.first()
if existing_racer:
flash('Racer ' + existing_racer.name +
' already linked with Strava account for ' +
strava_athlete.firstname + ' ' +
strava_athlete.lastname + '!')
current_app.logger.info('%s[%d] failed against %s[%d]',
racer.name, racer.id,
existing_racer.name, existing_racer.id)
return redirect(url_for('racer.details', id=id))
else:
racer.strava_access_token = access_token
racer.strava_id = strava_athlete.id
racer.strava_email = strava_athlete.email
racer.profile_url = strava_athlete.profile
db.session.commit()
current_app.logger.info('%s[%d]', racer.name, racer.id)
flash('Racer ' + racer.name + ' linked with Strava!')
return redirect(url_for('racer.details', id=id))
return redirect(url_for('racer.index'))
def authorize_strava():
if request.args.get('state') and request.args.get('code'):
id = request.args.get('state')
strava_code = request.args.get('code')
strava_client_id = current_app.config['STRAVA_CLIENT_ID']
strava_client_secret = current_app.config['STRAVA_CLIENT_SECRET']
strava_client = Client()
try:
access_token = (
strava_client.exchange_code_for_token(
client_id=strava_client_id,
client_secret=strava_client_secret,
code=strava_code))
except Exception:
return redirect(url_for('racer.index'))
else:
racer = Racer.query.get_or_404(id)
strava_client = Client(access_token)
strava_athlete = strava_client.get_athlete()
existing_racer = Racer.query\
.filter_by(strava_id=strava_athlete.id)\
.first()
if existing_racer:
flash('Racer ' + existing_racer.name +
' already linked with Strava account for ' +
strava_athlete.firstname + ' ' +
strava_athlete.lastname + '!')
current_app.logger.info('%s[%d] failed against %s[%d]',
racer.name, racer.id,
existing_racer.name, existing_racer.id)
return redirect(url_for('racer.details', id=id))
else:
racer.strava_access_token = access_token
racer.strava_id = strava_athlete.id
racer.strava_email = strava_athlete.email
racer.profile_url = strava_athlete.profile
db.session.commit()
current_app.logger.info('%s[%d]', racer.name, racer.id)
flash('Racer ' + racer.name + ' linked with Strava!')
return redirect(url_for('racer.details', id=id))
return redirect(url_for('racer.index'))
def token(request):
# Get temporary code after the request
code = request.GET.get("code")
# exchange the code for an access token.
client = Client()
access_token = client.exchange_code_for_token(client_id=STRAVA_CLIENT_ID,
client_secret=STRAVA_CLIENT_SECRET,
code=code)
# Get Athlete
athlete = client.get_athlete()
# See if the athlete exists in our DB
# current_athlete = get_object_or_404(Athlete, id_strava = athlete.id)
# current_athlete = ""
try:
current_athlete = Athlete.objects.get(id_strava = athlete.id)
except (KeyError, Athlete.DoesNotExist):
current_athlete = Athlete(first_name=athlete.firstname, last_name=athlete.lastname, access_token=access_token, id_strava = athlete.id )
current_athlete.save()
# **************************
# Prep content for the HTML page.
# Get Activities.
activities = client.get_activities()
# Make a list of activities to send to the html page. These are all the activities for this athlete.
activity_list = []
name_list = []
for a in activities:
temp = [a.id, a.name, a.distance, a.moving_time, a.elapsed_time, a.start_date_local]
activity_list.append(temp)
# information to send to the html page
context = { 'activity_list': activity_list, 'current_athlete': current_athlete }
template = loader.get_template('shred/activities.html')
return HttpResponse(template.render(context))
def logged_in():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
state = request.args.get('state')
if error:
return render_template('login_error.html', error=error)
else:
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id=app.config['STRAVA_CLIENT_ID'],
client_secret=app.config['STRAVA_CLIENT_SECRET'],
code=code)
# Use the now-authenticated client to get the current athlete
strava_athlete = client.get_athlete()
athlete_model = db.session.query(Athlete).get(strava_athlete.id)
if not athlete_model:
return render_template('login_error.html', error="ATHLETE_NOT_FOUND")
multiple_teams = None
no_teams = False
team = None
try:
team = data.register_athlete_team(strava_athlete=strava_athlete, athlete_model=athlete_model)
except bafs.exc.MultipleTeamsError as multx:
multiple_teams = multx.teams
except bafs.exc.NoTeamsError:
no_teams = True
if not no_teams:
auth.login_athlete(strava_athlete)
return redirect(url_for('user.rides'))
else:
return render_template('login_results.html', athlete=strava_athlete,
team=team, multiple_teams=multiple_teams,
no_teams=no_teams)
def logged_in():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
state = request.args.get('state')
if error:
return render_template('login_error.html', error=error)
else:
#Requesting the authorization code to STRAVA
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id='30922',
client_secret='2791ad32fb846e9f5b567f0a0deba5bb168fe533',
code=code)
#Defining segments area bounds
bounds_CAM=[40.366,-4.385,41.197,-3.573]
bounds_NORT=[40.494,-3.876,41.197,-3.573]
bounds_PARACUELLOS=[40.499,-3.546,40.844,-3.364]
bounds_CASAVIEJA=[40.185,-5.043,40.458,-4.475]
eleListPara= extractData(client,bounds_PARACUELLOS)
eleListNort= extractData(client,bounds_NORT)
eleListCAM = extractData(client,bounds_CAM)
eleListCAS = extractData(client,bounds_CASAVIEJA)
# Dump to carto db
utils.dumpToCarto(eleListNort,'north')
utils.dumpToCarto(eleListPara,'para')
utils.dumpToCarto(eleListCAM,'cam')
utils.dumpToCarto(eleListCAS,'cas')
return render_template('segment_results.html', segmentsPara=eleListPara,
segmentsNort=eleListNort, segmentsCAM=eleListCAM,
segmentsCAS=eleListCAS)
def token(request):
code = request.GET.get("code", None)
if not code:
return HttpResponse('<a href=' + reverse('index') +
'>Failed, try again.</a>')
else:
client = Client()
access_token = client.exchange_code_for_token(
client_id=os.environ['SMOOTHIFY_ID'],
client_secret=os.environ['SMOOTHIFY_SECRET'],
code=code)
request.session['SMOOTHIFY_TOKEN'] = access_token
athlete = client.get_athlete()
request.session['ATHLETE_FIRSTNAME'] = athlete.firstname
request.session['ACTIVITY_ERROR'] = None
return HttpResponseRedirect('/activity/')
def display_page(query_string, strava_auth):
if strava_auth is None:
strava_auth = {}
body = strava_login_layout
if strava_auth.get('authenticated', False):
body = app_layout
elif query_string is not None:
query = parse_qs(str(query_string[1:]))
if 'code' in query:
client = Client()
response = client.exchange_code_for_token(
client_id=settings.STRAVA_CLIENT_ID,
client_secret=settings.STRAVA_CLIENT_SECRET,
code=query['code'])
strava_auth.update(response)
strava_auth['authenticated'] = True
body = app_layout
return body, strava_auth
def authenticate():
client = Client()
url = client.authorization_url(client_id=sm.client_id,
redirect_uri='http://localhost')
logger.info(
'Open this URL, then paste in the code provided in the URL: '
'%s', url)
code = input('Paste code here: ')
auth_dict = client.exchange_code_for_token(client_id=sm.client_id,
client_secret=sm.client_secret,
code=code)
logger.debug('Auth Dict: %s', auth_dict)
# Save the dict back to Secret manager
try:
sm.set_auth_dict(auth_dict)
except PermissionDenied:
logger.error(f'Looks like your token could not be saved. Try manually '
f'adding this value to your STRAVA_ACCESS_TOKEN secret:\n'
f' {json.dumps(auth_dict)}')
def logged_in():
"""
Method called by Strava (redirect) that includes parameters.
- state
- code
- error
"""
error = request.args.get('error')
state = request.args.get('state')
if error:
return render_template('login_error.html', error=error)
else:
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id=app.config['STRAVA_CLIENT_ID'],
client_secret=app.config['STRAVA_CLIENT_SECRET'],
code=code)
# Probably here you'd want to store this somewhere -- e.g. in a database.
strava_athlete = client.get_athlete()
return render_template('login_results.html', athlete=strava_athlete, access_token=access_token)
def login_verdict(query_string, logout_click, strava_auth):
# https://dash.plotly.com/advanced-callbacks
ctx = dash.callback_context
if not ctx.triggered:
trigger_id = 'No clicks yet'
else:
trigger_id = ctx.triggered[0]['prop_id'].split('.')[0]
ctx_msg = json.dumps(
{
'states': ctx.states,
'triggered': ctx.triggered,
'inputs': ctx.inputs
},
indent=2)
unauthenticated = style.SHOW
authenticated = style.HIDE
if trigger_id == 'strava-logout':
return unauthenticated, authenticated, {}
if strava_auth is None:
strava_auth = {}
if strava_auth.get('authenticated', False):
unauthenticated = style.HIDE
authenticated = style.SHOW
elif query_string is not None:
query = parse_qs(str(query_string[1:]))
if 'code' in query:
client = Client()
response = client.exchange_code_for_token(
client_id=settings.STRAVA_CLIENT_ID,
client_secret=settings.STRAVA_CLIENT_SECRET,
code=query['code'])
strava_auth.update(response)
strava_auth['authenticated'] = True
unauthenticated = style.HIDE
authenticated = style.SHOW
return unauthenticated, authenticated, strava_auth
def do_GET(self):
request_path = self.path
parsed_path = urlparse.urlparse(request_path)
client = Client()
if request_path.startswith('/authorization'):
self.send_response(200)
self.send_header(six.b("Content-type"), six.b("text/plain"))
self.end_headers()
self.wfile.write(six.b("Authorization Handler\n\n"))
code = urlparse.parse_qs(parsed_path.query).get('code')
if code:
code = code[0]
access_token = client.exchange_code_for_token(
client_id=self.server.client_id,
client_secret=self.server.client_secret,
code=code)
self.server.logger.info(
"Exchanged code {} for access token {}".format(
code, access_token))
self.wfile.write(
six.b("Access Token: {}\n".format(access_token)))
else:
self.server.logger.error("No code param received.")
self.wfile.write(six.b("ERROR: No code param recevied.\n"))
else:
url = client.authorization_url(
client_id=self.server.client_id,
redirect_uri='http://localhost:{}/authorization'.format(
self.server.server_port))
self.send_response(302)
self.send_header(six.b("Content-type"), six.b("text/plain"))
self.send_header(six.b('Location'), six.b(url))
self.end_headers()
self.wfile.write(six.b("Redirect to URL: {}\n".format(url)))
def do_GET(self):
# when we are called with a GET we want to get the "code" from the
# request string
code=""
splits=self.path.split("&")
for s in splits:
if s.startswith("code="):
code=s.split("code=")[1]
assert code
# Let's just do the dirty and do the auth inline with the request...
# It's not like we expect a lot of traffic anyway.
client = Client()
access_token = client.exchange_code_for_token(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
code=code)
with open(".hurtlocker", "w") as thefile:
thefile.write(json.dumps(access_token))
if access_token:
self.server.stop()
def do_GET(self):
querystring = urlparse(self.path).query
params = parse_qs(querystring)
client = Client()
token_data = client.exchange_code_for_token(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
code=params['code'][0])
# Write credentials to disk. Use the simplest pickle protocol
# to keep it human-readable.
with open(STRAVA_CREDENTIALS_FILE, 'wb') as f:
pickle.dump(token_data, f, 0)
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(
('This message means you have been successfully authenticated.'
'\n\nYou can now close this page.').encode("utf-8"))
print('Authentication succeeded')
print('Credentials have been saved to %s' % STRAVA_CREDENTIALS_FILE)
def auth(request):
global _loginId
print("Auth")
code = request.GET.get('code')
print("code=", code)
scope = request.GET.get('scope')
print("scope=", scope)
login = get_object_or_404(Login, pk=_loginId)
client = Client()
access_token = client.exchange_code_for_token(
client_id=login.clientID, client_secret=login.clientSecret, code=code)
print("access_token=", access_token)
user = client.get_athlete()
strUser = StravaUser.objects.filter(uid=user.id)
if not strUser.exists():
print('create user', )
strUser = StravaUser(uid=user.id, lastname=user.lastname, firstname=user.firstname, \
lastUpdate=(datetime.now()-timedelta(days=30)), token=access_token)
strUser.save()
else:
strUser.update(token=access_token)
request.session['access_token'] = access_token
#request.session['access_token'] = 'ff4f273a775a57ce1c7dcc837e18a059370d338c'
return redirect('/strava2/activities')
from config import *
from stravalib import Client
import sys
client = Client()
if len( sys.argv ) == 1:
url = client.authorization_url(client_id=STRAVA_CLIENT_ID,
redirect_uri='http://localhost', scope='view_private,write' )
print "Paste this URL in your browser:"
print
print url
print
print "And then re-run this script like so: "
print "\t" + sys.argv[0] + " <code>"
elif sys.argv[1] == 'test':
client = Client( access_token=STRAVA_ACCESS_TOKEN)
print client.get_athlete()
else:
code = sys.argv[1]
access_token = client.exchange_code_for_token(client_id=STRAVA_CLIENT_ID,
client_secret=STRAVA_CLIENT_SECRET,
code=code)
print "Your Strava access token is: " + access_token
from stravalib import Client
client = Client()
CLIENT_ID = "CLIENT ID"
CLIENT_SECRET = "CLIENT SECRET"
url = client.authorization_url(
client_id=CLIENT_ID,
scope="write",
redirect_uri='http://localhost')
# Go to that URL and retrieve the code
print(url)
CODE = "PUT THE CODE HERE"
access_token = client.exchange_code_for_token(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
code=CODE)
print(access_token)
def authorization(request):
client = Client()
code = request.GET['code']
access_token = client.exchange_code_for_token(client_id=MY_STRAVA_CLIENT_ID, client_secret=MY_STRAVA_CLIENT_SECRET, code=code)
# making a global variable to be used across views. don't know how this will work in practice
client = Client(access_token=access_token)
athlete = client.get_athlete() # Get current athlete details
global athleteId
athleteId = athlete.id
# if athlete doesn't exist, add them
if len(Athlete.objects.filter(athleteId=athleteId)) == 0:
ath = Athlete.objects.create(name=str(athlete.firstname+' '+athlete.lastname), athleteId=athleteId, profilePic=athlete.profile, city=athlete.city, country=athlete.country, sex=athlete.sex, premium=athlete.premium, created_at=athlete.created_at, updated_at=athlete.updated_at, followers=athlete.follower_count, friends=athlete.friend_count, email=athlete.email, weight=athlete.weight, meas_pref=athlete.measurement_preference, runsSummary = DataFrame({}).to_json(orient='records'), fitLines = DataFrame({}).to_json(orient='records'), masterList = DataFrame({}).to_json(orient='records'))
ath.profilePic.name = "rudyzPic"
ath.save(update_fields=['profilePic'])
# if athlete already exists, draw their file
elif len(Athlete.objects.filter(athleteId=athleteId)) == 1:
ath = Athlete.objects.get(athleteId=athleteId)
############################################
##### compiling new runs, updating summary
# athlete's existing runs summary
existingSummary = DataFrame(pd.read_json(ath.runsSummary))
existingFitlines = DataFrame(pd.read_json(ath.fitLines))
masterList = DataFrame(pd.read_json(ath.masterList))
activities = list(client.get_activities())
# activity IDs of runs already in the system
try:
ids = existingSummary.activityId
except AttributeError:
ids = []
for i in range(len(activities)):
#for i in range(30,37):
# Ignoring activities already in the system
if (len(ids) == 0) or (float(activities[i].id) not in list(ids)):
try:
# compiling df for raw json-ization
activityId = activities[i].id
run = client.get_activity_streams(activityId, types=['time','latlng','distance','heartrate','altitude','cadence'])
latlng = run['latlng'].data
time = run['time'].data
distance = run['distance'].data
heartrate = run['heartrate'].data
altitude = run['altitude'].data
cadence = run['cadence'].data
date = activities[i].start_date_local
activity = activityId
dfi = thresher.assemble(date, activityId, heartrate, distance, time, altitude, latlng, cadence)
# basic cleanup, only removing totally unreasonable values
dfi = thresher.basicClean(dfi)
# if we ever want to try our hand at improving strava's speed data (ie by predicting speed when GPS blanks), intervene here:
#dfi = thresher.addDistDeltas(dfi)
try:
fitline = thresher.getFitlineLws(dfi) # this adds speed-shifted columns
except:
fitline = pd.DataFrame({})
try:
mafScore = fitline[fitline.hr == 140.0].avgSpeed.iloc[0]
print "MAF "
print mafScore
except:
mafScore = np.nan
fitline_json = fitline.to_json(orient='records')
# getting summary info for run (as one-entry dict)
runSummary = thresher.getSingleSummaryDf(dfi)
# adding mafScore to summary
runSummary['mafScore'] = mafScore
print runSummary
# adding predicted hr and speed values
#dfi = thresher.getPred(dfi)
# saving entry to database
Activity.objects.create(act_id = activityId, name=str(activities[i].name), description=activities[i].description, act_type=activities[i].type, date=activities[i].start_date_local, timezone=activities[i].timezone, df=dfi.to_json(orient='records'), avgHr=runSummary['avgHr'], hrVar=runSummary['variation'], realMiles=runSummary['realMiles'], recovery=runSummary['recovery'], easy=runSummary['easy'], stamina=runSummary['stamina'], impulse=runSummary['impulse'], totalTime=runSummary['totalTime'], totalDist=runSummary['totalDist'], climb=runSummary['climb'], fitline=fitline_json, mafScore=mafScore, athlete=ath)
# updating runs summary
existingSummary = existingSummary.append(runSummary, ignore_index=True)
existingFitlines = existingFitlines.append(fitline, ignore_index=True)
masterList = masterList.append(dfi, ignore_index=True)
except:
continue
# saving updated runs summary to athlete profile
ath.runsSummary = existingSummary.to_json(orient='records')
ath.save(update_fields=['runsSummary'])
existingSummary.to_pickle("runsSummary.txt")
# saving updated runs summary to athlete profile
ath.fitLines = existingFitlines.to_json(orient='records')
ath.save(update_fields=['fitLines'])
ath.masterList = masterList.to_json(orient='records')
ath.save(update_fields=['masterList'])
# testing...
existingSummary = pd.read_json(ath.runsSummary)
#print(existingSummary)
existingFitlines = pd.read_json(ath.fitLines)
#print(existingFitlines)
global path
path = os.path.dirname(__file__)
# updating dataframe, pickling for use in other views
#global df
#df = thresher.masterAssemble(client)
masterDf = pd.read_json(ath.masterList)
#print(masterDf)
masterDf.to_pickle(str(path)+"/"+str(athlete.id)+"masterDf.txt")
return render(request, 'stravaChimp/authorization.html', {'code':code, 'access_token':access_token, 'athleteId':athleteId})
