restarting project

src/pole_dialogue/database.rs

@@ -0,0 +1,208 @@
+use sqlite::{State, Error};
+use crate::database;
+
+#[cfg(test)]
+fn drop_all(con: &sqlite::Connection) -> bool {
+    let mut result: bool;
+    match con
+            .execute(
+                "
+                DROP TABLE IF EXISTS poles;
+                ",
+            )
+        {
+            Ok(_a) => result = true,
+            Err(e) => {log::error!("error drop pole {}",e);result = false},
+        };
+
+    match con
+            .execute(
+                "
+                DROP TABLE IF EXISTS last;
+                ",
+            )
+        {
+            Ok(_a) => result && true,
+            Err(e) => {log::error!("error drop last {}",e);result && false},
+        }
+}
+
+fn create_databases(con: &sqlite::Connection) -> bool {
+        return create_poles_database(con) && create_last_database(con)
+    }
+
+fn create_poles_database(con: &sqlite::Connection) -> bool {
+        match con
+            .execute(
+                "
+                CREATE TABLE IF NOT EXISTS poles (npole INTEGER, user TEXT, user_name TEXT, id_group TEXT, id INTEGER PRIMARY KEY AUTOINCREMENT);
+                ",
+            )
+        {
+            Ok(_a) => return true,
+            Err(e) => {log::error!("error pole {}",e);return false},
+        }
+    }
+
+fn create_last_database(con: &sqlite::Connection) -> bool {
+        match con
+            .execute(
+                "
+                CREATE TABLE IF NOT EXISTS last (date TEXT, id_group TEXT, user TEXT, points INTEGER, id INTEGER PRIMARY KEY AUTOINCREMENT);
+                ",
+            )
+        {
+            Ok(_a) => return true,
+            Err(e) => {log::error!("error last {}",e);return false},
+        }
+    }
+
+
+
+pub struct DatabasePole {
+    ins_connection: &'static database::DB_CONNECTION,//Mutex<Box<sqlite::Connection>>,
+}
+
+impl<'a> DatabasePole{
+    #[cfg(not(test))]
+    pub fn get_database()->Self{
+        let ret = Self{
+            ins_connection: &database::DB_CONNECTION,
+        };
+        let raw = &**ret.ins_connection.lock().unwrap();
+        create_databases(raw);
+        //log::info!("create databases {}",ret.createDatabases());
+        ret
+    }
+
+    #[cfg(test)]
+    pub fn get_database()->Self{
+        let ret = Self{
+            ins_connection: &DB_CONNECTION,
+        };
+        let raw = &**ret.ins_connection.lock().unwrap();
+        drop_all(raw);
+        create_databases(raw);
+        //log::info!("create databases {}",ret.createDatabases());
+        ret
+    }
+
+    pub fn last_pole(&self, group_id : &str) -> Result<String, Error>{
+        let builder = self.ins_connection.lock().unwrap();
+        let mut statement = builder
+                                .prepare("SELECT date FROM last WHERE id_group = ? order by date desc")
+                                .unwrap();
+        statement.bind(1, group_id).unwrap();
+        statement.next().unwrap();
+        statement.read::<String>(0)
+    }
+
+    pub fn write_points(&self, group_id : &str, user_id: &str, user_name: &str, date: &str, points: i64){
+        let builder = self.ins_connection.lock().unwrap();
+        let mut statement = builder
+                                    .prepare("SELECT npole FROM poles WHERE user = ? AND id_group = ?")
+                                    .unwrap();
+        statement.bind(1, user_id).unwrap();
+        statement.bind(2, group_id).unwrap();
+
+        match statement.next().unwrap() {
+            State::Row => {
+                let mut statement2 = builder
+                                .prepare("UPDATE poles SET npole=? WHERE user=? AND id_group=?")
+                                .unwrap();
+                statement2.bind(1, statement.read::<i64>(0).unwrap()+points).unwrap();
+                statement2.bind(2, user_id).unwrap();
+                statement2.bind(3, group_id).unwrap();
+                statement2.next().unwrap();
+            }
+            State::Done => {
+                let mut statement2 = builder
+                                .prepare("INSERT INTO poles (npole, user, user_name, id_group) VALUES (?,?,?,?)")
+                                .unwrap();
+                statement2.bind(1, points).unwrap();
+                statement2.bind(2, user_id).unwrap();
+                statement2.bind(3, user_name).unwrap();
+                statement2.bind(4, group_id).unwrap();
+                statement2.next().unwrap();
+            }
+
+        };
+
+        let mut statement3 = builder
+                                .prepare("INSERT INTO last (date, id_group, user, points) VALUES (?,?,?,?)")
+                                .unwrap();
+        statement3.bind(1, date).unwrap();
+        statement3.bind(2, group_id).unwrap();
+        statement3.bind(3, user_id).unwrap();
+        statement3.bind(4, points).unwrap();
+        statement3.next().unwrap();
+        //while let State::Row = statement3.next().unwrap() {
+        //    log::info!("name = {}", statement.read::<String>(0).unwrap());
+        //}
+    }
+
+    pub fn check_user_pole(&self, group_id : &str, user_id: &str, date: &str) -> i64{
+        let builder = self.ins_connection.lock().unwrap();
+        let mut statement = builder
+                                .prepare("SELECT points FROM last WHERE id_group = ? AND user = ? AND date = :date")
+                                .unwrap();
+        statement.bind(1, group_id).unwrap();
+        statement.bind(2, user_id).unwrap();
+        statement.bind_by_name(":date", date).unwrap();
+        match statement.next().unwrap() {
+            State::Row => statement.read::<i64>(0).unwrap(),
+            State::Done => 0,
+        }
+    }
+
+    pub fn check_group_points(&self, group_id : &str, date: &str) -> i64{
+        let builder = self.ins_connection.lock().unwrap();
+        let mut statement = builder
+                                .prepare("SELECT points FROM last WHERE id_group = ? AND date = :date")
+                                .unwrap();
+        statement.bind(1, group_id).unwrap();
+        statement.bind_by_name(":date", date).unwrap();
+        match statement.next().unwrap() {
+            State::Row => statement.read::<i64>(0).unwrap(),
+            State::Done => 0,
+        }
+    }
+
+    pub fn get_top_users(&self, group_id : &str) -> Vec<(i64,String)>{
+        let builder = self.ins_connection.lock().unwrap();
+        let mut statement = builder
+                                .prepare("SELECT npole, user_name FROM poles where id_group=? order by npole desc limit 10")
+                                .unwrap();
+        statement.bind(1, group_id).unwrap();
+        let mut ret = Vec::new();
+        for i in 1 .. 10 {
+            match statement.next().unwrap() {
+                State::Row => ret.push((
+                                    statement.read::<i64>(0).unwrap(),
+                                    statement.read::<String>(1).unwrap()
+                                    )),
+                State::Done => return ret,
+            }
+        }
+        ret
+    }
+
+}
+
+#[cfg(test)]
+#[test]
+fn write_points(){
+    let data = DatabasePole::get_database();
+    let expected = 3;
+    data.write_points("000", "000", "2020-01-01", expected);
+    assert_eq!(expected, data.check_user_pole("000", "000", "2020-01-01"));
+}
+
+#[cfg(test)]
+#[test]
+fn last_pole(){
+    let data = DatabasePole::get_database();
+    let group_id = "000";
+    data.write_points(group_id, "000", "2020-01-02", 3);
+    assert_eq!("2020-01-02", data.last_pole(group_id).unwrap());
+}