Struct wicrs_server::hub::Hub

pub struct Hub {
    pub channels: HashMap<ID, Channel>,
    pub members: HashMap<String, HubMember>,
    pub bans: HashSet<String>,
    pub mutes: HashSet<String>,
    pub description: String,
    pub owner: String,
    pub groups: HashMap<ID, PermissionGroup>,
    pub default_group: ID,
    pub name: String,
    pub id: ID,
    pub created: DateTime<Utc>,
}

Represents a group of users, permission groups and channels.

Fields

channels: HashMap<ID, Channel>

Map of channels to their IDs.

members: HashMap<String, HubMember>

Map of hub members to their corresponding user’s IDs.

bans: HashSet<String>

List of IDs of all users that are banned from the hub.

mutes: HashSet<String>

List of IDs of all the users who cannot send any messages in the hub.

description: String

Description of the hub.

owner: String

ID of the user who owns the hub, also the creator.

groups: HashMap<ID, PermissionGroup>

Map of permission groups to their IDs.

default_group: ID

ID of the default permission group to be given to new hub members, for now this is always the “everyone” group.

name: String

Name of the hub.

id: ID

ID of the hub.

created: DateTime<Utc>

Time the hub was created in milliseconds since Unix Epoch.

Implementations

impl Hub

pub fn new(name: String, id: ID, creator: String) -> Self

Creates a new hub given the ID of the user who should be the owner, the name and the ID the hub should have.

pub async fn new_channel(&mut self, member_id: &str, name: String) -> Result<ID>

Creates a new channel while checking that the given user has permission to do so.

Errors

This function will return an error in the following situations, but is not limited to just these cases:

• Failed to pass check_name_validity.
• The user it not in the hub.
• The user does not have permission create new channels.
• Any of the reasons outlined in Channel::create_dir.

pub fn get_channel(&self, member_id: &str, channel_id: ID) -> Result<&Channel>

Gets a reference to the channel. Returns an error if the channel could not be found or the user did not have permission to view the channel.

pub fn get_channel_mut(
    &mut self,
    member_id: &str,
    channel_id: ID
) -> Result<&mut Channel>

Gets a mutable reference to the channel. Returns an error if the channel could not be found or the user did not have permission to view the channel.

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

Checks if the user with the given ID is in the hub.

pub fn check_membership(&self, member_id: &str) -> Result<()>

Checks if the user with the given ID is in the hub, if not in hub also checks if banned.

pub fn get_member(&self, member_id: &str) -> Result<&HubMember>

Gets a reference to the hub member, returns an error if the member could not be found.

pub fn get_member_mut(&mut self, member_id: &str) -> Result<&mut HubMember>

Gets a mutable reference to the hub member, returns an error if the member could not be found.

pub async fn change_channel_description(
    &mut self,
    user_id: &str,
    channel_id: ID,
    new_description: String
) -> Result<String>

Changes the description of a channel while checking that the given user has permission to do so.

Errors

This function will return an error in the following situations, but is not limited to just these cases:

• Description is bigger than crate::MAX_DESCRIPTION_SIZE.
• The user it not in the hub.
• The user does not have permission to view the channel.
• The user does not have permission to configure the channel.
• The channel does not exist.

pub async fn rename_channel(
    &mut self,
    user_id: &str,
    channel_id: ID,
    new_name: String
) -> Result<String>

Renames a channel while checking that the given user has permission to do so.

Errors

This function will return an error in the following situations, but is not limited to just these cases:

• Failed to pass check_name_validity.
• The user it not in the hub.
• The user does not have permission to view the channel.
• The user does not have permission to configure the channel.
• The channel does not exist.

pub async fn delete_channel(&mut self, user_id: &str, channel_id: ID) -> Result

Deletes a channel while checking that the given user has permission to do so.

Errors

This function will return an error in the following situations, but is not limited to just these cases:

• The user is not in the hub.
• The channel does not exist.
• THe user does not have permission to view the channel.
• The user does not have permission to delete the channel.

pub fn get_info_path(&self) -> String

Gets the file path to be used for storing the hub’s data.

pub fn get_data_path(&self) -> String

Gets the path of the directory in which channel folders should be stored.

pub async fn save(&self) -> Result

Saves the hub’s data to disk.

Errors

This function will return an error in the following situations, but is not limited to just these cases:

• The hub data could not be serialized.
• The hub info folder does not exist and could not be created.
• The data could not be written to the disk.

pub async fn load(id: ID) -> Result<Self>

Loads a hub’s data given its ID.

Errors

This function will return an error in the following situations, but is not limited to just these cases:

• There is no hub with that ID.
• The hub’s data file was corrupt and could not be deserialized.

pub fn user_join(&mut self, user_id: String) -> Result<HubMember>

Adds a user to a hub, creating and returning the resulting hub member.

Errors

This function will return an error in the following situations, but is not limited to just this case:

• The default permission group could not be found.

pub fn user_leave(&mut self, user_id: &str) -> Result

Removes the given user from the hub.

Errors

This function will return an error in the following situations, but is not limited to just these cases:

• The user is not in the hub.
• One of the permission groups the user was in could not be found in the hub.

pub fn kick_user(&mut self, user_id: &str) -> Result

Kicks the given user from the hub, forcing them to leave.

Errors

This function will return an error in the following situations, but is not limited to just these cases:

• The user could not be removed from the hub for any of the reasons outlined in Hub::user_leave.
• The user’s data failed to load for any of the reasons outlined in [User::load].
• The user’s data failed to save for any of the reasons outlined in [User::save].

pub fn ban_user(&mut self, user_id: String) -> Result

Kicks the given user and adds them to the banned list.

Errors

Possible errors outlined by Hub::kick_user.

pub fn unban_user(&mut self, user_id: &str)

Removes the given user from the banned lis.

pub fn mute_user(&mut self, user_id: String)

Adds the given user to the mute list, preventing them from sending messages.

pub fn unmute_user(&mut self, user_id: &str)

Removes the given user from the mutes list, allowing them to send messages.

pub fn get_channels_for_user(
    &self,
    user_id: &str
) -> Result<HashMap<ID, Channel>>

Gets a list of the channels that the given user has permission to view.

Errors

This function will only return an error if the given user is not in the hub.

pub fn strip(&self, user_id: &str) -> Result<Self>

Returns a hub object with only the items that the given user is allowed to view. Only hides channels that the user does not have permission to view.

Errors

Possible errors are outlined by Hub::get_channels_for_user.

Trait Implementations

impl Clone for Hub

fn clone(&self) -> Hub

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ContainerType for Hub

fn resolve_field<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context<'life2>
) -> Pin<Box<dyn Future<Output = ServerResult<Option<Value>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Resolves a field value and outputs it as a json value async_graphql::Value.

fn find_entity<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context<'life2>,
    params: &'life3 Value
) -> Pin<Box<dyn Future<Output = ServerResult<Option<Value>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

Find the GraphQL entity with the given name from the parameter.

fn collect_all_fields(
    &'a self,
    ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>,
    fields: &mut Fields<'a>
) -> Result<(), ServerError> where
    Self: Send + Sync, 

Collect all the fields of the container that are queried in the selection set.

impl Debug for Hub

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Hub

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

Deserialize this value from the given Serde deserializer.

impl OutputType for Hub

fn resolve<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    ctx: &'life1 ContextSelectionSet<'life2>,
    _field: &'life3 Positioned<Field>
) -> Pin<Box<dyn Future<Output = ServerResult<Value>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

Resolve an output value to async_graphql::Value.

impl Serialize for Hub

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

Serialize this value into the given Serde serializer.

impl Type for Hub

fn type_name() -> Cow<'static, str>

Type the name.

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.

fn qualified_type_name() -> String

Qualified typename.

fn introspection_type_name(&self) -> Cow<'static, str>

Introspection type name

impl ObjectType for Hub