update todo

migrations/2023-08-27-090522_users/up.sql

@@ -6,7 +6,9 @@ CREATE TABLE users (
     account_id    INTEGER  references accounts(id),
     registered    INTEGER  NOT NULL,
 
-    username  TEXT  NOT NULL  COLLATE case_insensitive,
+    -- idk why but we get weird errors if we use `COLLATE case_insensitive`
+    -- maybe troubleshoot later, this works fine for now.
+    username  TEXT  NOT NULL, -- COLLATE case_insensitive,
 
     stars           INTEGER  NOT NULL  DEFAULT 0,
     demons          INTEGER  NOT NULL  DEFAULT 0,

readme.md

@@ -34,6 +34,6 @@ _these features are implemented_
 
 ## todo
 
-- ___fix the fucking get users for usernames!!!!___
+- get users multiple pages
 - move authorization logic to (./src/helpers/accounts.rs)[./src/helpers/accounts.rs]
 - make gjp2 authentication faster (bcrypt?)

src/endpoints/users/get_users.rs

@@ -3,7 +3,6 @@ use rocket::http::Status;
 use rocket::response::status;
 
 use diesel::prelude::*;
-use diesel::result::Error;
 
 use crate::helpers;
 use crate::db;
@@ -14,7 +13,7 @@ pub struct FormGetUsers {
     str: String
 }
 
-#[post("/accounts/getGJUsers20.php", data = "<input>")]
+#[post("/getGJUsers20.php", data = "<input>")]
 pub fn get_users(input: Form<FormGetUsers>) -> status::Custom<&'static str> {
     let connection = &mut db::establish_connection_pg();
 
@@ -22,53 +21,75 @@ pub fn get_users(input: Form<FormGetUsers>) -> status::Custom<&'static str> {
     use crate::schema::users::dsl::*;
     use crate::models::User;
 
-    let mut query = users.into_boxed();
+    let mut query_users = users.into_boxed();
 
     match input.str.parse::<i32>() {
-        Ok(id_value) => query = query.filter(id.eq(id_value)),
+        Ok(id_value) => query_users = query_users.filter(id.eq(id_value)),
-        Err(_) => query = query.filter(username.like(input.str.to_owned() + "%"))
+        Err(_) => query_users = query_users.filter(username.ilike(input.str.to_owned() + "%"))
     };
 
-    let results = query
+    let mut results: Vec<String> = vec![];
-        .order(stars.desc())
-        .limit(10)
-        .offset(input.page * 10)
-        .get_result::<User, >(connection)
-        .expect("Fatal error loading users");
 
-    let response = helpers::format::format(hashmap! {
+    for result in {
-        1 => results.username,
+        query_users
-        2 => results.id.to_string(),
+            .order(stars.desc())
-        3 => results.stars.to_string(),
+            .offset(input.page * 10)
-        4 => results.demons.to_string(),
+            .limit(10)
-        8 => results.creator_points.to_string(),
+            .get_results::<User, >(connection)
-        9 => {
+            .expect("Fatal error loading users")
-            vec![
+    } {
-                results.cube,
+        let formatted_result = helpers::format::format(hashmap! {
-                results.ship,
+            1 => result.username,
-                results.ball,
+            2 => result.id.to_string(),
-                results.ufo,
+            3 => result.stars.to_string(),
-                results.wave,
+            4 => result.demons.to_string(),
-                results.robot
+            8 => result.creator_points.to_string(),
-            ][results.icon_type as usize].to_string()
+            9 => {
-        },
+                vec![
-        10 => results.color1.to_string(),
+                    result.cube,
-        11 => results.color2.to_string(),
+                    result.ship,
-        13 => results.coins.to_string(),
+                    result.ball,
-        14 => results.icon_type.to_string(),
+                    result.ufo,
-        15 => results.special.to_string(),
+                    result.wave,
-        16 => {
+                    result.robot
-            match results.account_id {
+                ][result.icon_type as usize].to_string()
-                Some(account_id_value) => account_id_value.to_string(),
+            },
-                None => match results.udid {
+            10 => result.color1.to_string(),
-                    Some(udid_value) => udid_value.to_string(),
+            11 => result.color2.to_string(),
-                    None => panic!("user has no account_id or udid?!?!?")
+            13 => result.coins.to_string(),
+            14 => result.icon_type.to_string(),
+            15 => result.special.to_string(),
+            16 => {
+                match result.account_id {
+                    Some(account_id_value) => account_id_value.to_string(),
+                    None => match result.udid {
+                        Some(udid_value) => udid_value.to_string(),
+                        None => panic!("user has no account_id or udid?!?!?")
+                    }
                 }
             }
-        }
+        });
-    });
 
-    println!("{}", response);
+        results.push(formatted_result)
+    };
 
-    return status::Custom(Status::Ok, "1")
+    let mut query_users_count = users.into_boxed();
+
+    match input.str.parse::<i32>() {
+        Ok(id_value) => query_users_count = query_users_count.filter(id.eq(id_value)),
+        Err(_) => query_users_count = query_users_count.filter(username.ilike(input.str.to_owned() + "%"))
+    };
+
+    let amount = query_users_count
+        .count()
+        .get_result::<i64>(connection)
+        .expect("Error querying user count");
+
+    let response = if amount < 1 {
+        String::from("-1")
+    } else {
+        vec![results.join("|"), format!("{}:#{}:10", amount, input.page * 10)].join("#")
+    };
+
+    return status::Custom(Status::Ok, Box::leak(response.into_boxed_str()))
 }