database.rs: include external carte to handle db methods

Signed-off-by: Ralf Zerres <ralf.zerres@networkx.de>
2020-06-09 15:44:29 +02:00
parent 4094a6a92e
commit 6778746116
1 changed files with 327 additions and 0 deletions
--- a/src/database.rs
+++ b/src/database.rs
@@ -0,0 +1,327 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+// module: db
+#![warn(clippy::pedantic)]
+#![warn(clippy::nursery)]
+
+//#[cfg(test)]
+use diesel::debug_query;
+use diesel::dsl::*;
+use diesel::prelude::*;
+//use diesel::sql_query;
+use diesel::sqlite::Sqlite;
+use diesel::sqlite::SqliteConnection;
+use dotenv::dotenv;
+//use serde_derive;
+use serde_json;
+use std::env;
+use std::error::Error;
+
+// modules
+pub mod models;
+pub mod schema;
+pub mod types;
+
+//use crate::db::models::Users;
+use crate::db::models::Harm;
+use models::User;
+use models::UserRole;
+use schema::*;
+
+// functions
+pub fn establish_connection() -> SqliteConnection {
+    dotenv().ok();
+
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    SqliteConnection::establish(&database_url)
+        .unwrap_or_else(|_| panic!("Error connecting to {}", &database_url))
+    /*
+     * WIP: integrate tracing!
+    trace!(
+        target: "diesel",
+        type: "Sqlite3",
+        status: "connected"
+    );
+     */
+}
+
+/*
+ * base functions
+pub fn users_insert_default_values(conn: &SqliteConnection) -> QueryResult<usize> {
+    //use schema::users::dsl::*;
+
+    insert_into(users).default_values().execute(conn)
+}
+
+#[test]
+fn examine_sql_users_insert_default_values() {
+    use schema::users::dsl::*;
+
+    let query = insert_into(users).default_values();
+    let sql = "INSERT INTO `users` DEFAULT VALUES -- binds: []";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn user_roles_insert_default_values(conn: &SqliteConnection) -> QueryResult<usize> {
+    use schema::user_roles::dsl::*;
+
+    insert_into(user_roles).default_values().execute(conn)
+}
+
+#[test]
+fn examine_sql_user_roles_insert_default_values() {
+    use schema::user_roles::dsl::*;
+
+    let query = insert_into(user_roles).default_values();
+    let sql = "INSERT INTO `user_roles` DEFAULT VALUES -- binds: []";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn user_harms_insert_default_values(conn: &SqliteConnection) -> QueryResult<usize> {
+    use schema::harms::dsl::*;
+
+    insert_into(harms).default_values().execute(conn)
+}
+
+#[test]
+fn examine_sql_harms_insert_default_values() {
+    use schema::harms::dsl::*;
+
+    let query = insert_into(harms).default_values();
+    let sql = "INSERT INTO `harms` DEFAULT VALUES -- binds: []";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn users_insert_single_column(conn: &SqliteConnection) -> QueryResult<usize> {
+    use schema::users::dsl::*;
+
+    insert_into(users)
+        .values(alias.eq("Hiedemann"))
+        .execute(conn)
+}
+
+#[test]
+fn examine_sql_users_insert_single_column() {
+    use schema::users::dsl::*;
+
+    let query = insert_into(users).values(alias.eq("Hiedemann"));
+    let sql = "INSERT INTO `users` (`alias`) VALUES (?) \
+               -- binds: [\"Hiedemann\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn users_insert_multiple_columns(conn: &SqliteConnection) -> QueryResult<usize> {
+    use schema::users::dsl::*;
+
+    insert_into(users)
+        .values((
+            first_name.eq("Lothar"),
+            last_name.eq("Schlömer"),
+            alias.eq("102"),
+        ))
+        .execute(conn)
+}
+
+#[test]
+fn examine_sql_user_insert_multiple_columns() {
+    use models::Users;
+    //use crate::db::models::Users;
+    use crate::db::schema::users::dsl::*;
+
+    let query = insert_into(users).values((
+        first_name.eq("Lothar"),
+        last_name.eq("Schlömer"),
+        alias.eq("102"),
+    ));
+    let sql = "INSERT INTO `users` (`first_name`, `last_name`, `alias`) \
+               VALUES (?, ?, ?) \
+               -- binds: [\"Lothar\", \"Schlömer\", \"102\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn user_insert_struct_via_json(conn: &SqliteConnection) -> Result<(), Box<dyn Error>> {
+    use models::insert::NewUser;
+    use schema::users::dsl::*;
+
+    let json = r#"{ "alias": "Daniela", "first_name": "Daniela","last_name": "Knocke" }"#;
+    let user_struct = serde_json::from_str::<NewUser>(json)?;
+
+    insert_into(users).values(&user_struct).execute(conn)?;
+
+    Ok(())
+}
+*/
+
+/*
+#[test]
+fn examine_sql_user_insert_struct_via_json() {
+    use models::NewUser;
+    use schema::users::dsl::*;
+
+    let json = r#"{ "last_name": "Knocke", "first_name": "Daniela", "alias": "Sekretariat" }"#;
+    let user_form = serde_json::from_str::<NewUser>(json).unwrap();
+    let query = insert_into(users).values(&user_form);
+    let sql = "INSERT INTO `users` (`last_name`, `first_name`, `alias`) \
+               VALUES (?, ?, ?) \
+               -- binds: [\"Knocke\", \"Daniela\", \"Sekretariat\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+ */
+
+/*
+pub fn user_insert_struct_json_option(conn: &SqliteConnection) -> Result<(), Box<dyn Error>> {
+    use models::NewUser;
+    use schema::users::dsl::*;
+
+    let json = r#"{ "alias": "Networkx", "email_confirmed": true,
+    "email": "support@networkx.de", "first_name": null, "last_name": null }"#; let user_form =
+    serde_json::from_str::<NewUser>(json)?;
+
+    insert_into(users).values(&user_form).execute(conn)?;
+
+    Ok(())
+}
+ */
+
+/*
+#[test]
+fn examine_sql_user_insert_struct_json_option() {
+    use schema::users::dsl::*;
+    use models::NewUser;
+
+    let json = r#"{ "alias": "Networkx", "email_confirmed": true, "email": "support@networkx.de", "first_name": null, "last_name": null }"#;
+    let user_form = serde_json::from_str::<NewUser>(json).unwrap();
+    let query = insert_into(users).values(&user_form);
+    let sql = "INSERT INTO `users` (`alias`, `email`, `email_confirmed`) \
+               VALUES (?, ?, ?) \
+               -- binds: [\"Networkx\", \"support@networkx.de\", \"$true\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+*/
+
+// WIP
+/*
+#[test]
+fn examine_sql_users_insert_get_results() {
+    use diesel::result::Error;
+
+    let conn = establish_connection();
+    conn.test_transaction::<_, Error, _>(|| {
+        use diesel::select;
+        use chrono::NaiveDateTime;
+        use schema::users::dsl::*;
+        //use schema::users::*;
+
+        let now = select(diesel::dsl::now).get_result::<NaiveDateTime>(&conn)?;
+
+        let inserted_users = conn.transaction::<_, Error, _>(|| {
+            let inserted_count = insert_into(users)
+                .values(&vec![
+                    (id.eq(1), last_name.eq("Hiedemann"), first_name.eq("Eric")),
+                    (id.eq(2), last_name.eq("Schlömer"), first_name.eq("Lothar")),
+                    //(id.eq(1), first_name.eq("Eric"), last_name.eq("Hiedemann"), alias.eq("Eric.Hiedemann")),
+                    //(id.eq(2), first_name.eq("Lothar"), last_name.eq("Schlömer"), alias.eq("othar.Schlömer")),
+                ])
+                .execute(&conn)?;
+
+            /*
+            Ok(users
+                .order(id.desc())
+                .limit(inserted_count as i64)
+                .load(&conn)?
+                .into_iter()
+                .rev()
+                .collect::<Vec<_>>())
+            */
+        })?;
+
+        /*
+        let expected_users = vec![
+            User {
+                id: 1,
+                last_name: "Hiedemann".into(),
+                first_name: "Eric".into(),
+                alias: "Eric.Hiedemann".into(),
+                email: None,
+                email_confirmed: false,
+                password_hash: None,
+                initials: None,
+                date_created: now,
+                date_updated: now,
+            },
+            User {
+                id: 2,
+                last_name: "Schlömer".into(),
+                first_name: "Lothar".into(),
+                alias: "Lothar.Schlömer".into(),
+                email: None,
+                email_confirmed: false,
+                password_hash: None,
+                initials: None,
+                date_created: now,
+                date_updated: now,
+            },
+        ];
+        assert_eq!(expected_users, inserted_users);
+         */
+
+        Ok(())
+    });
+}
+*/
+
+/*
+pub fn create_numberharm<'a>(connection: &SqliteConnection, NumberHarm: &'a str) {
+    let numberHarm = models::NewNumberHarm { NumberHarm };
+
+    diesel::insert_into(schema::NumberHarm::table)
+        .values(&numberHarm)
+        .execute(connection)
+        .expect("Error inserting new task");
+}
+ */
+
+/*
+pub fn create_userid<'a>(connection: &SqliteConnection, User: &'a str) {
+    let user = models::NewUser { User };
+
+    diesel::insert_into(schema::User::table)
+        .values(&user)
+        .execute(connection)
+        .expect("Error inserting new task");
+}
+ */
+
+/*
+pub fn create_userclaimid<'a>(connection: &SqliteConnection, UserClaim: &'a str) {
+    let userClaim = models::NewUserClaim { UserClaim };
+
+    diesel::insert_into(schema::UserClaim::table)
+        .values(&userClaim)
+        .execute(connection)
+        .expect("Error inserting new task");
+}
+
+pub fn create_userrole<'a>(connection: &SqliteConnection, UserRole: &'a str) {
+    let userRole = models::NewUserRole { UserRole };
+
+    diesel::insert_into(schema::UserRole::table)
+        .values(&userRole)
+        .execute(connection)
+        .expect("Error inserting new task");
+}
+
+pub fn create_useruserrole<'a>(connection: &SqliteConnection, UserUserRole: &'a str) {
+    let userUserRole = models::NewUserUserRole { UserUserRole };
+
+    diesel::insert_into(schema::UserUserRole::table)
+        .values(&userUserRole)
+        .execute(connection)
+        .expect("Error inserting new task");
+}
+*/