Rework the models directory

1 files changed, 329 insertions, 0 deletions

diff --git a/src/model/channel/group.rs b/src/model/channel/group.rs
new file mode 100644
index 0000000..9d3335f
--- /dev/null
+++ b/src/model/channel/group.rs
@@ -0,0 +1,329 @@
+use std::borrow::Cow;
+use std::fmt::Write as FmtWrite;
+use std::io::Read;
+use ::client::{CACHE, rest};
+use ::model::*;
+use ::utils::builder::{CreateMessage, GetMessages, Search};
+
+impl Group {
+    /// Marks the group as being read up to a certain [`Message`].
+    ///
+    /// Refer to the documentation for [`rest::ack_message`] for more
+    /// information.
+    ///
+    /// # Errors
+    ///
+    /// If the `cache` is enabled, returns a
+    /// [`ClientError::InvalidOperationAsBot`] if the current user is a bot
+    /// user.
+    ///
+    /// [`ClientError::InvalidOperationAsBot`]: ../client/enum.ClientError.html#variant.InvalidOperationAsUser
+    /// [`Message`]: struct.Message.html
+    /// [`rest::ack_message`]: ../client/rest/fn.ack_message.html
+    pub fn ack<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
+        #[cfg(feature="cache")]
+        {
+            if CACHE.read().unwrap().user.bot {
+                return Err(Error::Client(ClientError::InvalidOperationAsBot));
+            }
+        }
+
+        self.channel_id.ack(message_id)
+    }
+
+    /// Adds the given user to the group. If the user is already in the group,
+    /// then nothing is done.
+    ///
+    /// Refer to [`rest::add_group_recipient`] for more information.
+    ///
+    /// **Note**: Groups have a limit of 10 recipients, including the current
+    /// user.
+    ///
+    /// [`rest::add_group_recipient`]: ../client/rest/fn.add_group_recipient.html
+    pub fn add_recipient<U: Into<UserId>>(&self, user: U) -> Result<()> {
+        let user = user.into();
+
+        // If the group already contains the recipient, do nothing.
+        if self.recipients.contains_key(&user) {
+            return Ok(());
+        }
+
+        rest::add_group_recipient(self.channel_id.0, user.0)
+    }
+
+    /// Broadcasts that the current user is typing in the group.
+    #[inline]
+    pub fn broadcast_typing(&self) -> Result<()> {
+        self.channel_id.broadcast_typing()
+    }
+
+    /// React to a [`Message`] with a custom [`Emoji`] or unicode character.
+    ///
+    /// [`Message::react`] may be a more suited method of reacting in most
+    /// cases.
+    ///
+    /// Requires the [Add Reactions] permission, _if_ the current user is the
+    /// first user to perform a react with a certain emoji.
+    ///
+    /// [`Emoji`]: struct.Emoji.html
+    /// [`Message`]: struct.Message.html
+    /// [`Message::react`]: struct.Message.html#method.react
+    /// [Add Reactions]: permissions/constant.ADD_REACTIONS.html
+    #[inline]
+    pub fn create_reaction<M, R>(&self, message_id: M, reaction_type: R)
+        -> Result<()> where M: Into<MessageId>, R: Into<ReactionType> {
+        self.channel_id.create_reaction(message_id, reaction_type)
+    }
+
+    /// Deletes all messages by Ids from the given vector in the channel.
+    ///
+    /// Refer to [`Channel::delete_messages`] for more information.
+    ///
+    /// Requires the [Manage Messages] permission.
+    ///
+    /// **Note**: This uses bulk delete endpoint which is not available
+    /// for user accounts.
+    ///
+    /// **Note**: Messages that are older than 2 weeks can't be deleted using
+    /// this method.
+    ///
+    /// [`Channel::delete_messages`]: enum.Channel.html#method.delete_messages
+    /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
+    #[inline]
+    pub fn delete_messages(&self, message_ids: &[MessageId]) -> Result<()> {
+        self.channel_id.delete_messages(message_ids)
+    }
+
+    /// Deletes all permission overrides in the channel from a member
+    /// or role.
+    ///
+    /// **Note**: Requires the [Manage Channel] permission.
+    ///
+    /// [Manage Channel]: permissions/constant.MANAGE_CHANNELS.html
+    #[inline]
+    pub fn delete_permission(&self, permission_type: PermissionOverwriteType) -> Result<()> {
+        self.channel_id.delete_permission(permission_type)
+    }
+
+    /// Deletes the given [`Reaction`] from the channel.
+    ///
+    /// **Note**: Requires the [Manage Messages] permission, _if_ the current
+    /// user did not perform the reaction.
+    ///
+    /// [`Reaction`]: struct.Reaction.html
+    /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
+    #[inline]
+    pub fn delete_reaction<M, R>(&self, message_id: M, user_id: Option<UserId>, reaction_type: R)
+        -> Result<()> where M: Into<MessageId>, R: Into<ReactionType> {
+        self.channel_id.delete_reaction(message_id, user_id, reaction_type)
+    }
+
+    /// Edits a [`Message`] in the channel given its Id.
+    ///
+    /// Message editing preserves all unchanged message data.
+    ///
+    /// Refer to the documentation for [`CreateMessage`] for more information
+    /// regarding message restrictions and requirements.
+    ///
+    /// **Note**: Requires that the current user be the author of the message.
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`ClientError::MessageTooLong`] if the content of the message
+    /// is over the [`the limit`], containing the number of unicode code points
+    /// over the limit.
+    ///
+    /// [`ClientError::MessageTooLong`]: ../client/enum.ClientError.html#variant.MessageTooLong
+    /// [`CreateMessage`]: ../utils/builder/struct.CreateMessage.html
+    /// [`Message`]: struct.Message.html
+    /// [`the limit`]: ../utils/builder/struct.CreateMessage.html#method.content
+    #[inline]
+    pub fn edit_message<F, M>(&self, message_id: M, f: F) -> Result<Message>
+        where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
+        self.channel_id.edit_message(message_id, f)
+    }
+
+    /// Gets a message from the channel.
+    ///
+    /// Requires the [Read Message History] permission.
+    ///
+    /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
+    #[inline]
+    pub fn get_message<M: Into<MessageId>>(&self, message_id: M) -> Result<Message> {
+        self.channel_id.get_message(message_id)
+    }
+
+    /// Gets messages from the channel.
+    ///
+    /// Requires the [Read Message History] permission.
+    ///
+    /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
+    #[inline]
+    pub fn get_messages<F>(&self, f: F) -> Result<Vec<Message>>
+        where F: FnOnce(GetMessages) -> GetMessages {
+        self.channel_id.get_messages(f)
+    }
+
+    /// Gets the list of [`User`]s who have reacted to a [`Message`] with a
+    /// certain [`Emoji`].
+    ///
+    /// Refer to [`Channel::get_reaction_users`] for more information.
+    ///
+    /// **Note**: Requires the [Read Message History] permission.
+    ///
+    /// [`Channel::get_reaction_users`]: enum.Channel.html#variant.get_reaction_users
+    /// [`Emoji`]: struct.Emoji.html
+    /// [`Message`]: struct.Message.html
+    /// [`User`]: struct.User.html
+    /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
+    #[inline]
+    pub fn get_reaction_users<M, R, U>(&self,
+                                       message_id: M,
+                                       reaction_type: R,
+                                       limit: Option<u8>,
+                                       after: Option<U>)
+        -> Result<Vec<User>> where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
+        self.channel_id.get_reaction_users(message_id, reaction_type, limit, after)
+    }
+
+    /// Returns the formatted URI of the group's icon if one exists.
+    pub fn icon_url(&self) -> Option<String> {
+        self.icon.as_ref().map(|icon|
+            format!(cdn!("/channel-icons/{}/{}.webp"), self.channel_id, icon))
+    }
+
+    /// Leaves the group.
+    #[inline]
+    pub fn leave(&self) -> Result<Group> {
+        rest::leave_group(self.channel_id.0)
+    }
+
+    /// Generates a name for the group.
+    ///
+    /// If there are no recipients in the group, the name will be "Empty Group".
+    /// Otherwise, the name is generated in a Comma Separated Value list, such
+    /// as "person 1, person 2, person 3".
+    pub fn name(&self) -> Cow<str> {
+        match self.name {
+            Some(ref name) => Cow::Borrowed(name),
+            None => {
+                let mut name = match self.recipients.values().nth(0) {
+                    Some(recipient) => recipient.read().unwrap().name.clone(),
+                    None => return Cow::Borrowed("Empty Group"),
+                };
+
+                for recipient in self.recipients.values().skip(1) {
+                    let _ = write!(name, ", {}", recipient.read().unwrap().name);
+                }
+
+                Cow::Owned(name)
+            }
+        }
+    }
+
+    /// Retrieves the list of messages that have been pinned in the group.
+    #[inline]
+    pub fn pins(&self) -> Result<Vec<Message>> {
+        self.channel_id.pins()
+    }
+
+    /// Removes a recipient from the group. If the recipient is already not in
+    /// the group, then nothing is done.
+    ///
+    /// **Note**: This is only available to the group owner.
+    pub fn remove_recipient<U: Into<UserId>>(&self, user: U) -> Result<()> {
+        let user = user.into();
+
+        // If the group does not contain the recipient already, do nothing.
+        if !self.recipients.contains_key(&user) {
+            return Ok(());
+        }
+
+        rest::remove_group_recipient(self.channel_id.0, user.0)
+    }
+
+    /// Sends a message with just the given message content in the channel.
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`ClientError::MessageTooLong`] if the content of the message
+    /// is over the above limit, containing the number of unicode code points
+    /// over the limit.
+    ///
+    /// [`ChannelId`]: ../model/struct.ChannelId.html
+    /// [`ClientError::MessageTooLong`]: enum.ClientError.html#variant.MessageTooLong
+    #[inline]
+    pub fn say(&self, content: &str) -> Result<Message> {
+        self.channel_id.say(content)
+    }
+
+    /// Performs a search request to the API for the group's channel's
+    /// [`Message`]s.
+    ///
+    /// Refer to the documentation for the [`Search`] builder for examples and
+    /// more information.
+    ///
+    /// **Note**: Bot users can not search.
+    ///
+    /// # Errors
+    ///
+    /// If the `cache` is enabled, returns a
+    /// [`ClientError::InvalidOperationAsBot`] if the current user is a bot.
+    ///
+    /// [`ClientError::InvalidOperationAsBot`]: ../client/enum.ClientError.html#variant.InvalidOperationAsBot
+    /// [`Message`]: struct.Message.html
+    /// [`Search`]: ../utils/builder/struct.Search.html
+    #[inline]
+    pub fn search<F: FnOnce(Search) -> Search>(&self, f: F) -> Result<SearchResult> {
+        self.channel_id.search(f)
+    }
+
+    /// Sends a file along with optional message contents. The filename _must_
+    /// be specified.
+    ///
+    /// Refer to [`ChannelId::send_file`] for examples and more information.
+    ///
+    /// The [Attach Files] and [Send Messages] permissions are required.
+    ///
+    /// **Note**: Message contents must be under 2000 unicode code points.
+    ///
+    /// # Errors
+    ///
+    /// If the content of the message is over the above limit, then a
+    /// [`ClientError::MessageTooLong`] will be returned, containing the number
+    /// of unicode code points over the limit.
+    ///
+    /// [`ChannelId::send_file`]: struct.ChannelId.html#method.send_file
+    /// [`ClientError::MessageTooLong`]: ../client/enum.ClientError.html#variant.MessageTooLong
+    /// [Attach Files]: permissions/constant.ATTACH_FILES.html
+    /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
+    pub fn send_file<F, R>(&self, file: R, filename: &str, f: F) -> Result<Message>
+        where F: FnOnce(CreateMessage) -> CreateMessage, R: Read {
+        self.channel_id.send_file(file, filename, f)
+    }
+
+    /// Sends a message to the group with the given content.
+    ///
+    /// Refer to the documentation for [`CreateMessage`] for more information
+    /// regarding message restrictions and requirements.
+    ///
+    /// **Note**: Requires the [Send Messages] permission.
+    ///
+    /// [`CreateMessage`]: ../utils/builder/struct.CreateMessage.html
+    /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
+    #[inline]
+    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
+        self.channel_id.send_message(f)
+    }
+
+    /// Unpins a [`Message`] in the channel given by its Id.
+    ///
+    /// Requires the [Manage Messages] permission.
+    ///
+    /// [`Message`]: struct.Message.html
+    /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
+    #[inline]
+    pub fn unpin<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
+        self.channel_id.unpin(message_id)
+    }
+}