Struct RoomPolicy 

pub struct RoomPolicy {
    pub room: String,
    pub owner: Option<String>,
    pub members: BTreeMap<String, Role>,
    pub grants: Vec<Grant>,
}

Everything that decides authority in one room.

Fields

room: String

owner: Option<String>

The owner, by person id. Structural: holds everything and cannot be removed, demoted or denied by a grant.

members: BTreeMap<String, Role>

Members other than the owner and the role preset each holds.

grants: Vec<Grant>

Every grant in the room, role presets included.

Implementations

impl RoomPolicy

pub fn new(room: impl Into<String>, owner: impl Into<String>) -> RoomPolicy

A new room: its owner and every role’s preset grants.

pub fn unowned(room: impl Into<String>, presets_by: &Subject) -> RoomPolicy

A room with no owner yet and the role presets in place.

pub fn rehome(&mut self, room: impl Into<String>)

Move the policy to another room id: every grant on this room’s nodes now names room. Grants on other rooms are untouched.

pub fn node(&self) -> TreePath

pub fn is_owner(&self, person: &str) -> bool

pub fn role_of(&self, person: &str) -> Option<Role>

The role a person holds: Owner for the owner, None for a non-member.

pub fn is_blocked(&self, person: &str) -> bool

Whether person is blocked: their own grants deny every kind on the whole room. A blocked member stays on record (history keeps naming them) but holds nothing; the owner is never blocked.

pub fn active_role(&self, person: &str) -> Option<Role>

The role person acts with: their role, unless they are blocked.

pub fn block(&self, person: &str, granted_by: Subject) -> Grant

The grant that blocks person, given by granted_by.

pub fn is_banned(&self, person: &str) -> bool

Whether person is banned: the room holds their block:<person> grant. A banned person is not admitted again until unban.

pub fn restricted_until(&self, person: &str, cx: &Context<'_>) -> Option<u64>

Until when person is restricted, if a restriction of theirs is live in cx.

pub fn is_member(&self, person: &str) -> bool

pub fn subjects_of(&self, person: &str) -> Vec<Subject>

The subjects a person is known by here: themselves and their role.

pub fn party(&self, person: &str) -> Party<'_>

A person’s own authority in the room.

pub fn person_on_device<'a>( &'a self, person: &str, foreign: bool, foreign_bound: &'a [Grant], ) -> Authority<'a>

person’s authority from one of their devices: their own, and from a device that is not theirs (foreign), held to foreign_bound and to the room’s grants for such devices too.

pub fn task_answer( &self, task: &str, node: &TreePath, kind: ActionKind, cx: &Context<'_>, ) -> Option<Answer>

The answer task task’s own grant set gives for an action of kind at node, or None when the task carries no grant set.

pub fn party_of(&self, subject: Subject) -> Party<'_>

The room’s grants naming a delegation subject (an agent, an app, a task), for bounding a person’s authority.

pub fn app_authors(&self, app: &str, cx: &Context<'_>) -> bool

Whether application app is an author of the room: its grants let it change the room’s content (roles::app_authorship).

pub fn grants_of<'a>( &'a self, subject: &'a Subject, ) -> impl Iterator<Item = &'a Grant> + 'a

The grants naming subject.

pub fn check_action( &self, actor: &Authority<'_>, action: &str, cx: &Context<'_>, approved: bool, ) -> Result<(), Refusal>

Whether the actor may perform a governance action. approved says the host witnessed the person’s approval when the answer is Ask.

Errors

Refusal::NotPermitted or Refusal::NeedsApproval.

pub fn lapse_tasks(&mut self, open: impl Fn(&str) -> bool) -> Vec<GrantId>

Drop the grants that lapsed with their task (Grant::lapsed_with_tasks). The ids dropped.

pub fn spend(&mut self, spent: &[GrantId]) -> bool

Drop the Once grants among spent: an action ran on them. Any other grant named stays. Returns whether anything was dropped.

pub fn check_invite( &self, actor_person: &str, actor: &Authority<'_>, role: Role, cx: &Context<'_>, approved: bool, ) -> Result<(), Refusal>

Whether actor_person (acting through actor) may invite someone with role. An invite never carries more than the inviter’s role.

Errors

When the invite action is not granted or role exceeds the inviter’s.

pub fn check( &self, actor_person: &str, actor: &Authority<'_>, change: &Change, cx: &Context<'_>, approved: bool, ) -> Result<(), Refusal>

Whether actor_person (acting through actor) may make change, without making it: what a door asks before it commits the change by its own means.

Errors

As Self::apply.

pub fn apply( &mut self, actor_person: &str, actor: &Authority<'_>, change: Change, cx: &Context<'_>, approved: bool, ) -> Result<(), Refusal>

Applies a governance change made by actor_person through actor.

Errors

When the action is not granted, or the change breaks a structural rule: the owner stays, roles and grants never exceed the actor’s own.

pub fn check_within( actor: &Authority<'_>, grant: &Grant, cx: &Context<'_>, ) -> Result<(), Refusal>

Whether grant gives no more than actor holds on its node, for each kind it covers. A Deny never exceeds.

Errors

Refusal::AboveActorGrant for the first kind it exceeds.

Trait Implementations

impl Clone for RoomPolicy

fn clone(&self) -> RoomPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RoomPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RoomPolicy

fn deserialize<__D>( __deserializer: __D, ) -> Result<RoomPolicy, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RoomPolicy

fn eq(&self, other: &RoomPolicy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RoomPolicy

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RoomPolicy

impl StructuralPartialEq for RoomPolicy