added database

srv/src/db/init.sql

@@ -0,0 +1,6 @@
+CREATE TABLE
+    IF NOT EXISTS list (
+        itemname TEXT NOT NULL PRIMARY KEY,
+        checked INT NOT NULL, -- actually a boolean
+        amount INT NOT NULL
+    ) STRICT;

srv/src/main.rs

@@ -1,62 +1,70 @@
 #[macro_use]
 extern crate rocket;
 
-use std::sync::Mutex;
+use std::env;
 
 use inkopslista_lib::{Item, ItemData};
 use rocket::{serde::json::Json, State};
-use serde::{Deserialize, Serialize};
+use sqlite::ConnectionThreadSafe;
 
 #[get("/")]
 fn index() -> &'static str {
     "hello world"
 }
 
-// http GET hemma.nubo.sh/api/list/
-// response: [
-//   Item { name: "Mjölk", ItemData { checked: true } }
-// ]
 #[get("/api/list")]
-fn get_list(mock_db: &State<Mutex<MockDb>>) -> Json<Vec<Item>> {
-    let mock_db = mock_db.lock().unwrap();
-    Json(mock_db.list.clone())
+fn get_list(db: &State<ConnectionThreadSafe>) -> Json<Vec<Item>> {
+    // TODO errorhandling
+    let query = "SELECT * FROM list;";
+    let list = db
+        .prepare(query)
+        .unwrap()
+        .into_iter()
+        .map(|row| {
+            let row = row.unwrap();
+            Item {
+                name: row.read::<&str, _>("itemname").to_string(),
+                data: ItemData {
+                    checked: row.read::<i64, _>("checked") > 0,
+                    amount: row.read::<i64, _>("amount"),
+                },
+            }
+        })
+        .collect();
+    Json(list)
 }
 
-// http PUT hemma.nubo.sh/api/list/mjölk
-// body: ItemData {
-//     checked: true,
-// }
 #[put("/api/list/<item>", data = "<data>")]
-fn put_list(item: &str, data: Json<ItemData>, mock_db: &State<Mutex<MockDb>>) {
-    println!("{} {:?}", item, data);
-
-    let mut mock_db = mock_db.lock().unwrap();
-    if let Some(item) = mock_db.list.iter_mut().find(|x| x.name == item) {
-        item.data = data.into_inner()
-    } else {
-        mock_db.list.push(Item {
-            name: item.to_string(),
-            data: data.into_inner(),
-        });
-    }
+fn put_list(item: &str, data: Json<ItemData>, db: &State<ConnectionThreadSafe>) {
+    // TODO: errorhandling
+    let query =
+        "INSERT INTO list VALUES(?, ?, ?) ON CONFLICT DO UPDATE SET checked = ?, amount = ?;";
+    let mut statement = db.prepare(query).unwrap();
+    let data = data.into_inner();
+    statement.bind((1, item)).unwrap();
+    statement.bind((2, data.checked as i64)).unwrap();
+    statement.bind((3, data.amount)).unwrap();
+    statement.bind((4, data.checked as i64)).unwrap();
+    statement.bind((5, data.amount)).unwrap();
+    while let Ok(sqlite::State::Row) = statement.next() {}
 }
 
 #[delete("/api/list/<item>")]
-fn delete_item(item: &str, mock_db: &State<Mutex<MockDb>>) {
-    let mut mock_db = mock_db.lock().unwrap();
-    if let Some(index) = mock_db.list.iter().position(|x| x.name == item) {
-        mock_db.list.remove(index);
-    }
+fn delete_item(item: &str, db: &State<ConnectionThreadSafe>) {
+    // TODO: Eror handling
+    let query = "DELETE FROM list WHERE itemname = ?";
+    let mut statement = db.prepare(query).unwrap();
+    statement.bind((1, item)).unwrap();
+    while let Ok(sqlite::State::Row) = statement.next() {}
 }
 
 #[launch]
 fn rocket() -> _ {
+    let db_path = env::var("DB_PATH").unwrap();
+    let db = sqlite::Connection::open_thread_safe(db_path).unwrap();
+    db.execute(include_str!("db/init.sql"))
+        .expect("unable to initialize database");
     rocket::build()
-        .manage(Mutex::new(MockDb::default()))
+        .manage(db)
         .mount("/", routes![index, get_list, put_list, delete_item])
 }
-
-#[derive(Serialize, Deserialize, Default, Debug)]
-struct MockDb {
-    pub list: Vec<Item>,
-}