diff options
Diffstat (limited to 'src/db.rs')
| -rw-r--r-- | src/db.rs | 253 |
1 files changed, 253 insertions, 0 deletions
diff --git a/src/db.rs b/src/db.rs new file mode 100644 index 0000000..43a2cc7 --- /dev/null +++ b/src/db.rs @@ -0,0 +1,253 @@ +use serde::{Serialize, Deserialize}; +use sha2::{Digest, Sha256}; +use std::collections::HashMap; +use std::path::PathBuf; +use std::{fs::File, io::Write}; + +use crate::uid::{self, UID}; + +#[derive(Serialize, Deserialize)] +pub struct Config { + dbsave: PathBuf, + realm: String, +} +impl Config { + pub fn new() -> Config { + Config { dbsave: "db.json".into(), realm: "localhost".into() } + } +} + +#[derive(Debug, Serialize, Deserialize, Clone, Copy)] +enum Color { + White, + Red, + Blue, + Green, + Yellow, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +struct Token { + color: Color, + amount: usize, +} +impl Token { + pub fn new(color: Color, amount: usize) -> Token { + Token { color, amount } + } +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct User { + name: String, + hashed_password: String, + id: UID, + sessions: HashMap<String, String>, + tokovec: Vec<Token>, +} +impl User { + pub fn new(name: String, password: String, id: UID) -> User { + let base_tokens = vec![ + Token::new(Color::White, 2), + Token::new(Color::Red, 2), + Token::new(Color::Blue, 2), + Token::new(Color::Green, 2), + Token::new(Color::Yellow, 2), + ]; + + let hashed_password = User::hash(&password); + + User { name, hashed_password, id, tokovec: base_tokens, sessions: HashMap::new() } + } + + fn hash(t: &String) -> String { + let hashed = Sha256::digest(&t); + let hashed = base16ct::lower::encode_string(&hashed); + + hashed + } + + fn new_session(&mut self, client: String) -> String { + let hash: [u8; 32] = rand::random(); + let hash = User::hash(&hash.iter().map(|v| {format!("{}", v)}).collect()); + self.sessions.insert(hash.clone(), client); + hash + } + + fn rm_session(&mut self, session: &String) -> Result<(), String> { + match self.sessions.remove(session) { + Some(_) => Ok(()), + None => Err("Could not find sessoin".into()), + } + } + + fn clear_sessions(&mut self) { + self.sessions.clear() + } + + fn get_sessions(&mut self) -> Vec<(String, String)> { + self.sessions.iter().map(|(k, v)| { + (k.clone(), v.clone()) + }).collect() + } + + fn login(&mut self, password: &String, clientid: &String) -> Result<String, String> { + if self.hashed_password == User::hash(password) { + Ok(self.new_session(clientid.clone())) + } else { + Err("Could not login".into()) + } + } + + fn authenticate(&self, session: &String) -> bool { + match self.sessions.get(session) { + // Session authenticated/found + Some(_) => true, + // Session not found + None => false, + } + + } + + fn logout(&mut self, session: &String) -> Result<(), String> { + if self.authenticate(session) { + self.rm_session(session) + } else { + Err("Not Authenticated".into()) + } + } + + pub fn get_name(&self) -> String { + self.name.clone() + } + pub fn hex_id(&self) -> String { + self.id.to_hex() + } +} + +#[derive(Serialize, Deserialize)] +pub struct DB { + pub uid_generator: uid::Generator, + users: Vec<User>, + config: Config, +} +impl DB { + async fn save(&self) -> Result<(), String> { + let mut f = match File::create(&self.config.dbsave) { + Ok(n) => n, + Err(n) => { + match n.kind() { + std::io::ErrorKind::PermissionDenied => panic!("{:?}: Permission Denied", &self.config.dbsave), + n => return Err(n.to_string()), + } + }, + }; + let s = match serde_json::to_string(self) { + Ok(n) => n, + Err(n) => return Err(n.to_string()), + }; + match f.write(s.as_bytes()) { + Ok(_) => return Ok(()), + Err(n) => return Err(n.to_string()), + }; + } + pub fn load(c: Config) -> Self { + match File::open(&c.dbsave) { + Ok(n) => { + match serde_json::from_reader(n) { + Ok(n) => n, + Err(n) => panic!("{}", n), + } + }, + Err(n) => match n.kind() { + std::io::ErrorKind::PermissionDenied => panic!("{:?}: Permission Denied", &c.dbsave), + _ => DB::new(c), + }, + } + } + pub fn new(config: Config) -> Self { + DB { uid_generator: uid::Generator::new(), users: vec![], config } + } + + pub async fn get_user(&mut self, id: &str) -> Result<&User, String> { + match UID::from(id.to_string()) { + Ok(n) => { + for u in self.users.iter_mut() { + if u.id == n { + return Ok(u) + } + } + }, + Err(_) => (), + } + + Err("Not Found".into()) + } + pub async fn get_mut_user(&mut self, id: &str) -> Result<&mut User, String> { + match UID::from(id.to_string()) { + Ok(n) => { + for u in self.users.iter_mut() { + if u.id == n { + return Ok(u) + } + } + }, + Err(_) => (), + } + + Err("Not Found".into()) + } + + pub async fn get_user_by_name(&self, name: &str) -> Result<Vec<User>, String> { + let mut vec = vec![]; + for u in self.users.clone() { + if u.name == name { + vec.push(u) + } + } + + if vec.len() == 0 { + Err("Not Found".into()) + } else { + return Ok(vec) + } + + } + + pub async fn get_all_users(&self) -> Result<Vec<User>, String> { + if self.users.len() == 0 { + Err("No Users".into()) + } else { + Ok(self.users.clone()) + } + } + + pub async fn new_user(&mut self, name: String, password: String, id: UID) -> Result<(), String> { + let user = User::new(name, password, id); + self.users.push(user); + self.save().await + } + + pub async fn login(&mut self, id: &String, password: &String, clientid: &String) -> Result<String, String> { + let r = match self.get_mut_user(id).await { + Ok(n) => { + n.login(password, clientid) + }, + Err(n) => Err(n) + }; + + let _ = self.save().await; + r + } + pub async fn logout(&mut self, id: &String, session: &String) -> Result<(), String> { + let r = match self.get_mut_user(id).await { + Ok(n) => { + n.logout(session) + }, + Err(n) => Err(n) + }; + + let _ = self.save().await; + r + } +} |