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 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))