feat: some refactoring and /v1/api/provider/nex_token/@me

src/account/account.rs

@@ -53,7 +53,8 @@ pub struct User {
     pub region: i32,
     pub mii_data: String,
     pub creation_date: NaiveDateTime,
-    pub updated: NaiveDateTime
+    pub updated: NaiveDateTime,
+    pub nex_password: String
 }
 
 fn generate_nintendo_hash(pid: i32, text_password: &str) -> String{

src/nnid/oauth/generate_token.rs

@@ -3,10 +3,17 @@ use rocket::form::Form;
 use serde::{Deserialize, Serialize};
 use crate::account::account::User;
 use crate::error::{Error, Errors};
+use crate::nnid::oauth::generate_token::token_type::{AUTH_REFRESH_TOKEN, AUTH_TOKEN};
 use crate::nnid::oauth::TokenData;
 use crate::Pool;
 use crate::xml::Xml;
 
+pub mod token_type{
+    pub const AUTH_REFRESH_TOKEN: i32 = 1;
+    pub const AUTH_TOKEN: i32 = 0;
+    pub const NEX_TOKEN: i32 = 2;
+}
+
 const ACCOUNT_ID_OR_PASSWORD_ERRORS: Errors = Errors{
     error: &[
         Error{
@@ -40,51 +47,33 @@ pub struct TokenReturnData {
     expires_in: i32
 }
 
-impl TokenReturnData {
-    async fn create_token(pid: i32, pool: &Pool, is_refresh_token: bool) -> (i64, i32){
-        let token_type = if is_refresh_token{
-            0x0
-        } else {
-            0x1
-        };
-        let data = sqlx::query!(
-            "insert into tokens (token_type, pid)
-            values ($1, $2) returning token_id, random",
-            token_type, pid
+pub async fn create_token(pool: &Pool, pid: i32, token_type: i32, title_id: Option<&str>) -> String{
+    let data = sqlx::query!(
+            "insert into tokens (token_type, pid, title_id)
+            values ($1, $2, $3) returning token_id, random",
+            token_type, pid, title_id
         )
-            .fetch_one(pool)
-            .await.unwrap();
+        .fetch_one(pool)
+        .await.unwrap();
 
-        (data.token_id, data.random)
-    }
-    async fn create_regular_token(pid: i32, pool: &Pool) -> (i64, i32){
-        Self::create_token(pid, pool, false).await
-    }
+    let token_id = data.token_id;
+    let random = data.random;
 
-    async fn create_refresh_token(pid: i32, pool: &Pool) -> (i64, i32){
-        Self::create_token(pid, pool, true).await
-    }
+    let token = TokenData {
+        token_id,
+        random,
+        pid
+    };
 
+    token.encode().to_string()
+}
+
+
+impl TokenReturnData {
     async fn new(pid: i32, pool: &Pool) -> Self{
-        let (token_id, random) = Self::create_regular_token(pid, pool).await;
+        let token = create_token(pool, pid, AUTH_TOKEN, None).await;
 
-        let token = TokenData {
-            token_id,
-            random,
-            pid
-        };
-
-        let token = token.encode().to_string();
-
-        let (token_id, random) = Self::create_refresh_token(pid, pool).await;
-
-        let refresh_token = TokenData {
-            token_id,
-            random,
-            pid
-        };
-
-        let refresh_token = refresh_token.encode().to_string();
+        let refresh_token = create_token(pool, pid, AUTH_REFRESH_TOKEN, None).await;
 
         Self{
             token,

src/nnid/provider.rs

@@ -1,7 +1,12 @@
 use std::net::Ipv4Addr;
 use std::str::FromStr;
-use rocket::get;
+use rocket::{get, State};
 use serde::Serialize;
+use sqlx::types::ipnetwork::IpNetwork::V4;
+use crate::account::account::Auth;
+use crate::nnid::oauth::generate_token::create_token;
+use crate::nnid::oauth::generate_token::token_type::NEX_TOKEN;
+use crate::Pool;
 use crate::xml::Xml;
 
 #[derive(Serialize)]
@@ -15,6 +20,37 @@ struct NexToken{
 }
 
 #[get("/v1/api/provider/nex_token/@me?<game_server_id>")]
-pub async fn get_nex_token(game_server_id: String) -> Option<Xml<NexToken>>{
-    None
+pub async fn get_nex_token(pool: &State<Pool>, auth: Auth<true>, game_server_id: String) -> Option<Xml<NexToken>>{
+    // just gonna put this here as a side note for the future:
+    // we could also be using key derivation to derive the nex token as if it were a key
+    // that way we could reduce the data the database needs to store and also reduce the transfer
+    // cost of sending an entire row from the user table (which is required for the auth code unless
+    // we change the way we read in data to essentially having the user object be a proxy for its
+    // table row)
+    let pool = pool.inner();
+
+    let server = sqlx::query!(
+        "select * from nex_servers where game_server_id = $1",
+        game_server_id
+    )   .fetch_one(pool).await.ok()?;
+
+    let token = create_token(pool, auth.pid, NEX_TOKEN, None).await;
+
+    let V4(host) = server.address else {
+        return None
+    };
+
+    let host = host.ip();
+
+    Some(
+        Xml(
+            NexToken{
+                host,
+                port: server.port as u16,
+                nex_password: auth.nex_password.clone(),
+                pid: auth.pid,
+                token
+            }
+        )
+    )
 }