Minimal Leptos setup

src/lib.rs

@@ -1,201 +1,9 @@
-use chrono::offset::Utc;
-use rusqlite::{types::ToSqlOutput, ToSql};
-use tauri::{Manager, State};
-use tauri_plugin_fs::FsExt;
-use tokio::sync::Mutex;
-use std::collections::HashMap;
-
-mod app_state;
-mod data_door;
-
-use app_state::AppState;
-
-#[derive(Clone, Copy, Debug)]
-enum Store {
-	Aldi,
-	Edeka,
-	Dm,
-	Lidl,
-	Rewe,
-	Tegut,
-}
-
-#[derive(Clone, Copy, Debug)]
-enum Account {
-	Sumpf,
-	Heinersyndikat,
-}
-
-struct Inventory {
-	acc: Account,
-	cash: i64,
-	vouchers: Vec<VoucherInventory>,
-}
-
-#[derive(Debug)]
-struct VoucherInventory {
-	store: Store,
-	count: i64,
-}
-
-impl TryFrom<&str> for Store {
-	type Error = ();
-
-	fn try_from(s: &str) -> Result<Self, Self::Error> {
-		match s {
-			"aldi" => Ok(Store::Aldi),
-			"edeka" => Ok(Store::Edeka),
-			"dm" => Ok(Store::Dm),
-			"lidl" => Ok(Store::Lidl),
-			"rewe" => Ok(Store::Rewe),
-			"tegut" => Ok(Store::Tegut),
-			_ => Err(()),
-		}
-	}
-}
-
-impl TryFrom<&str> for Account {
-	type Error = ();
-
-	fn try_from(s: &str) -> Result<Self, Self::Error> {
-		match s {
-			"sumpf" => Ok(Account::Sumpf),
-			"hs" => Ok(Account::Heinersyndikat),
-			_ => Err(()),
-		}
-	}
-}
-
-impl ToSql for Store {
-	fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
-		match self {
-			Store::Aldi => 0.to_sql(),
-			Store::Edeka => 1.to_sql(),
-			Store::Dm => 2.to_sql(),
-			Store::Lidl => 3.to_sql(),
-			Store::Rewe => 4.to_sql(),
-			Store::Tegut => 5.to_sql(),
-		}
-	}
-}
-
-impl ToSql for Account {
-	fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
-		match self {
-			Account::Sumpf => 0.to_sql(),
-			Account::Heinersyndikat => 1.to_sql(),
-		}
-	}
-}
-
-fn parse_inventory(data: HashMap<String, String>) -> Result<Inventory, ()> {
-	let a = data.get("cafe-inventory-acc").ok_or(())?;
-	let acc: Account = Account::try_from(a.as_ref())?;
-	let mut vouchers = Vec::new();
-	for s in ["aldi", "dm", "lidl", "rewe", "tegut"] {
-		let Ok(store) = s.try_into() else {
-			println!("Did not find '{}' in inventory data.", s);
-			continue;
-		};
-		match data.get(&format!("cafe-inventory-{}", s)) {
-			None => (),
-			Some(c) => {
-				let c = if c == "" {"0"} else {c};
-				let Ok(count) = c.parse() else {
-					println!("Invalid count '{}' for '{}' in inventory data.", c, s);
-					continue;
-				};
-				let v = VoucherInventory { store, count };
-				vouchers.push(v);
-			},
-		}
-	}
-	unimplemented!()
-}
-
-#[tauri::command]
-async fn inventory(
-	data: HashMap<String, String>,
-	state: State<'_, Mutex<AppState>>,
-) -> Result<(), ()> {
-	let now = Utc::now().timestamp();
-	let state = state.lock().await;
-	let inv = parse_inventory(data)?;
-	for v in inv.vouchers {
-		state.db.execute(
-			"INSERT INTO voucher_inventory VALUES ()",
-			(
-				inv.acc,
-				v.store,
-				v.count,
-				now,
-			),
-		)
-		.map_err(|e| println!("{:?}", e))?;
-	};
-	Ok(())
-}
-
-#[tauri::command]
-async fn swap(
-	store: &str,
-	acc: i64,
-	state: State<'_, Mutex<AppState>>,
-) -> Result<(), ()> {
-	let state = state.lock().await;
-	let store: Store = store.try_into()?;
-	state.db.execute(
-		"INSERT INTO swap VALUES (?1, ?2, ?3, ?4, ?5)",
-		(
-			store,
-			acc,
-			i64::from_ne_bytes(state.id.to_ne_bytes()),
-			Utc::now().timestamp(),
-			false,
-		),
-	)
-	.map_err(|e| println!("{:?}", e))?;
-	Ok(())
-}
-
-#[tauri::command]
-async fn count(state: State<'_, Mutex<AppState>>) -> Result<String, ()> {
-	let state = state.lock().await;
-	let mut stmt =
-		state.db.prepare("SELECT COUNT(*) FROM swap")
-			.map_err(|e| println!("{:?}", e))?;
-	let mut rows = stmt.query([]).map_err(|e| println!("{:?}", e))?;
-	let row = rows.next().map_err(|e| println!("{:?}", e))?;
-	let row = match row {
-		Some(r) => Ok(r),
-		None => {
-			println!("No rows");
-			Err(())
-		}
-	}?;
-	let cnt: u64 = row.get(0).map_err(|e| println!("{:?}", e))?;
-	Ok(cnt.to_string())
-}
+mod commands;
+#[cfg(feature = "server")]
+mod server;
 
+#[cfg(feature = "server")]
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
-	let state = AppState::new();
-	tauri::Builder::default()
-		.plugin(tauri_plugin_fs::init())
-		.setup(|app| {
-			app.manage(Mutex::new(state));
-			let scope = app.fs_scope();
-			let path = app.path();
-			scope.allow_directory(path.temp_dir()?, false)?;
-			Ok(())
-		})
-		.invoke_handler(tauri::generate_handler![
-			swap,
-			count,
-			inventory,
-			data_door::pull_data,
-			data_door::push_data,
-		])
-		.run(tauri::generate_context!())
-		.expect("error while running tauri application");
+	server::run();
 }