class Strava:
def __init__(self, token):
self._token = token
self._client = None
self._verbose = True
def connect(self):
self._client = Client()
token = self._token
refresh_response = self._client.refresh_access_token(
client_id=token['client_id'],
client_secret=token['client_secret'],
refresh_token=token['refresh_token'])
token.update(refresh_response)
self._token = token
athlete = self._client.get_athlete()
if self._verbose:
logger.info("Connected to STRAVA as athelete \"{} {}\"".format(
athlete.firstname, athlete.lastname))
return self._token
def set_weight(self, weight):
self._client.update_athlete(weight=weight)
@property
def client(self):
return self._client
def map():
#return to index if user has no session cookie
if not session:
return redirect(request.url_root+'authenticate', code=302)
#redirect to reauthenticate if token has expired
if time.time() > session['expires_at']:
return redirect(request.url_root+'authenticate', code=302)
# create strava client and pull activities
client = Client(session['access_token'])
activities=list(client.get_activities())
# add polylines
gmap = gmplot.GoogleMapPlotter(0,0, 12,config.google_api_key)
for i in reversed(range(len(activities))):
try:
pl=polyline.decode(activities[i].to_dict()['map']['summary_polyline'])
lats,longs=zip(*pl)
gmap.plot(lats,longs, 'cornflowerblue', edge_width=4)#,edge_alpha=0.3)
except:
print('no polyline for '+activities[i].to_dict()['name'])
gmap.center = (mean(lats),mean(longs))
#output maps html file and load back in as string form(kinda hacky since the draw() function only outputs files)
file_name=str(session['athlete_id'])+'.html'
os.chdir('/tmp')
gmap.draw(file_name)
with open(file_name, 'r') as map_file:
html_string = map_file.read()
os.remove(file_name)
return html_string
def handle(self, *args, **options):
self.stdout.write("Updating the Acacia event miles")
client = Client()
rides_after = datetime(2018, 9, 1)
rides_before = datetime(2018, 9, 3)
participants = BigBulletRider.objects.exclude(
access_token__isnull=True)
for particpant in participants:
self.stdout.write("Looking up activities for " +
str(particpant.name))
client.access_token = particpant.access_token
activities = client.get_activities(before=rides_before,
after=rides_after)
for activity in activities:
km = unithelper.kilometers(activity.distance).num
self.stdout.write("Got activity " + str(activity.id) +
" distance = " + str(km) + " = " +
str(activity))
ride, created = BigBulletRide.objects.get_or_create(
activity_id=activity.id,
bullet=particpant,
distance=km,
start_date=activity.start_date)
self.stdout.write("Created = " + str(created))
def get(request):
""" Request -and store- a strava access token. """
client = Client()
# Extract the code from the response
code = request.GET.get('code')
access_token = client.exchange_code_for_token(
client_id=settings.STRAVA_CLIENT_ID,
client_secret=settings.STRAVA_CLIENT_SECRET,
code=code
)
strava_athlete = client.get_athlete()
try:
athlete = Athlete.objects.get(strava_id=strava_athlete.id)
athlete.strava_token = access_token
except Athlete.DoesNotExist:
athlete = Athlete(strava_id=strava_athlete.id, strava_token=access_token)
athlete.save()
cache_key = _get_cache_key(request)
cache.delete(cache_key)
redir_url = '{}?start_date={}&end_date={}'.format(
reverse_lazy('strava-summary'),
_get_start_date(request),
_get_end_date(request)
)
return HttpResponseRedirect(redir_url)
def freshness():
c = Client(access_token=session['token'])
try:
limit = int(request.args.get("limit"))
except (TypeError, ValueError):
limit = None
activities = list(c.get_activities(limit=limit))
date = activities[-1].start_date.date()
dates = []
week_vals = []
month_vals = []
while date <= datetime.datetime.now().date():
dates.append(datetime.datetime.combine(date, datetime.datetime.min.time()))
min_week_date = date - datetime.timedelta(days=7)
min_month_date = date - datetime.timedelta(days=30)
M_PER_MILE = 1609
week_vals.append(sum(float(a.distance) / M_PER_MILE for a in activities if a.start_date.date() <= date and a.start_date.date() > min_week_date))
month_vals.append((7 / 30.0) * sum(float(a.distance) / M_PER_MILE for a in activities if a.start_date.date() <= date and a.start_date.date() > min_month_date))
date += datetime.timedelta(days=1)
data = [dates, week_vals, month_vals]
return render_template('freshness.html', data=data)
def api_profiles_activities_id(player_id, activity_id):
if not request.stream:
return '', 400
activity_id = int(activity_id) & 0xffffffffffffffff
activity = activity_pb2.Activity()
activity.ParseFromString(request.stream.read())
update_protobuf_in_db('activity', activity, activity_id)
response = '{"id":%s}' % activity_id
if request.args.get('upload-to-strava') != 'true':
return response, 200
try:
from stravalib.client import Client
except ImportError:
logger.warn(
"stravalib is not installed. Skipping Strava upload attempt.")
return response, 200
strava = Client()
try:
with open('%s/strava_token.txt' % STORAGE_DIR, 'r') as f:
strava.access_token = f.read().rstrip('\r\n')
except:
logger.warn(
"Failed to read %s/strava_token.txt. Skipping Strava upload attempt."
)
return response, 200
try:
# See if there's internet to upload to Strava
strava.upload_activity(BytesIO(activity.fit),
data_type='fit',
name=activity.name)
# XXX: assume the upload succeeds on strava's end. not checking on it.
except:
logger.warn("Strava upload failed. No internet?")
return response, 200
def get_runs(request, n):
""" Get most recent n runs associated with an account.
"""
# Our admin object
admin = _get_admin(request)
# Be sure it exists
if not admin.exists_document('strava_access_token'):
request.response.status_int = 403
return
# Get the access token
access_token = admin.get_document('strava_access_token')
running_docs = {
a: admin.get_document(a)
for a in admin.list_documents() if a.startswith('run_')
}
strava_client = StravaClient(
access_token=access_token['strava_access_token'])
runs = []
for a in strava_client.get_activities():
if 'run_' + str(a.id) in running_docs:
run = running_docs['run_' + str(a.id)]
else:
run = {
'id': a.id,
'timestamp': a.start_date_local.isoformat(),
'duration': a.elapsed_time.total_seconds(),
'distance': unithelper.miles(a.distance).num,
'name': a.name,
'description': a.description
}
if a.map.summary_polyline is not None:
run['map_polyline'] = a.map.summary_polyline
if a.start_latlng is not None and a.start_date is not None and 'darksky' in request.registry.settings[
'secrets']:
fio = ForecastIO.ForecastIO(
request.registry.settings['secrets']['darksky']
['darksky_secret'],
units=ForecastIO.ForecastIO.UNITS_US,
latitude=float(a.start_latlng[0]),
longitude=float(a.start_latlng[1]),
time=str(int(time.mktime(a.start_date.timetuple()))))
if fio.has_currently():
currently = FIOCurrently.FIOCurrently(fio)
run['temperature'] = currently.temperature
run['weather_icon'] = currently.icon
admin.create_document(run, doc_id='run_' + str(a.id))
runs.append(run)
if n is not None and len(runs) == n:
break
# Return appropriately
request.response.status_int = 200
return {'runs': runs}
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 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 __init__(self):
self.client = Client()
self.API_CALL_PAUSE_SECONDS = 1.5 # 40 requests per minute
# the self-authorization is NOT working right now -- using hard-coded URL / ACCESS_CODE right now
#url = self.client.authorization_url(client_id=CLIENT_ID,
# redirect_uri='http://localhost:5000/authorization')
#code = request.args.get('code') # or whatever flask does
#url = 'http://www.strava.com/oauth/authorize?client_id=16424&response_type=code&redirect_uri=http://localhost/5001&approval_prompt=force&scope=write'
#print(url)
access_token = self.client.exchange_code_for_token(
client_id=CLIENT_ID, client_secret=CLIENT_SECRET, code=ACCESS_CODE)
# Now store that access token somewhere (a database?)
self.client.access_token = access_token
# retrieve the athlete
self.athlete = self.client.get_athlete()
print("For {}, I now have an access token".format(self.athlete.id))
# name of tables in model
self.user_TBL = 'users'
self.activity_TBL = 'activities'
self.streams_TBL = 'streams'
self.gear_TBL = 'gear'
# streams to extract from strava
self.streams = [
'time', 'latlng', 'distance', 'altitude', 'velocity_smooth',
'heartrate', 'cadence', 'temp', 'moving', 'grade_smooth'
]
def get_runs(request, n):
""" Get most recent n runs associated with an account.
"""
# Our admin object
admin = _get_admin(request)
# Be sure it exists
if not admin.exists_document('strava_access_token'):
request.response.status_int = 403
return
# Get the access token
access_token = admin.get_document('strava_access_token')
running_docs = {
a:admin.get_document(a) for a in admin.list_documents() if a.startswith('run_')
}
strava_client = StravaClient(access_token=access_token['strava_access_token'])
runs = []
for a in strava_client.get_activities():
if 'run_' + str(a.id) in running_docs:
run = running_docs['run_' + str(a.id)]
else:
run = {
'id': a.id,
'timestamp': a.start_date_local.isoformat(),
'duration': a.elapsed_time.total_seconds(),
'distance': unithelper.miles(a.distance).num,
'name': a.name,
'description': a.description
}
if a.map.summary_polyline is not None:
run['map_polyline'] = a.map.summary_polyline
if a.start_latlng is not None and a.start_date is not None and 'darksky' in request.registry.settings['secrets']:
fio = ForecastIO.ForecastIO(
request.registry.settings['secrets']['darksky']['darksky_secret'],
units=ForecastIO.ForecastIO.UNITS_US,
latitude=float(a.start_latlng[0]),
longitude=float(a.start_latlng[1]),
time=str(int(time.mktime(a.start_date.timetuple())))
)
if fio.has_currently():
currently = FIOCurrently.FIOCurrently(fio)
run['temperature'] = currently.temperature
run['weather_icon'] = currently.icon
admin.create_document(run, doc_id='run_' + str(a.id))
runs.append(run)
if n is not None and len(runs) == n:
break
# Return appropriately
request.response.status_int = 200
return {
'runs':
runs
}
def strava_upload(tcxfiles, login=None):
logging.basicConfig(level=logging.DEBUG)
client = Client()
creds = read_strava_auth_file()
if login == None:
if len(creds) > 0:
print("found strava credentials for: " )
n = 0
for email in creds.keys():
print(str(n) + " " + email)
n += 1
index_input = raw_input("enter the number corresponding to your email address. Or just press enter to use your default browser to login\n")
if re.match("\A\d+\Z", index_input):
index = int(index_input)
if index < len(creds):
login = creds.keys()[index]
if login and creds.has_key(login):
client.access_token = creds[login]
else:
strava_authorize(client)
for tcxfile in tcxfiles:
r = post_file_to_strava(client, tcxfile)
if(r.status_code == 401):
print("invalid auth token, rerequesting authorization")
strava_authorize(client)
r = post_file_to_strava(client, tcxfile)
if(r.status_code not in [200,201]):
print("error uploading file. HTTP response code: " + str(r.status_code))
print(str(r.text))
def rides(request):
if (not request.user.is_authenticated):
return JsonResponse({"user_auth": False})
client = Client()
user = AuthUser.objects.get(user_id=request.user.id)
client.access_token = user.auth_code
_before = datetime.now()
_after = datetime(2018, 4, 1)
batched_activities = client.get_activities(before=_before, after=_after)
list_activities = list(batched_activities)
rtn_activity_list = []
for a in list_activities:
detailed_activity = client.get_activity(a.id)
_new_activity = JsonActivity(detailed_activity.id, detailed_activity.map.polyline, a.distance, a.start_date)
rtn_activity_list.append(_new_activity.toJson())
rtn = {
"user_auth": True,
"activities": rtn_activity_list
}
return JsonResponse(rtn)
def create_context():
token_struct = session.get('token_struct')
if token_struct == None:
raise NoToken
try:
access_token = token_struct['access_token']
except KeyError:
raise NoToken
client = Client(access_token=access_token)
try:
refresh_token(client)
athlete = client.get_athlete()
except AccessUnauthorized:
raise
athlete_dir = os.path.join(current_app.instance_path, 'athletes',
str(athlete.id))
if not os.path.isdir(athlete_dir):
make_dirs(athlete_dir)
with open(os.path.join(athlete_dir, 'athlete.json'), 'w') as f:
json.dump(athlete.to_dict(), f)
return client, athlete
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 handle(self, *args, **options):
settings_obj = Site.objects.get_current().settings
self.stdout.write("Updating the Strava cache...")
if settings.STRAVA_ACCESS_TOKEN == None:
self.stdout.write("You must set STRAVA_ACCESS_TOKEN")
return
client = Client()
client.access_token = settings.STRAVA_ACCESS_TOKEN
if settings.STRAVA_CYCLING_CLUB != 0:
cycling_club = client.get_club(settings.STRAVA_CYCLING_CLUB)
self.stdout.write("Got this many cyclists = " +
str(cycling_club.member_count))
settings_obj.cyclists = cycling_club.member_count
# self.stdout.write("Getting cycling activities")
# cycling_activities = client.get_club_activities(settings.STRAVA_CYCLING_CLUB) # Just get all of them, database can dedupe
# self.insert_into_db(cycling_activities, ActivityCache.RIDE)
if settings.STRAVA_RUNNING_CLUB != 0:
running_club = client.get_club(settings.STRAVA_RUNNING_CLUB)
self.stdout.write("Got this many runners = " +
str(running_club.member_count))
settings_obj.runners = running_club.member_count
# self.stdout.write("Getting running activities")
# running_activities = client.get_club_activities(settings.STRAVA_RUNNING_CLUB)
# self.insert_into_db(running_activities, ActivityCache.RUN)
settings_obj.save()
def upload_activity(uid=None, file_name=None):
try:
strava_token = ref.child("users").child(uid).child(
"strava_token").get().val()
print(strava_token)
c = StravaClient(access_token=strava_token)
file_name += ".gpx"
url = storageRef.child("users").child(uid).child("gpx").child(
file_name).get_url(None)
gcontext = ssl.SSLContext(ssl.PROTOCOL_TLSv1) # Only for gangstars
url_response = urllib.request.urlopen(url, context=gcontext)
data = url_response.read()
parsed_data = data.decode('utf-8')
c.upload_activity(parsed_data, 'gpx')
return json.dumps({'locationSuccess': True}), 200, {
'Content-Type': 'text/javascript; charset=utf-8'
}
except KeyError:
return json.dumps({'locationSuccess': False}), 403, {
'Content-Type': 'text/javascript; charset=utf-8'
}
def index():
#if the user has already used the app(and has a cookie saved)
if session:
#if user is already authenticated and not expired
if (time.time() < session['expires_at']):
return render_template('index.html',auth_link=request.url_root+'map')
#if the user's token is expired, refresh the oken
else:
token = refresh_token(session['refresh_token'])
#if a code is being returned
if request.args.get('code'):
#take code and convert to token
code = request.args.get('code')
token = token_exchange(code)
# if this is the user's first visit, load page for authentication
else:
return render_template('index.html',auth_link=request.url_root+'authenticate')
#store token and athlete_id in flask session
session.clear()
client = Client(token['access_token'])
athlete_id = client.get_athlete().id
session['athlete_id'] = athlete_id
session['expires_at'] = token['expires_at']
session['access_token'] = token['access_token']
session['refresh_token'] = token['refresh_token']
session['code'] = code
#send to map page
return redirect(request.url_root+'map', code=302)
def collect_ride_data(self, challenge):
"""
Pull the latest ride data from Strava via the API
"""
client = Client()
client.access_token = self.strava_config['access-token']
#activities = client.get_club_activities(165009)
activities = client.get_club_activities(challenge.get_group_id())
act_list = []
for activity in activities:
if not activity.type == 'Ride' and not activity.type == 'VirtualRide':
print 'Non-ride activity: %s, type: %s' % (activity.name, activity.type)
continue
act = Activity(activity.id)
act.set_athlete(activity.athlete.id)
act.set_name(activity.name)
act.set_gmt_date(activity.start_date) # GMT Start date
act.set_elapsed_time(activity.elapsed_time)
act.set_distance(round(unithelper.kilometers(activity.distance).num, 2))
act.set_elevation(unithelper.meters(activity.total_elevation_gain).num)
act.set_ride_type(activity.type)
act.set_trainer_ride(activity.trainer)
act_list.append(act)
db_store = GTDataStore(challenge.get_db_path(), self.verbose)
db_store.store_if_new(act_list)
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 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 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_strava_api(secret, ID):
all_act = []
client = Client(access_token=secret)
tot = total_num(client)
me = client.get_athlete(ID)
activities = client.get_activities()
for i in trange(tot):
df = pd.DataFrame()
_a = activities.next()
_streams = client.get_activity_streams(_a.id, types=types)
for item in types:
if item in _streams.keys():
df[item] = pd.Series(_streams[item].data, index=None)
df['act_id'] = _a.id
df['act_name'] = _a.name
df['act_type'] = _a.type
df['lat'] = map(split_lat, (df['latlng']))
df['lon'] = map(split_long, (df['latlng']))
df['time'] = df['distance'] / (df['velocity_smooth'])
df.fillna(0)
all_act.append(df)
del df
with open(save_file + '.pkl', 'wb') as fp:
pickle.dump(all_act, fp)
pd.concat(all_act, ignore_index=True).to_csv(save_file + '.csv')
return all_act
def parse_input_to_map(access_token):
client = Client(access_token)
all_activities = client.get_activities()
date_activities_map = {}
for activity in all_activities:
date = str(activity.start_date)[0:10]
date_formated = datetime.datetime.strptime(str(date),
"%Y-%m-%d").date()
# group activities by weeks with monday date as a key
monday = date_formated - datetime.timedelta(date_formated.weekday())
if monday in date_activities_map:
date_found = False
for day_activity in date_activities_map[monday]:
if date_formated in day_activity:
day_activity[date_formated].append(activity)
date_found = True
break
if not date_found:
date_activities_map[monday].append({date_formated: [activity]})
else:
date_activities_map[monday] = [{
date_formated: [activity]
}]
# [{"2020-03-03": [Activity]}]
print("Success! Activities from strava retrieved, start building table")
print("Total number of weeks with at least 1 training:" +
str(len(date_activities_map)))
return date_activities_map
def __init__(self, api_key=None, csv_path=None, df=None):
self.api_key = api_key
self.csv_path = csv_path
self.df = df
if self.api_key:
self.client = Client(access_token=self.api_key)
class StravaData:
RUNNER_ID = None
ACCESS_TOKEN = None
client = None
def __init__(self, runner_id, access_token):
self.RUNNER_ID = runner_id
self.ACCESS_TOKEN = access_token
self.client = Client()
self.client.access_token = access_token
def getAthlete(self):
athlete = self.client.get_athlete()
return athlete
def getActivities(self):
activities = self.client.get_activities()
return activities
def getActivity(self, id):
activity = self.client.get_activity(id)
return activity
def getActivityStreams(self, id, types):
streams = self.client.get_activity_streams(id,
types=types,
resolution='medium')
return streams
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 send_run_to_strava():
'''Ask whether to send a run to strava if it hasn't already. Option to
add a description. Update on_strava field in database if successfully
sent or prompted to do so if not sent.'''
cfg.read(os.path.join(os.getenv('HOME'), '.config/strava.cfg'))
access_token = cfg.get('Strava', 'access_token')
client = Client()
client.access_token = access_token
runs = get_list_of_runs_not_on_strava()
for run in runs:
print run
send = raw_input("Send this run to Strava? (Y|N): ")
if (send[0] in ['Y', 'y']):
start_time = raw_input(
"What time did the activity start HH:MM:SS: ")
date_of_activity = "%sT%sZ", (run.run_date, start_time)
description = raw_input("Add an optional description: ")
client.create_activity(run.name,
ACTIVITY_TYPE,
date_of_activity,
run.time,
description,
unithelper.miles(run.distance))
mark_run_as_on_strava(run.run_date, run.route_id, run.athlete_id)
logging.info("Sent this activity to Strava: %s", run)
else:
update = raw_input("Update this run as on Strava (Y|N): ")
if (update[0] in ['Y', 'y']):
mark_run_as_on_strava(
run.run_date, run.route_id, run.athlete_id)
def get_token(client_id, client_secret, code):
"""Exchange a temporary code for a permanent token"""
client = Client()
response = client.exchange_code_for_token(client_id = client_id, client_secret = client_secret, code = code)
print("[+] A new permanent token was generated, with the following details:\n\t- access token: {}\n\t- refresh access token: {}\n\t- expireS at: {}".format(response["access_token"], response["refresh_token"], response["expires_at"]))
def get_followers(request, id):
followers = []
if (request.user.userinfo != None):
followers += [str(request.user.userinfo.athlete_id)]
client = Client(access_token=request.user.userinfo.strava_code)
for f in client.get_athlete_friends():
followers += [str(f.id)]
return HttpResponse(json.dumps(followers), content_type="application/json")
def make_client(client_id, client_secret, refresh_token):
client = Client()
refresh_response = client.refresh_access_token(
client_id=client_id, client_secret=client_secret, refresh_token=refresh_token
)
client.access_token = refresh_response["access_token"]
return client
def get(self):
code = self.request.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id=conf.SV_CLIENT_ID, client_secret=conf.SV_CLIENT_SECRET, code=code)
user_id = UserManager().AddUserToken(access_token)
self.redirect('/user/{0}'.format(user_id))
def auth_done(request):
code = request.GET.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
code=code)
request.session['access_token'] = access_token
return redirect('home')
def login():
params = {
'client_id': CLIENT_ID,
'redirect_uri': HOSTNAME + '/oauth_authorized/'
}
client = Client()
url = client.authorization_url(**params)
return redirect(url)
def main(ctx):
client = Client()
client.access_token = get_access_token()
ctx.obj['client'] = client
ctx.obj['athlete'] = client.get_athlete()
ctx.obj['bikes'] = get_bikes(ctx.obj['athlete'])
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 __get_strava_client(request):
client = Client()
if request.user:
if request.user.social_auth:
provider = request.user.social_auth.get(provider='strava')
if provider:
if 'access_token' in provider.extra_data.keys():
client.access_token = provider.extra_data['access_token']
return client
def _get_club_members():
""" Get all athletes belonging to our club. """
athlete = Athlete.objects.order_by('?').first()
if not athlete:
return []
client = Client(access_token=athlete.strava_token)
return client.get_club_members(settings.STRAVA_CHALLENGE_CLUB_ID)
def oauth_authorized():
client = Client()
code = request.args.get('code')
access_token = client.exchange_code_for_token(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
code=code)
session['access_token'] = access_token
return redirect(url_for('index'))
def authorization():
code = request.args.get('code')
client = Client()
access_token = client.exchange_code_for_token(client_id=MY_STRAVA_CLIENT_ID,
client_secret=MY_STRAVA_CLIENT_SECRET,
code=code)
response = redirect("/")
response.set_cookie('access_token', access_token)
return response
def get_images(segment_id):
access_token = request.cookies.get('access_token')
if not access_token:
return redirect("/")
client = Client(rate_limiter=limiter.DefaultRateLimiter())
client.access_token = access_token
# look into this: https://github.com/saimn/sigal/
images = get_images_from_segment(segment_id, client)
return render_template('test.html', images=images)
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 check_oauth_token(cls, access_token):
if not access_token:
return False
c = Client()
c.access_token = access_token
try:
c.get_athlete()
except HTTPError:
return False
else:
return True
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_emails():
email_list = []
athletes = athlete.objects.all()
for each_athlete in athletes: # for each athlete
client = Client(access_token=each_athlete.access_token)
this_athlete_email = client.get_athlete().email
email_list.append(this_athlete_email)
string_of_emails = ""
for value in email_list:
string_of_emails += str(value)
string_of_emails += "; "
print(string_of_emails)
def get_user(self):
client = Client()
token = self.accessToken()
if token is None:
return None
client.access_token = token
athlete = client.get_athlete()
return dict(first_name=athlete.firstname,
last_name=athlete.lastname,
email=athlete.email)
def auth():
try:
code = request.args["code"]
c = Client()
token = c.exchange_code_for_token(app.config['STRAVA_ID'], app.config['STRAVA_SECRET'], code)
except (KeyError, requests.exceptions.HTTPError):
return redirect("/")
session["token"] = c.access_token = token
a = c.get_athlete() # Technically shouldn't be needed as the athlete details are returned in the oauth call
session["athlete"] = {"firstname": a.firstname, "picture": a.profile_medium}
return redirect("/")
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 set_access_token(request):
""" Exchange the provided code for an access token and store it
"""
# Our strava code
json = request.json_body
code = json['code']
# If we don't have a strava secret, we can't make the key exchange
if 'strava' not in request.registry.settings['secrets']:
request.response.status_int = 500
return
# Exchange the code for an access token
# The API will throw an unspecified error if code is invalid.
# Catch that rather than taking down the server.
access_token = ""
try:
client = StravaClient()
access_token = client.exchange_code_for_token(client_id=request.registry.settings['secrets']['strava']['strava_id'],
client_secret=request.registry.settings['secrets']['strava']['strava_secret'],
code=code)
except:
# Return an error
request.response.status_int = 502
return
# Our admin object
admin = _get_admin(request)
#Create the access token if it doesn't exist, or update the stored one
if not admin.exists_document('strava_access_token'):
# Store the access token
admin.create_document({'strava_access_token': access_token}, doc_id='strava_access_token')
else:
# Update the stored access token
stored_access_token = admin.get_document('strava_access_token')
try:
admin.update_document({'strava_access_token': access_token, '_id':'strava_access_token', '_rev':stored_access_token['_rev']})
except:
# We likely hit a race condition where the _rev is no longer valid. Return accordingly.
request.response.status_int = 409
return
# Return appropriately
request.response.status_int = 200
return {
'access_token':
access_token
}
def AddUserToken(self, token):
client = Client(token)
athlete = client.get_athlete()
# Simplified logic not to add duplicate user tokens.
# todo: check the user is not in the user token table.
if self.GetMemcacheToken(athlete.id) is None:
rider = UserToken(strava_id=athlete.id, strava_token=token)
rider.put()
memcache.add(self.GetMemcacheKey(athlete.id), token, 60)
return athlete.id
def index(request): # Get KM cycled from Strava API from stravalib.client import Client from stravalib import unithelper strava = Client(settings.STRAVA_TOKEN) profile = strava.get_athlete(settings.STRAVA_ID) cycled = 0 for b in profile.bikes: cycled += float(b.distance) / 1000 return render_to_response( 'cv/index.html', locals(), context_instance=RequestContext(request) )
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 authorized():
# get access token to make requests
client = Client()
code = request.args.get('code')
client.access_token = client.exchange_code_for_token(client_id=creds.client_id, client_secret=creds.client_secret, code=code) # add id and secret
# get data
today = datetime.datetime.strptime(str(datetime.date.today()), "%Y-%m-%d")
one_month_ago = today - dateutil.relativedelta.relativedelta(months=1)
athlete = client.get_athlete()
activities = client.get_activities(after=one_month_ago)
rides = toolkit.get_activity_types(activities, 'ride')
runs = toolkit.get_activity_types(activities, 'run')
ride_set = ActivitySet("Rides", rides)
run_set = ActivitySet("Runs", runs)
return render_template('main.html', athlete=athlete, activity_sets=[ride_set, run_set])
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
def setUp(self):
if not os.path.exists(TEST_CFG):
raise Exception("Unable to run the write tests without a tests.ini that defines an access_token with write privs.")
cfg = ConfigParser.SafeConfigParser()
with open(TEST_CFG) as fp:
cfg.readfp(fp, 'test.ini')
access_token = cfg.get('write_tests', 'access_token')
self.client = Client(access_token=access_token)
def index():
access_token = session.get('access_token')
if access_token is None:
return redirect(url_for('login'))
client = Client(access_token=access_token)
athlete = client.get_athlete() # client.protocol.get('/athletes/your_id')
athlete_id = athlete.id
# bo = 'hi'
# kim = 'yo'
# c = bo + kim
stats_m = client.protocol.get('/athletes/' + str(athlete_id) + '/stats')
stats_mi = {
'run_distance': m_to_mi(stats_m['recent_run_totals']['distance']),
'run_count': stats_m['recent_run_totals']['count'],
'run_elevation': el(stats_m['recent_run_totals']['elevation_gain']),
'run_pace': average_pace(stats_m['recent_run_totals']['distance'], stats_m['recent_run_totals']['moving_time']),
'run_distance_ytd': m_to_mi(stats_m['ytd_run_totals']['distance']),
'run_count_ytd': stats_m['ytd_run_totals']['count'],
'run_elevation_ytd': el(stats_m['ytd_run_totals']['elevation_gain']),
'run_pace_ytd': average_pace(stats_m['ytd_run_totals']['distance'], stats_m['ytd_run_totals']['moving_time']),
'run_distance_all': m_to_mi(stats_m['all_run_totals']['distance']),
'run_count_all': stats_m['all_run_totals']['count'],
'run_elevation_all': el(stats_m['all_run_totals']['elevation_gain']),
'run_pace_all': average_pace(stats_m['all_run_totals']['distance'], stats_m['all_run_totals']['moving_time']),
'ride_distance': m_to_mi(stats_m['recent_ride_totals']['distance']),
'ride_count': stats_m['recent_ride_totals']['count'],
'ride_elevation': el(stats_m['recent_ride_totals']['elevation_gain']),
'ride_speed': average_mph(stats_m['recent_ride_totals']['distance'], stats_m['recent_ride_totals']['moving_time']),
'ride_distance_ytd': m_to_mi(stats_m['ytd_ride_totals']['distance']),
'ride_count_ytd': stats_m['ytd_ride_totals']['count'],
'ride_elevation_ytd': el(stats_m['ytd_ride_totals']['elevation_gain']),
'ride_speed_ytd': average_mph(stats_m['ytd_ride_totals']['distance'], stats_m['ytd_ride_totals']['moving_time']),
'ride_distance_all': m_to_mi(stats_m['all_ride_totals']['distance']),
'ride_count_all': stats_m['all_ride_totals']['count'],
'ride_elevation_all': el(stats_m['all_ride_totals']['elevation_gain']),
'ride_speed_all': average_mph(stats_m['all_ride_totals']['distance'], stats_m['all_ride_totals']['moving_time']),
}
# raise Exception(stats_mi['run_distance'])
return render_template('index.html', athlete=athlete, stats=stats_mi, athlete_id=athlete)
def mileage():
c = Client(access_token=session["token"])
limit = int(request.args.get("limit", 200))
activity_models = list(c.get_activities(limit=limit))
activities = []
for a in activity_models:
activities.append({
"name": a.name,
"distance": float(a.distance),
"time": a.moving_time.seconds,
"type": a.type,
"date": a.start_date.isoformat(),
"day": a.start_date.weekday()
})
data = json.dumps(activities)
return render_template('mileage.html', data=data)
def handle(self, *args, **options):
client = Client()
client.access_token = '20bf9e2864c1411d17d9cab8c11aa8dbe626aedd'
cityEntries = City.objects.all()
resetPlaceChanges = False
if not cityEntries:
cityEntries = createDefaultCitySegments()
resetPlaceChanges = True
for city in cityEntries:
updater = CityLeaderboardUpdater(city, client)
updater.update()
# Delete placement changes if data has just been reset
if resetPlaceChanges:
placementChanges = PlacementChange.objects.all()
for pc in placementChanges.iterator():
pc.delete()
print("Updated at " + str(timezone.now()))
def fitness():
c = Client(access_token=session["token"])
try:
limit = int(request.args.get("limit"))
except (TypeError, ValueError):
limit = None
try:
smooth = int(request.args.get("smooth")) / 2
except (ValueError, TypeError):
smooth = 3
activities = list(c.get_activities(limit=limit))
# Bit of a mess. Long run is 2. Old activities are 0, new activities are None
ALLOWED_ACTIVITIES = [None, 0, 2, u"0", u"2"]
activities = list(reversed([a for a in activities if a.average_heartrate and a.workout_type in ALLOWED_ACTIVITIES and a.type == "Run"]))
activities = [a for a in activities if a.average_heartrate > 100 and 1000 * float(a.average_speed) / (a.average_heartrate - 60) < 80] # Sanity for me
vals = [1000 * float(a.average_speed) / (a.average_heartrate - 60) for a in activities]
names = ["{} {}".format(a.name, a.start_date) for a in activities]
smoothed_vals = []
for index, val in enumerate(vals):
slice = vals[max(0, index-smooth):index+smooth+1]
smoothed_vals.append(sum(slice) / (0.0 + len(slice)))
vals_and_dist = [(1000 * float(a.average_speed) / (a.average_heartrate - 60), float(a.distance)) for a in activities]
dist_smoothed_vals = []
for index, val in enumerate(vals):
slice = vals_and_dist[max(0, index-smooth):index+smooth+1]
tot = 0
dist = 0
for run in slice:
tot += run[0] * run[1]
dist += run[1]
dist_smoothed_vals.append(tot / float(dist))
data = [names, vals, smoothed_vals, dist_smoothed_vals]
return render_template('fitness.html', data=data)
