slacko 0.2.2

Comprehensive Rust SDK for the Slack API with stealth mode support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Reactions API
//!
//! Methods for adding and removing emoji reactions.

use crate::client::SlackClient;
use crate::error::Result;
use crate::types::Message;
use serde::{Deserialize, Serialize};

/// Reactions API client
pub struct ReactionsApi {
    client: SlackClient,
}

impl ReactionsApi {
    pub(crate) fn new(client: SlackClient) -> Self {
        Self { client }
    }

    /// Add a reaction to a message
    ///
    /// # Arguments
    ///
    /// * `channel` - Channel ID
    /// * `timestamp` - Message timestamp
    /// * `name` - Emoji name (without colons)
    pub async fn add(
        &self,
        channel: &str,
        timestamp: &str,
        name: &str,
    ) -> Result<ReactionAddResponse> {
        let params = ReactionAddRequest {
            channel: channel.to_string(),
            timestamp: timestamp.to_string(),
            name: name.to_string(),
        };

        self.client.post("reactions.add", &params).await
    }

    /// Remove a reaction from a message
    ///
    /// # Arguments
    ///
    /// * `channel` - Channel ID
    /// * `timestamp` - Message timestamp
    /// * `name` - Emoji name (without colons)
    pub async fn remove(
        &self,
        channel: &str,
        timestamp: &str,
        name: &str,
    ) -> Result<ReactionRemoveResponse> {
        let params = ReactionRemoveRequest {
            channel: channel.to_string(),
            timestamp: timestamp.to_string(),
            name: name.to_string(),
        };

        self.client.post("reactions.remove", &params).await
    }

    /// Get reactions for a message
    ///
    /// # Arguments
    ///
    /// * `channel` - Channel ID
    /// * `timestamp` - Message timestamp
    pub async fn get(&self, channel: &str, timestamp: &str) -> Result<ReactionGetResponse> {
        let params = [("channel", channel), ("timestamp", timestamp)];

        self.client.get("reactions.get", &params).await
    }

    /// List reactions made by the authenticated user
    pub async fn list(&self) -> Result<ReactionListResponse> {
        let params = ReactionListRequest {
            user: None,
            count: Some(100),
            page: None,
        };

        self.client.post("reactions.list", &params).await
    }

    /// List reactions with custom parameters
    pub async fn list_with_options(
        &self,
        params: ReactionListRequest,
    ) -> Result<ReactionListResponse> {
        self.client.post("reactions.list", &params).await
    }
}

// Request/Response types

#[derive(Debug, Serialize)]
pub struct ReactionAddRequest {
    pub channel: String,
    pub timestamp: String,
    pub name: String,
}

#[derive(Debug, Deserialize)]
pub struct ReactionAddResponse {}

#[derive(Debug, Serialize)]
pub struct ReactionRemoveRequest {
    pub channel: String,
    pub timestamp: String,
    pub name: String,
}

#[derive(Debug, Deserialize)]
pub struct ReactionRemoveResponse {}

#[derive(Debug, Deserialize)]
pub struct ReactionGetResponse {
    #[serde(rename = "type")]
    pub item_type: String,
    pub message: Message,
}

#[derive(Debug, Serialize)]
pub struct ReactionListRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub count: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page: Option<u32>,
}

#[derive(Debug, Deserialize)]
pub struct ReactionListResponse {
    pub items: Vec<ReactionItem>,
}

#[derive(Debug, Deserialize)]
pub struct ReactionItem {
    #[serde(rename = "type")]
    pub item_type: String,
    pub channel: String,
    pub message: Message,
}