def upload_files(self, files):
"""
Upload files to Strava
"""
# connect to Strava API
client = Client(self.config.strava["access_token"])
for fn in files:
try:
upload = client.upload_activity(open(self.src_path + fn, "r"),
"fit")
activity = upload.wait(30, 10)
# if a file has been uploaded, copy it locally, as this ensures
# we don't attempt to re-upload the same activity in future
if activity:
shutil.copy(self.src_path + fn, self.dest_path + fn)
logging.debug("new file uploaded: {0}, {1} ({2})".format(
activity.name, activity.distance, fn))
except exc.ActivityUploadFailed as error:
print error
def main():
token = get_token()
if not token:
print("No API token available, can't continue")
return
client = Client(token)
activities = client.get_activities()
print("Looking for activites that have 'commute' in the title, but don't "
"have the commute property set on them...")
interactive = True
for a in activities:
if not a.commute and "commute" in a.name.lower():
print(
"Found activity '{}' on {} - https://www.strava.com/activities/{}"
"".format(a.name, a.start_date.astimezone(tz=None), a.id))
i = ""
if not interactive:
i = "y"
while i not in ("y", "n", "a", "q"):
i = input("Add the commute tag to this activity? [y/n/a/q]: "
).lower()
if i == "y":
client.update_activity(a.id, commute=True)
print("Added commute tag")
elif i == "q":
break
elif i == "a":
interactive = False
print("Done")
def load_strava_tracks(self, strava_config: str) -> typing.List[Track]:
tracks = []
tracks_names = []
if self.cache_dir:
self.strava_cache_file = os.path.join(self.cache_dir, strava_config)
if os.path.isfile(self.strava_cache_file):
with open(self.strava_cache_file) as f:
strava_cache_data = json.load(f)
tracks = [self._strava_cache_to_track(i) for i in strava_cache_data]
tracks_names = [track.file_names[0] for track in tracks]
with open(strava_config) as f:
strava_data = json.load(f)
filter_type = strava_data.pop("activity_type", None)
client = Client()
response = client.refresh_access_token(**strava_data)
client.access_token = response["access_token"]
filter_dict = {"before": datetime.datetime.utcnow()}
if tracks:
max_time = max(track.start_time() for track in tracks)
filter_dict = {"after": max_time - datetime.timedelta(days=2)}
for activity in client.get_activities(**filter_dict):
# tricky to pass the timezone
if str(activity.id) in tracks_names:
continue
if filter_type and activity.type not in (
[filter_type] if isinstance(filter_type, str) else filter_type
): # pylint: disable=superfluous-parens
continue
t = Track()
t.load_strava(activity)
tracks.append(t)
self._store_strava_tracks_to_cache(tracks)
return self._filter_and_merge_tracks(tracks)
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 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 get_strava_client():
token = get_strava_access_token()
rate_limiter = RateLimiter()
rate_limiter.rules.append(
XRateLimitRule({
'short': {
'usageFieldIndex': 0,
'usage': 0,
# 60s * 15 = 15 min
'limit': 100,
'time': (60 * 15),
'lastExceeded': None,
},
'long': {
'usageFieldIndex': 1,
'usage': 0,
# 60s * 60m * 24 = 1 day
'limit': 1000,
'time': (60 * 60 * 24),
'lastExceeded': None
}
}))
client = Client(rate_limiter=rate_limiter)
client.access_token = token
return client
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 load_strava_tracks(self, strava_config: str) -> typing.List[Track]:
tracks = []
tracks_names = []
if self.cache_dir:
self.strava_cache_file = os.path.join(self.cache_dir,
strava_config)
if os.path.isfile(self.strava_cache_file):
with open(self.strava_cache_file) as f:
strava_cache_data = json.load(f)
tracks = [
self._strava_cache_to_track(i)
for i in strava_cache_data
]
tracks_names = [track.file_names[0] for track in tracks]
with open(strava_config) as f:
strava_data = json.load(f)
client = Client()
response = client.refresh_access_token(**strava_data)
client.access_token = response["access_token"]
fliter_dict = {"before": datetime.datetime.utcnow()}
if tracks:
max_time = max(track.start_time for track in tracks)
if max_time:
fliter_dict = {"after": max_time - datetime.timedelta(days=2)}
for activate in client.get_activities(**fliter_dict):
# tricky to pass the timezone
if str(activate.id) in tracks_names:
continue
t = Track()
t.load_strava(activate)
tracks.append(t)
self._store_strava_tracks_to_cache(tracks)
return self._filter_and_merge_tracks(tracks)
def _strava_auth_url(config):
client = Client()
client_id = config['STRAVA_CLIENT_ID']
redirect = 'http://127.0.0.1:5000/strava_auth'
url = client.authorization_url(client_id=client_id,
redirect_uri=redirect)
return url
def main():
access_token = getToken()
if access_token == None:
return redirectAuth()
client = Client(access_token=access_token)
athlete = client.get_athlete() # Get current athlete details
#if you want a simple output of first name, last name, just use this line:
#return athlete.firstname + ' ' + athlete.lastname
#now get most recent activity for this athlete...
names = []
maps = []
for a in client.get_activities(before = "2016-08-12T00:00:00Z", limit=1):
names.append(a.name)
maps.append(a.map)
# another simple output for this bit is to return the name of the route
#return names[0]
# but a sightly more complicated output is this matplotlib figure --
m = maps[0]
summary_lat_lon = polyline.decode(m.summary_polyline)
lats = [i[0] for i in summary_lat_lon]
lons = [i[1] for i in summary_lat_lon]
session['name']=names[0]
session['lats']=lats
session['lons']=lons
return redirect('/simple.png')
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 get_auth_url():
"""Get the Strava authorization URL."""
client = Client()
auth_url = client.authorization_url(
client_id=STRAVA_CLIENT_ID,
redirect_uri= REDIRECT_URI)
return auth_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 strava_login():
client = Client()
authorize_url = client.authorization_url(
client_id=STRAVA_CLIENT_ID,
redirect_uri=f'{APP_URL}/strava/callback')
return RedirectResponse(authorize_url)
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 getActivitiesView(request):
global _loginId
#print (' >>>> getActivitiesView, get_queryset')
client = Client(request.session.get('access_token'))
print(' >>>> getActivitiesView, client=', client)
act = Activity.objects.filter(
uid=client.get_athlete().id).order_by('-strTime')
#print (' >>>> getActivitiesView, acts=',act)
tid = request.session.get('task_id')
result = AsyncResult(tid)
print(' >>>> getActivitiesView, state=', result.state)
print(' >>>> getActivitiesView, meta_data=', result.info)
actList = []
for actItem in act:
#print (actItem)
serializer = ActivityItemSerializer(actItem)
#print ('serializer.data: ',serializer.data)
actList.append(serializer.data)
if (result.info['total'] is None):
result.info['total'] = 0
if (result.info['current'] is None):
result.info['current'] = 0
data = {
'nbAct': result.info['total'],
'currentAct': result.info['current'],
'activities': actList
}
#print ('data=',data)
return JsonResponse(data)
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 get_activity_data(access_token):
client = Client(access_token)
athlete = client.get_athlete()
activity_stats = client.get_athlete_stats()
run_count = activity_stats.all_run_totals.count
bike_count = activity_stats.all_ride_totals.count
swim_count = activity_stats.all_swim_totals.count
total_count = run_count + bike_count + swim_count
all_activities = client.get_activities()
run_activities = []
swim_activities = []
bike_activities = []
calorie_count = 0.0
for activity in all_activities:
if (activity.type == "Run"):
run_activities.append(activity)
calorie_count += (float(activity.distance) / 1000) * float(athlete.weight) * 1.036
if (activity.type == "Swim"):
swim_activities.append(activity)
if (activity.type == "Ride"):
bike_activities.append(activity)
return ({"Runs": run_activities, "Swims" : swim_activities, "Rides": bike_activities, "Calorie_Count" : calorie_count})
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))
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 ActivitiesView(generic.ListView):
global _loginId
print('ActivitiesView')
template_name = 'strava2/activity_list.html'
context_object_name = 'activities_list'
def get_queryset(self):
#swagger_client.configuration.access_token = self.request.session.get('access_token')
#api_instance = swagger_client.ActivitiesApi()
#print ('api_instance=',api_instance)
#before = 56 # Integer | An epoch timestamp to use for filtering activities that have taken place before a certain time. (optional)
#after = 56 # Integer | An epoch timestamp to use for filtering activities that have taken place after a certain time. (optional)
#page = 56 # Integer | Page number. (optional)
#per_page = 56
#api_response = api_instance.get_logged_in_athlete_activities(before=before, after=after, page=page, per_page=per_page)
#pprint(api_response)
self.client = Client(self.request.session.get('access_token'))
return Activity.objects.filter(
uid=self.client.get_athlete().id).order_by('-strTime')
def get_context_data(self, **kwargs):
context = super(ActivitiesView, self).get_context_data(**kwargs)
login = get_object_or_404(Login, pk=_loginId)
user = self.client.get_athlete()
print("lastname=", user.lastname)
print('firstname=', user.firstname)
print('mail=', user.email)
print('id=', user.id)
login.userName = user.lastname
login.firstName = user.firstname
context['login'] = login
return context
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 main():
with open('secrets.txt') as f:
MY_STRAVA_CLIENT_ID = f.readline().strip()
MY_STRAVA_CLIENT_SECRET = f.readline().strip()
with open('maps.txt') as f:
gid = f.readline().strip()
session['gid']=gid #google map api key
access_token = getToken(MY_STRAVA_CLIENT_ID, MY_STRAVA_CLIENT_SECRET)
if access_token == None:
return redirectAuth(MY_STRAVA_CLIENT_ID)
#session['access_token'] = access_token
client = Client(access_token=session['access_token'])
athlete = client.get_athlete() # Get current athlete details
clubs = athlete.clubs
session['num_clubs']=len(clubs)
cnames = []
cids = []
for i in range(len(clubs)):
cnames.append(clubs[i].name)
cids.append(clubs[i].id)
session['cids']=cids
session['cnames']=cnames
session['athlete_name'] = athlete.firstname + ' ' + athlete.lastname
return redirect('/cluboptions')
def process():
token = session.get('access_token', None)
if token is None:
return redirect(url_for('login'))
client = Client(token)
athlete = client.get_athlete()
activities = client.get_activities()
points = [pnt for a in activities for pnt in (a.end_latlng, a.start_latlng) if pnt]
#temp = [pnt for ints in point_intercepts(points) for pnt in ints]
#temp = filter_close_points(points)
seg = []
for grps in group_points(points):
out = []
for pnt in grps:
out.append("<trkpt lat=\"{0.lat}\" lon=\"{0.lon}\"></trkpt>".format(pnt))
seg.append("<trkseg>{}</trkseg>".format("".join(out)))
return """<?xml version="1.0" encoding="UTF-8"?>
<gpx version="1.0">
<name>TEST</name>
<trk>{}</trk>
</gpx>""".format("".join(seg))
return "<html><body><img src='{}'/>{} {}</body></html>".format(athlete.profile, athlete.firstname, athlete.lastname)
def main(action, filename):
if action != "DOWNLOAD":
return 0
try:
with open(STRAVA_CREDENTIALS_FILE, 'r') as f:
access_token = f.read().strip(' \t\n\r')
except FileNotFoundError:
print('No Strava credentials provided.')
print('You first need to run the script to fetch the credentials')
print('./40-upload_to_strava.py')
return -1
try:
client = Client(access_token=access_token)
print('Uploading {}: '.format(os.path.basename(filename)), end='')
with open(filename, 'rb') as f:
upload = client.upload_activity(
activity_file=f,
data_type='fit',
private=STRAVA_UPLOAD_PRIVATE,
)
except (ActivityUploadFailed, FileNotFoundError) as err:
print('FAILED')
print('Reason:', err)
return -1
print('SUCCESS')
return 0
def get(self, request, athlete_id):
if request.user.is_authenticated():
template = loader.get_template('athlete.html')
try:
token = StravaToken.objects.get(user=request.user.id)
except ObjectDoesNotExist:
logger.error("Either the entry or blog doesn't exist.")
client_id = settings.CLIENT_ID
client_secret = settings.CLIENT_SECRET
client = Client(access_token=token.token)
logger.info(token.user)
logger.info(token.token)
athlete = client.get_athlete()
logger.info(athlete.city)
activities = client.get_activities(limit=10)
for activity in activities:
logger.info(
u"{0.name} {0.moving_time} {0.suffer_score}".format(
activity))
context = {
# 'latest_question_list': latest_question_list,
}
return HttpResponse(template.render(context, request))
else:
raise Http404("user is not login.")
def __init__(self):
# Strava client to hold information for tracker.
self.client = Client()
# Time token expires at.
self.token_expires_at_ = None
# Client information.
self.client_id = None
self.client_secret = None
# Time in seconds between refreshes.
self.sleep_time_ = 300
# Number of target activities per week.
self.target_ = 4
# Private display object.
self.display_ = Display()
# Activity tracking variables.
self.start_date = datetime.datetime.utcnow().date()
self.next_week = self.start_date + datetime.timedelta(weeks=1)
self.week_streak = 0
self.num_activities = 0
# Filename of save file.
self.save_file_ = 'streak.yaml'
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 login():
c = Client()
url = c.authorization_url(client_id='30922',
redirect_uri=url_for('.logged_in', _external=True),
approval_prompt='auto')
#Showing the login page
return render_template('login.html', authorize_url=url)
def give_kudos(activity_id):
client = Client(access_token=os.environ.get('STRAVA_ACCESS_TOKEN'))
activity = client.get_activity(activity_id)
logger.info('activity = {}'.format(activity))
athlete = client.get_athlete(activity.athlete.id)
logger.info('Giving kudos to {}'.format(athlete.username))
logger.info('Email: {}'.format(athlete.email))
send_email(athlete, activity)
def fetch_runs(user):
client = Client(access_token=user['strava_token'])
runs = []
for activity in client.get_activities(limit=10):
if activity.type != 'Run':
continue
runs.append(activity2run(activity))
return runs
def get_client():
client = Client()
token = load_token()
client.refresh_token = token["refresh_token"]
if token["expires_at"] < time.time():
token = refresh_token(client)
client.access_token = token["access_token"]
return client
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
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 get_activitys(LIMIT):
TOKEN = retreve_token(c['client_id'], c['client_secret'])
data = list()
client = Client(access_token=TOKEN)
activitys = client.get_activities(limit=LIMIT)
for activ in activitys:
data.append(activ.to_dict())
return data
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 __init__(self, cfg):
self.token = cfg.get('token')
self.convert_swim = cfg.get('convert_swim')
self.client = Client(access_token=self.token)
self.athlete = self.client.get_athlete()
self.activities = self.client.get_activities()
print('Loading data for: {} {}'.format(self.athlete.firstname.encode('utf8'), self.athlete.lastname.encode('utf8')))
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 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 join():
c = Client()
public_url = c.authorization_url(client_id=app.config['STRAVA_CLIENT_ID'],
redirect_uri=url_for('.authorization', _external=True),
approval_prompt='auto')
private_url = c.authorization_url(client_id=app.config['STRAVA_CLIENT_ID'],
redirect_uri=url_for('.authorization', _external=True),
approval_prompt='auto',
scope='view_private')
return render_template('authorize.html', public_authorize_url=public_url, private_authorize_url=private_url)
def login():
c = Client()
url = c.authorization_url(
client_id=config.STRAVA_CLIENT_ID,
redirect_uri=url_for('.logged_in', _external=True),
approval_prompt='auto',
scope=['read_all', 'activity:read_all', 'profile:read_all'],
)
return render_template('login.html',
authorize_url=url,
competition_title=config.COMPETITION_TITLE)
def strava_email(self):
if self.strava_access_token is None:
return None
if self.strava_profile_last_fetch is None or\
(datetime.now(pytz.timezone('UTC')) -\
self.strava_profile_last_fetch)\
> timedelta(minutes=5):
self.strava_profile_last_fetch = datetime.now(pytz.timezone('UTC'))
strava_client = Client(self.strava_access_token)
strava_athlete = strava_client.get_athlete()
self.strava_email = strava_athlete.email
return self._strava_email
def get_activity_map():
# just to see if i can plot my own activity map!
f = open('secrets.txt', 'r')
MY_STRAVA_CLIENT_ID = f.readline().strip()
MY_STRAVA_CLIENT_SECRET = f.readline().strip()
STORED_ACCESS_TOKEN = f.readline().strip()
f.close()
from stravalib import Client
client = Client(access_token=STORED_ACCESS_TOKEN)
client.get_athlete(7656735) # Get current athlete details
#now get most recent activity for this athlete...
a=client.get_activities(before = "2016-08-11T00:00:00Z", limit=1)
session['map']=a.map
session['name']=a.name
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 process():
token = session.get('access_token', None)
if token is None:
return redirect(url_for('login'))
client = Client(token)
athlete = client.get_athlete()
activities = client.get_activities()
for a in activities:
if not a.commute and "commute" in a.name.lower():
print(a)
client.update_activity(a.id, commute=True)
return "<html><body>processed</body></html>"
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 deauthorize_strava(id):
racer = Racer.query.get_or_404(id)
if racer.strava_access_token:
strava_access_token = racer.strava_access_token
strava_client = Client(strava_access_token)
strava_client.deauthorize()
racer.strava_access_token = None
racer.strava_id = None
racer.strava_email = None
racer.strava_profile_url = None
racer.strava_profile_last_fetch = None
current_app.logger.info('%s[%d]', racer.name, racer.id)
db.session.commit()
flash('Racer ' + racer.name + ' deauthorized from Strava!')
return redirect(url_for('racer.details', id=id))
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 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 details(id):
racer = Racer.query.get_or_404(id)
teams = (Team.query.join(Participant)
.join(Racer)
.filter_by(id=id)
.join(Race)
.order_by(Race.date.desc())
.all())
current_team = racer.current_team
if current_team in teams:
teams.remove(current_team)
current_year = datetime.date.today().year
current_membership = (
AcaMembership.query.with_entities(
AcaMembership.paid, AcaMembership.season_pass)
.filter(AcaMembership.year == current_year)
.filter(AcaMembership.racer_id == racer.id)
).first()
strava_client = Client()
strava_client_id = current_app.config['STRAVA_CLIENT_ID']
strava_url = (
strava_client.authorization_url(
client_id=strava_client_id,
redirect_uri=url_for('racer.authorize_strava', _external=True),
state=racer.id,
approval_prompt='force'))
if racer.strava_access_token:
access_token = racer.strava_access_token
try:
strava_client = Client(access_token)
strava_client.get_athlete()
except Exception:
racer.strava_access_token = None
racer.strava_id = None
racer.strava_email = None
racer.strava_profile_url = None
racer.strava_profile_last_fetch = None
current_app.logger.info('forced strava deauth %s[%d]', racer.name, racer.id)
db.session.commit()
return render_template('racer/details.html', racer=racer,
current_membership=current_membership,
current_team=current_team, teams=teams,
strava_url=strava_url)
def load_strava_data(user_id):
user = User.objects.get(id=user_id)
token = user.social_auth.get(provider='strava').tokens
c = StravaClient(token)
# fetch 200 activities
activities = c.get_activities(limit=200)
for track in activities:
activity, created = Activity.objects.get_or_create(
guID=track.id,
user=user
)
print track.id
activity.provider = Activity.STRAVA_PROVIDER
activity.location_city = track.location_city
activity.location_country = track.location_country
full_activity = c.get_activity(track.id)
activity.polyline = full_activity.map.polyline
activity.moving_time = full_activity.moving_time
activity.start_date = full_activity.start_date
activity.distance = float(
unithelper.meters(
track.distance
)
)
activity.total_elevation_gain = float(
unithelper.meters(
track.total_elevation_gain
)
)
activity.resource_state = track.resource_state
activity.description = track.description
if hasattr(track, 'start_latlng') and track.start_latlng is not None:
activity.start_point = Point(
track.start_latlng.lon,
track.start_latlng.lat
)
activity.save()
if activity.polyline:
activity.route = LineString(polyline_decode(activity.polyline))
activity.save()
def strava_profile_url(self):
if self.strava_access_token is None:
return None
if self.strava_profile_last_fetch is None or\
(datetime.now(pytz.timezone('UTC')) -\
self.strava_profile_last_fetch)\
> timedelta(minutes=5):
self.strava_profile_last_fetch = datetime.now(pytz.timezone('UTC'))
strava_client = Client(self.strava_access_token)
strava_athlete = strava_client.get_athlete()
if strava_athlete.profile == 'avatar/athlete/large.png':
self.strava_profile_url = None
else:
self.strava_profile_url = strava_athlete.profile
return self._strava_profile_url
def join():
c = Client()
public_url = c.authorization_url(
client_id=config.STRAVA_CLIENT_ID,
redirect_uri=url_for('.authorization', _external=True),
approval_prompt='auto',
scope=['read', 'activity:read', 'profile:read_all'],
)
private_url = c.authorization_url(
client_id=config.STRAVA_CLIENT_ID,
redirect_uri=url_for('.authorization', _external=True),
approval_prompt='auto',
scope=['read_all', 'activity:read_all', 'profile:read_all'],
)
return render_template('authorize.html',
public_authorize_url=public_url,
private_authorize_url=private_url,
competition_title=config.COMPETITION_TITLE)
def load_activities():
users_id = session['athlete']['id']
c = Client(access_token=session['token'])
activities = list(c.get_activities())
cur = g.db.cursor()
# Delete activities before loading to prevent id clashes
cur.execute('delete from activities where users_id = ?', [users_id])
g.db.commit()
# TODO: bulk create
for a in activities:
cur.execute('insert into activities (id, name, distance, start_time, users_id) values (?, ?, ?, ?, ?)',
(a.id, a.name, int(a.distance) / 1609, a.start_date, users_id))
g.db.commit()
cur.close()
return redirect('/activities')
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:
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 main():
assert len(args.athlete_ids) == len(args.access_tokens)
logger.info("app id: %i, fetching friends for ids %s" % \
(args.id_strava_app, str(args.athlete_ids)))
for i in range( len(args.access_tokens) ):
client = Client()
client.access_token = args.access_tokens[i]
athlete_id = args.athlete_ids[i]
time.sleep(TIME_PAUSE)
friends = [ friend.id for friend in client.get_athlete_friends() ]
time.sleep(TIME_PAUSE)
followers = [ follower.id for follower in client.get_athlete_followers() ]
add_friends_to_db(conn, athlete_id, friends, type="friend")
add_friends_to_db(conn, athlete_id, followers, type="follower")
logger.info("Done.")
def dave():
config = configparser.ConfigParser()
config.read(BEE42_INI)
ini_beeminder = config[BEE42_INI_BEEMINDER]
username = ini_beeminder[BEE42_INI_USERNAME]
token = ini_beeminder[BEE42_INI_TOKEN]
strava_token = ini_beeminder[BEE42_INI_STRAVA_TOKEN]
user = User(username, token)
print("Username:"******"tz:", user.timezone, "update:", user.updated_at, "goals", user.goalslugs, "db:", user.deadbeat)
strava_client = Client(access_token=strava_token)
strava_athlete = strava_client.get_athlete()
print(strava_athlete.firstname)
strava_activities = strava_client.get_activities(limit=15)
for a in strava_activities:
if (a.type == "Run"):
print(add_run(user, a))
elif (a.type == "Ride"):
print(add_ride(user, a))
