Struct Invite 

pub struct Invite {
    pub id: String,
    pub creator_id: String,
    pub recipient_id: String,
    pub entity_id: String,
    pub entity_type: EntityType,
    pub role: String,
    pub message: Option<String>,
    pub status: InviteStatus,
    pub created_at: i64,
    pub expires_at: Option<i64>,
    pub resolved_at: Option<i64>,
    pub resolved_by: Option<String>,
}

An invitation to join an entity.

Invites are created by entity members with appropriate permissions and target a specific four-word identity. On acceptance, the recipient becomes a member with the specified role.

Fields

id: String

Unique identifier for this invite.

creator_id: String

Four-word identity of the invite creator.

recipient_id: String

Four-word identity of the intended recipient.

entity_id: String

Target entity ID.

entity_type: EntityType

Target entity type.

role: String

Role to grant on acceptance.

message: Option<String>

Optional message from creator to recipient.

status: InviteStatus

Current status of the invite.

created_at: i64

When the invite was created (Unix timestamp ms).

expires_at: Option<i64>

When the invite expires, if set (Unix timestamp ms).

resolved_at: Option<i64>

When the invite was resolved (accepted/rejected/revoked).

resolved_by: Option<String>

Who resolved the invite (recipient for accept/reject, admin for revoke).

Implementations

impl Invite

pub fn new( creator_id: String, recipient_id: String, entity_id: String, entity_type: EntityType, role: String, message: Option<String>, expires_in_hours: Option<u32>, ) -> Self

Create a new pending invite.

Arguments

• creator_id - Four-word identity of the creator
• recipient_id - Four-word identity of the recipient
• entity_id - ID of the entity to join
• entity_type - Type of the entity
• role - Role to grant on acceptance
• message - Optional message to recipient
• expires_in_hours - Optional expiration in hours from now

Example

use communitas_core::invite::Invite;
use communitas_core::crdt::EntityType;

let invite = Invite::new(
    "alice-brave-cloud-dawn".to_string(),
    "bob-calm-river-east".to_string(),
    "project-123".to_string(),
    EntityType::Project,
    "member".to_string(),
    Some("Join our project!".to_string()),
    Some(168), // 1 week
);

assert!(invite.is_pending());
assert!(invite.is_valid());

pub fn set_id(self, id: String) -> Self

Set a custom ID on this invite (builder pattern).

Returns self for method chaining.

pub fn is_pending(&self) -> bool

Check if the invite is still pending.

pub fn is_accepted(&self) -> bool

Check if the invite has been accepted.

pub fn is_resolved(&self) -> bool

Check if the invite is in a terminal state.

pub fn is_expired(&self) -> bool

Check if the invite has expired based on current time.

pub fn is_expired_at(&self, at: DateTime<Utc>) -> bool

Check if the invite would be expired at a given time.

pub fn is_valid(&self) -> bool

Check if the invite is valid (pending and not expired).

pub fn is_valid_at(&self, at: DateTime<Utc>) -> bool

Check if the invite would be valid at a given time.

pub fn accept(&mut self, acceptor_id: &str) -> Result<(), InviteActionError>

Accept the invite.

Returns Err if invite is not in a valid state.

pub fn accept_at( &mut self, acceptor_id: &str, at: DateTime<Utc>, ) -> Result<(), InviteActionError>

Accept the invite at a specific time (for testing).

pub fn reject(&mut self, rejector_id: &str) -> Result<(), InviteActionError>

Reject the invite.

Returns Err if invite is not in a valid state.

pub fn reject_at( &mut self, rejector_id: &str, at: DateTime<Utc>, ) -> Result<(), InviteActionError>

Reject the invite at a specific time (for testing).

pub fn revoke(&mut self, revoker_id: &str) -> Result<(), InviteActionError>

Revoke the invite (creator or admin action).

Returns Err if invite is not pending.

pub fn revoke_at( &mut self, revoker_id: &str, at: DateTime<Utc>, ) -> Result<(), InviteActionError>

Revoke the invite at a specific time (for testing).

pub fn mark_expired(&mut self) -> Result<(), InviteActionError>

Mark the invite as expired.

This is typically called during cleanup when checking validity.

pub fn mark_expired_at( &mut self, at: DateTime<Utc>, ) -> Result<(), InviteActionError>

Mark the invite as expired at a specific time.

pub fn created_at_datetime(&self) -> DateTime<Utc>

Get the created_at timestamp as DateTime.

pub fn expires_at_datetime(&self) -> Option<DateTime<Utc>>

Get the expires_at timestamp as DateTime, if set.

pub fn resolved_at_datetime(&self) -> Option<DateTime<Utc>>

Get the resolved_at timestamp as DateTime, if set.

pub fn time_remaining(&self) -> Option<Duration>

Get time remaining until expiration, if applicable.

pub fn time_remaining_at(&self, at: DateTime<Utc>) -> Option<Duration>

Get time remaining until expiration at a specific time.

Trait Implementations

impl Clone for Invite

fn clone(&self) -> Invite

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Invite

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Invite

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Invite

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

where __S: Serializer,

Serialize this value into the given Serde serializer.