From 1916e5fce5e1b9ad8ec6ab459cae328973881b97 Mon Sep 17 00:00:00 2001 From: Jean Date: Tue, 14 Jul 2026 14:43:18 +0000 Subject: [PATCH] Split GroupServ into one file per command REGISTER/DROP/INFO/LIST/ADD/DEL/FLAGS each move to their own file; the two shared guards (login check, can-manage) stay in lib.rs beside the dispatcher. No behaviour change. --- modules/groupserv/src/add.rs | 26 ++++ modules/groupserv/src/del.rs | 23 ++++ modules/groupserv/src/drop.rs | 22 ++++ modules/groupserv/src/flags.rs | 53 ++++++++ modules/groupserv/src/info.rs | 16 +++ modules/groupserv/src/lib.rs | 206 ++++-------------------------- modules/groupserv/src/list.rs | 20 +++ modules/groupserv/src/register.rs | 20 +++ 8 files changed, 207 insertions(+), 179 deletions(-) create mode 100644 modules/groupserv/src/add.rs create mode 100644 modules/groupserv/src/del.rs create mode 100644 modules/groupserv/src/drop.rs create mode 100644 modules/groupserv/src/flags.rs create mode 100644 modules/groupserv/src/info.rs create mode 100644 modules/groupserv/src/list.rs create mode 100644 modules/groupserv/src/register.rs diff --git a/modules/groupserv/src/add.rs b/modules/groupserv/src/add.rs new file mode 100644 index 0000000..f2bba4b --- /dev/null +++ b/modules/groupserv/src/add.rs @@ -0,0 +1,26 @@ +use fedserv_api::{Sender, ServiceCtx, Store}; + +// ADD : add a plain member (no flags). Needs founder or `f`. +pub fn handle(me: &str, from: &Sender, name: Option<&str>, target: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { + let Some(acc) = super::account(me, from, ctx) else { return }; + let (Some(name), Some(target)) = (name, target) else { + ctx.notice(me, from.uid, "Syntax: ADD "); + return; + }; + let Some(g) = db.group(name) else { + ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); + return; + }; + if !super::can_manage(&g, acc) { + ctx.notice(me, from.uid, format!("You need the founder or the \x02f\x02 flag to manage \x02{name}\x02.")); + return; + } + let Some(canonical) = db.resolve_account(target).map(str::to_string) else { + ctx.notice(me, from.uid, format!("\x02{target}\x02 isn't registered.")); + return; + }; + match db.group_set_flags(name, &canonical, "") { + Ok(()) => ctx.notice(me, from.uid, format!("Added \x02{canonical}\x02 to \x02{name}\x02.")), + Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), + } +} diff --git a/modules/groupserv/src/del.rs b/modules/groupserv/src/del.rs new file mode 100644 index 0000000..215d493 --- /dev/null +++ b/modules/groupserv/src/del.rs @@ -0,0 +1,23 @@ +use fedserv_api::{Sender, ServiceCtx, Store}; + +// DEL : remove a member. Needs founder or the `f` flag. +pub fn handle(me: &str, from: &Sender, name: Option<&str>, target: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { + let Some(acc) = super::account(me, from, ctx) else { return }; + let (Some(name), Some(target)) = (name, target) else { + ctx.notice(me, from.uid, "Syntax: DEL "); + return; + }; + let Some(g) = db.group(name) else { + ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); + return; + }; + if !super::can_manage(&g, acc) { + ctx.notice(me, from.uid, format!("You need the founder or the \x02f\x02 flag to manage \x02{name}\x02.")); + return; + } + match db.group_del_member(name, target) { + Ok(true) => ctx.notice(me, from.uid, format!("Removed \x02{target}\x02 from \x02{name}\x02.")), + Ok(false) => ctx.notice(me, from.uid, format!("\x02{target}\x02 isn't in \x02{name}\x02.")), + Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), + } +} diff --git a/modules/groupserv/src/drop.rs b/modules/groupserv/src/drop.rs new file mode 100644 index 0000000..6f6f2b4 --- /dev/null +++ b/modules/groupserv/src/drop.rs @@ -0,0 +1,22 @@ +use fedserv_api::{Sender, ServiceCtx, Store}; + +// DROP : delete a group. Founder only. +pub fn handle(me: &str, from: &Sender, name: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { + let Some(acc) = super::account(me, from, ctx) else { return }; + let Some(name) = name else { + ctx.notice(me, from.uid, "Syntax: DROP "); + return; + }; + let Some(g) = db.group(name) else { + ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); + return; + }; + if !g.founder.eq_ignore_ascii_case(acc) { + ctx.notice(me, from.uid, format!("Only \x02{name}\x02's founder can drop it.")); + return; + } + match db.group_drop(name) { + Ok(()) => ctx.notice(me, from.uid, format!("Group \x02{name}\x02 has been dropped.")), + Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), + } +} diff --git a/modules/groupserv/src/flags.rs b/modules/groupserv/src/flags.rs new file mode 100644 index 0000000..a5d71d7 --- /dev/null +++ b/modules/groupserv/src/flags.rs @@ -0,0 +1,53 @@ +use fedserv_api::{apply_flags, Sender, ServiceCtx, Store, GROUP_FLAGS}; + +// FLAGS [account [+/-flags]]: list, show, or change group-access flags. +// Listing/showing is open; changing needs the founder or the `f` flag. +pub fn handle(me: &str, from: &Sender, name: Option<&str>, target: Option<&str>, delta: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { + let Some(acc) = super::account(me, from, ctx) else { return }; + let Some(name) = name else { + ctx.notice(me, from.uid, "Syntax: FLAGS [account [+/-flags]]"); + return; + }; + let Some(g) = db.group(name) else { + ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); + return; + }; + // List. + let Some(target) = target else { + ctx.notice(me, from.uid, format!("Flags for \x02{}\x02:", g.name)); + ctx.notice(me, from.uid, format!(" \x02{}\x02 (founder): \x02F\x02", g.founder)); + for m in &g.members { + ctx.notice(me, from.uid, format!(" \x02{}\x02: \x02{}\x02", m.account, if m.flags.is_empty() { "(member)" } else { &m.flags })); + } + return; + }; + let current = g.members.iter().find(|m| m.account.eq_ignore_ascii_case(target)).map(|m| m.flags.clone()); + // Show one. + let Some(delta) = delta else { + match current { + Some(f) => ctx.notice(me, from.uid, format!("\x02{target}\x02 in \x02{name}\x02: \x02{}\x02", if f.is_empty() { "(member)" } else { &f })), + None => ctx.notice(me, from.uid, format!("\x02{target}\x02 isn't in \x02{name}\x02.")), + } + return; + }; + // Change — needs founder or f flag. + if !super::can_manage(&g, acc) { + ctx.notice(me, from.uid, format!("You need the founder or the \x02f\x02 flag to change \x02{name}\x02.")); + return; + } + let Some(canonical) = db.resolve_account(target).map(str::to_string) else { + ctx.notice(me, from.uid, format!("\x02{target}\x02 isn't registered.")); + return; + }; + let updated = match apply_flags(current.as_deref().unwrap_or(""), delta, GROUP_FLAGS) { + Ok(f) => f, + Err(bad) => { + ctx.notice(me, from.uid, format!("\x02{bad}\x02 isn't a valid group flag. Valid: \x02{GROUP_FLAGS}\x02.")); + return; + } + }; + match db.group_set_flags(name, &canonical, &updated) { + Ok(()) => ctx.notice(me, from.uid, format!("\x02{canonical}\x02 in \x02{name}\x02 now holds \x02{}\x02.", if updated.is_empty() { "(member)" } else { &updated })), + Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), + } +} diff --git a/modules/groupserv/src/info.rs b/modules/groupserv/src/info.rs new file mode 100644 index 0000000..a314049 --- /dev/null +++ b/modules/groupserv/src/info.rs @@ -0,0 +1,16 @@ +use fedserv_api::{Sender, ServiceCtx, Store}; + +// INFO : show a group's founder and member count. +pub fn handle(me: &str, from: &Sender, name: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { + let Some(name) = name else { + ctx.notice(me, from.uid, "Syntax: INFO "); + return; + }; + let Some(g) = db.group(name) else { + ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); + return; + }; + ctx.notice(me, from.uid, format!("Information for \x02{}\x02:", g.name)); + ctx.notice(me, from.uid, format!(" Founder : \x02{}\x02", g.founder)); + ctx.notice(me, from.uid, format!(" Members : {}", g.members.len())); +} diff --git a/modules/groupserv/src/lib.rs b/modules/groupserv/src/lib.rs index 5d8b947..144f72e 100644 --- a/modules/groupserv/src/lib.rs +++ b/modules/groupserv/src/lib.rs @@ -4,8 +4,26 @@ //! channel access. Members carry group-access flags (the same flag primitive //! ChanServ uses): F founder, f manage members, i invite, c channel-access, //! s set, m memo. Managing members needs the founder or the `f` flag. +//! +//! `lib.rs` holds the dispatcher and the two shared guards; each command lives +//! in its own file. -use fedserv_api::{apply_flags, NetView, Sender, Service, ServiceCtx, Store, GROUP_FLAGS}; +use fedserv_api::{NetView, Sender, Service, ServiceCtx, Store}; + +#[path = "register.rs"] +mod register; +#[path = "drop.rs"] +mod drop; +#[path = "info.rs"] +mod info; +#[path = "list.rs"] +mod list; +#[path = "add.rs"] +mod add; +#[path = "del.rs"] +mod del; +#[path = "flags.rs"] +mod flags; pub struct GroupServ { pub uid: String, @@ -25,23 +43,19 @@ impl Service for GroupServ { fn on_command(&mut self, from: &Sender, args: &[&str], ctx: &mut ServiceCtx, _net: &dyn NetView, db: &mut dyn Store) { let me = self.uid.as_str(); match args.first().map(|s| s.to_ascii_uppercase()).as_deref() { - Some("REGISTER") => register(me, from, args.get(1).copied(), ctx, db), - Some("DROP") => drop(me, from, args.get(1).copied(), ctx, db), - Some("INFO") => info(me, from, args.get(1).copied(), ctx, db), - Some("LIST") => list(me, from, ctx, db), - Some("ADD") => add(me, from, args.get(1).copied(), args.get(2).copied(), ctx, db), - Some("DEL") => del(me, from, args.get(1).copied(), args.get(2).copied(), ctx, db), - Some("FLAGS") => flags(me, from, args.get(1).copied(), args.get(2).copied(), args.get(3).copied(), ctx, db), - Some("HELP") | None => help(me, from, ctx), + Some("REGISTER") => register::handle(me, from, args.get(1).copied(), ctx, db), + Some("DROP") => drop::handle(me, from, args.get(1).copied(), ctx, db), + Some("INFO") => info::handle(me, from, args.get(1).copied(), ctx, db), + Some("LIST") => list::handle(me, from, ctx, db), + Some("ADD") => add::handle(me, from, args.get(1).copied(), args.get(2).copied(), ctx, db), + Some("DEL") => del::handle(me, from, args.get(1).copied(), args.get(2).copied(), ctx, db), + Some("FLAGS") => flags::handle(me, from, args.get(1).copied(), args.get(2).copied(), args.get(3).copied(), ctx, db), + Some("HELP") | None => ctx.notice(me, from.uid, "GroupServ manages user groups. \x02REGISTER\x02 , \x02DROP\x02 , \x02INFO\x02 , \x02LIST\x02, \x02ADD\x02/\x02DEL\x02 , \x02FLAGS\x02 [account [+/-flags]]. Grant a group channel access with ChanServ \x02FLAGS #chan !group +o\x02 — every member then inherits it."), Some(other) => ctx.notice(me, from.uid, format!("I don't know \x02{other}\x02. Try \x02HELP\x02.")), } } } -fn help(me: &str, from: &Sender, ctx: &mut ServiceCtx) { - ctx.notice(me, from.uid, "GroupServ manages user groups. \x02REGISTER\x02 , \x02DROP\x02 , \x02INFO\x02 , \x02LIST\x02, \x02ADD\x02/\x02DEL\x02 , \x02FLAGS\x02 [account [+/-flags]]. Grant a group channel access with ChanServ \x02FLAGS #chan !group +o\x02 — every member then inherits it."); -} - // The caller must be logged in; returns their account. fn account<'a>(me: &str, from: &'a Sender, ctx: &mut ServiceCtx) -> Option<&'a str> { match from.account { @@ -58,169 +72,3 @@ fn can_manage(group: &fedserv_api::GroupView, who: &str) -> bool { group.founder.eq_ignore_ascii_case(who) || group.members.iter().any(|m| m.account.eq_ignore_ascii_case(who) && (m.flags.contains('F') || m.flags.contains('f'))) } - -fn register(me: &str, from: &Sender, name: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { - let Some(acc) = account(me, from, ctx) else { return }; - let Some(name) = name else { - ctx.notice(me, from.uid, "Syntax: REGISTER "); - return; - }; - if !name.starts_with('!') || name.len() < 2 { - ctx.notice(me, from.uid, "A group name starts with \x02!\x02, e.g. \x02!staff\x02."); - return; - } - let acc = acc.to_string(); - match db.group_register(name, &acc) { - Ok(()) => ctx.notice(me, from.uid, format!("Group \x02{name}\x02 registered — you're the founder.")), - Err(fedserv_api::ChanError::Exists) => ctx.notice(me, from.uid, format!("\x02{name}\x02 is already registered.")), - Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), - } -} - -fn drop(me: &str, from: &Sender, name: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { - let Some(acc) = account(me, from, ctx) else { return }; - let Some(name) = name else { - ctx.notice(me, from.uid, "Syntax: DROP "); - return; - }; - let Some(g) = db.group(name) else { - ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); - return; - }; - if !g.founder.eq_ignore_ascii_case(acc) { - ctx.notice(me, from.uid, format!("Only \x02{name}\x02's founder can drop it.")); - return; - } - match db.group_drop(name) { - Ok(()) => ctx.notice(me, from.uid, format!("Group \x02{name}\x02 has been dropped.")), - Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), - } -} - -fn info(me: &str, from: &Sender, name: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { - let Some(name) = name else { - ctx.notice(me, from.uid, "Syntax: INFO "); - return; - }; - let Some(g) = db.group(name) else { - ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); - return; - }; - ctx.notice(me, from.uid, format!("Information for \x02{}\x02:", g.name)); - ctx.notice(me, from.uid, format!(" Founder : \x02{}\x02", g.founder)); - ctx.notice(me, from.uid, format!(" Members : {}", g.members.len())); -} - -fn list(me: &str, from: &Sender, ctx: &mut ServiceCtx, db: &mut dyn Store) { - // Operators see every group; others see the ones they belong to. - let names = if from.privs.any() { - db.groups() - } else if let Some(acc) = from.account { - db.groups_of(acc) - } else { - Vec::new() - }; - if names.is_empty() { - ctx.notice(me, from.uid, "No groups to show."); - return; - } - for n in &names { - ctx.notice(me, from.uid, format!(" \x02{n}\x02")); - } - ctx.notice(me, from.uid, format!("End of list ({} group(s)).", names.len())); -} - -fn add(me: &str, from: &Sender, name: Option<&str>, target: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { - let Some(acc) = account(me, from, ctx) else { return }; - let (Some(name), Some(target)) = (name, target) else { - ctx.notice(me, from.uid, "Syntax: ADD "); - return; - }; - let Some(g) = db.group(name) else { - ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); - return; - }; - if !can_manage(&g, acc) { - ctx.notice(me, from.uid, format!("You need the founder or the \x02f\x02 flag to manage \x02{name}\x02.")); - return; - } - let Some(canonical) = db.resolve_account(target).map(str::to_string) else { - ctx.notice(me, from.uid, format!("\x02{target}\x02 isn't registered.")); - return; - }; - match db.group_set_flags(name, &canonical, "") { - Ok(()) => ctx.notice(me, from.uid, format!("Added \x02{canonical}\x02 to \x02{name}\x02.")), - Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), - } -} - -fn del(me: &str, from: &Sender, name: Option<&str>, target: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { - let Some(acc) = account(me, from, ctx) else { return }; - let (Some(name), Some(target)) = (name, target) else { - ctx.notice(me, from.uid, "Syntax: DEL "); - return; - }; - let Some(g) = db.group(name) else { - ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); - return; - }; - if !can_manage(&g, acc) { - ctx.notice(me, from.uid, format!("You need the founder or the \x02f\x02 flag to manage \x02{name}\x02.")); - return; - } - match db.group_del_member(name, target) { - Ok(true) => ctx.notice(me, from.uid, format!("Removed \x02{target}\x02 from \x02{name}\x02.")), - Ok(false) => ctx.notice(me, from.uid, format!("\x02{target}\x02 isn't in \x02{name}\x02.")), - Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), - } -} - -fn flags(me: &str, from: &Sender, name: Option<&str>, target: Option<&str>, delta: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { - let Some(acc) = account(me, from, ctx) else { return }; - let Some(name) = name else { - ctx.notice(me, from.uid, "Syntax: FLAGS [account [+/-flags]]"); - return; - }; - let Some(g) = db.group(name) else { - ctx.notice(me, from.uid, format!("\x02{name}\x02 isn't registered.")); - return; - }; - // List. - let Some(target) = target else { - ctx.notice(me, from.uid, format!("Flags for \x02{}\x02:", g.name)); - ctx.notice(me, from.uid, format!(" \x02{}\x02 (founder): \x02F\x02", g.founder)); - for m in &g.members { - ctx.notice(me, from.uid, format!(" \x02{}\x02: \x02{}\x02", m.account, if m.flags.is_empty() { "(member)" } else { &m.flags })); - } - return; - }; - let current = g.members.iter().find(|m| m.account.eq_ignore_ascii_case(target)).map(|m| m.flags.clone()); - // Show one. - let Some(delta) = delta else { - match current { - Some(f) => ctx.notice(me, from.uid, format!("\x02{target}\x02 in \x02{name}\x02: \x02{}\x02", if f.is_empty() { "(member)" } else { &f })), - None => ctx.notice(me, from.uid, format!("\x02{target}\x02 isn't in \x02{name}\x02.")), - } - return; - }; - // Change — needs founder or f flag. - if !can_manage(&g, acc) { - ctx.notice(me, from.uid, format!("You need the founder or the \x02f\x02 flag to change \x02{name}\x02.")); - return; - } - let Some(canonical) = db.resolve_account(target).map(str::to_string) else { - ctx.notice(me, from.uid, format!("\x02{target}\x02 isn't registered.")); - return; - }; - let updated = match apply_flags(current.as_deref().unwrap_or(""), delta, GROUP_FLAGS) { - Ok(f) => f, - Err(bad) => { - ctx.notice(me, from.uid, format!("\x02{bad}\x02 isn't a valid group flag. Valid: \x02{GROUP_FLAGS}\x02.")); - return; - } - }; - match db.group_set_flags(name, &canonical, &updated) { - Ok(()) => ctx.notice(me, from.uid, format!("\x02{canonical}\x02 in \x02{name}\x02 now holds \x02{}\x02.", if updated.is_empty() { "(member)" } else { &updated })), - Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), - } -} diff --git a/modules/groupserv/src/list.rs b/modules/groupserv/src/list.rs new file mode 100644 index 0000000..783f823 --- /dev/null +++ b/modules/groupserv/src/list.rs @@ -0,0 +1,20 @@ +use fedserv_api::{Sender, ServiceCtx, Store}; + +// LIST: operators see every group; others see the ones they belong to. +pub fn handle(me: &str, from: &Sender, ctx: &mut ServiceCtx, db: &mut dyn Store) { + let names = if from.privs.any() { + db.groups() + } else if let Some(acc) = from.account { + db.groups_of(acc) + } else { + Vec::new() + }; + if names.is_empty() { + ctx.notice(me, from.uid, "No groups to show."); + return; + } + for n in &names { + ctx.notice(me, from.uid, format!(" \x02{n}\x02")); + } + ctx.notice(me, from.uid, format!("End of list ({} group(s)).", names.len())); +} diff --git a/modules/groupserv/src/register.rs b/modules/groupserv/src/register.rs new file mode 100644 index 0000000..c0610f5 --- /dev/null +++ b/modules/groupserv/src/register.rs @@ -0,0 +1,20 @@ +use fedserv_api::{Sender, ServiceCtx, Store}; + +// REGISTER : create a group with you as its founder. +pub fn handle(me: &str, from: &Sender, name: Option<&str>, ctx: &mut ServiceCtx, db: &mut dyn Store) { + let Some(acc) = super::account(me, from, ctx) else { return }; + let Some(name) = name else { + ctx.notice(me, from.uid, "Syntax: REGISTER "); + return; + }; + if !name.starts_with('!') || name.len() < 2 { + ctx.notice(me, from.uid, "A group name starts with \x02!\x02, e.g. \x02!staff\x02."); + return; + } + let acc = acc.to_string(); + match db.group_register(name, &acc) { + Ok(()) => ctx.notice(me, from.uid, format!("Group \x02{name}\x02 registered — you're the founder.")), + Err(fedserv_api::ChanError::Exists) => ctx.notice(me, from.uid, format!("\x02{name}\x02 is already registered.")), + Err(_) => ctx.notice(me, from.uid, "Sorry, that didn't work. Please try again in a moment."), + } +}