Create data type for user visible entries

4 files changed, 85 insertions, 1 deletions

diff --git a/src/importer.rs b/src/importer.rs
index b1c1b18..c831ca9 100644
--- a/src/importer.rs
+++ b/src/importer.rs
@@ -10,6 +10,7 @@ use std::time::Duration;
 use std::time::Instant;
 use threadpool::ThreadPool;
 use serde_json::to_value;
+use serde_json::Value;
 
 use crate::diesel::Connection;
 use crate::db;
@@ -119,7 +120,7 @@ impl<StravaApi: strava::StravaApi> Importer<StravaApi> {
             *running = true;
             pool.execute({
                 let shared = self.shared.clone();
-                move || run_periodically(shared, Duration::from_secs(10))
+                move || run_periodically(shared, Duration::from_secs(5))
             });
         }
     }
@@ -130,6 +131,44 @@ impl<StravaApi: strava::StravaApi> Importer<StravaApi> {
     }
 }
 
+fn to_run(data: &Value) -> Result<Value, Error> {
+    info!("to_run");
+    macro_rules! get {
+        ($id:ident str $e:expr) => {
+            $id[$e].as_str().ok_or_else(
+                || Error::UnexpectedJson($id.clone()))
+        };
+
+        ($id:ident f64 $e:expr) => {
+            $id[$e].as_f64().ok_or_else(
+                || Error::UnexpectedJson($id.clone()))
+        };
+    };
+
+    Ok(json!({
+        "type": "run",
+        "distance": get!(data f64 "distance")?,
+        "elapsed_time": get!(data f64 "elapsed_time")?,
+    }))
+}
+
+fn process_strava_activity<S: strava::StravaApi>(
+    shared: Arc<ImporterSharedData<S>>,
+    data: models::RawData) -> Result<Value, Error> {
+
+    let json_error = || Error::UnexpectedJson(data.payload.clone());
+    let dtype = data.payload["type"].as_str().ok_or_else(json_error)?;
+
+    let payload = match dtype {
+        "Run" => {
+            to_run(&data.payload)?
+        },
+        &_ => Err(Error::InternalError)?,
+    };
+
+    Ok(payload)
+}
+
 fn process_raw_data<S: strava::StravaApi>(
     shared: Arc<ImporterSharedData<S>>,
     key: &models::RawDataKey,
@@ -138,7 +177,18 @@ fn process_raw_data<S: strava::StravaApi>(
     let data = db::get_raw_data(&shared.conn.lock().unwrap(), key)?;
     println!("Process raw data: {:#?}", data);
 
+    let payload = match data.data_type {
+        models::DataType::StravaActivity => {
+            process_strava_activity(shared.clone(), data)?
+        }
+    };
+
+    info!("Process finished. Payload: {:#?}", payload);
     unimplemented!();
+
+    task.state = models::TaskState::SUCCESSFUL;
+    db::update_task(&shared.conn.lock().unwrap(), task)?;
+    Ok(())
 }
 
 fn process_all_raw_data<S: strava::StravaApi>(
diff --git a/src/lib.rs b/src/lib.rs
index b80a235..25b56e9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,9 @@
 extern crate rocket;
 
 #[macro_use]
+extern crate serde_json;
+
+#[macro_use]
 extern crate rocket_contrib;
 
 #[macro_use]
diff --git a/src/models.rs b/src/models.rs
index 50e1877..c88f938 100644
--- a/src/models.rs
+++ b/src/models.rs
@@ -1,3 +1,4 @@
+use crate::schema::entries;
 use crate::schema::raw_data;
 use crate::schema::config;
 use crate::schema::strava_tokens;
@@ -149,3 +150,21 @@ pub struct RawData {
     pub username: String,
     pub payload: Value,
 }
+
+#[derive(Insertable, Debug, Serialize, Deserialize, Clone)]
+#[table_name = "entries"]
+pub struct NewEntry<'a> {
+    pub username: &'a str,
+    pub entry_type: &'a str,
+    pub timestamp: Option<DateTime<Utc>>,
+    pub payload: Value,
+}
+
+#[derive(Queryable, Debug, Serialize, Deserialize, Clone)]
+pub struct Entry {
+    pub username: String,
+    pub entry_type: String,
+    pub id: i64,
+    pub timestamp: Option<DateTime<Utc>>,
+    pub payload: Value,
+}
diff --git a/src/schema.rs b/src/schema.rs
index 1584424..2303714 100644
--- a/src/schema.rs
+++ b/src/schema.rs
@@ -8,6 +8,16 @@ table! {
 }
 
 table! {
+    entries (username, entry_type, id) {
+        username -> Varchar,
+        entry_type -> Varchar,
+        id -> Int8,
+        timestamp -> Nullable<Timestamptz>,
+        payload -> Jsonb,
+    }
+}
+
+table! {
     raw_data (data_type, id) {
         data_type -> Varchar,
         id -> Int8,
@@ -42,12 +52,14 @@ table! {
     }
 }
 
+joinable!(entries -> users (username));
 joinable!(raw_data -> users (username));
 joinable!(strava_tokens -> users (username));
 joinable!(tasks -> users (username));
 
 allow_tables_to_appear_in_same_query!(
     config,
+    entries,
     raw_data,
     strava_tokens,
     tasks,