Strava API integration - Oauth and DB Sync

User authentication, access and refresh tokens retrieval, tokens encryption and storage. Added code to connect to Strava API, and download and insert to DB all activity data for the selected timeframe.
Also few bug fixes, and general clean-up

Author: pgalko

src/athletedataapp_apache.py

@@ -114,6 +114,23 @@ def config(filename, section, encr_pass=None):
                         db[param[0]] = ""
                 else:
                     db[param[0]] = param[1]
+        elif section == 'strava':
+            params = parser.items(section)
+            for param in params:
+                if param[0] == 'strava_client_id':
+                    try:
+                        decrypted_param = decrypt(base64.b64decode(param[1]), encr_pass)
+                        db[param[0]] = str(decrypted_param)
+                    except:
+                        db[param[0]] = ""
+                elif param[0] == 'strava_client_secret':
+                    try:
+                        decrypted_param = decrypt(base64.b64decode(param[1]), encr_pass)
+                        db[param[0]] = str(decrypted_param)
+                    except:
+                        db[param[0]] = ""
+                else:
+                    db[param[0]] = param[1]
         elif section == 'anticaptcha':
             params = parser.items(section)
             for param in params:

src/athletedataapp_flask.py

@@ -91,7 +91,7 @@ def get_databases_list(encr_pass):
 def retrieve_decrypt_creds(synch_req_db_list,encr_pass):
     sql_get_creds = """
     SELECT 
-        gc_email,gc_password,mfp_username,mfp_password,diasend_username,diasend_password,dropbox_access_token,glimp_export_link,libreview_export_link,mm_export_link,oura_refresh_token,ath_un
+        gc_email,gc_password,mfp_username,mfp_password,diasend_username,diasend_password,dropbox_access_token,glimp_export_link,libreview_export_link,mm_export_link,oura_refresh_token,strava_refresh_token,ath_un
     FROM
         athlete;
     """
@@ -129,6 +129,9 @@ def retrieve_decrypt_creds(synch_req_db_list,encr_pass):
 
                 oura_encr_token = None
                 oura_decr_token = None
+
+                strava_encr_token = None
+                strava_decr_token = None
 
                 glimp_encr_export_link = None
                 glimp_decr_export_link = None
@@ -192,7 +195,8 @@ def retrieve_decrypt_creds(synch_req_db_list,encr_pass):
                 libreview_encr_export_link=result[8]
                 mm_encr_export_link=result[9]
                 oura_encr_token=result[10]
-                ath_un=result[11]
+                strava_encr_token=result[11]
+                ath_un=result[12]
 
                 #Now decrypt (gc_encr_pw,mfp_encr_pw,dbx_encr_token and others)
                 if gc_encr_pw is not None:
@@ -211,9 +215,11 @@ def retrieve_decrypt_creds(synch_req_db_list,encr_pass):
                     mm_decr_export_link = decrypt(base64.b64decode(mm_encr_export_link), encr_pass)	
                 if oura_encr_token is not None:
                     oura_decr_token = decrypt(base64.b64decode(oura_encr_token), encr_pass)
+                if strava_encr_token is not None:
+                    strava_decr_token = decrypt(base64.b64decode(strava_encr_token), encr_pass)
 
                 ###Execute auto synch from "main_data_autosynch.py"###
-                auto_synch(ath_un, db, db_host, superuser_un, superuser_pw, gc_un, gc_decr_pw, mfp_un, mfp_decr_pw, cgm_un, cgm_decr_pw, glimp_decr_export_link, libreview_decr_export_link, mm_decr_export_link, dbx_decr_token, oura_decr_token, encr_pass)
+                auto_synch(ath_un, db, db_host, superuser_un, superuser_pw, gc_un, gc_decr_pw, mfp_un, mfp_decr_pw, cgm_un, cgm_decr_pw, glimp_decr_export_link, libreview_decr_export_link, mm_decr_export_link, dbx_decr_token, oura_decr_token, strava_decr_token, encr_pass)
 
             except (Exception, psycopg2.DatabaseError) as error:
                 with ConsolidatedProgressStdoutRedirection():

src/database_ini_parser.py

@@ -41,6 +41,7 @@ CREATE TABLE public.athlete (
     libreview_export_link character varying(300),
     mm_export_link character varying(300),
     oura_refresh_token character varying(300)
+    strava_refresh_token character varying(300)
 );
 
 ALTER TABLE public.athlete OWNER TO postgres;
@@ -966,6 +967,105 @@ ALTER TABLE public.oura_sleep_detail_id_seq OWNER TO postgres;
 
 ALTER SEQUENCE public.oura_sleep_detail_id_seq OWNED BY public.oura_sleep_detail.id;
 
+--
+--STRAVA ACTIVITY SUMMARY
+---
+CREATE TABLE public.strava_activity_summary(
+  id integer NOT NULL,
+  athlete_id    integer,
+  strava_athlete_id    bigint,
+  name  character varying, 
+  distance    real,
+  moving_time  integer,  
+  elapsed_time    integer,
+  total_elevation_gain    real,
+  type    character varying,
+  workout_type    integer,
+  strava_activity_id    bigint,
+  external_id    character varying,
+  upload_id    bigint,
+  start_date    character varying,
+  start_date_local    character varying,
+  timezone    character varying,
+  utc_offset   integer,
+  start_latitude    numeric,
+  start_longitude   numeric,
+  end_latitude    numeric,
+  end_longitude    numeric,
+  location_city    character varying,
+  location_state    character varying,
+  location_country    character varying,
+  map  character varying,
+  summary_polyline    character varying,   
+  trainer    boolean,
+  commute    boolean,
+  manual    boolean,
+  gear_id    character varying,
+  average_speed  real,  
+  max_speed    real,
+  average_cadence    real,
+  average_temp    real,
+  average_watts    real,
+  weighted_average_watts    real,
+  kilojoules    real,
+  device_watts    boolean,
+  average_heartrate   real,
+  max_heartrate    real,
+  max_watts    real,
+  elev_high    real,
+  elev_low    real,
+  suffer_score   real
+);
+
+ALTER TABLE public.strava_activity_summary OWNER TO postgres;
+
+CREATE SEQUENCE public.strava_activity_summary_id_seq
+    AS integer
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+	
+ALTER TABLE public.strava_activity_summary_id_seq OWNER TO postgres;
+
+ALTER SEQUENCE public.strava_activity_summary_id_seq OWNED BY public.strava_activity_summary.id;
+
+--
+--STRAVA ACTIVITY STREAMS
+--
+CREATE TABLE public.strava_activity_streams(
+  id integer NOT NULL,
+  activity_id    integer,
+  time_gmt    character varying,
+  distance    real,
+  latitude    numeric,
+  longitude    numeric,
+  altitude    real,
+  velocity_smooth    real,
+  heartrate    integer,
+  cadence    integer,
+  watts    integer,
+  temp    integer,
+  moving    boolean,
+  grade_smooth    real
+);
+
+ALTER TABLE public.strava_activity_streams OWNER TO postgres;
+
+CREATE SEQUENCE public.strava_activity_streams_id_seq
+    AS integer
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+	
+ALTER TABLE public.strava_activity_streams_id_seq OWNER TO postgres;
+
+ALTER SEQUENCE public.strava_activity_streams_id_seq OWNED BY public.strava_activity_streams.id;
+
+
 
 --
 --AUTO INCREMENTS
@@ -1018,6 +1118,11 @@ ALTER TABLE ONLY public.oura_activity_detail ALTER COLUMN id SET DEFAULT nextval
 
 ALTER TABLE ONLY public.oura_sleep_detail ALTER COLUMN id SET DEFAULT nextval('public.oura_sleep_detail_id_seq'::regclass);
 
+ALTER TABLE ONLY public.strava_activity_summary ALTER COLUMN id SET DEFAULT nextval('public.strava_activity_summary_id_seq'::regclass);
+
+ALTER TABLE ONLY public.strava_activity_streams ALTER COLUMN id SET DEFAULT nextval('public.strava_activity_streams_id_seq'::regclass);
+
+
 --
 --PRIMARY KEYS
 ---
@@ -1096,6 +1201,11 @@ ALTER TABLE ONLY public.oura_activity_detail
 ALTER TABLE ONLY public.oura_sleep_detail
     ADD CONSTRAINT oura_sleep_detail_pkey PRIMARY KEY (id);
 
+ALTER TABLE ONLY public.strava_activity_summary
+    ADD CONSTRAINT strava_activity_summary_pkey PRIMARY KEY (id);
+
+ALTER TABLE ONLY public.strava_activity_streams
+    ADD CONSTRAINT strava_activity_streams_pkey PRIMARY KEY (id);
 
 --
 --UNIQUES
@@ -1163,6 +1273,11 @@ ALTER TABLE ONLY public.oura_activity_detail
 ALTER TABLE ONLY public.oura_sleep_detail	
 	ADD CONSTRAINT unique_oura_sleep_detail UNIQUE (timestamp_gmt);
 
+ALTER TABLE ONLY public.strava_activity_summary	
+	ADD CONSTRAINT unique_strava_activity_summary UNIQUE (start_date);
+
+ALTER TABLE ONLY public.strava_activity_streams	
+	ADD CONSTRAINT unique_strava_activity_streams UNIQUE (time_gmt);
 
 --
 --INDEXES
@@ -1272,6 +1387,9 @@ ALTER TABLE ONLY public.oura_activity_detail
 ALTER TABLE ONLY public.oura_sleep_detail
     ADD CONSTRAINT fk_oura_sleep_detail_sleep_summary_id FOREIGN KEY (oura_sleep_id) REFERENCES public.oura_sleep_daily_summary(id);
 
+ALTER TABLE ONLY public.strava_activity_summary
+    ADD CONSTRAINT fk_strava_activity_summary_athlete_id FOREIGN KEY (athlete_id) REFERENCES public.athlete(id);
 
-
+ALTER TABLE ONLY public.strava_activity_streams
+    ADD CONSTRAINT fk_strava_activity_streams_strava_activity_id FOREIGN KEY (activity_id) REFERENCES public.strava_activity_summary(id);
 

src/db_auto_sync.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python
+import psycopg2
+from database_ini_parser import config
+from Athlete_Data_Utills import StdoutRedirection,ErrorStdoutRedirection,ProgressStdoutRedirection
+import sys
+from db_encrypt import generate_key,pad_text,unpad_text
+import Crypto.Random
+from Crypto.Cipher import AES
+import base64
+import datetime
+
+#----Crypto Variables----
+# salt size in bytes
+SALT_SIZE = 16
+# number of iterations in the key generation
+NUMBER_OF_ITERATIONS = 2000 # PG:Consider increasing number of iterations
+# the size multiple required for AES
+AES_MULTIPLE = 16
+
+
+def decrypt(ciphertext, password):
+    salt = ciphertext[0:SALT_SIZE]
+    #iv = ciphertext[:AES.block_size]
+    ciphertext_sans_salt = ciphertext[SALT_SIZE:]
+    key = generate_key(password, salt, NUMBER_OF_ITERATIONS)
+    cipher = AES.new(key, AES.MODE_ECB) #PG: Consider changing to MODE_CBC
+    padded_plaintext = cipher.decrypt(ciphertext_sans_salt)
+    plaintext = unpad_text(padded_plaintext)
+    return plaintext 
+
+def check_strava_token_exists(ath_un,db_host,db_name,superuser_un,superuser_pw,encr_pass):
+    conn = None
+    ath_un = ath_un
+    db_name = db_name
+    decrypted_strava_token = None
+
+    sql_check_strava_token_exists = """
+    SELECT strava_refresh_token FROM athlete WHERE ath_un = %s;
+    """
+
+    try: 
+        # connect to the PostgreSQL server
+        conn = psycopg2.connect(dbname=db_name, host=db_host, user=superuser_un, password=superuser_pw)
+
+        # create a cursor
+        cur = conn.cursor()
+
+        # execute a statement
+        try:
+            cur.execute(sql_check_strava_token_exists,(ath_un,))
+            result = cur.fetchone()
+            if result[0] is not None:  
+                token_exists = True
+                strava_token = result[0]
+                #Decrypt strava token
+                decrypted_strava_token = decrypt(base64.b64decode(strava_token), encr_pass)
+            else:
+                token_exists = False
+            conn.commit()
+        except Exception as e:
+            with ErrorStdoutRedirection(ath_un):
+                print((str(datetime.datetime.now()) + ' [' + sys._getframe().f_code.co_name + ']' + ' Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + '  ' + str(e)))
+            token_exists = False
+
+        # close the communication with the PostgreSQL
+        cur.close()
+    except (Exception, psycopg2.DatabaseError) as error:
+        with ErrorStdoutRedirection(ath_un):
+            print((str(datetime.datetime.now()) + ' [' + sys._getframe().f_code.co_name + ']' + ' Error on line {}'.format(sys.exc_info()[-1].tb_lineno) + '  ' + str(error)))
+
+    finally:
+        if conn is not None:
+            conn.close()
+    
+    return token_exists, decrypted_strava_token
+
+

src/db_schema.sql

@@ -72,7 +72,7 @@ def insert_last_synch_timestamp(ath_un,encr_pass,db_name):
             conn_localhost.close
 
 @processify
-def user_tokens_insert(ath_un,db_host,db_name,superuser_un,superuser_pw,dbx_auth_token,oura_refresh_token,encr_pass,save_pwd):
+def user_tokens_insert(ath_un,db_host,db_name,superuser_un,superuser_pw,dbx_auth_token,oura_refresh_token,strava_refresh_token,encr_pass,save_pwd):
 
     if save_pwd == True:
         #Encrypt dbx token
@@ -87,14 +87,22 @@ def user_tokens_insert(ath_un,db_host,db_name,superuser_un,superuser_pw,dbx_auth
             encrypted_oura_refresh_token = encrypted_oura_refresh_token.decode('utf-8')
         else:
             encrypted_oura_refresh_token = None
+        #Encrypt strava token
+        if strava_refresh_token is not None:
+            encrypted_strava_refresh_token = base64.b64encode(encrypt(strava_refresh_token, encr_pass))
+            encrypted_strava_refresh_token = encrypted_strava_refresh_token.decode('utf-8')
+        else:
+            encrypted_strava_refresh_token = None
     else:
         encrypted_dbx_auth_token = None
         encrypted_oura_refresh_token = None
+        encrypted_strava_refresh_token = None
 
     #Query params lists
     ath_user = (ath_un, )
     auth_token_tuple = (encrypted_dbx_auth_token, )
     oura_token_tuple = (encrypted_oura_refresh_token, )
+    strava_token_tuple = (encrypted_strava_refresh_token, )
 
     conn = None
 
@@ -158,6 +166,23 @@ def user_tokens_insert(ath_un,db_host,db_name,superuser_un,superuser_pw,dbx_auth
 
     """
 
+    sql_insert_strava_refresh_token = """
+    DO
+    $do$
+    BEGIN
+    IF
+
+    EXISTS (SELECT id FROM athlete WHERE ath_un = %s) THEN
+
+    UPDATE athlete SET strava_refresh_token = %s where ath_un= %s;
+
+    END IF;
+    
+    END
+    $do$
+
+    """
+
     try:
 
         # connect to the PostgreSQL server
@@ -184,6 +209,12 @@ def user_tokens_insert(ath_un,db_host,db_name,superuser_un,superuser_pw,dbx_auth
             cur.execute(sql_insert_oura_refresh_token,(ath_user,oura_token_tuple,ath_user))
             conn.commit()
 
+        if strava_refresh_token is not None:
+            with ProgressStdoutRedirection(ath_un):
+                print('Inserting Strava refresh token into postgreSQL:')
+            cur.execute(sql_insert_strava_refresh_token,(ath_user,strava_token_tuple,ath_user))
+            conn.commit()
+
         # close the communication with the PostgreSQL
         cur.close()
     except (Exception, psycopg2.DatabaseError) as error: