328 lines
9.4 KiB
Rust
328 lines
9.4 KiB
Rust
// SPDX-License-Identifier: 0BSD, MIT
|
|
/*
|
|
* advotracker - Hotline tackingtool for Advocats
|
|
*
|
|
* Copyright 2020-2021 Ralf Zerres <ralf.zerres@networkx.de>
|
|
*/
|
|
|
|
// 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");
|
|
}
|
|
*/
|