Slack Conversations API updates

src/client/src/api/conversations.rs

@@ -5,11 +5,12 @@
 use rsb_derive::Builder;
 use serde::{Deserialize, Serialize};
 use serde_with::skip_serializing_none;
+use rvstruct::ValueStruct;
 
-use crate::ClientResult;
-use crate::SlackClientSession;
+use crate::*;
 use slack_morphism_models::*;
 use std::collections::HashSet;
+use futures::future::{BoxFuture, FutureExt};
 
 impl<'a> SlackClientSession<'a> {
     ///
@@ -41,6 +42,48 @@ impl<'a> SlackClientSession<'a> {
     ) -> ClientResult<SlackApiConversationsCreateResponse> {
         self.http_api.http_post("conversations.create", req).await
     }
+
+    ///
+    /// https://api.slack.com/methods/conversations.history
+    ///
+    pub async fn conversations_history(
+        &self,
+        req: &SlackApiConversationsHistoryRequest,
+    ) -> ClientResult<SlackApiConversationsHistoryResponse> {
+        self.http_api
+            .http_get(
+                "conversations.history",
+                &vec![
+                    ("channel", req.channel.as_ref().map(|x| x.value())),
+                    ("cursor", req.cursor.as_ref().map(|x| x.value())),
+                    ("limit", req.limit.map(|v| v.to_string()).as_ref()),
+                    ("inclusive",req.inclusive.map(|v| v.to_string()).as_ref()),
+                    ("latest", req.latest.as_ref().map(|x| x.value())),
+                    ("oldest", req.oldest.as_ref().map(|x| x.value())),
+                ],
+            )
+            .await
+    }
+
+    ///
+    /// https://api.slack.com/methods/conversations.info
+    ///
+    pub async fn conversations_info(
+        &self,
+        req: &SlackApiConversationsInfoRequest,
+    ) -> ClientResult<SlackApiConversationsInfoResponse> {
+        self.http_api
+            .http_get(
+                "conversations.info",
+                &vec![
+                    ("channel", Some(req.channel.value())),
+                    ("include_num_members", req.include_num_members.map(|v| v.to_string()).as_ref()),
+                    ("include_locale",req.include_locale.map(|v| v.to_string()).as_ref())
+                ],
+            )
+            .await
+    }
+
 }
 
 #[skip_serializing_none]
@@ -79,3 +122,70 @@ pub struct SlackApiConversationsCreateRequest {
 pub struct SlackApiConversationsCreateResponse {
     pub channel: SlackChannelInfo,
 }
+
+#[skip_serializing_none]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
+pub struct SlackApiConversationsHistoryRequest {
+    pub channel: Option<SlackChannelId>,
+    pub cursor: Option<SlackCursorId>,
+    pub latest: Option<SlackTs>,
+    pub limit: Option<u16>,
+    pub oldest: Option<SlackTs>,
+    pub inclusive : Option<bool>
+}
+
+#[skip_serializing_none]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
+pub struct SlackApiConversationsHistoryResponse {
+    pub messages: Vec<SlackHistoryMessage>,
+    pub response_metadata: Option<SlackResponseMetadata>,
+    pub has_more: Option<bool>,
+    pub pin_count: Option<u64>,
+}
+
+impl SlackApiScrollableRequest for SlackApiConversationsHistoryRequest {
+    type ResponseType = SlackApiConversationsHistoryResponse;
+    type CursorType = SlackCursorId;
+    type ResponseItemType = SlackHistoryMessage;
+
+    fn with_new_cursor(&self, new_cursor: Option<&Self::CursorType>) -> Self {
+        self.clone().opt_cursor(new_cursor.cloned())
+    }
+
+    fn scroll<'a, 's>(
+        &'a self,
+        session: &'a SlackClientSession<'s>,
+    ) -> BoxFuture<'a, ClientResult<Self::ResponseType>> {
+        async move { session.conversations_history(&self).await }.boxed()
+    }
+}
+
+impl SlackApiScrollableResponse for SlackApiConversationsHistoryResponse {
+    type CursorType = SlackCursorId;
+    type ResponseItemType = SlackHistoryMessage;
+
+    fn next_cursor(&self) -> Option<&Self::CursorType> {
+        self.response_metadata
+            .as_ref()
+            .map(|rm| rm.next_cursor.as_ref())
+            .flatten()
+    }
+
+    fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
+        Box::new(self.messages.iter())
+    }
+}
+
+#[skip_serializing_none]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
+pub struct SlackApiConversationsInfoRequest{
+    pub channel : SlackChannelId,
+    pub include_locale: Option<bool>,
+    pub include_num_members: Option<bool>
+}
+
+#[skip_serializing_none]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
+pub struct SlackApiConversationsInfoResponse{
+    pub channel: SlackChannelInfo
+}

src/models/src/messages/mod.rs

@@ -3,6 +3,7 @@ use crate::common::*;
 use rsb_derive::Builder;
 use serde::{Deserialize, Serialize};
 use serde_with::skip_serializing_none;
+use crate::events::SlackMessageEventType;
 
 #[skip_serializing_none]
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
@@ -28,3 +29,13 @@ pub struct SlackMessage {
     #[serde(flatten)]
     pub content: SlackMessageContent,
 }
+
+#[skip_serializing_none]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
+pub struct SlackHistoryMessage {
+    #[serde(flatten)]
+    pub origin: SlackMessageOrigin,
+    #[serde(flatten)]
+    pub content: SlackMessageContent,
+    pub subtype: Option<SlackMessageEventType>,
+}