updated queries to use the new user schema columns

removed old tests which have to be rebuilt from scratch

server/src/users.rs

@@ -1,65 +1,44 @@
 use chrono::Utc;
 use rocket_contrib::json::{Json, JsonValue};
-use crate::rand_utils::{new_user_id, new_key};
+use crate::rand_utils::new_key;
 use crate::models::{User, USER_ONLINE, USER_OFFLINE};
-use crate::payload::NewUserResponse;
 use crate::{DBConn, schema};
 use diesel::{self, prelude::*};
 use diesel::result::Error;
 
-pub fn create_new_user(conn: DBConn, name: String) -> User {
+pub fn create_new_user(conn: DBConn, new_name: String) -> User {
     /*
      * Should only eveer be called under good circumstances
     */
     use schema::users::dsl::*;
-    use diesel::result::Error;
     use crate::models::InsertableUser;
 
     let ins = InsertableUser {
-        name: name,
+        name: new_name,
         secret: new_key(),
-        date: time,
+        date: Utc::now().timestamp() as u64,
         status: USER_ONLINE,
     };
     // insert the nwe user data then return usable user data to the client
-    diesel::insert_into(users::table)
+    diesel::insert_into(users)
         .values(&ins)
         .execute(&conn.0);
 
     let new_user_data : Result<User, diesel::result::Error> = users
-        .filter(userid.eq(ins.id))
+        .filter(id.eq(ins.date))
         .first(&conn.0);
 
     new_user_data.unwrap()
 }
 
 
-pub fn new_user_response(user: &Option<User>, msg: Option<&'static str>) -> NewUserResponse {
-    if let Some(u) = user {
-        NewUserResponse {
-            userid: Some(u.userid),
-            username: Some(u.username.clone()),
-            key: Some(u.key.clone()),
-            err: None
-        }
-    }
-    else{
-        NewUserResponse {
-            userid: None,
-            username: None,
-            key: None, 
-            err: Some(msg.unwrap())
-        }
-    }
-}
-
 #[delete("/remove/<hash>")]
 pub fn remove_user(hash: u64, conn: DBConn) -> JsonValue {
     // Attempt to remove the user first
     use schema::users::dsl::*;
     use diesel::result::Error;
 
-    let res: Result<usize, Error> = diesel::delete(users.filter(userid.eq(hash))).execute(&conn.0);
+    let res: Result<usize, Error> = diesel::delete(users.filter(id.eq(hash))).execute(&conn.0);
     match res {
         Ok(_res) => json!({"staus":"ok"}),
         Err(_e) => json!({"status":"err"}),
@@ -73,7 +52,7 @@ pub fn remove_user(hash: u64, conn: DBConn) -> JsonValue {
 pub fn get_user_list(conn: DBConn) -> Json<Vec<(u64, String, i32)>> {
     use schema::users::dsl::*;
 
-    let db_response: Result<Vec<(u64, String, i32)>, Error> = users.select((userid, username, status))
+    let db_response: Result<Vec<(u64, String, i32)>, Error> = users.select((id, name, status))
         .filter(status.ne(USER_OFFLINE))
         .load::<(u64, String, i32)>(&conn.0);
 
@@ -85,7 +64,6 @@ pub fn get_user_list(conn: DBConn) -> Json<Vec<(u64, String, i32)>> {
 
 #[cfg(test)]
 mod user_tests {
-    use super::create_new_user;
     use super::*;
     use rocket;
     use rocket::local::Client;
@@ -99,19 +77,6 @@ mod user_tests {
         }
     }
 
-    #[test]
-    fn generate_bs_users() {
-        use diesel::mysql::MysqlConnection;
-        // please don't ask me why this is here it just is
-        let conn = MysqlConnection::establish("mysql://freechat_dev:password@localhost:3306/freechat")
-            .unwrap();
-        for _i in 0..100 {
-            let user = create_new_user();
-            let _bs = diesel::insert_into(schema::users::table)
-                .values(&user)
-                .execute(&conn);
-        }
-    }
 
     #[test]
     fn get_user_list() {
@@ -124,25 +89,4 @@ mod user_tests {
         println!("{}", body);
     }
 
-
-    #[test]
-    fn user_struct() {
-        println!("{:?}", create_new_user());
-    }
-
-    #[test]
-    fn remove_user_pass() {
-        let user = create_new_user();
-        println!("Client to remove: {:?}", user);
-
-        let app = rocket_inst!(remove_user);
-        let client = Client::new(app).expect("Bad rocket instance");
-
-        let mut response = client.delete(format!("/users/remove/{}", user.userid)).dispatch();
-        let body: String = response.body_string().unwrap();
-
-        assert_eq!(response.status(), Status::Ok);
-        println!("{}", body);
-    }
-    //TODO: fail case for removing users
 }