torsten/yourchat2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add delete room command and enhance room management in yourchat2

Browse Source 
Introduced the `delete_room` command to allow users to remove temporary chat rooms, with appropriate access checks for room creators and admins. Updated the `RoomMeta` structure to include the `created_by_chat_user_id` field for better tracking of room ownership. Enhanced error handling in room access validation for improved user feedback during room deletion and initialization processes.
This commit is contained in:
Torsten Schulz (local)
2026-03-04 23:08:22 +01:00
parent d620b8f8ae
commit 553602d5b4
3 changed files with 218 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
src/commands.rs
View File

@@ -105,6 +105,10 @@ pub async fn handle_command(
handle_create_room_command(client_id, &current, Arc::clone(&state), Arc::clone(&config)).await;
return;
}
"delete_room" => {
handle_delete_room_command(client_id, &current, Arc::clone(&state), Arc::clone(&config)).await;
return;
}
_ => {
handle_unknown_command(client_id, &current, Arc::clone(&state)).await;
return;
@@ -165,7 +169,7 @@ async fn handle_init_command(
};
(resolved_room_name, room_meta)
};
if !room_access_allowed(
if let Err(access_error) = room_access_allowed(
Some(&room_meta),
profile.falukant_user_id,
profile.gender_id,
@@ -177,7 +181,7 @@ async fn handle_init_command(
)
.await
{
send_error(client_id, Arc::clone(&state), "room_not_found_or_join_failed").await;
send_error(client_id, Arc::clone(&state), access_error).await;
return;
}
@@ -315,7 +319,7 @@ async fn handle_join_command(
client.rights.clone(),
)
};
if !room_access_allowed(
if let Err(access_error) = room_access_allowed(
Some(&room_meta),
falukant_user_id,
gender_id,
@@ -327,7 +331,7 @@ async fn handle_join_command(
)
.await
{
send_error(client_id, Arc::clone(&state), "room_not_found_or_join_failed").await;
send_error(client_id, Arc::clone(&state), access_error).await;
return;
}
let (from_room, user_name, actual_room_name) = {
@@ -871,6 +875,7 @@ async fn handle_create_room_command(
max_age: parsed.max_age,
is_public: parsed.is_public,
owner_id: Some(owner_chat_user_id),
created_by_chat_user_id: Some(owner_chat_user_id),
room_type_id: parsed.room_type_id,
friends_of_owner_only: parsed.friends_of_owner_only,
is_temporary: true,
@@ -898,6 +903,183 @@ async fn handle_create_room_command(
.await;
}
async fn handle_delete_room_command(
client_id: ClientId,
command: &Command,
state: Arc<RwLock<ChatState>>,
config: Arc<ServerConfig>,
) {
if !state::authorize(client_id, command, Arc::clone(&state)).await {
return;
}
let room_name = command
.room
.clone()
.or(command.name.clone())
.or(command.message.clone())
.unwrap_or_default();
let room_name = room_name.trim().to_string();
if room_name.is_empty() {
send_error(client_id, Arc::clone(&state), "missing_room_name").await;
return;
}
#[derive(Clone)]
struct UserSnapshot {
client_id: ClientId,
user_name: String,
falukant_user_id: Option<i32>,
gender_id: Option<i32>,
age: Option<i32>,
right_type_ids: HashSet<i32>,
rights: HashSet<String>,
}
let (resolved_room, room_meta, requester_chat_user_id, requester_is_admin, room_members, users, candidate_rooms) = {
let guard = state.read().await;
let Some(resolved_room) = resolve_room_name(&guard, &room_name) else {
send_error(client_id, Arc::clone(&state), "room_not_found").await;
return;
};
let Some(room_meta) = guard.room_meta.get(&resolved_room).cloned() else {
send_error(client_id, Arc::clone(&state), "room_not_found").await;
return;
};
if !room_meta.is_temporary {
send_error(client_id, Arc::clone(&state), "only_temporary_rooms_can_be_deleted").await;
return;
}
let Some(requester) = guard.clients.get(&client_id) else {
return;
};
let requester_chat_user_id = requester.chat_user_id;
let requester_is_admin = requester.rights.contains("admin");
let members = guard
.rooms
.get(&resolved_room)
.cloned()
.unwrap_or_default()
.into_iter()
.collect::<Vec<_>>();
let users = members
.iter()
.filter_map(|id| {
let c = guard.clients.get(id)?;
Some(UserSnapshot {
client_id: *id,
user_name: c.user_name.clone(),
falukant_user_id: c.falukant_user_id,
gender_id: c.gender_id,
age: c.age,
right_type_ids: c.right_type_ids.clone(),
rights: c.rights.clone(),
})
})
.collect::<Vec<_>>();
let mut rooms = guard
.room_meta
.iter()
.filter(|(name, _)| *name != &resolved_room)
.map(|(name, meta)| (name.clone(), meta.clone()))
.collect::<Vec<_>>();
rooms.sort_by(|a, b| a.0.cmp(&b.0));
(
resolved_room,
room_meta,
requester_chat_user_id,
requester_is_admin,
members,
users,
rooms,
)
};
let creator_can_delete = requester_chat_user_id.is_some()
&& room_meta.created_by_chat_user_id.is_some()
&& requester_chat_user_id == room_meta.created_by_chat_user_id;
if !creator_can_delete && !requester_is_admin {
send_error(client_id, Arc::clone(&state), "permission_denied").await;
return;
}
let mut reassignments: Vec<(ClientId, String, String)> = Vec::new();
for user in &users {
let mut assigned: Option<String> = None;
for (candidate_name, candidate_meta) in &candidate_rooms {
if room_access_allowed(
Some(candidate_meta),
user.falukant_user_id,
user.gender_id,
user.age,
&user.right_type_ids,
&user.rights,
"",
&config,
)
.await
.is_ok()
{
assigned = Some(candidate_name.clone());
break;
}
}
let Some(target_room) = assigned else {
send_error(client_id, Arc::clone(&state), "no_fallback_room_for_all_users").await;
return;
};
reassignments.push((user.client_id, user.user_name.clone(), target_room));
}
{
let mut guard = state.write().await;
if !guard.room_meta.contains_key(&resolved_room) {
drop(guard);
send_error(client_id, Arc::clone(&state), "room_not_found").await;
return;
}
guard.room_meta.remove(&resolved_room);
guard.rooms.remove(&resolved_room);
guard.dice_games.remove(&resolved_room);
for (uid, _uname, target_room) in &reassignments {
if let Some(client) = guard.clients.get_mut(uid) {
client.room = target_room.clone();
}
guard.rooms.entry(target_room.clone()).or_default().insert(*uid);
}
}
for (_uid, _uname, target_room) in &reassignments {
state::mark_room_occupied(target_room, Arc::clone(&state)).await;
}
for (uid, uname, target_room) in &reassignments {
state::send_to_client(
*uid,
Arc::clone(&state),
json!({"type":5, "message":"room_entered", "to": target_room}),
)
.await;
state::broadcast_room(
target_room,
Arc::clone(&state),
json!({"type":"system","message": format!("{uname} joined {target_room}")}),
Some(*uid),
)
.await;
}
for uid in room_members {
state::send_room_list(uid, Arc::clone(&state)).await;
}
state::send_to_client(
client_id,
Arc::clone(&state),
json!({"type":"system","message":"room_deleted","room": resolved_room}),
)
.await;
}
async fn handle_unknown_command(client_id: ClientId, command: &Command, state: Arc<RwLock<ChatState>>) {
if command.password.is_some() {
send_error(
@@ -920,9 +1102,9 @@ async fn room_access_allowed(
user_rights: &HashSet<String>,
provided_password: &str,
config: &ServerConfig,
) -> bool {
) -> Result<(), &'static str> {
let Some(room) = room_meta else {
return false;
return Err("room_not_found");
};
let is_admin = user_rights.contains("admin");
let has_required_right = room
@@ -933,73 +1115,73 @@ async fn room_access_allowed(
if let Some(required_gender) = room.gender_restriction_id {
if required_gender > 0 && user_gender_id != Some(required_gender) {
return false;
return Err("room_gender_restricted");
}
}
if !room.is_public {
let Some(owner_id) = room.owner_id else {
return false;
return Err("room_private");
};
let Some(fid) = falukant_user_id else {
return false;
return Err("room_private");
};
let is_owner = db::user_is_room_owner(config, owner_id, fid).await;
if !is_owner && !is_admin && !has_required_right {
return false;
return Err("room_private");
}
}
if let Some(room_password) = &room.password {
if !room_password.is_empty() && !password_matches(room_password, provided_password) {
return false;
return Err("room_password_invalid");
}
}
if let Some(min_age) = room.min_age {
if min_age > 0 {
let Some(fid) = falukant_user_id else {
return false;
return Err("room_age_data_missing");
};
if fid <= 0 {
return false;
return Err("room_age_data_missing");
}
let Some(user_age) = age else {
return false;
return Err("room_age_data_missing");
};
if user_age < min_age {
return false;
return Err("room_min_age_not_met");
}
}
}
if let Some(max_age) = room.max_age {
if max_age > 0 {
let Some(user_age) = age else {
return false;
return Err("room_age_data_missing");
};
if user_age > max_age {
return false;
return Err("room_max_age_exceeded");
}
}
}
if let Some(required_right) = room.required_user_right_id {
if required_right > 0 && !user_right_type_ids.contains(&required_right) {
return false;
return Err("room_required_right_missing");
}
}
if room.friends_of_owner_only {
let Some(owner_id) = room.owner_id else {
return false;
return Err("room_friends_only");
};
let Some(fid) = falukant_user_id else {
return false;
return Err("room_friends_only");
};
if !db::is_friend_of_room_owner(config, owner_id, fid).await && !is_admin {
return false;
return Err("room_friends_only");
}
}
true
Ok(())
}
fn password_matches(stored_password_or_hash: &str, provided_password: &str) -> bool {
@@ -1292,6 +1474,18 @@ fn command_from_chat_line(message: &str, token: Option<String>) -> Option<Comman
to: None,
user_name: None,
}),
"/dr" | "/delete_room" => Some(Command {
cmd_type: Value::String("delete_room".to_string()),
token,
name: None,
room: None,
message: Some(rest),
value: None,
password: None,
rounds: None,
to: None,
user_name: None,
}),
"/do" => Some(Command {
cmd_type: Value::String("do".to_string()),
token,