database handling moved to subdir (db)

* lib.rs: update local name bindings and module path (use, pub mod)
* db/mod.rs: functions, tests
* db/schemas: database schemas created via diesel
* db/models: types und enums generated for db handling
* db/types: traits and implementations te serialize, deserialize

Signed-off-by: Ralf Zerres <ralf.zerres@networkx.de>

src/db/mod.rs

@@ -0,0 +1,313 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+//use diesel::{debug_query, dsl::insert_into};
+#[cfg(test)]
+use diesel::debug_query;
+use diesel::dsl::*;
+use diesel::prelude::*;
+//use diesel::sql_query;
+#[cfg(test)]
+use diesel::sqlite::Sqlite;
+use diesel::sqlite::SqliteConnection;
+use dotenv::dotenv;
+use std::env;
+use std::error::Error;
+//use models::ConfirmState;
+
+// modules
+pub mod models;
+pub mod schema;
+pub mod types;
+
+// 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"
+    );
+     */
+}
+
+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 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::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");
+}
+*/

src/db/models.rs

@@ -0,0 +1,110 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+use chrono::NaiveDateTime;
+use super::types::ConfirmState;
+
+//use diesel::sql_types::Bool;
+use super::schema::*;
+
+// usage: INSERT
+//#[table_name = "users"]
+#[derive(Debug, Deserialize)]
+pub struct NewUser<'a> {
+    last_name: &'a str,
+    first_name: &'a str,
+    alias: &'a str,
+    email: Option<&'a str>,
+    //email_confirmed: &'a ConfirmState,
+    password_hash: Option<&'a str>,
+    initials: Option<&'a str>,
+    //date_created: &'a NaiveDateTime,
+    //date_updated: &'a NaiveDateTime
+}
+
+// usage: SELECT, UPDATE
+//#[derive(Debug, Deserialize, PartialEq, Queryable)]
+#[derive(Queryable, PartialEq, Debug)]
+struct User {
+    // id: the auto incremented primary index
+    id: i32,
+    last_name: String,
+    first_name: String,
+    alias: Option<String>,
+    email: Option<String>,
+    email_confirmed: Option<ConfirmState>,
+    password_hash: Option<String>,
+    initials: Option<String>,
+    date_created: NaiveDateTime,
+    date_updated: NaiveDateTime
+}
+
+/*
+impl NewUser<'_> {
+    // Given 'User' struct is converted to a 'NewUser' struct
+    // used to insert new rows
+    pub fn from_user<'a>(user: User) -> NewUser<'a> {
+        NewUser {
+            // id: not needed, since autupdated from db-backend
+            //user_id: user.user_id,
+            email: user.email,
+            //email_confirmed: user.email_confirmed,
+            password_hash: user.password_hash,
+            initials: user.initials,
+            last_name: user.last_name,
+            first_name: user.first_name,
+            //date_created: user.date_created,
+            //date_updated: user.date_updated,
+        }
+    }
+}
+ */
+
+// usage: INSERT
+#[derive(Deserialize, Insertable)]
+#[table_name = "user_roles"]
+pub struct NewUserRole<'a> {
+    //id: &'a i32,
+    name: &'a str
+}
+
+// usage: SELECT, UPDATE
+#[derive(Debug, Deserialize, PartialEq, Queryable)]
+struct UserRoles {
+    id: i32,
+    name: String,
+}
+
+// usage: INSERT
+#[derive(Deserialize, Insertable)]
+#[table_name = "harms"]
+pub struct NewHarm<'a> {
+    //id: &'a i32,
+    number_harm: &'a str,
+    number_policyholder: &'a str,
+    number_callback: &'a str,
+    //date_fallback: &'a NaiveDateTime,
+    //date_recording: &'a NaiveDateTime,
+    //user_id: &'a i32,
+    //date_changed: &'a NaiveDateTime,
+    //user_id_changed: &'a i32
+}
+
+// usage: SELECT, UPDATE
+//#[derive(Debug, Deserialize, PartialEq, Queryable)]
+#[derive(Queryable, PartialEq, Debug)]
+struct Harms {
+    id: i32,
+    number_harm: String,
+    number_policyholder: String,
+    number_callback: String,
+    date_fallback: NaiveDateTime,
+    date_recording: NaiveDateTime,
+    user_id: i32,
+    date_changed: NaiveDateTime,
+    user_id_changed: i32
+}

src/db/schema.rs

@@ -0,0 +1,64 @@
+table! {
+    harms (id) {
+        id -> Nullable<Integer>,
+        number_harm -> Nullable<Text>,
+        number_policyholder -> Nullable<Text>,
+        number_callback -> Nullable<Text>,
+        date_fallback -> Nullable<Timestamp>,
+        date_recording -> Timestamp,
+        user_id -> Integer,
+        date_changed -> Timestamp,
+        user_id_changed -> Nullable<Integer>,
+    }
+}
+
+table! {
+    user_claims (id) {
+        id -> Nullable<Integer>,
+        user_id -> Nullable<Integer>,
+        #[sql_name = "type"]
+        type_ -> Nullable<Text>,
+        value -> Nullable<Text>,
+    }
+}
+
+table! {
+    user_roles (id) {
+        id -> Nullable<Integer>,
+        name -> Nullable<Text>,
+    }
+}
+
+table! {
+    user_user_roles (user_id, role_id) {
+        user_id -> Integer,
+        role_id -> Integer,
+    }
+}
+
+table! {
+    users (id) {
+        id -> Nullable<Integer>,
+        last_name -> Nullable<Text>,
+        first_name -> Nullable<Text>,
+        alias -> Nullable<Text>,
+        email -> Nullable<Text>,
+        email_confirmed -> Integer,
+        password_hash -> Nullable<Text>,
+        initials -> Nullable<Text>,
+        date_created -> Timestamp,
+        date_updated -> Timestamp,
+    }
+}
+
+joinable!(user_claims -> users (user_id));
+joinable!(user_user_roles -> user_roles (role_id));
+joinable!(user_user_roles -> users (user_id));
+
+allow_tables_to_appear_in_same_query!(
+    harms,
+    user_claims,
+    user_roles,
+    user_user_roles,
+    users,
+);

src/db/types.rs

@@ -0,0 +1,161 @@
+// WIP
+
+use diesel::sqlite::Sqlite;
+use diesel::deserialize::FromSql;
+use diesel::backend::Backend;
+use diesel::sql_types::{Bool, Integer};
+use diesel::serialize::{ToSql, Output};
+
+//use super::models::ConfirmState;
+//use crate::db::models::ConfirmState;
+
+// trait: meaningful enum/types for email confirmation states
+// in analogy: https://noyez.gitlab.io/post/2018-08-05-a-small-custom-bool-type-in-diesel/
+
+#[repr(i32)]
+#[derive(AsExpression, Copy, Clone, Debug, PartialEq, FromSqlRow)]
+#[sql_type = "Integer"]
+pub enum ConfirmState {
+    Unconfirmed = 0,
+    Confirmed = 1,
+    Authorized = 2,
+    Blocked = 3,
+}
+
+impl<DB> ToSql<Integer, DB> for ConfirmState
+where
+    DB: Backend,
+    Bool: ToSql<Integer, DB> {
+    fn to_sql<W: std::io::Write>(
+        &self,
+        out: &mut Output<W, DB>,
+    ) -> diesel::serialize::Result {
+        let int_value;
+        match &self {
+            ConfirmState::Unconfirmed => int_value = 0,
+            ConfirmState::Confirmed =>  int_value = 1,
+            ConfirmState::Authorized =>  int_value = 2,
+            ConfirmState::Blocked =>  int_value = 3,
+        }
+        println!("Writing to sql: i32:{:?}", &int_value);
+        <i32 as ToSql<Integer, DB>>::to_sql(&int_value, out)
+    }
+}
+
+/*
+impl FromSql<Integer, Sqlite>
+    for ConfirmState
+{
+    fn from_sql(
+        bytes: Option<&<diesel::sqlite::Sqlite as diesel::backend::Backend>::RawValue>,
+    ) -> diesel::deserialize::Result<Self> {
+        <i32 as diesel::deserialize::FromSql<
+                diesel::sql_types::Integer, diesel::sqlite::Sqlite>>::from_sql()
+            .map(ConfirmState::Confirmed)
+    }
+}
+ */
+
+impl <DB> FromSql<Integer, DB> for ConfirmState
+where
+    DB: Backend<RawValue = [u8]>,
+    i32: FromSql<Integer, DB>
+{
+    fn from_sql(bytes: Option<&DB::RawValue>) -> diesel::deserialize::Result<Self> {
+        match <i32 as FromSql<Integer, DB>>::from_sql(bytes)? {
+            0 => Ok(ConfirmState::Unconfirmed),
+            1 => Ok(ConfirmState::Confirmed),
+            2 => Ok(ConfirmState::Authorized),
+            3 => Ok(ConfirmState::Blocked),
+            x => Err(format!("Unrecognized variant {}", x).into()),
+        }
+    }
+}
+
+/*
+impl<DB> FromSql<Integer, DB> for ConfirmState
+where
+    DB: Backend,
+    i32: FromSql<Bool, DB> {
+    //fn from_sql(bytes: Option<diesel::backend::Backend>::RawValue<DB>) -> diesel::deserialize::Result<Self> {
+    fn from_sql(
+        bytes: Option<&<DB>::RawValue>,
+    ) -> diesel::deserialize::Result<Self> {
+        //println!("Reading from sql: bytes:{:?}", bytes);
+        match bytes {
+            <i32 as diesel::deserialize::FromSql<Integer, DB>>::from_sql(bytes)
+                .map(ConfirmState::Confirmed)
+        }
+        /*
+        Some(bytes) => if bytes[0] != 0 {
+        Ok(ConfirmState::Confirmed) }
+        else { Ok(ConfirmState::Unconfirmed) }
+        }
+        //<i32 as diesel::deserialize::FromSql<Integer, DB>>::from_sql(bytes).map(ConfirmState::Confirmed)
+        //fn from_sql(bytes: Option<Bool>) -> diesel::deserialize::Result<Self> {
+        //    println!("Reading from sql: bytes:{:?}", bytes);
+        //    match bytes {
+        //        Some(bytes) => if bytes[0] != 0 {
+        //            Ok(ConfirmState::Confirmed) }
+        //        else { Ok(ConfirmState::Unconfirmed) },
+        //        None => Ok(ConfirmState::Unconfirmed),
+        //    }
+         */
+    }
+}
+ */
+
+/*
+impl<DB: diesel::backend::Backend<RawValue = [u8]>>
+    diesel::deserialize::FromSql<diesel::sql_types::Integer, DB> for ConfirmState
+{
+    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+        <i32 as diesel::deserialize::FromSql<diesel::sql_types::Integer, DB>>::from_sql(
+            bytes,
+        )
+        .map($name)
+    }
+}
+ */
+
+struct ConfirmStateVisitor;
+use serde::de::{self, Visitor};
+use serde::de::Deserialize;
+use serde::de::Deserializer;
+
+impl<'de> Visitor<'de> for ConfirmStateVisitor {
+    type Value = ConfirmState;
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        //formatter.write_str("a boolean or string of \"Confirmed\", \"Unconfirmed\", \"Authorized\", \"Unauthorized\".")
+        formatter.write_str("a boolean or string of \"Confirmed\", \"Unconfirmed\".")
+    }
+    fn visit_bool<E>(self, value: bool) -> Result<ConfirmState, E>
+    where
+        E: de::Error,     {
+        match value {
+            true => Ok(ConfirmState::Confirmed),
+            false => Ok(ConfirmState::Unconfirmed),
+        }
+    }
+    fn visit_str<E>(self, value: &str) -> Result<ConfirmState, E>
+    where
+        E: de::Error,
+    {
+        match value {
+            //"Confirmed" | "Authorized" => Ok(ConfirmState::Confirmed),
+            //"Unconfirmed" | "Unauthorized" => Ok(ConfirmState::Unconfirmed),
+            "Confirmed" => Ok(ConfirmState::Confirmed),
+            "Unconfirmed" => Ok(ConfirmState::Unconfirmed),
+            _s => Err(E::custom(format!("Unknown string value: {}", _s))),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ConfirmState {
+    fn deserialize<D>(deserializer: D) -> Result<ConfirmState, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_any(ConfirmStateVisitor)
+    }
+}

src/lib.rs

@@ -1,9 +1,26 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: 0BSD, MIT
+ */
+
+extern crate chrono;
+extern crate dotenv;
+#[macro_use]
+extern crate diesel;
+#[macro_use]
+extern crate serde_derive;
+extern crate serde_json;
+
+pub mod db;
+
 // This function adds two integers (given as arguments) and returns the sum.
 //
 // # Examples
 //
 // ```
-// assert_eq!(8, advotracker::internal_adder(4, 4));
+// assert_eq!(8, advotracker_backend::internal_adder(4, 4));
 // ```
 
 fn internal_adder(a: i32, b: i32) -> i32 {

src/schema.rs

@@ -1,36 +0,0 @@
-table! {
-    User (id) {
-        id -> Integer,
-        userId -> Integer,
-        email -> Text,
-        emailConfirmed -> Integer,
-        passwordHash -> Text,
-        initials -> Text,
-        lastName -> Text,
-        firstName -> Text,
-    }
-    UserRole (id) {
-        id -> Integer,
-        name -> Text,
-    }
-    UserUserRole (id) {
-        userId -> Integer,
-        roleId -> Integer,
-    }
-    UserClaim (id) {
-        id -> Integer,
-        userId -> Integer,
-        type -> Text,
-        value -> Text,
-    }
-    NumberHarm (id) {
-        id -> Integer,
-        numberHarm -> Text,
-        numberPolicyholder -> Text,
-        numberCollback -> Text,
-        dateRecording -> Date,
-        userId -> Integer,
-        dateChanged -> Date,
-        userIdChanged -> Integer,
-    }
-}