🔨 Refactors into packages models and dtos

src/api/tracker.rs

@@ -1,29 +1,73 @@
-use crate::dtos::TrackerDTO;
+use crate::dtos::tracker::TrackerDTO;
-use crate::models::{AppState, Tracker};
+use crate::models::AppState;
-use crate::schema::trackers::dsl::trackers;
+use crate::models::tracker::{NewTracker, Tracker};
-use diesel::{QueryDsl, RunQueryDsl, SelectableHelper};
+use crate::schema::trackers;
+use chrono::Utc;
+use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl, SelectableHelper};
 use rocket::State;
+use rocket::http::Status;
 use rocket::serde::json::Json;
+use uuid::Uuid;
 
 #[get("/?<offset>&<limit>")]
 pub fn index(
     offset: Option<i64>,
     limit: Option<i64>,
-    data: &State<AppState>,
+    state: &State<AppState>,
-) -> Json<Vec<TrackerDTO>> {
+) -> Result<Json<Vec<TrackerDTO>>, Status> {
-    let mut db = data.db.lock().unwrap();
+    let mut db = state.db.lock().unwrap();
 
     let offset = offset.unwrap_or(0);
     let limit = limit.unwrap_or(10);
 
-    println!("hey");
+    let results = trackers::dsl::trackers
-    let results = trackers
         .offset(offset)
         .limit(limit)
         .select(Tracker::as_select())
         .load(&mut *db)
-        .expect("Error loading trackers");
+        .ok();
 
-    println!("hi");
+    match results {
-    Json(results.iter().map(TrackerDTO::from).collect())
+        Some(results) => Ok(Json(results.iter().map(TrackerDTO::from).collect())),
+        None => Err(Status::InternalServerError),
+    }
+}
+
+#[get("/<id>")]
+pub fn get(id: String, state: &State<AppState>) -> Result<Json<TrackerDTO>, Status> {
+    let mut db = state.db.lock().unwrap();
+
+    let id = match Uuid::parse_str(id.as_str()).ok() {
+        Some(id) => id,
+        None => return Err(Status::NotFound),
+    };
+
+    let result = trackers::dsl::trackers
+        .filter(trackers::id.eq(id))
+        .first::<Tracker>(&mut *db)
+        .ok();
+
+    match result {
+        Some(tracker) => Ok(Json(TrackerDTO::from(&tracker))),
+        None => Err(Status::NotFound),
+    }
+}
+
+#[post("/")]
+pub fn create(state: &State<AppState>) -> Result<Json<TrackerDTO>, Status> {
+    let mut db = state.db.lock().unwrap();
+
+    let new = NewTracker {
+        created_at: Utc::now().naive_utc(),
+    };
+    let result = diesel::insert_into(trackers::table)
+        .values(&new)
+        .returning(Tracker::as_returning())
+        .get_result(&mut *db)
+        .ok();
+
+    match result {
+        Some(tracker) => Ok(Json(TrackerDTO::from(&tracker))),
+        None => Err(Status::InternalServerError),
+    }
 }

src/dtos/hit.rs

@@ -1,22 +1,6 @@
-use chrono::{DateTime, Utc};
+use crate::models::hit::Hit;
-use crate::models::{Hit, Tracker};
 use serde::Serialize;
 
-#[derive(Serialize)]
-pub struct TrackerDTO {
-    pub id: String,
-    pub created_at: String,
-}
-
-impl TrackerDTO {
-    pub fn from(tracker: &Tracker) -> TrackerDTO {
-        TrackerDTO {
-            id: tracker.id.to_string(),
-            created_at: tracker.created_at.to_string(),
-        }
-    }
-}
-
 #[derive(Serialize)]
 pub struct HitDTO {
     pub id: String,

src/dtos/mod.rs

@@ -0,0 +1,2 @@
+pub mod hit;
+pub mod tracker;

src/dtos/tracker.rs

@@ -0,0 +1,17 @@
+use crate::models::tracker::Tracker;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize)]
+pub struct TrackerDTO {
+    pub id: String,
+    pub created_at: String,
+}
+
+impl TrackerDTO {
+    pub fn from(tracker: &Tracker) -> TrackerDTO {
+        TrackerDTO {
+            id: tracker.id.to_string(),
+            created_at: tracker.created_at.to_string(),
+        }
+    }
+}

src/main.rs

@@ -1,12 +1,10 @@
 mod api;
+mod dtos;
 mod models;
 mod schema;
-mod dtos;
 
 use crate::api::tracker;
-use crate::models::Hit;
+use diesel::{Connection, PgConnection};
-use crate::schema::hits::dsl::*;
-use diesel::{Connection, PgConnection, QueryDsl, RunQueryDsl, SelectableHelper};
 use std::env;
 
 #[macro_use]
@@ -22,19 +20,12 @@ fn rocket() -> _ {
     dotenv::dotenv().ok();
 
     let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
-    let mut db = PgConnection::establish(&database_url)
+    let db = PgConnection::establish(&database_url)
         .expect(&format!("Error connecting to {}", database_url));
 
-    let results = hits
-        .limit(5)
-        .select(Hit::as_select())
-        .load(&mut db)
-        .expect("Error loading hits");
-    println!("results: {}", results.len());
-
     let app_data = models::AppState::new(db);
     rocket::build()
         .manage(app_data)
         .mount("/", routes![index])
-        .mount("/tracker", routes![tracker::index])
+        .mount("/tracker", routes![tracker::index, tracker::get, tracker::create])
 }

src/models.rs

@@ -1,36 +0,0 @@
-use chrono::NaiveDateTime;
-use diesel::{PgConnection, Queryable, Selectable};
-use std::sync::{Arc, Mutex};
-use uuid::Uuid;
-
-#[derive(Queryable, Selectable, Clone)]
-#[diesel(table_name = crate::schema::trackers)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Tracker {
-    pub id: Uuid,
-    pub created_at: NaiveDateTime,
-}
-
-#[derive(Queryable, Selectable, Clone)]
-#[diesel(table_name = crate::schema::hits)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Hit {
-    pub id: Uuid,
-    pub tracker_id: Uuid,
-    pub ip: String,
-    pub agent: Option<String>,
-    pub language: Option<String>,
-    pub created_at: NaiveDateTime,
-}
-
-pub struct AppState {
-    pub db: Arc<Mutex<PgConnection>>,
-}
-
-impl AppState {
-    pub fn new(db: PgConnection) -> Self {
-        AppState {
-            db: Arc::new(Mutex::new(db)),
-        }
-    }
-}

src/models/hit.rs

@@ -0,0 +1,15 @@
+use chrono::NaiveDateTime;
+use diesel::{Queryable, Selectable};
+use uuid::Uuid;
+
+#[derive(Queryable, Selectable, Clone)]
+#[diesel(table_name = crate::schema::hits)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Hit {
+    pub id: Uuid,
+    pub tracker_id: Uuid,
+    pub ip: String,
+    pub agent: Option<String>,
+    pub language: Option<String>,
+    pub created_at: NaiveDateTime,
+}

src/models/mod.rs

@@ -0,0 +1,17 @@
+use diesel::PgConnection;
+use std::sync::{Arc, Mutex};
+
+pub mod hit;
+pub mod tracker;
+
+pub struct AppState {
+    pub db: Arc<Mutex<PgConnection>>,
+}
+
+impl AppState {
+    pub fn new(db: PgConnection) -> Self {
+        AppState {
+            db: Arc::new(Mutex::new(db)),
+        }
+    }
+}

src/models/tracker.rs

@@ -0,0 +1,18 @@
+use chrono::NaiveDateTime;
+use diesel::{Insertable, Queryable, Selectable};
+use uuid::Uuid;
+
+#[derive(Queryable, Selectable, Clone)]
+#[diesel(table_name = crate::schema::trackers)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Tracker {
+    pub id: Uuid,
+    pub created_at: NaiveDateTime,
+}
+
+#[derive(Insertable)]
+#[diesel(table_name = crate::schema::trackers)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct NewTracker {
+    pub created_at: NaiveDateTime,
+}