use std::collections::HashSet;
use crate::SpacePatchOp;
use jmap_chat_types::{ChannelPermission, ChatPermission};
pub fn resolve_channel_permissions(
space_permissions: HashSet<ChatPermission>,
space_id: &str,
member_id: &str,
role_ids: &HashSet<&str>,
overrides: &[ChannelPermission],
) -> HashSet<ChatPermission> {
let role_records: Vec<&ChannelPermission> = overrides
.iter()
.filter(|o| {
let target = o.target_id.as_ref();
o.target_type.as_str() == "role" && (target == space_id || role_ids.contains(target))
})
.collect();
let member_records: Vec<&ChannelPermission> = overrides
.iter()
.filter(|o| o.target_type.as_str() == "member" && o.target_id.as_ref() == member_id)
.collect();
let mut perms = space_permissions;
for records in [role_records, member_records] {
for o in &records {
for p in &o.deny {
perms.retain(|q| q.as_str() != p.as_str());
}
}
for o in &records {
perms.extend(o.allow.iter().cloned());
}
}
perms
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RequiredPermissions {
Known(&'static [ChatPermission]),
UnknownOp,
}
pub fn required_permissions_for_op(op: &SpacePatchOp) -> RequiredPermissions {
match op {
SpacePatchOp::AddRole(_)
| SpacePatchOp::RemoveRole(_)
| SpacePatchOp::UpdateRole { .. } => {
RequiredPermissions::Known(&[ChatPermission::ManageRoles])
}
SpacePatchOp::AddMember(_) | SpacePatchOp::RemoveMember(_) => {
RequiredPermissions::Known(&[ChatPermission::ManageMembers])
}
SpacePatchOp::UpdateMember { patch, .. } => match (&patch.role_ids, &patch.nick) {
(Some(_), Some(_)) => RequiredPermissions::Known(&[
ChatPermission::ManageMembers,
ChatPermission::ManageRoles,
]),
(Some(_), None) => RequiredPermissions::Known(&[ChatPermission::ManageRoles]),
(None, _) => RequiredPermissions::Known(&[ChatPermission::ManageMembers]),
},
SpacePatchOp::AddChannel(_)
| SpacePatchOp::RemoveChannel(_)
| SpacePatchOp::UpdateChannel { .. } => {
RequiredPermissions::Known(&[ChatPermission::ManageChannels])
}
SpacePatchOp::AddCategory(_)
| SpacePatchOp::RemoveCategory(_)
| SpacePatchOp::UpdateCategory { .. } => {
RequiredPermissions::Known(&[ChatPermission::ManageChannels])
}
_ => RequiredPermissions::UnknownOp,
}
}
#[cfg(test)]
mod tests {
use super::*;
use jmap_chat_types::Clearable;
use jmap_chat_types::{
CategoryCreate, CategoryPatch, ChannelCreate, ChannelPatch, MemberPatch, RoleCreate,
RolePatch,
};
use jmap_types::Id;
fn role_fixture() -> RoleCreate {
serde_json::from_value(serde_json::json!({
"name": "Moderator",
"permissions": ["chat:read"],
"position": 0
}))
.expect("role fixture must deserialize")
}
fn category_fixture() -> CategoryCreate {
serde_json::from_value(serde_json::json!({
"name": "Voice",
"position": 0,
"channelIds": []
}))
.expect("category fixture must deserialize")
}
fn channel_create_fixture() -> ChannelCreate {
serde_json::from_value(serde_json::json!({
"name": "general"
}))
.expect("channelCreate fixture must deserialize")
}
#[test]
fn add_role_requires_manage_roles() {
let op = SpacePatchOp::AddRole(role_fixture());
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageRoles])
);
}
#[test]
fn remove_role_requires_manage_roles() {
let op = SpacePatchOp::RemoveRole(Id::from("r1"));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageRoles])
);
}
#[test]
fn update_role_requires_manage_roles() {
let mut patch = RolePatch::default();
patch.name = Some("Renamed".to_owned());
let op = SpacePatchOp::UpdateRole {
id: Id::from("r1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageRoles])
);
}
#[test]
fn add_member_requires_manage_members_only() {
let op = SpacePatchOp::AddMember(jmap_chat_types::MemberCreate::new(
Id::from("u1"),
vec![Id::from("r1"), Id::from("r2")],
));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageMembers])
);
}
#[test]
fn remove_member_requires_manage_members() {
let op = SpacePatchOp::RemoveMember(Id::from("u1"));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageMembers])
);
}
#[test]
fn update_other_member_nick_only_requires_manage_members_only() {
let mut patch = MemberPatch::default();
patch.nick = Some(Clearable::Set("Captain".to_owned()));
let op = SpacePatchOp::UpdateMember {
user_id: Id::from("u1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageMembers])
);
}
#[test]
fn update_member_role_ids_change_requires_manage_roles_only() {
let mut patch = MemberPatch::default();
patch.role_ids = Some(vec![Id::from("r1")]);
let op = SpacePatchOp::UpdateMember {
user_id: Id::from("u1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageRoles])
);
}
#[test]
fn update_member_role_ids_and_nick_requires_both() {
let mut patch = MemberPatch::default();
patch.role_ids = Some(vec![Id::from("r1")]);
patch.nick = Some(Clearable::Set("Captain".to_owned()));
let op = SpacePatchOp::UpdateMember {
user_id: Id::from("u1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[
ChatPermission::ManageMembers,
ChatPermission::ManageRoles
])
);
}
#[test]
fn update_member_role_ids_empty_still_counts_as_change() {
let mut patch = MemberPatch::default();
patch.role_ids = Some(vec![]);
let op = SpacePatchOp::UpdateMember {
user_id: Id::from("u1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageRoles])
);
}
#[test]
fn add_channel_requires_manage_channels() {
let op = SpacePatchOp::AddChannel(channel_create_fixture());
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageChannels])
);
}
#[test]
fn remove_channel_requires_manage_channels() {
let op = SpacePatchOp::RemoveChannel(Id::from("ch1"));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageChannels])
);
}
#[test]
fn update_channel_requires_manage_channels() {
let mut patch = ChannelPatch::default();
patch.name = Some("renamed".to_owned());
let op = SpacePatchOp::UpdateChannel {
id: Id::from("ch1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageChannels])
);
}
#[test]
fn add_category_requires_manage_channels() {
let op = SpacePatchOp::AddCategory(category_fixture());
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageChannels])
);
}
#[test]
fn remove_category_requires_manage_channels() {
let op = SpacePatchOp::RemoveCategory(Id::from("cat1"));
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageChannels])
);
}
#[test]
fn update_category_requires_manage_channels() {
let mut patch = CategoryPatch::default();
patch.name = Some("Voice".to_owned());
let op = SpacePatchOp::UpdateCategory {
id: Id::from("cat1"),
patch,
};
assert_eq!(
required_permissions_for_op(&op),
RequiredPermissions::Known(&[ChatPermission::ManageChannels])
);
}
#[test]
fn required_permissions_serialize_to_spec_names() {
let mut both = MemberPatch::default();
both.role_ids = Some(vec![Id::from("r1")]);
both.nick = Some(Clearable::Set("Captain".to_owned()));
let cases = [
(
SpacePatchOp::UpdateMember {
user_id: Id::from("u1"),
patch: both,
},
serde_json::json!(["manage_members", "manage_roles"]),
),
(
SpacePatchOp::RemoveChannel(Id::from("ch1")),
serde_json::json!(["manage_channels"]),
),
];
for (op, wire) in cases {
let RequiredPermissions::Known(slice) = required_permissions_for_op(&op) else {
panic!("op must have a known requirement");
};
assert_eq!(serde_json::to_value(slice).expect("serialize"), wire);
}
}
#[test]
fn helper_returns_typed_known_or_unknown() {
fn assert_typed_return<F>(_f: F)
where
F: Fn(&SpacePatchOp) -> RequiredPermissions,
{
}
assert_typed_return(required_permissions_for_op);
}
#[test]
fn unknown_op_variant_is_distinct_from_any_known_arm() {
let a = RequiredPermissions::Known(&[ChatPermission::ManageRoles]);
let b = RequiredPermissions::Known(&[ChatPermission::ManageMembers]);
let u = RequiredPermissions::UnknownOp;
assert_ne!(a, b);
assert_ne!(a, u);
assert_ne!(b, u);
assert_eq!(u, RequiredPermissions::UnknownOp);
}
use serde_json::json;
fn overrides(v: serde_json::Value) -> Vec<ChannelPermission> {
serde_json::from_value(v).expect("hand-written ChannelPermission[]")
}
fn set(items: &[&str]) -> HashSet<ChatPermission> {
serde_json::from_value(json!(items)).expect("hand-written permission names")
}
fn resolve(base: &[&str], roles: &[&str], o: serde_json::Value) -> HashSet<ChatPermission> {
let role_ids: HashSet<&str> = roles.iter().copied().collect();
resolve_channel_permissions(set(base), "s1", "m1", &role_ids, &overrides(o))
}
#[test]
fn step1_no_overrides_keeps_space_union() {
assert_eq!(
resolve(&["view", "send"], &["r1"], json!([])),
set(&["view", "send"])
);
}
#[test]
fn step2_role_deny_removes_permission() {
let o = json!([
{ "targetId": "r1", "targetType": "role", "allow": [], "deny": ["send"] },
{ "targetId": "r9", "targetType": "role", "allow": [], "deny": ["view"] }
]);
assert_eq!(resolve(&["view", "send"], &["r1"], o), set(&["view"]));
}
#[test]
fn step3_role_allow_overrides_role_deny() {
let o = json!([
{ "targetId": "r1", "targetType": "role", "allow": [], "deny": ["send"] },
{ "targetId": "r2", "targetType": "role", "allow": ["send"], "deny": [] }
]);
assert_eq!(
resolve(&["view", "send"], &["r1", "r2"], o),
set(&["view", "send"])
);
}
#[test]
fn step4_member_deny_overrides_role_allow() {
let o = json!([
{ "targetId": "r1", "targetType": "role", "allow": ["send"], "deny": [] },
{ "targetId": "m1", "targetType": "member", "allow": [], "deny": ["send"] }
]);
assert_eq!(resolve(&["view"], &["r1"], o), set(&["view"]));
}
#[test]
fn step5_member_allow_overrides_role_deny() {
let o = json!([
{ "targetId": "r1", "targetType": "role", "allow": [], "deny": ["send", "view"] },
{ "targetId": "m1", "targetType": "member", "allow": ["send"], "deny": [] },
{ "targetId": "m2", "targetType": "member", "allow": ["view"], "deny": [] }
]);
assert_eq!(resolve(&["view", "send"], &["r1"], o), set(&["send"]));
}
#[test]
fn target_type_selects_the_id_space() {
let o = json!([
{ "targetId": "m1", "targetType": "role", "allow": ["pin"], "deny": [] },
{ "targetId": "r1", "targetType": "member", "allow": ["ban"], "deny": [] }
]);
assert_eq!(resolve(&["view"], &["r1"], o), set(&["view"]));
}
#[test]
fn space_id_role_record_addresses_everyone() {
let o = json!([
{ "targetId": "s1", "targetType": "role", "allow": ["pin"], "deny": ["send"] }
]);
assert_eq!(resolve(&["view", "send"], &[], o), set(&["view", "pin"]));
}
#[test]
fn member_allow_overrides_everyone_deny() {
let o = json!([
{ "targetId": "s1", "targetType": "role", "allow": [], "deny": ["send"] },
{ "targetId": "m1", "targetType": "member", "allow": ["send"], "deny": [] }
]);
assert_eq!(resolve(&["view", "send"], &[], o), set(&["view", "send"]));
}
#[test]
fn space_id_member_record_matches_nothing() {
let o = json!([
{ "targetId": "s1", "targetType": "member", "allow": [], "deny": ["send"] }
]);
assert_eq!(resolve(&["view", "send"], &[], o), set(&["view", "send"]));
}
#[test]
fn forged_other_spelling_denies_but_never_grants() {
let mut o = overrides(json!([
{ "targetId": "m1", "targetType": "member", "allow": [], "deny": [] }
]));
o[0].deny.push(ChatPermission::Other("send".to_owned()));
o[0].allow.push(ChatPermission::Other("pin".to_owned()));
let role_ids = HashSet::new();
let perms = resolve_channel_permissions(set(&["view", "send"]), "s1", "m1", &role_ids, &o);
assert!(!perms.contains(&ChatPermission::Send));
assert!(!perms.contains(&ChatPermission::Pin));
assert!(perms.contains(&ChatPermission::View));
}
}