tetratto/crates/core/src/model/channels.rs

use serde::{Serialize, Deserialize};
use tetratto_shared::{snow::AlmostSnowflake, unix_epoch_timestamp};

use super::communities_permissions::CommunityPermission;

/// A channel is a more "chat-like" feed in communities.
#[derive(Serialize, Deserialize)]
pub struct Channel {
    pub id: usize,
    pub community: usize,
    pub owner: usize,
    pub created: usize,
    /// The minimum role (as bits) that can read this channel.
    pub minimum_role_read: u32,
    /// The minimum role (as bits) that can write to this channel.
    pub minimum_role_write: u32,
    /// The position of this channel in the UI.
    ///
    /// Top (0) to bottom.
    pub position: usize,
    /// The members of the chat (ids). Should be empty if `community > 0`.
    ///
    /// The owner should not be a member of the channel since any member can update members.
    pub members: Vec<usize>,
    /// The title of the channel.
    pub title: String,
}

impl Channel {
    /// Create a new [`Channel`].
    pub fn new(community: usize, owner: usize, position: usize, title: String) -> Self {
        Self {
            id: AlmostSnowflake::new(1234567890)
                .to_string()
                .parse::<usize>()
                .unwrap(),
            community,
            owner,
            created: unix_epoch_timestamp() as usize,
            minimum_role_read: (CommunityPermission::DEFAULT | CommunityPermission::MEMBER).bits(),
            minimum_role_write: (CommunityPermission::DEFAULT | CommunityPermission::MEMBER).bits(),
            position,
            members: Vec::new(),
            title,
        }
    }

    /// Check if the given `uid` can post in the channel.
    pub fn check_post(&self, uid: usize, membership: Option<CommunityPermission>) -> bool {
        let mut is_member = false;

        if let Some(membership) = membership {
            is_member = membership.bits() >= self.minimum_role_write
        }

        (uid == self.owner) | is_member | self.members.contains(&uid)
    }

    /// Check if the given `uid` can post in the channel.
    pub fn check_read(&self, uid: usize, membership: Option<CommunityPermission>) -> bool {
        let mut is_member = false;

        if let Some(membership) = membership {
            is_member = membership.bits() >= self.minimum_role_read
        }

        (uid == self.owner) | is_member | self.members.contains(&uid)
    }
}

#[derive(Serialize, Deserialize)]
pub struct Message {
    pub id: usize,
    pub channel: usize,
    pub owner: usize,
    pub created: usize,
    pub edited: usize,
    pub content: String,
    pub context: MessageContext,
}

impl Message {
    pub fn new(channel: usize, owner: usize, content: String) -> Self {
        let now = unix_epoch_timestamp() as usize;

        Self {
            id: AlmostSnowflake::new(1234567890)
                .to_string()
                .parse::<usize>()
                .unwrap(),
            channel,
            owner,
            created: now,
            edited: now,
            content,
            context: MessageContext::default(),
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct MessageContext;

impl Default for MessageContext {
    fn default() -> Self {
        Self
    }
}