480 lines
15 KiB
Rust
480 lines
15 KiB
Rust
use egui::{Context, SelectableLabel};
|
|
use tarpc::context;
|
|
use tarpc::tokio_serde::formats::Json;
|
|
use realm_auth::types::RealmAuthClient;
|
|
use realm_shared::types::ErrorCode::RPCError;
|
|
use regex::Regex;
|
|
use tarpc::client::RpcError;
|
|
use tracing::log::*;
|
|
use realm_server::types::{RealmChatClient, Room};
|
|
use realm_shared::stoken;
|
|
use realm_shared::types::ErrorCode;
|
|
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| {
|
|
egui::menu::bar(ui, |ui| {
|
|
if app.current_user.is_none() && ui.button("Sign Up").clicked() {
|
|
app.signup_window_open = true;
|
|
}
|
|
|
|
if app.current_user.is_none() && ui.button("Login").clicked() {
|
|
app.login_window_open = true;
|
|
}
|
|
|
|
if app.current_user.is_some() && ui.button("Logout").clicked() {
|
|
let address = app.current_user.clone().unwrap().auth_address;
|
|
let username = app.current_user.clone().unwrap().username;
|
|
let token = app.current_user.clone().unwrap().token;
|
|
|
|
let _handle = tokio::spawn(async move {
|
|
let mut transport = tarpc::serde_transport::tcp::connect(&address, Json::default);
|
|
transport.config_mut().max_frame_length(usize::MAX);
|
|
|
|
let result = transport.await;
|
|
let connection = match result {
|
|
Ok(connection) => connection,
|
|
Err(e) => {
|
|
tracing::error!("Failed to connect to server: {}", e);
|
|
return;
|
|
}
|
|
};
|
|
|
|
let client = RealmAuthClient::new(tarpc::client::Config::default(), connection).spawn();
|
|
let result = client.sign_out(context::current(), username, token).await;
|
|
|
|
match result {
|
|
Ok(_) => info!("Signed out!"), // TODO: properly handle this
|
|
Err(e) => error!("Error signing out: {:?}", e),
|
|
}
|
|
});
|
|
|
|
app.current_user = None;
|
|
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("Info").clicked() {
|
|
app.info_window_open = true;
|
|
}
|
|
|
|
if ui.button("Quit").clicked() {
|
|
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
|
|
}
|
|
|
|
ui.add_space(16.0);
|
|
|
|
egui::widgets::global_theme_preference_buttons(ui);
|
|
});
|
|
});
|
|
}
|
|
|
|
pub fn servers(app: &mut RealmApp, ctx: &Context) {
|
|
egui::SidePanel::left("servers").show(ctx, |ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.heading("Servers");
|
|
if app.current_user.is_some() && ui.button("+").clicked() {
|
|
app.server_window_open = true;
|
|
}
|
|
if !app.selected_serverid.is_empty() && ui.button("-").clicked() {
|
|
let server = app.active_servers.clone().unwrap().into_iter().find(|s| s.server_id.eq(&app.selected_serverid)).unwrap();
|
|
let token = app.current_user.as_ref().unwrap().token.clone();
|
|
let userid = app.current_user.as_ref().unwrap().username.clone();
|
|
let send_channel = app.leave_server_channel.0.clone();
|
|
let _handle = tokio::spawn(async move {
|
|
let result = server.tarpc_conn.leave_server(
|
|
context::current(),
|
|
stoken(&token, &server.server_id, &server.domain, server.port),
|
|
userid
|
|
).await;
|
|
|
|
match result {
|
|
Ok(r) => {
|
|
match r {
|
|
Ok(_) => send_channel.send(Ok((server.server_id.clone(), server.domain.clone(), server.port))).unwrap(),
|
|
Err(e) => send_channel.send(Err(e)).unwrap()
|
|
}
|
|
},
|
|
Err(_) => send_channel.send(Err(RPCError)).unwrap(),
|
|
}
|
|
});
|
|
}
|
|
});
|
|
ui.separator();
|
|
|
|
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() {
|
|
if app.selected_serverid.eq(&server.server_id) {
|
|
app.selected_serverid.clear();
|
|
} else {
|
|
app.selected_serverid = server.server_id.clone();
|
|
}
|
|
app.selected_roomid.clear();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
pub fn rooms(app: &mut RealmApp, ctx: &Context) {
|
|
egui::SidePanel::left("rooms").show(ctx, |ui| {
|
|
let mut current_server: Option<CServer> = None;
|
|
if let Some(servers) = app.active_servers.clone() {
|
|
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.clone() {
|
|
if server.is_admin && ui.button("+").clicked() {
|
|
app.room_window_open = true;
|
|
}
|
|
if server.is_admin && !app.selected_roomid.is_empty() && ui.button("-").clicked() {
|
|
let token = app.current_user.as_ref().unwrap().token.clone();
|
|
let roomid = app.selected_roomid.clone();
|
|
let userid = app.current_user.as_ref().unwrap().username.clone();
|
|
let send_channel = app.delete_room_channel.0.clone();
|
|
let _handle = tokio::spawn(async move {
|
|
let result = server.tarpc_conn.delete_room(
|
|
context::current(),
|
|
stoken(&token, &server.server_id, &server.domain, server.port),
|
|
userid,
|
|
roomid
|
|
).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(),
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
ui.separator();
|
|
|
|
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| {
|
|
|
|
});
|
|
}
|
|
|
|
pub fn modals(app: &mut RealmApp, ctx: &Context) {
|
|
egui::Window::new("Info")
|
|
.open(&mut app.info_window_open)
|
|
.min_size((500.0, 200.0))
|
|
.show(ctx, |ui| {
|
|
egui::ScrollArea::vertical().show(ui, |ui| {
|
|
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));
|
|
|
|
ui.separator();
|
|
|
|
if let Some(servers) = &app.active_servers {
|
|
for server in servers {
|
|
ui.heading(&server.server_id);
|
|
ui.label(format!("{:?}", server));
|
|
}
|
|
}
|
|
|
|
ui.separator();
|
|
|
|
ui.label(format!("Current user: {:?}", app.current_user));
|
|
});
|
|
});
|
|
|
|
egui::Window::new("Signup")
|
|
.open(&mut app.signup_window_open)
|
|
.min_size((500.0, 200.0))
|
|
.show(ctx, |ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.label("Domain: ");
|
|
ui.text_edit_singleline(&mut app.login_window_server_domain);
|
|
ui.label("Port: ");
|
|
if ui.text_edit_singleline(&mut app.login_window_server_port).changed() {
|
|
let re = Regex::new(r"[^0-9]+").unwrap();
|
|
app.login_window_server_port = re.replace_all(&app.login_window_server_port, "").to_string();
|
|
}
|
|
});
|
|
|
|
ui.horizontal(|ui| {
|
|
ui.label("Username: ");
|
|
ui.text_edit_singleline(&mut app.login_window_username);
|
|
});
|
|
|
|
ui.horizontal(|ui| {
|
|
ui.label("Email: ");
|
|
ui.text_edit_singleline(&mut app.login_window_email);
|
|
});
|
|
|
|
if ui.button("Create Account").clicked() {
|
|
let login_window_server_address = format!("{}:{}", app.login_window_server_domain, app.login_window_server_port);
|
|
let login_window_username = format!("@{}:{}", app.login_window_username, app.login_window_server_domain);
|
|
let login_window_email = app.login_window_email.clone();
|
|
let send_channel = app.login_start_channel.0.clone();
|
|
|
|
let _handle = tokio::spawn(async move {
|
|
let mut transport = tarpc::serde_transport::tcp::connect(login_window_server_address, Json::default);
|
|
transport.config_mut().max_frame_length(usize::MAX);
|
|
|
|
let result = transport.await;
|
|
let connection = match result {
|
|
Ok(connection) => connection,
|
|
Err(e) => {
|
|
tracing::error!("Failed to connect to server: {}", e);
|
|
return;
|
|
}
|
|
};
|
|
|
|
let client = RealmAuthClient::new(tarpc::client::Config::default(), connection).spawn();
|
|
let result = client.create_account_flow(context::current(), login_window_username, login_window_email).await;
|
|
|
|
match result {
|
|
Ok(r) => send_channel.send(r).unwrap(),
|
|
Err(_) => send_channel.send(Err(RPCError)).unwrap(),
|
|
};
|
|
});
|
|
|
|
//ui.close_menu()
|
|
}
|
|
});
|
|
|
|
egui::Window::new("Login")
|
|
.open(&mut app.login_window_open)
|
|
.min_size((500.0, 200.0))
|
|
.show(ctx, |ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.label("Domain: ");
|
|
ui.text_edit_singleline(&mut app.login_window_server_domain);
|
|
ui.label("Port: ");
|
|
if ui.text_edit_singleline(&mut app.login_window_server_port).changed() {
|
|
let re = Regex::new(r"[^0-9]+").unwrap();
|
|
app.login_window_server_port = re.replace_all(&app.login_window_server_port, "").to_string();
|
|
}
|
|
});
|
|
|
|
ui.horizontal(|ui| {
|
|
ui.label("Username: ");
|
|
ui.text_edit_singleline(&mut app.login_window_username);
|
|
});
|
|
|
|
if ui.button("Send Login Code").clicked() {
|
|
let login_window_server_address = format!("{}:{}", app.login_window_server_domain, app.login_window_server_port);
|
|
let login_window_username = format!("@{}:{}", app.login_window_username, app.login_window_server_domain);
|
|
let send_channel = app.login_start_channel.0.clone();
|
|
|
|
let _handle = tokio::spawn(async move {
|
|
let mut transport = tarpc::serde_transport::tcp::connect(login_window_server_address, Json::default);
|
|
transport.config_mut().max_frame_length(usize::MAX);
|
|
|
|
let result = transport.await;
|
|
let connection = match result {
|
|
Ok(connection) => connection,
|
|
Err(e) => {
|
|
tracing::error!("Failed to connect to server: {}", e);
|
|
return;
|
|
}
|
|
};
|
|
|
|
let client = RealmAuthClient::new(tarpc::client::Config::default(), connection).spawn();
|
|
let result = client.create_login_flow(context::current(), Some(login_window_username), None).await;
|
|
|
|
match result {
|
|
Ok(r) => send_channel.send(r).unwrap(),
|
|
Err(_) => send_channel.send(Err(RPCError)).unwrap(),
|
|
};
|
|
});
|
|
|
|
//ui.close_menu()
|
|
}
|
|
});
|
|
|
|
egui::Window::new("Auth Code")
|
|
.open(&mut app.login_ready_for_code_input)
|
|
.min_size((500.0, 200.0))
|
|
.show(ctx, |ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.label("Code: ");
|
|
if ui.text_edit_singleline(&mut app.login_window_code).changed() {
|
|
let re = Regex::new(r"[^0-9]+").unwrap();
|
|
app.login_window_code = re.replace_all(&app.login_window_code, "").to_string();
|
|
}
|
|
});
|
|
|
|
if ui.button("Login").clicked() {
|
|
let login_window_server_address = format!("{}:{}", app.login_window_server_domain, app.login_window_server_port);
|
|
let login_window_code = app.login_window_code.clone();
|
|
let login_window_username = format!("@{}:{}", app.login_window_username, app.login_window_server_domain);
|
|
let send_channel = app.login_ending_channel.0.clone();
|
|
|
|
let _handle = tokio::spawn(async move {
|
|
let mut transport = tarpc::serde_transport::tcp::connect(login_window_server_address, Json::default);
|
|
transport.config_mut().max_frame_length(usize::MAX);
|
|
|
|
let result = transport.await;
|
|
let connection = match result {
|
|
Ok(connection) => connection,
|
|
Err(e) => {
|
|
tracing::error!("Failed to connect to server: {}", e);
|
|
return;
|
|
}
|
|
};
|
|
|
|
let client = RealmAuthClient::new(tarpc::client::Config::default(), connection).spawn();
|
|
let result = client.finish_login_flow(context::current(), login_window_username, login_window_code.parse::<u32>().unwrap()).await;
|
|
|
|
match result {
|
|
Ok(r) => {
|
|
send_channel.send(r).unwrap();
|
|
}
|
|
Err(e) => {
|
|
send_channel.send(Err(RPCError)).unwrap();
|
|
}
|
|
}
|
|
});
|
|
|
|
//ui.close_menu()
|
|
}
|
|
});
|
|
|
|
egui::Window::new("Add Server")
|
|
.open(&mut app.server_window_open)
|
|
.min_size((500.0, 200.0))
|
|
.show(ctx, |ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.label("Domain: ");
|
|
ui.text_edit_singleline(&mut app.server_window_domain);
|
|
});
|
|
|
|
ui.horizontal(|ui| {
|
|
ui.label("Port: ");
|
|
if ui.text_edit_singleline(&mut app.server_window_port).changed() {
|
|
let re = Regex::new(r"[^0-9]+").unwrap();
|
|
app.login_window_code = re.replace_all(&app.server_window_port, "").to_string();
|
|
}
|
|
});
|
|
|
|
|
|
if app.current_user.is_some() && ui.button("Add Server").clicked() {
|
|
let domain = app.server_window_domain.clone();
|
|
let port = app.server_window_port.clone();
|
|
let auth_address = app.current_user.clone().unwrap().auth_address;
|
|
let auth_username = app.current_user.clone().unwrap().username;
|
|
let auth_token = app.current_user.clone().unwrap().token;
|
|
let send_channel = app.add_server_channel.0.clone();
|
|
|
|
let _handle = tokio::spawn(async move {
|
|
let mut transport = tarpc::serde_transport::tcp::connect(auth_address, Json::default);
|
|
transport.config_mut().max_frame_length(usize::MAX);
|
|
|
|
let result = transport.await;
|
|
let connection = match result {
|
|
Ok(connection) => connection,
|
|
Err(e) => {
|
|
tracing::error!("Failed to connect to server: {}", e);
|
|
return;
|
|
}
|
|
};
|
|
|
|
let client = RealmAuthClient::new(tarpc::client::Config::default(), connection).spawn();
|
|
let result = client.add_server(
|
|
context::current(), auth_username, auth_token, domain.clone(), port.parse::<u16>().unwrap()).await;
|
|
|
|
match result {
|
|
Ok(r) => {
|
|
match r {
|
|
Ok(_) => {
|
|
info!("Server added successfully!");
|
|
send_channel.send(Ok(format!("{}:{}", domain, port))).unwrap();
|
|
},
|
|
Err(e) => error!("Error adding server: {:?}", e),
|
|
}
|
|
},
|
|
Err(_) => { send_channel.send(Err(RPCError)).unwrap(); },
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
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();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} |