|
|
|
use std::collections::{HashMap, HashSet};
|
|
|
|
|
|
|
|
use elefren::AppData;
|
|
|
|
|
|
|
|
use crate::error::GroupError;
|
|
|
|
use crate::store;
|
|
|
|
|
|
|
|
/// This is the inner data struct holding the config
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
|
|
|
pub(crate) struct Config {
|
|
|
|
groups: HashMap<String, GroupConfig>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Config {
|
|
|
|
pub(crate) fn iter_groups(&self) -> impl Iterator<Item=&GroupConfig>{
|
|
|
|
self.groups.values()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn get_group_config(&self, acct : &str) -> Option<&GroupConfig> {
|
|
|
|
self.groups.get(acct)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn set_group_config(&mut self, grp : GroupConfig) {
|
|
|
|
self.groups.insert(grp.acct.clone(), grp);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/// This is the inner data struct holding a group's config
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
|
|
#[serde(default)]
|
|
|
|
pub(crate) struct GroupConfig {
|
|
|
|
enabled: bool,
|
|
|
|
/// Group actor's acct
|
|
|
|
acct: String,
|
|
|
|
/// elefren data
|
|
|
|
appdata : AppData,
|
|
|
|
/// List of admin account "acct" names, e.g. piggo@piggo.space
|
|
|
|
admin_users: HashSet<String>,
|
|
|
|
/// List of users allowed to post to the group, if it is member-only
|
|
|
|
member_users: HashSet<String>,
|
|
|
|
/// List of users banned from posting to the group
|
|
|
|
banned_users: HashSet<String>,
|
|
|
|
/// True if only members should be allowed to write
|
|
|
|
member_only: bool,
|
|
|
|
/// Banned domain names, e.g. kiwifarms.cc
|
|
|
|
banned_servers: HashSet<String>,
|
|
|
|
/// Last seen notification timestamp
|
|
|
|
last_notif_ts: u64,
|
|
|
|
|
|
|
|
#[serde(skip)]
|
|
|
|
dirty: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for GroupConfig {
|
|
|
|
fn default() -> Self {
|
|
|
|
Self {
|
|
|
|
enabled: true,
|
|
|
|
acct: "".to_string(),
|
|
|
|
appdata: AppData {
|
|
|
|
base: Default::default(),
|
|
|
|
client_id: Default::default(),
|
|
|
|
client_secret: Default::default(),
|
|
|
|
redirect: Default::default(),
|
|
|
|
token: Default::default()
|
|
|
|
},
|
|
|
|
admin_users: Default::default(),
|
|
|
|
member_users: Default::default(),
|
|
|
|
banned_users: Default::default(),
|
|
|
|
member_only: false,
|
|
|
|
banned_servers: Default::default(),
|
|
|
|
last_notif_ts: 0,
|
|
|
|
dirty: false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl GroupConfig {
|
|
|
|
pub(crate) fn new(acct : String, appdata: AppData) -> Self {
|
|
|
|
Self {
|
|
|
|
acct,
|
|
|
|
appdata,
|
|
|
|
..Default::default()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn is_enabled(&self) -> bool {
|
|
|
|
self.enabled
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn set_enabled(&mut self, ena: bool){
|
|
|
|
self.enabled = ena;
|
|
|
|
self.mark_dirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn get_appdata(&self) -> &AppData {
|
|
|
|
&self.appdata
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn set_appdata(&mut self, appdata: AppData) {
|
|
|
|
self.appdata = appdata;
|
|
|
|
self.mark_dirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn get_admins(&self) -> impl Iterator<Item=&String> {
|
|
|
|
self.admin_users.iter()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn get_members(&self) -> impl Iterator<Item=&String> {
|
|
|
|
self.member_users.iter()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn set_last_notif(&mut self, ts: u64) {
|
|
|
|
self.last_notif_ts = self.last_notif_ts.max(ts);
|
|
|
|
self.mark_dirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn get_last_notif(&self) -> u64 {
|
|
|
|
self.last_notif_ts
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn get_acct(&self) -> &str {
|
|
|
|
&self.acct
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn is_admin(&self, acct: &str) -> bool {
|
|
|
|
self.admin_users.contains(acct)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn is_member(&self, acct: &str) -> bool {
|
|
|
|
self.member_users.contains(acct)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn is_banned(&self, acct: &str) -> bool {
|
|
|
|
self.banned_users.contains(acct)
|
|
|
|
|| self.is_users_server_banned(acct)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn is_server_banned(&self, server: &str) -> bool {
|
|
|
|
self.banned_servers.contains(server)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Check if the user's server is banned
|
|
|
|
fn is_users_server_banned(&self, acct: &str) -> bool {
|
|
|
|
let server = acct_to_server(acct);
|
|
|
|
self.is_server_banned(server)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn can_write(&self, acct: &str) -> bool {
|
|
|
|
if self.is_admin(acct) {
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
!self.is_banned(acct) && (
|
|
|
|
!self.is_member_only()
|
|
|
|
|| self.is_member(acct)
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn set_admin(&mut self, acct: &str, admin: bool) -> Result<(), GroupError> {
|
|
|
|
if admin {
|
|
|
|
if self.is_banned(acct) {
|
|
|
|
return Err(GroupError::UserIsBanned);
|
|
|
|
}
|
|
|
|
self.admin_users.insert(acct.to_owned());
|
|
|
|
} else {
|
|
|
|
self.admin_users.remove(acct);
|
|
|
|
}
|
|
|
|
self.mark_dirty();
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn set_member(&mut self, acct: &str, member: bool) -> Result<(), GroupError> {
|
|
|
|
if member {
|
|
|
|
if self.is_banned(acct) {
|
|
|
|
return Err(GroupError::UserIsBanned);
|
|
|
|
}
|
|
|
|
self.member_users.insert(acct.to_owned());
|
|
|
|
} else {
|
|
|
|
self.member_users.remove(acct);
|
|
|
|
}
|
|
|
|
self.mark_dirty();
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn ban_user(&mut self, acct: &str, ban: bool) -> Result<(), GroupError> {
|
|
|
|
if ban {
|
|
|
|
if self.is_admin(acct) {
|
|
|
|
return Err(GroupError::UserIsAdmin);
|
|
|
|
}
|
|
|
|
self.banned_users.insert(acct.to_owned());
|
|
|
|
} else {
|
|
|
|
self.banned_users.remove(acct);
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn ban_server(&mut self, server: &str, ban: bool) -> Result<(), GroupError> {
|
|
|
|
if ban {
|
|
|
|
for acct in &self.admin_users {
|
|
|
|
let acct_server = acct_to_server(acct);
|
|
|
|
if acct_server == server {
|
|
|
|
return Err(GroupError::AdminsOnServer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self.banned_servers.insert(server.to_owned());
|
|
|
|
} else {
|
|
|
|
self.banned_servers.remove(server);
|
|
|
|
}
|
|
|
|
self.mark_dirty();
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn set_member_only(&mut self, member_only: bool) {
|
|
|
|
self.member_only = member_only;
|
|
|
|
self.mark_dirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn is_member_only(&self) -> bool {
|
|
|
|
self.member_only
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn mark_dirty(&mut self) {
|
|
|
|
self.dirty = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn is_dirty(&self) -> bool {
|
|
|
|
self.dirty
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn clear_dirty_status(&mut self) {
|
|
|
|
self.dirty = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn acct_to_server(acct: &str) -> &str {
|
|
|
|
acct.split('@').nth(1)
|
|
|
|
.unwrap_or_default()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use crate::error::GroupError;
|
|
|
|
use crate::store::data::{acct_to_server, GroupConfig};
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_acct_to_server() {
|
|
|
|
assert_eq!("pikachu.rocks", acct_to_server("raichu@pikachu.rocks"));
|
|
|
|
assert_eq!("pikachu.rocks", acct_to_server("m@pikachu.rocks"));
|
|
|
|
assert_eq!("", acct_to_server("what"));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_default_rules() {
|
|
|
|
let mut group = GroupConfig::default();
|
|
|
|
assert!(!group.is_member_only());
|
|
|
|
assert!(!group.is_member("piggo@piggo.space"));
|
|
|
|
assert!(!group.is_admin("piggo@piggo.space"));
|
|
|
|
assert!(group.can_write("piggo@piggo.space"), "anyone can post by default");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_member_only() {
|
|
|
|
let mut group = GroupConfig::default();
|
|
|
|
assert!(group.can_write("piggo@piggo.space"), "rando can write in public group");
|
|
|
|
|
|
|
|
group.set_member_only(true);
|
|
|
|
assert!(!group.can_write("piggo@piggo.space"), "rando can't write in member-only group");
|
|
|
|
|
|
|
|
// Admin in member only
|
|
|
|
group.set_admin("piggo@piggo.space", true).unwrap();
|
|
|
|
assert!(group.can_write("piggo@piggo.space"), "admin non-member can write in member-only group");
|
|
|
|
group.set_admin("piggo@piggo.space", false).unwrap();
|
|
|
|
assert!(!group.can_write("piggo@piggo.space"), "removed admin removes privileged write access");
|
|
|
|
|
|
|
|
// Member in member only
|
|
|
|
group.set_member("piggo@piggo.space", true).unwrap();
|
|
|
|
assert!(group.can_write("piggo@piggo.space"), "member can post in member-only group");
|
|
|
|
group.set_admin("piggo@piggo.space", true).unwrap();
|
|
|
|
assert!(group.can_write("piggo@piggo.space"), "member+admin can post in member-only group");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_banned_users() {
|
|
|
|
// Banning single user
|
|
|
|
let mut group = GroupConfig::default();
|
|
|
|
group.ban_user("piggo@piggo.space", true).unwrap();
|
|
|
|
assert!(!group.can_write("piggo@piggo.space"), "banned user can't post");
|
|
|
|
group.ban_user("piggo@piggo.space", false).unwrap();
|
|
|
|
assert!(group.can_write("piggo@piggo.space"), "un-ban works");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_banned_members() {
|
|
|
|
// Banning single user
|
|
|
|
let mut group = GroupConfig::default();
|
|
|
|
group.set_member_only(true);
|
|
|
|
|
|
|
|
group.set_member("piggo@piggo.space", true).unwrap();
|
|
|
|
assert!(group.can_write("piggo@piggo.space"), "member can write");
|
|
|
|
assert!(group.is_member("piggo@piggo.space"), "member is member");
|
|
|
|
assert!(!group.is_banned("piggo@piggo.space"), "user not banned by default");
|
|
|
|
|
|
|
|
group.ban_user("piggo@piggo.space", true).unwrap();
|
|
|
|
assert!(group.is_member("piggo@piggo.space"), "still member even if banned");
|
|
|
|
assert!(group.is_banned("piggo@piggo.space"), "banned user is banned");
|
|
|
|
|
|
|
|
assert!(!group.can_write("piggo@piggo.space"), "banned member can't post");
|
|
|
|
|
|
|
|
// unban
|
|
|
|
group.ban_user("piggo@piggo.space", false).unwrap();
|
|
|
|
assert!(group.can_write("piggo@piggo.space"), "un-ban works");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_server_ban() {
|
|
|
|
let mut group = GroupConfig::default();
|
|
|
|
assert!(group.can_write("hitler@nazi.camp"), "randos can write");
|
|
|
|
|
|
|
|
group.ban_server("nazi.camp", true).unwrap();
|
|
|
|
assert!(!group.can_write("hitler@nazi.camp"), "users from banned server can't write");
|
|
|
|
assert!(!group.can_write("1488@nazi.camp"), "users from banned server can't write");
|
|
|
|
assert!(group.can_write("troll@freezepeach.xyz"), "other users can still write");
|
|
|
|
|
|
|
|
group.ban_server("nazi.camp", false).unwrap();
|
|
|
|
assert!(group.can_write("hitler@nazi.camp"), "server unban works");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_sanity() {
|
|
|
|
let mut group = GroupConfig::default();
|
|
|
|
|
|
|
|
group.set_admin("piggo@piggo.space", true).unwrap();
|
|
|
|
assert_eq!(Err(GroupError::UserIsAdmin), group.ban_user("piggo@piggo.space", true), "can't bad admin users");
|
|
|
|
group.ban_user("piggo@piggo.space", false).expect("can unbad admin");
|
|
|
|
|
|
|
|
group.ban_user("hitler@nazi.camp", true).unwrap();
|
|
|
|
assert_eq!(Err(GroupError::UserIsBanned), group.set_admin("hitler@nazi.camp", true), "can't make banned users admins");
|
|
|
|
|
|
|
|
group.ban_server("freespeechextremist.com", true).unwrap();
|
|
|
|
assert_eq!(Err(GroupError::UserIsBanned), group.set_admin("nibber@freespeechextremist.com", true), "can't make server-banned users admins");
|
|
|
|
|
|
|
|
assert!(group.is_admin("piggo@piggo.space"));
|
|
|
|
assert_eq!(Err(GroupError::AdminsOnServer), group.ban_server("piggo.space", true), "can't bad server with admins");
|
|
|
|
}
|
|
|
|
}
|