.gitignore

@@ -20,4 +20,3 @@ Cargo.lock
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
-/config.toml

src/api/v1/register.rs

@@ -93,14 +93,17 @@ pub async fn res(mut payload: web::Payload, data: web::Data<Data>) -> Result<Htt
         ))
     }
 
-    // TODO: Check security of this implementation
+    Ok(match data.pool.execute(
-    Ok(match sqlx::query(&format!("INSERT INTO users VALUES ( '{}', $1, NULL, $2, $3, false )", uuid))
+        &*format!(
-        .bind(account_information.identifier)
+            // FIXME: This can never be put into prod, it works for testing
+            "INSERT INTO users VALUES ( '{}', '{}', NULL, '{}', '{}', '0' )",
+            uuid,
+            account_information.identifier,
             // FIXME: Password has no security currently, either from a client or server perspective
-        .bind(account_information.password)
+            account_information.password,
-        .bind(account_information.email)
+            account_information.email,
-        .execute(&data.pool)
+        )
-        .await {
+    ).await {
         Ok(_out) => {
             HttpResponse::Ok().json(
                 Response {
@@ -123,10 +126,9 @@ pub async fn res(mut payload: web::Payload, data: web::Data<Data>) -> Result<Htt
                     email_available: false,
                     ..Default::default()
                 }),
-                    _ => {
+                _ => HttpResponse::Forbidden().json(ResponseError {
-                        eprintln!("{}", err_msg);
+                    ..Default::default()
-                        HttpResponse::InternalServerError().finish()
+                })
-                    }
             }
         },
     })

src/api/v1/stats.rs

@@ -17,16 +17,9 @@ struct Response {
 
 #[get("/stats")]
 pub async fn res(data: web::Data<Data>) -> impl Responder {
-    let accounts;
-    if let Ok(users) = sqlx::query("SELECT uuid FROM users").fetch_all(&data.pool).await {
-        accounts = users.len();
-    } else {
-        return HttpResponse::InternalServerError().finish()
-    }
-
     let response = Response {
         // TODO: Get number of accounts from db
-        accounts,
+        accounts: 0,
         uptime: SystemTime::now()
             .duration_since(data.start_time)
             .expect("Seriously why dont you have time??")

src/main.rs

@@ -26,22 +26,15 @@ async fn main() -> Result<(), Error> {
     TODO: Figure out if a table should be used here and if not then what.
     Also figure out if these should be different types from what they currently are and if we should add more "constraints"
     */
-    sqlx::raw_sql(r#"
+    pool.execute(r#"CREATE TABLE IF NOT EXISTS users (
-        CREATE TABLE IF NOT EXISTS users (
+    uuid uuid UNIQUE NOT NULL,
-            uuid uuid PRIMARY KEY UNIQUE NOT NULL,
     username varchar(32) UNIQUE NOT NULL,
     display_name varchar(64),
     password varchar(512) NOT NULL,
     email varchar(100) UNIQUE NOT NULL,
-            email_verified boolean NOT NULL DEFAULT FALSE
+    email_verified integer NOT NULL DEFAULT '0',
-        );
+    PRIMARY KEY (uuid)
-        CREATE TABLE IF NOT EXISTS instance_permissions (
+    )"#).await?;
-            uuid uuid REFERENCES users(uuid),
-            administrator boolean NOT NULL DEFAULT FALSE
-        )
-    "#)
-    .execute(&pool)
-    .await?;
 
     let data = Data {
         pool,