Exchange and store strava tokens

1 files changed, 32 insertions, 9 deletions

diff --git a/src/server.rs b/src/server.rs
index 275ffed..a2ed2b1 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,6 +1,7 @@
 use rocket::config::Config;
 use rocket::config::Environment;
 use rocket::config::Value;
+use rocket::http;
 use rocket::http::Cookie;
 use rocket::http::Cookies;
 use rocket::http::Status;
@@ -17,9 +18,12 @@ use std::collections::HashMap;
 use crate::db;
 use crate::error::Error;
 use crate::strava;
+use crate::models;
 
 pub struct Params {
     pub base_url: String,
+    pub strava_client_id: String,
+    pub strava_client_secret: String,
 }
 
 #[database("db")]
@@ -34,6 +38,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for LoggedInUser {
     type Error = Error;
 
     fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        println!("trying to get logged in user");
         let conn = request
             .guard::<Db>()
             .map_failure(|(s, ())| (s, Error::InternalError))?;
@@ -44,9 +49,11 @@ impl<'a, 'r> FromRequest<'a, 'r> for LoggedInUser {
                 .get_private("user")
                 .map(|cookie| cookie.value().to_string())
                 .ok_or(Error::NotFound)?;
+            println!("username: {:?}", username);
             db::get_user(&conn, &username)?;
             Ok(LoggedInUser { username: username })
         })();
+        println!("user: {:#?}", user);
 
         use request::Outcome;
         match user {
@@ -88,7 +95,9 @@ struct LoginData {
 fn login_submit(conn: Db, data: Form<LoginData>, mut cookies: Cookies) -> Result<Redirect, Error> {
     match db::authenticate(&*conn, &data.username, &data.password) {
         Ok(_user) => {
-            cookies.add_private(Cookie::new("user", data.username.clone()));
+            let mut cookie = Cookie::new("user", data.username.clone());
+            cookie.set_same_site(http::SameSite::Lax);
+            cookies.add_private(cookie);
             Ok(Redirect::to(uri!(index).to_string()))
         }
         Err(Error::NotFound) => Ok(Redirect::to(uri!(login: failed = true).to_string())),
@@ -98,15 +107,24 @@ fn login_submit(conn: Db, data: Form<LoginData>, mut cookies: Cookies) -> Result
 
 #[get("/link_strava_callback?<code>")]
 fn link_strava_callback(
-    config: State<Params>,
+    conn: Db,
+    user: LoggedInUser,
+    params: State<Params>,
     code: String,
-) -> Result<String, impl std::error::Error> {
-    strava::exchange_token("&config.client_id", "&config.client_secret", &code)
-        .map(|t| format!("{:#?}", t))
+) -> Result<String, Error> {
+    let token = strava::exchange_token(&params.strava_client_id, &params.strava_client_secret, &code)?;
+    let result = format!("{:#?}", token);
+    db::insert_strava_token(&*conn, &models::StravaToken {
+        username: user.username,
+        refresh_token: token.refresh_token,
+        access_token: token.access_token,
+        expires_at: token.expires_at
+    })?;
+    Ok(result)
 }
 
 #[get("/link_strava")]
-fn link_strava(config: State<Params>) -> Redirect {
+fn link_strava(params: State<Params>) -> Redirect {
     Redirect::to(format!(
         concat!(
             "https://www.strava.com/oauth/authorize?",
@@ -116,18 +134,23 @@ fn link_strava(config: State<Params>) -> Redirect {
             "approval_prompt=force&",
             "scope=read",
         ),
-        "config.client_id",
-        format!("{}/link_strava_callback", config.base_url)
+        params.strava_client_id,
+        format!("{}/link_strava_callback", params.base_url)
     ))
 }
 
-pub fn start(conn: diesel::PgConnection, db_url: &str, params: Params) {
+pub fn start(conn: diesel::PgConnection, db_url: &str, base_url: &str) {
     let mut database_config = HashMap::new();
     let mut databases = HashMap::new();
     database_config.insert("url", Value::from(db_url));
     databases.insert("db", Value::from(database_config));
 
     let persistent_config = db::get_config(&conn).expect("loading config");
+    let params = Params {
+        base_url: base_url.to_string(),
+        strava_client_id: persistent_config.strava_client_id,
+        strava_client_secret: persistent_config.strava_client_secret,
+    };
 
     let config = Config::build(Environment::Development)
         .extra("databases", databases)