From 6778746116b7fdafc69810ceb0827a1b55734e38 Mon Sep 17 00:00:00 2001 From: Ralf Zerres Date: Tue, 9 Jun 2020 15:44:29 +0200 Subject: [PATCH] database.rs: include external carte to handle db methods Signed-off-by: Ralf Zerres --- src/database.rs | 327 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 327 insertions(+) create mode 100644 src/database.rs diff --git a/src/database.rs b/src/database.rs new file mode 100644 index 0000000..bc1345f --- /dev/null +++ b/src/database.rs @@ -0,0 +1,327 @@ +/* + * advotracker - Hotline tackingtool for Advocats + * + * Copyright 2019 Ralf Zerres + * 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 { + //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::(&query).to_string()); +} + +pub fn user_roles_insert_default_values(conn: &SqliteConnection) -> QueryResult { + 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::(&query).to_string()); +} + +pub fn user_harms_insert_default_values(conn: &SqliteConnection) -> QueryResult { + 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::(&query).to_string()); +} + +pub fn users_insert_single_column(conn: &SqliteConnection) -> QueryResult { + 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::(&query).to_string()); +} + +pub fn users_insert_multiple_columns(conn: &SqliteConnection) -> QueryResult { + 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::(&query).to_string()); +} + +pub fn user_insert_struct_via_json(conn: &SqliteConnection) -> Result<(), Box> { + 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::(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::(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::(&query).to_string()); +} + */ + +/* +pub fn user_insert_struct_json_option(conn: &SqliteConnection) -> Result<(), Box> { + 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::(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::(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::(&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::(&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::>()) + */ + })?; + + /* + 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"); +} +*/