database library

* introduce generic functions for db connection
* introduce CRUD functions for each database table
* now-*    -> Create
* get-*    -> Read
* set-*    -> Update
* remove-* -> Delete
* introduce source for function tests

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

src/functions.rs

@@ -0,0 +1,15 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+// table specific functions
+pub mod db_connection;
+pub mod harms;
+pub mod roles;
+pub mod user_roles;
+pub mod users;
+//pub mod wip;
+pub mod tests;

src/functions/db_connection.rs

@@ -0,0 +1,41 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+//use diesel::debug_query;
+use diesel::prelude::*;
+use diesel::sqlite::SqliteConnection;
+use diesel::sqlite::Sqlite;
+use dotenv::dotenv;
+use std::env;
+
+// generic functions
+pub fn establish_connection() -> SqliteConnection {
+    // load our .env file
+    dotenv().ok();
+
+    // set database_url to the given  DATABASE_URL env variable
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+
+    // establish a new SQLite connection (taking the reference from database_url)
+    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 show_query<T>(query: &T)
+where
+    T: diesel::query_builder::QueryFragment<Sqlite>,
+{
+    dbg!(diesel::debug_query::<Sqlite, _>(&query));
+}

src/functions/harms.rs

@@ -0,0 +1,188 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+//#[cfg(test)]
+
+use chrono::{Local, NaiveDateTime};
+use diesel;
+use diesel::debug_query;
+use diesel::dsl::*;
+use diesel::prelude::*;
+use diesel::sqlite::{Sqlite, SqliteConnection};
+use diesel::{QueryDsl, RunQueryDsl};
+use std::error::Error;
+
+use crate::models::harms::{Harm, NewHarm};
+use crate::schema::harms;
+use crate::schema::harms::dsl::*;
+use crate::schema::harms::*;
+
+impl Harm {
+    // implement CRUD-Functions
+    // new-    -> Create
+    // get-    -> Read
+    // set-    -> Update
+    // remove- -> Delete
+
+    pub fn new(
+        param_id_harm: &str,
+        param_id_policyholder: Option<&str>,
+        param_id_callback: Option<&str>,
+        param_date_fallback: Option<NaiveDateTime>,
+        param_date_recording: NaiveDateTime,
+        param_id_user: i32,
+        connection: &SqliteConnection,
+    ) -> Result<(), Box<dyn Error>> {
+        let struct_harm = NewHarm {
+            id_harm: param_id_harm,
+            id_policyholder: param_id_policyholder,
+            id_callback: param_id_callback,
+            date_fallback: param_date_fallback,
+            date_recording: param_date_recording,
+            id_user: param_id_user,
+            date_created: Some(Local::now().naive_local()),
+            id_user_changed: param_id_user,
+            date_changed: Some(Local::now().naive_local()),
+        };
+
+        diesel::insert_into(harms::table)
+            .values(struct_harm)
+            .execute(connection)?;
+
+        Ok(())
+    }
+
+    /*
+    pub fn delete(param_hame_id: i32, connection: &SqliteConnection) -> Result<(), Box<dyn Error>> {
+        diesel::delete(dsl::harms.filter(dsl::id.eq(param_role_id)).find(id)).execute(connection)?;
+
+        Ok(())
+
+        // alternative:
+        // let old_count = get_count();
+        // assert_eq!(old_count.map(|count| count - 1), get_count());
+    }
+     */
+
+    pub fn get_all(connection: &SqliteConnection) -> Box<Vec<Harm>> {
+        Box::new(
+            harms
+                .order(harms::id.asc())
+                .load::<Harm>(connection)
+                .expect("Error loading harms"),
+        )
+    }
+
+    pub fn get(
+        param_id_harm: &str,
+        connection: &SqliteConnection,
+    ) -> Result<Vec<Harm>, Box<dyn Error>> {
+        let query = harms
+            .filter(id_harm.eq(param_id_harm))
+            .load::<Harm>(connection)
+            .expect("Error loading harm");
+        debug_query::<Sqlite, _>(&query);
+
+        Ok(query)
+    }
+
+    pub fn update(
+        param_id: i32,
+        param_id_harm: &str,
+        connection: &SqliteConnection,
+    ) -> Result<(), Box<dyn Error>> {
+        let query = diesel::update(harms.filter(id.eq(param_id)))
+            .set(id_harm.eq(param_id_harm))
+            .execute(connection);
+
+        debug_query::<Sqlite, _>(&query);
+
+        Ok(())
+    }
+}
+
+pub fn set_harms_single_column(connection: &SqliteConnection) -> QueryResult<usize> {
+    insert_into(harms)
+        .values(id_harm.eq("123456789"))
+        .execute(connection)
+}
+
+#[test]
+fn examine_set_harms_single_column() {
+    let query = insert_into(harms).values(id_harm.eq("123456789"));
+    let sql = "INSERT INTO `harms` (`id_harm`) VALUES (?) \
+               -- binds: [\"123456789\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn set_harms_multi_column(connection: &SqliteConnection) -> QueryResult<usize> {
+    insert_into(harms)
+        .values((
+            id_harm.eq("123456789"),
+            id_policyholder.eq("110-123456789"),
+            id_callback.eq("0221 93123456789"),
+        ))
+        .execute(connection)
+}
+
+#[test]
+fn examine_set_harms_multi_column() {
+    let query = insert_into(harms).values((
+        id_harm.eq("123456789"),
+        id_policyholder.eq("110-123456789"),
+        id_callback.eq("0221 93123456789"),
+    ));
+    let sql = "INSERT INTO `harms` (`id_harm`, `id_policyholder`, `id_callback`) \
+               VALUES (?, ?, ?) \
+               -- binds: [\"123456789\", \"110-123456789\", \"0221 93123456789\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn set_harms_struct_json(connection: &SqliteConnection) -> Result<(), Box<dyn Error>> {
+    let json = r#"{ "id_harm": "123456789", "id_policyholder": "110-123456789", "id_callback": "0221 92123456789", "date_recording": "2019-11-16 20:00:15.114957766"}"#;
+    let harm_struct = serde_json::from_str::<NewHarm>(json)?;
+
+    insert_into(harms)
+        .values(&harm_struct)
+        .execute(connection)?;
+
+    Ok(())
+}
+
+#[test]
+fn examine_set_harms_struct_json() {
+    let json = r#"{ "id_harm": "123456789", "id_policyholder": "110-123456789", "id_callback": "0221 93123456789", "date_recording": "2019-11-19T00:08:00", "id_user": 102, "id_user_changed": 101 }"#;
+    let harm_struct = serde_json::from_str::<NewHarm>(json).unwrap();
+    let query = insert_into(harms).values(&harm_struct);
+    let sql =
+        "INSERT INTO `harms` (`id_harm`, `id_policyholder`, `id_callback`, `date_recording`, `id_user`, `id_user_changed`) \
+         VALUES (?, ?, ?, ?, ?, ?) \
+         -- binds: [\"123456789\", \"110-123456789\", \"0221 93123456789\", 2019-11-19T00:08:00, 102, 101]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn set_harms_struct_json_option(connection: &SqliteConnection) -> Result<(), Box<dyn Error>> {
+    let json = r#"{ "id_harm": "123456789", "id_policyholder": null, "id_callback": null, "date_recording": "2019-11-19T00:08:00", 102, 101 }"#;
+    let harm_struct = serde_json::from_str::<NewHarm>(json)?;
+
+    insert_into(harms)
+        .values(&harm_struct)
+        .execute(connection)?;
+
+    Ok(())
+}
+
+#[test]
+fn examine_set_harms_struct_json_option() {
+    let json = r#"{ "id_harm": "123456789", "id_policyholder": null, "id_callback": null, "date_recording": "2019-11-19T00:08:00", "id_user": 102, "id_user_changed": 101 }"#;
+    let harm_struct = serde_json::from_str::<NewHarm>(json).unwrap();
+    let query = insert_into(harms).values(&harm_struct);
+    let sql = "INSERT INTO `harms` (`id_harm`, `date_recording`, `id_user`, `id_user_changed`) \
+               VALUES (?, ?, ?, ?) \
+               -- binds: [\"123456789\", 2019-11-19T00:08:00, 102, 101]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}

src/functions/roles.rs

@@ -0,0 +1,101 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+//#[cfg(test)]
+
+use chrono::Local;
+use diesel::debug_query;
+use diesel::prelude::*;
+use diesel::sqlite::{Sqlite, SqliteConnection};
+use diesel::{QueryDsl, RunQueryDsl};
+use std::error::Error;
+
+//use crate::functions::establish_connection;
+//use crate::models::roles::{NewRole, Role, RoleList};
+use crate::models::roles::{NewRole, Role};
+use crate::schema::roles;
+use crate::schema::roles::dsl::*;
+use crate::schema::roles::*;
+
+impl Role {
+    // implement CRUD-Functions for our trait
+    // new-    -> Create
+    // show-   -> Read
+    // update- -> Update
+    // delete- -> Delete
+
+    pub fn new(
+        param_role_name: &str,
+        param_id_user_changed: i32,
+        connection: &SqliteConnection,
+    ) -> Result<(), Box<dyn Error>> {
+        //let row = Self::get(param_role_name, param_user_id_changed, &connection);
+        //if row.len() == 0 {
+        // create a new role row
+        let struct_role = NewRole {
+            name: param_role_name,
+            date_created: Some(Local::now().naive_local()),
+            id_user_changed: param_id_user_changed,
+            date_changed: Some(Local::now().naive_local()),
+        };
+        diesel::insert_into(roles::table)
+            .values(struct_role)
+            .execute(connection)?;
+
+        Ok(())
+        //else {
+        //    Err(("row already exists!"))
+        //}
+    }
+
+    /*
+    pub fn delete(param_role_id: i32, connection: &SqliteConnection) -> Result<(), Box<dyn Error>> {
+        diesel::delete(dsl::roles.filter(dsl::id.eq(param_role_id)).find(id)).execute(connection)?;
+
+        Ok(())
+
+        // alternative:
+        // let old_count = get_count();
+        // assert_eq!(old_count.map(|count| count - 1), get_count());
+    }
+     */
+
+    pub fn get_all(connection: &SqliteConnection) -> Box<Vec<Role>> {
+        Box::new(
+            roles
+                .order(roles::id.asc())
+                .load::<Role>(connection)
+                .expect("Error loading roles"),
+        )
+    }
+
+    pub fn get(
+        param_role_name: &str,
+        connection: &SqliteConnection, //) -> Vec<Role> {
+    ) -> Result<Vec<Role>, Box<dyn Error>> {
+        let query = roles
+            .filter(name.eq(param_role_name))
+            .load::<Role>(connection)
+            .expect("Error loading roles");
+        debug_query::<Sqlite, _>(&query);
+
+        Ok(query)
+    }
+
+    pub fn update(
+        param_id: i32,
+        param_role_name: &str,
+        connection: &SqliteConnection,
+    ) -> Result<(), Box<dyn Error>> {
+        let query = diesel::update(roles.filter(id.eq(param_id)))
+            .set(name.eq(param_role_name))
+            .execute(connection);
+        debug_query::<Sqlite, _>(&query);
+
+        Ok(())
+    }
+}

src/functions/tests.rs

@@ -0,0 +1,178 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+#[cfg(test)]
+use diesel::debug_query;
+use diesel::dsl::*;
+use diesel::prelude::*;
+#[cfg(test)]
+use diesel::sqlite::Sqlite;
+#[cfg(test)]
+use diesel::sqlite::SqliteConnection;
+
+use crate::schema;
+
+// defaults
+pub fn set_users_default_values(connection: &SqliteConnection) -> QueryResult<usize> {
+    use schema::users::dsl::*;
+
+    insert_into(users).default_values().execute(connection)
+}
+
+#[test]
+fn examine_set_users_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 set_roles_default_values(connection: &SqliteConnection) -> QueryResult<usize> {
+    use schema::roles::dsl::*;
+
+    insert_into(roles).default_values().execute(connection)
+}
+
+#[test]
+fn examine_set_roles_default_values() {
+    use schema::roles::dsl::*;
+
+    let query = insert_into(roles).default_values();
+    let sql = "INSERT INTO `roles` DEFAULT VALUES -- binds: []";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn set_user_roles_default_values(connection: &SqliteConnection) -> QueryResult<usize> {
+    use schema::user_roles::dsl::*;
+
+    insert_into(user_roles).default_values().execute(connection)
+}
+
+#[test]
+fn examine_set_user_roles_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 set_harms_default_values(connection: &SqliteConnection) -> QueryResult<usize> {
+    use schema::harms::dsl::*;
+
+    insert_into(harms).default_values().execute(connection)
+}
+
+#[test]
+fn examine_set_harms_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 set_users_email_confirmed(connection: &SqliteConnection) -> QueryResult<usize> {
+    use schema::users::dsl::*;
+
+    diesel::update(users)
+        .set(email_confirmed.eq(1))
+        .execute(connection)
+}
+
+pub fn set_users_single_column(connection: &SqliteConnection) -> QueryResult<usize> {
+    use schema::users::dsl::*;
+
+    insert_into(users)
+        .values(alias_name.eq("Hiedemann"))
+        .execute(connection)
+}
+
+#[test]
+fn examine_set_users_single_column() {
+    use schema::users::dsl::*;
+
+    let query = insert_into(users).values(alias_name.eq("Hiedemann"));
+    let sql = "INSERT INTO `users` (`alias_name`) VALUES (?) \
+               -- binds: [\"Hiedemann\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+pub fn set_users_multiple_columns(connection: &SqliteConnection) -> QueryResult<usize> {
+    use schema::users::dsl::*;
+
+    insert_into(users)
+        .values((
+            first_name.eq("Lothar"),
+            last_name.eq("Schlömer"),
+            alias_name.eq("102"),
+        ))
+        .execute(connection)
+}
+
+#[test]
+fn examine_set_user_multiple_columns() {
+    use schema::users::dsl::*;
+
+    let query = diesel::insert_into(users).values((
+        first_name.eq("Lothar"),
+        last_name.eq("Schlömer"),
+        alias_name.eq("102"),
+    ));
+    let sql = "INSERT INTO `users` (`first_name`, `last_name`, `alias_name`) \
+               VALUES (?, ?, ?) \
+               -- binds: [\"Lothar\", \"Schlömer\", \"102\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+
+/*
+#[test]
+fn examine_set_user_struct_json() {
+    use crate::models::users::NewUser;
+    use schema::users::dsl::*;
+    //use serde_json::json;
+
+    /*_let json_struct = json!({
+        "last_name": "Knocke",
+        "first_name": "Daniela",
+        "alias_name": "Sekretariat",
+        "email": "knocke@kanzlei.hiedemann.de",
+        "email_confirmed": 1,
+        "password_hash": "",
+        "initials": "dkn",
+        "date_create": "2019-11-16 20:00:14.114957766",
+        "id_changed": 1,
+        "date_changed": "2019-11-16 20:00:15.114957766",
+    });*/
+
+    let json = r#"{ "last_name": "Knocke", "first_name": "Daniela", "alias_name": "Sekretariat", "email": "knocke@kanzlei.hiedemann.de", "email_confirmed": 1, "initials": "dkn", "password_hash": "testpassword", "date_created": "2019-11-16 20:00:14.114957766", "id_changed": 1", "date_changed": "2019-11-16 20:00:15.114957766" }"#;
+    let user_struct = serde_json::from_str::<NewUser>(json).unwrap();
+    let query = diesel::insert_into(users).values(&user_struct);
+    //let query = serde_json::from_str::<User>(&json_struct);
+    let sql = "diesel::INSERT INTO `users` (`last_name`, `first_name`, `alias_name`, `email`, `email_confirmed`, `initials`, `password_hash`, `date_create`, `id_changed`, `data_updated`) \
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \
+               -- binds: [\"Knocke\", \"Daniela\", \"Sekretariat\", \"knocke@kanzlei.hiedemann.de\", 1, \"dkn\", \"testpassword\", \"2019-11-16 20:00:14.114957766\", 1, \"2019-11-16 20:00:15.114957766\"]";
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}
+*/
+
+#[test]
+fn examine_set_user_struct_json_option() {
+    use crate::models::users::NewUser;
+    use schema::users::dsl::*;
+    use serde_json;
+
+    let json = r#"{ "last_name": "Knocke", "first_name": null, "alias_name": null, "email": "knocke@kanzlei.hiedemann.de", "email_confirmed": 1, "initials": "dkn", "password_hash": "test", "date_created": null, "id_changed": 1, "date_changed": null }"#;
+    let user_struct = serde_json::from_str::<NewUser>(json).unwrap();
+    let query = diesel::insert_into(users).values(&user_struct);
+    let sql = "INSERT INTO `users` (`last_name`, `email`, `email_confirmed`, `initials`, `password_hash`, `id_changed`) \
+               VALUES (?, ?, ?, ?, ?, ?) \
+               -- binds: [\"Knocke\", \"knocke@kanzlei.hiedemann.de\", 1, \"dkn\", \"test\", 1]";
+    //assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
+}

src/functions/user_roles.rs

@@ -0,0 +1,75 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+//#[cfg(test)]
+
+use diesel::debug_query;
+use diesel::prelude::*;
+use diesel::sqlite::{Sqlite, SqliteConnection};
+use diesel::{QueryDsl, RunQueryDsl};
+use std::error::Error;
+
+use crate::models::user_roles::{NewUserRole, UserRole};
+use crate::schema::user_roles;
+use crate::schema::user_roles::dsl::*;
+use crate::schema::user_roles::*;
+
+impl UserRole {
+    pub fn new(
+        param_id_user: i32,
+        param_id_role: i32,
+        connection: &SqliteConnection,
+    ) -> Result<(), Box<dyn Error>> {
+        let struct_user_role = NewUserRole {
+            id_user: param_id_user,
+            id_role: param_id_role,
+            //date_created: Some(Local::now().naive_local()),
+            //id_user_changed: param_id_user_changed,
+            //date_changed: Some(Local::now().naive_local()),
+        };
+        diesel::insert_into(user_roles::table)
+            .values(struct_user_role)
+            .execute(connection)?;
+
+        Ok(())
+    }
+
+    pub fn get_all(connection: &SqliteConnection) -> Box<Vec<UserRole>> {
+        Box::new(
+            user_roles
+                .order(user_roles::id_user.asc())
+                .load::<UserRole>(connection)
+                .expect("Error loading user_roles"),
+        )
+    }
+
+    pub fn get(
+        param_id_role: i32,
+        connection: &SqliteConnection,
+    ) -> Result<Vec<UserRole>, Box<dyn Error>> {
+        let query = user_roles
+            .filter(id_role.eq(param_id_role))
+            .load::<UserRole>(connection)
+            .expect("Error loading user_roles");
+        debug_query::<Sqlite, _>(&query);
+
+        Ok(query)
+    }
+
+    pub fn update(
+        param_id_user: i32,
+        param_id_role: i32,
+        connection: &SqliteConnection,
+    ) -> Result<(), Box<dyn Error>> {
+        let query = diesel::update(user_roles.filter(id_user.eq(param_id_user)))
+            .set(id_role.eq(param_id_role))
+            .execute(connection);
+        debug_query::<Sqlite, _>(&query);
+
+        Ok(())
+    }
+}

src/functions/users.rs

@@ -0,0 +1,180 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+use bcrypt::{hash, DEFAULT_COST};
+use chrono::Local;
+use diesel::debug_query;
+use diesel::prelude::*;
+use diesel::sqlite::Sqlite;
+#[cfg(test)]
+use diesel::sqlite::SqliteConnection;
+use diesel::{QueryDsl, RunQueryDsl};
+use serde_json;
+use std::error::Error;
+
+//use crate::models::users::{NewUser, RegisterUser, User, UserList};
+use crate::models::users::{NewUser, RegisterUser, User};
+use crate::schema::users;
+use crate::schema::users::dsl::*;
+
+impl User {
+    // implement CRUD-Functions
+    // new-    -> Create
+    // get-    -> Read
+    // set-    -> Update
+    // remove- -> Delete
+
+    pub fn new(
+        param_last_name: &str,
+        param_first_name: Option<&str>,
+        param_alias_name: Option<&str>,
+        param_email: Option<&str>,
+        param_email_confirmed: Option<i32>,
+        param_password_hash: &str,
+        param_initials: Option<&str>,
+        param_id_user: i32,
+        connection: &SqliteConnection,
+    ) -> Result<(), Box<dyn Error>> {
+        let struct_user = NewUser {
+            last_name: param_last_name,
+            first_name: param_first_name,
+            alias_name: param_alias_name,
+            email: param_email,
+            email_confirmed: param_email_confirmed,
+            password_hash: param_password_hash,
+            //password_hash: Self::hash_password(param_password_hash.to_string()).unwrap(),
+            initials: param_initials,
+            date_created: Some(Local::now().naive_local()),
+            id_changed: param_id_user,
+            date_changed: Some(Local::now().naive_local()),
+        };
+
+        diesel::insert_into(users::table)
+            .values(struct_user)
+            .execute(connection)?;
+
+        Ok(())
+    }
+
+    pub fn get_all(connection: &SqliteConnection) -> Box<Vec<User>> {
+        Box::new(
+            users
+                .order(users::id.asc())
+                .load::<User>(connection)
+                .expect("Error loading users"),
+        )
+    }
+
+    /*
+    pub fn get(
+        param_last_name: &str,
+        connection: &SqliteConnection,
+    ) -> Result<Vec<User>, Box<dyn Error>> {
+        let query = users
+            .filter(last_name.eq(param_last_name))
+            .load::<User>(connection)
+            .expect("Error loading users");
+        debug_query::<Sqlite, _>(&query);
+
+        Ok(query)
+    }
+     */
+
+    pub fn update(param_id: i32, connection: &SqliteConnection) -> Result<(), Box<dyn Error>> {
+        let query = users.filter(id.eq(param_id)).execute(connection)?;
+
+        debug_query::<Sqlite, _>(&query);
+
+        Ok(())
+    }
+
+    // helper functions
+    pub fn hash_password(plain: &str) -> Result<String, Box<dyn Error>> {
+        Ok(hash(plain, DEFAULT_COST)?)
+    }
+
+    // tests
+    pub fn set_users_email_confirmed(connection: &SqliteConnection) -> QueryResult<usize> {
+        diesel::update(users)
+            .set(email_confirmed.eq(1))
+            .execute(connection)
+    }
+
+    pub fn set_users_single_column(connection: &SqliteConnection) -> QueryResult<usize> {
+        diesel::insert_into(users)
+            .values(alias_name.eq("Hiedemann"))
+            .execute(connection)
+    }
+
+    pub fn set_users_multiple_columns(connection: &SqliteConnection) -> QueryResult<usize> {
+        diesel::insert_into(users)
+            .values((
+                first_name.eq("Lothar"),
+                last_name.eq("Schlömer"),
+                alias_name.eq("102"),
+            ))
+            .execute(connection)
+    }
+
+    pub fn set_user_struct_json(connection: &SqliteConnection) -> Result<(), Box<dyn Error>> {
+        let json = r#"{ "first_name": "Daniela", "last_name": "Knocke", "alias_name": "Sekretariat", "email": "knocke@kanzlei.hiedemann.de",  "email_confirmed": 1, "password_hash": "", "initials": "dkn" }"#;
+        let user_struct = serde_json::from_str::<NewUser>(json)?;
+
+        diesel::insert_into(users)
+            .values(&user_struct)
+            .execute(connection)?;
+
+        Ok(())
+    }
+
+    pub fn set_user_struct_json_option(
+        connection: &SqliteConnection,
+    ) -> Result<(), Box<dyn Error>> {
+        let json = r#"{ "first_name": null, "last_name": "Knocke", "alias_name": null, "email": "knocke@kanzlei.hiedemann.de", "email_confirmed": 1, "password_hash": "", "initials": "dkn", "id_changed": 1 }"#;
+        let user_form = serde_json::from_str::<NewUser>(json)?;
+
+        diesel::insert_into(users)
+            .values(&user_form)
+            .execute(connection)?;
+
+        Ok(())
+    }
+}
+
+impl<'a> RegisterUser<'a> {
+    //pub fn validates(self) -> Result<(), Error> {
+    pub fn validates(self) -> Result<RegisterUser<'a>, &'static str> {
+        let password_are_equal = self.password_hash == self.password_confirmation;
+        let password_not_empty = self.password_hash.len() > 0;
+        if password_are_equal && password_not_empty {
+            Ok(self)
+        //else if !password_are_equal {
+        //   Err("Password and Password Confirmation does not match")
+        } else {
+            Err("Wrong Password, check it is not empty")
+        }
+    }
+
+    /*
+        pub fn get_all(
+            connection: &SqliteConnection,
+            //) -> Product {
+            //) -> Box<Vec<User>> {
+        ) -> Result<Vec<User>, Box<dyn Error>> {
+            let data = users
+                .filter(last_name.like("H%"))
+                //.order(users::id.desc())
+                .load(connection)?;
+            debug_query::<Sqlite, _>(&data);
+
+            Ok(data)
+
+            // We return a value by leaving it without a comma
+            //UserList(all_users)
+        }
+    */
+}

src/functions/wip.rs

@@ -0,0 +1,139 @@
+// WIP
+
+use diesel::dsl::*;
+use diesel::prelude::*;
+//#[cfg(test)]
+//use diesel::sqlite::Sqlite;
+//#[cfg(test)]
+//use diesel::sqlite::SqliteConnection;
+//use serde_derive;
+//use std::error::Error;
+
+use crate::schema;
+
+pub fn set_users_single_column_batch(conn: &SqliteConnection) -> QueryResult<usize> {
+    use schema::users::dsl::*;
+
+    insert_into(users)
+        .values(&vec![last_name.eq("Zerres"), last_name.eq("Plank")])
+        .execute(conn)
+}
+
+/*
+#[test]
+fn examine_sql_users_insert_get_results() {
+    use diesel::result::Error;
+
+    let connection = establish_connection();
+    connection.test_transaction::<_, Error, _>(|| {
+        use diesel::select;
+        use diesel::dsl;
+        use chrono::NaiveDateTime;
+        use schema::users::dsl::*;
+        use models::insert::NewUser;
+        //use models::User;
+
+        //let now = select(dsl::now).get_result::<NaiveDateTime>(&connection)?;
+
+        let inserted_users = connection.transaction::<_, Error, _>(|| {
+            let inserted_count = insert_into(users)
+                .values(&vec![
+                    (id.eq(1), last_name.eq("Hiedemann"), first_name.eq("Eric"),
+                    alias.eq("Eric.Hiedemann"), email_confirmed.eq(0),initials.eq("EH")),
+                    (id.eq(2), last_name.eq("Schlömer"), first_name.eq("Lothar"),
+                    alias.eq("Lothar.Schlömer"), email_confirmed.eq(0), initials.eq("LS")),
+                ])
+                .execute(&connection)?;
+
+            Ok(users
+                .order(id.desc())
+                .limit(inserted_count as i64)
+                .load(&connection)?
+                .into_iter()
+                .rev()
+                .collect::<Vec<_>>())
+        })?;
+
+        let expected_users = vec![
+            NewUser {
+                //id: 1,
+                last_name: "Hiedemann".into(),
+                first_name: "Eric".into(),
+                alias: "Eric.Hiedemann".into(),
+                email: "".into(),
+                email_confirmed: 0,
+                password_hash: "".into(),
+                initials: "EH".into(),
+                //date_created: now,
+                //date_updated: now,
+            },
+            NewUser {
+                //id: 2,
+                last_name: "Schlömer".into(),
+                first_name: "Lothar".into(),
+                alias: "Lothar.Schlömer".into(),
+                email: "".into(),
+                email_confirmed: 0,
+                password_hash: "".into(),
+                initials: ("LS").into(),
+                //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/lib.rs

@@ -0,0 +1,20 @@
+/*
+ * advotracker - Hotline tackingtool for Advocats
+ *
+ * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
+ * SPDX-License-Identifier: (0BSD or MIT)
+ */
+
+// backend database crate
+//#![recursion_limit = "128"]
+#![warn(clippy::pedantic)]
+#![warn(clippy::nursery)]
+
+// modules
+pub mod models;
+pub mod schema;
+
+#[macro_use]
+extern crate diesel;
+
+pub mod functions;