store joined servers on auth server

auth/migrations/20240725215330_create_everything.sql

@@ -5,6 +5,7 @@ CREATE TABLE IF NOT EXISTS user (
                 email VARCHAR(255) NOT NULL,
                 new_email VARCHAR(255),
                 avatar TEXT NOT NULL,
+                servers TEXT NOT NULL,
                 login_code INT(6),
                 tokens TEXT,
                 google_oauth VARCHAR(255),

auth/src/server.rs

@@ -9,7 +9,7 @@ use regex::Regex;
 use sha3::{Digest, Sha3_256};
 use sha3::digest::Update;
 use sqlx::{Pool, query, Sqlite};
-use sqlx::sqlite::SqliteQueryResult;
+use sqlx::sqlite::{SqliteQueryResult, SqliteRow};
 use tarpc::context::Context;
 use tracing::*;
 use tracing::log::__private_api::log;
@@ -354,6 +354,7 @@ impl RealmAuth for RealmAuthServer {
 		Ok(())
 	}
 
+	// TODO: find a way of supporting, post-capstone work
 	// async fn change_username(self, _: Context, username: String, token: String, new_username: String) -> Result<(), ErrorCode> {
 	//     info!("API Request: change_username( username -> {}, token -> {}, new_username -> {} )", username, token, new_username);
 	//
@@ -410,6 +411,7 @@ impl RealmAuth for RealmAuthServer {
 					username: row.username,
 					email: row.email,
 					avatar: row.avatar,
+					servers: row.servers,
 					login_code: None,
 					bigtoken: row.tokens,
 					google_oauth: row.google_oauth,
@@ -508,6 +510,82 @@ impl RealmAuth for RealmAuthServer {
 		}
 	}
 
+	async fn add_server(self, _: Context, username: String, token: String, domain: String) -> Result<(), ErrorCode> {
+		if !self.is_authorized(&username, &token).await? {
+			return Err(Unauthorized)
+		}
+
+		let result = query!("SELECT servers FROM user WHERE username = ?", username).fetch_one(&self.db_pool).await;
+		match result {
+			Ok(row) => {
+				let mut vec_servers = row.servers.split('|').collect::<Vec<&str>>();
+				for server in &vec_servers {
+					if server.eq(&domain) {
+						return Err(AlreadyJoinedServer)
+					}
+				}
+
+				vec_servers.push(&domain);
+				let new_servers = vec_servers.join("|");
+
+				let result = query!("UPDATE user SET servers = ? WHERE username = ?", new_servers, username).fetch_one(&self.db_pool).await;
+				match result {
+					Ok(_) => Ok(()),
+					Err(_) => Err(Error)
+				}
+			}
+			Err(_) => Err(Error)
+		}
+	}
+
+	async fn remove_server(self, _: Context, username: String, token: String, domain: String) -> Result<(), ErrorCode> {
+		if !self.is_authorized(&username, &token).await? {
+			return Err(Unauthorized)
+		}
+
+		let result = query!("SELECT servers FROM user WHERE username = ?", username).fetch_one(&self.db_pool).await;
+		match result {
+			Ok(row) => {
+				let mut vec_servers = row.servers.split('|').collect::<Vec<&str>>();
+				for i in 0..vec_servers.len() {
+					if vec_servers.get(i).unwrap().eq(&domain) {
+						vec_servers.remove(i);
+
+						let new_servers = vec_servers.join("|");
+						let result = query!("UPDATE user SET servers = ? WHERE username = ?", new_servers, username).fetch_one(&self.db_pool).await;
+						return match result {
+							Ok(_) => Ok(()),
+							Err(_) => Err(Error)
+						}
+					}
+				}
+				
+				Err(NotInServer)
+			}
+			Err(_) => Err(Error)
+		}
+	}
+
+	async fn get_joined_servers(self, _: Context, username: String, token: String) -> Result<Vec<String>, ErrorCode> {
+		if !self.is_authorized(&username, &token).await? {
+			return Err(Unauthorized)
+		}
+
+		let result = query!("SELECT servers FROM user WHERE username = ?", username).fetch_one(&self.db_pool).await;
+		match result {
+			Ok(row) => {
+				let vec_servers = row.servers.split('|').collect::<Vec<&str>>();
+				let mut servers = Vec::new();
+				for server in vec_servers {
+					servers.push(server.to_string())
+				}
+				
+				Ok(servers)
+			}
+			Err(_) => Err(Error)
+		}
+	}
+
 	async fn get_avatar_for_user(self, _: Context, username: String) -> Result<String, ErrorCode> {
 		info!("API Request: get_avatar_for_user( username -> {} )", username);
 

auth/src/types.rs

@@ -18,6 +18,9 @@ pub trait RealmAuth {
     async fn sign_out(username: String, token: String) -> Result<(), ErrorCode>;
     async fn delete_account_flow(username: String, token: String) -> Result<(), ErrorCode>;
     async fn finish_delete_account_flow(username: String, token: String, login_code: u16) -> Result<(), ErrorCode>;
+    async fn add_server(username: String, token: String, domain: String) -> Result<(), ErrorCode>;
+    async fn remove_server(username: String, token: String, domain: String) -> Result<(), ErrorCode>;
+    async fn get_joined_servers(username: String, token: String) -> Result<Vec<String>, ErrorCode>;
     
     //NOTE: Anyone can call
     async fn get_avatar_for_user(username: String) -> Result<String, ErrorCode>;
@@ -30,6 +33,7 @@ pub struct AuthUser {
     pub username: String,
     pub email: String,
     pub avatar: String,
+    pub servers: String,
     pub login_code: Option<u16>,
     pub bigtoken: Option<String>,
     pub google_oauth: Option<String>,

shared/src/types.rs

@@ -13,6 +13,8 @@ pub enum ErrorCode {
     InvalidToken,
     UnableToConnectToMail,
     UnableToSendMail,
+    AlreadyJoinedServer,
+    NotInServer,
     
     MessageNotFound,
     RoomNotFound,