joshuafhiggins/realm-chat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Selecting/Creating/Joining Rooms & Severs!

Browse Source
This commit is contained in:
Joshua Higgins
2024-10-13 16:46:28 -04:00
Unverified
parent 3d2445c94c
commit 8168f19b5f
9 changed files with 473 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
client/src/app.rs
View File

@@ -1,10 +1,11 @@
use tarpc::client::RpcError;
use tarpc::context;
use tarpc::tokio_serde::formats::Json;
use tokio::sync::broadcast;
use tokio::sync::broadcast::{Receiver, Sender};
use tracing::log::*;
use realm_auth::types::RealmAuthClient;
use realm_server::types::{RealmChatClient, User};
use realm_server::types::{RealmChatClient, Room, User};
use realm_shared::stoken;
use realm_shared::types::ErrorCode::*;
use realm_shared::types::ErrorCode;
@@ -15,9 +16,6 @@ use crate::ui::gui;
#[derive(serde::Deserialize, serde::Serialize)]
#[serde(default)] // if we add new fields, give them default values when deserializing old state
pub struct RealmApp {
// Example stuff:
pub label: String,
pub selected: bool,
#[serde(skip)]
pub selected_serverid: String,
#[serde(skip)]
@@ -58,6 +56,15 @@ pub struct RealmApp {
pub server_window_domain: String,
#[serde(skip)]
pub server_window_port: String,
#[serde(skip)]
pub room_window_open: bool,
#[serde(skip)]
pub room_window_name: String,
#[serde(skip)]
pub room_window_admin_only_send: bool,
#[serde(skip)]
pub room_window_admin_only_view: bool,
#[serde(skip)]
pub login_start_channel: (Sender<Result<(), ErrorCode>>, Receiver<Result<(), ErrorCode>>),
@@ -74,14 +81,16 @@ pub struct RealmApp {
#[serde(skip)]
pub fetching_servers_channel: (Sender<Result<CServer, ErrorCode>>, Receiver<Result<CServer, ErrorCode>>),
#[serde(skip)]
pub add_room_channel: (Sender<Result<CServer, ErrorCode>>, Receiver<Result<CServer, ErrorCode>>),
#[serde(skip)]
pub room_changes_channel: (Sender<Result<(CServer, Vec<Room>), ErrorCode>>, Receiver<Result<(CServer, Vec<Room>), ErrorCode>>)
}
impl Default for RealmApp {
fn default() -> Self {
Self {
// Example stuff:
label: "Hello World!".to_owned(),
selected: false,
selected_serverid: String::new(),
selected_roomid: String::new(),
current_user: None,
@@ -105,11 +114,18 @@ impl Default for RealmApp {
server_window_open: false,
server_window_domain: String::new(),
server_window_port: "5051".to_string(),
room_window_open: false,
room_window_name: String::new(),
room_window_admin_only_send: false,
room_window_admin_only_view: false,
fetching_user_data_channel: broadcast::channel(10),
add_server_channel: broadcast::channel(10),
join_server_channel: broadcast::channel(10),
fetching_servers_channel: broadcast::channel(10),
add_room_channel: broadcast::channel(10),
room_changes_channel: broadcast::channel(10),
}
}
}
@@ -171,9 +187,11 @@ pub fn fetch_user_data(send_channel: Sender<Result<CUser, ErrorCode>>, server_ad
});
}
pub fn fetch_server_data(addresses: Vec<String>, channel: Sender<Result<CServer, ErrorCode>>) {
pub fn fetch_server_data(channel: Sender<Result<CServer, ErrorCode>>, addresses: Vec<String>, token: String, username: String) {
for server_address in addresses {
let send_channel = channel.clone();
let token = token.clone();
let userid = username.clone();
let _handle = tokio::spawn(async move {
let mut transport = tarpc::serde_transport::tcp::connect(&server_address, Json::default);
@@ -190,19 +208,46 @@ pub fn fetch_server_data(addresses: Vec<String>, channel: Sender<Result<CServer,
let client = RealmChatClient::new(tarpc::client::Config::default(), connection).spawn();
let info = client.get_info(context::current()).await.unwrap();
let is_admin = client.is_user_admin(context::current(), info.server_id.clone()).await.unwrap();
let is_owner = client.is_user_owner(context::current(), info.server_id.clone()).await.unwrap();
let domain = server_address.split(':').collect::<Vec<&str>>()[0].to_string();
let port = server_address.split(':').collect::<Vec<&str>>()[1].to_string().parse::<u16>().unwrap();
let stoken = stoken(&token, &info.server_id, &domain, port);
let is_admin = client.is_user_admin(context::current(), userid.clone()).await.unwrap();
let is_owner = client.is_user_owner(context::current(), userid.clone()).await.unwrap();
let rooms = client.get_rooms(context::current(), stoken.clone(), userid.clone()).await.unwrap().unwrap();
send_channel.send(Ok(CServer {
tarpc_conn: client,
server_id: info.server_id,
domain: server_address.split(':').collect::<Vec<&str>>()[0].to_string(),
port: server_address.split(':').collect::<Vec<&str>>()[1].to_string().parse::<u16>().unwrap(),
domain,
port,
is_admin,
is_owner,
rooms,
})).unwrap();
});
}
}
pub fn fetch_rooms_data(send_channel: Sender<Result<(CServer, Vec<Room>), ErrorCode>>, server: CServer, token: String, userid: String) {
let _handle = tokio::spawn(async move {
let result = server.tarpc_conn.get_rooms(
context::current(),
stoken(&token, &server.server_id, &server.domain, server.port),
userid
).await;
match result {
Ok(r) => {
if let Ok(rooms) = r {
send_channel.send(Ok((server, rooms))).unwrap();
} else {
send_channel.send(Err(r.unwrap_err())).unwrap();
}
}
Err(_) => { send_channel.send(Err(RPCError)).unwrap(); }
}
});
}
impl eframe::App for RealmApp {
/// Called each time the UI needs repainting, which may be many times per second.
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
@@ -225,7 +270,12 @@ impl eframe::App for RealmApp {
// Fetching servers
if self.active_servers.is_none() && self.current_user.is_some() {
self.active_servers = Some(Vec::new());
fetch_server_data(self.current_user.clone().unwrap().server_addresses.clone(), self.fetching_servers_channel.0.clone());
fetch_server_data(
self.fetching_servers_channel.0.clone(),
self.current_user.as_ref().unwrap().server_addresses.clone(),
self.current_user.as_ref().unwrap().token.clone(),
self.current_user.as_ref().unwrap().username.clone()
);
}
// Starting the login flow
@@ -309,10 +359,17 @@ impl eframe::App for RealmApp {
let result = client.join_server(context::current(), stoken(&thread_token, &info.server_id, &domain, port), thread_username).await;
match result {
Ok(_) => {
Ok(r) => {
info!("Joined server!");
match r {
Ok(_) => { send_channel.send(Ok(())).unwrap(); },
Err(e) => { send_channel.send(Err(e)).unwrap(); },
}
},
Err(_) => {
error!("Error joining server");
send_channel.send(Err(RPCError)).unwrap();
},
Err(e) => error!("Error joining server: {:?}", e),
}
});
@@ -327,7 +384,12 @@ impl eframe::App for RealmApp {
match result {
Ok(_) => {
info!("Successfully joined a server");
fetch_server_data(self.current_user.clone().unwrap().server_addresses.clone(), self.fetching_servers_channel.0.clone());
fetch_server_data(
self.fetching_servers_channel.0.clone(),
self.current_user.as_ref().unwrap().server_addresses.clone(),
self.current_user.as_ref().unwrap().token.clone(),
self.current_user.as_ref().unwrap().username.clone()
);
},
Err(code) => {
error!("Error joining server: {:?}", code);
@@ -347,6 +409,40 @@ impl eframe::App for RealmApp {
Err(e) => error!("Error fetching server data: {:?}", e),
}
}
// Added Room
while let Ok(result) = self.add_room_channel.1.try_recv() {
match result {
Ok(server) => {
info!("Got room add! Fetching them...");
fetch_rooms_data(
self.room_changes_channel.0.clone(),
server,
self.current_user.as_ref().unwrap().token.clone(),
self.current_user.as_ref().unwrap().username.clone()
);
self.room_window_open = false;
}
Err(e) => error!("Error adding room: {:?}", e),
}
}
// Fetching rooms
while let Ok(result) = self.room_changes_channel.1.try_recv() {
match result {
Ok(tuple) => {
info!("Got room data for a server: {:?}", tuple);
if let Some(servers) = &mut self.active_servers {
for server in servers {
if server.server_id.eq(&tuple.0.server_id) {
server.rooms = tuple.1.clone();
}
}
}
}
Err(e) => error!("Error fetching room data: {:?}", e),
}
}
// File -> Quit
gui::top_panel(self, ctx);

6
client/src/types.rs
View File

@@ -1,3 +1,5 @@
use realm_server::types::{RealmChatClient, Room};
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct CUser {
pub id: i64,
@@ -9,11 +11,13 @@ pub struct CUser {
pub token: String,
}
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
#[derive(Clone, Debug)]
pub struct CServer {
pub tarpc_conn: RealmChatClient,
pub server_id: String,
pub domain: String,
pub port: u16,
pub is_admin: bool,
pub is_owner: bool,
pub rooms: Vec<Room>
}

117
client/src/ui/gui.rs
View File

@@ -5,7 +5,10 @@ use realm_auth::types::RealmAuthClient;
use realm_shared::types::ErrorCode::RPCError;
use regex::Regex;
use tracing::log::*;
use realm_server::types::Room;
use realm_shared::stoken;
use crate::app::RealmApp;
use crate::types::CServer;
pub fn top_panel(app: &mut RealmApp, ctx: &Context) {
egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
@@ -49,6 +52,10 @@ pub fn top_panel(app: &mut RealmApp, ctx: &Context) {
app.saved_username = None;
app.saved_token = None;
app.saved_auth_address = None;
app.active_servers = None;
app.selected_roomid.clear();
app.selected_serverid.clear();
}
if ui.button("Quit").clicked() {
@@ -72,10 +79,6 @@ pub fn servers(app: &mut RealmApp, ctx: &Context) {
});
ui.separator();
if ui.add(SelectableLabel::new(app.selected, "server")).clicked() {
app.selected = !app.selected;
}
if let Some(active_servers) = &mut app.active_servers {
for server in active_servers {
if ui.add(SelectableLabel::new(server.server_id.eq(&app.selected_serverid), server.server_id.clone())).clicked() {
@@ -84,6 +87,7 @@ pub fn servers(app: &mut RealmApp, ctx: &Context) {
} else {
app.selected_serverid = server.server_id.clone();
}
app.selected_roomid.clear();
}
}
}
@@ -92,32 +96,43 @@ pub fn servers(app: &mut RealmApp, ctx: &Context) {
pub fn rooms(app: &mut RealmApp, ctx: &Context) {
egui::SidePanel::left("rooms").show(ctx, |ui| {
ui.heading("Rooms");
let mut current_server: Option<&CServer> = None;
if let Some(servers) = &app.active_servers {
for server in servers {
if server.server_id.eq(&app.selected_serverid) {
current_server = Some(server);
}
}
}
ui.horizontal(|ui| {
ui.heading("Rooms");
if let Some(server) = current_server {
if server.is_admin && ui.button("+").clicked() {
app.room_window_open = true;
}
}
});
ui.separator();
if ui.add(SelectableLabel::new(app.selected, "room")).clicked() {
app.selected = !app.selected;
if let Some(server) = current_server {
for room in &server.rooms {
if ui.add(SelectableLabel::new(room.roomid.eq(&app.selected_roomid), room.roomid.clone())).clicked() {
if app.selected_roomid.eq(&room.roomid) {
app.selected_roomid.clear();
} else {
app.selected_roomid = room.roomid.clone();
}
}
}
}
});
}
pub fn messages(app: &mut RealmApp, ctx: &Context) {
egui::CentralPanel::default().show(ctx, |ui| {
// The central panel the region left after adding TopPanel's and SidePanel's
ui.heading("eframe template");
ui.horizontal(|ui| {
ui.label("Write something: ");
ui.text_edit_singleline(&mut app.label);
});
ui.add(egui::Slider::new(&mut app.value, 0.0..=10.0).text("value"));
if ui.button("Increment").clicked() {
app.value += 1.0;
}
ui.separator();
ui.label(format!("Saved username: {:?}", app.saved_username));
ui.label(format!("Saved token: {:?}", app.saved_token));
ui.label(format!("Saved auth address: {:?}", app.saved_auth_address));
@@ -126,12 +141,13 @@ pub fn messages(app: &mut RealmApp, ctx: &Context) {
if let Some(servers) = &app.active_servers {
for server in servers {
ui.label(format!("Active server: {:?}", server));
ui.heading(&server.server_id);
ui.label(format!("{:?}", server));
}
}
ui.separator();
ui.label(format!("Current user: {:?}", app.current_user));
});
}
@@ -339,4 +355,55 @@ pub fn modals(app: &mut RealmApp, ctx: &Context) {
});
}
});
egui::Window::new("Add Room")
.open(&mut app.room_window_open)
.min_size((500.0, 200.0))
.show(ctx, |ui| {
ui.horizontal(|ui| {
ui.label("Name: ");
ui.text_edit_singleline(&mut app.room_window_name);
});
ui.checkbox(&mut app.room_window_admin_only_send, "Only admins can send");
ui.checkbox(&mut app.room_window_admin_only_view, "Only admins can view");
if ui.button("Add Room").clicked() {
for server in app.active_servers.clone().unwrap() {
if server.server_id.eq(&app.selected_serverid) {
let token = app.current_user.as_ref().unwrap().token.clone();
let roomid = app.room_window_name.clone();
let admin_only_send = app.room_window_admin_only_send;
let admin_only_view = app.room_window_admin_only_view;
let userid = app.current_user.as_ref().unwrap().username.clone();
let send_channel = app.add_room_channel.0.clone();
let _handle = tokio::spawn(async move {
let result = server.tarpc_conn.create_room(
context::current(),
stoken(&token, &server.server_id, &server.domain, server.port),
userid,
Room {
id: 0,
roomid,
admin_only_send,
admin_only_view,
}
).await;
match result {
Ok(r) => {
match r {
Ok(_) => { send_channel.send(Ok(server)).unwrap(); }
Err(e) => { send_channel.send(Err(e)).unwrap(); }
}
}
Err(_) => {
send_channel.send(Err(RPCError)).unwrap();
}
}
});
}
}
}
});
}