146 lines
4.1 KiB
Rust
146 lines
4.1 KiB
Rust
use chrono::Utc;
|
|
use rocket_contrib::json::{Json, JsonValue};
|
|
use crate::rand_utils::{new_user_id, 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 {
|
|
use schema::users::dsl::*;
|
|
use diesel::result::Error;
|
|
use crate::models::InsertableUser;
|
|
|
|
let ins = InsertableUser {
|
|
name: name,
|
|
secret: new_key(),
|
|
date: time,
|
|
status: USER_ONLINE,
|
|
};
|
|
// insert the nwe user data then return usable user data to the client
|
|
diesel::insert_into(users::table)
|
|
.values(&ins)
|
|
.execute(&conn.0);
|
|
|
|
let new_user_data : Result<User, diesel::result::Error> = users
|
|
.filter(userid.eq(ins.id))
|
|
.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);
|
|
match res {
|
|
Ok(_res) => json!({"staus":"ok"}),
|
|
Err(_e) => json!({"status":"err"}),
|
|
}
|
|
}
|
|
|
|
|
|
// TODO: optional paramter where we can specify getting the offline users as well
|
|
// TODO: More optionally specify what kind of users we want online/offline/away etc.
|
|
#[get("/list")]
|
|
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))
|
|
.filter(status.ne(USER_OFFLINE))
|
|
.load::<(u64, String, i32)>(&conn.0);
|
|
|
|
match db_response {
|
|
Ok(data) => Json(data),
|
|
Err(_e) => Json(vec!())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod user_tests {
|
|
use super::create_new_user;
|
|
use super::*;
|
|
use rocket;
|
|
use rocket::local::Client;
|
|
use rocket::http::Status;
|
|
|
|
macro_rules! rocket_inst {
|
|
($func:expr) => {
|
|
rocket::ignite()
|
|
.mount("/users", routes![$func])
|
|
.attach(DBConn::fairing())
|
|
}
|
|
}
|
|
|
|
#[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() {
|
|
let app = rocket_inst!(get_user_list);
|
|
let client = Client::new(app).expect("Bad rocket instance");
|
|
|
|
let mut response = client.get("/users/list").dispatch();
|
|
let body: String = response.body_string().unwrap();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
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
|
|
}
|