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

//! Stars API
//!
//! Methods for starring and unstarring items.

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

/// Stars API client
pub struct StarsApi {
    client: SlackClient,
}

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

    /// Star a message, file, or channel
    ///
    /// # Arguments
    ///
    /// * `channel` - Channel ID (for messages)
    /// * `timestamp` - Message timestamp (optional)
    /// * `file` - File ID (optional)
    pub async fn add(
        &self,
        channel: Option<&str>,
        timestamp: Option<&str>,
        file: Option<&str>,
    ) -> Result<StarAddResponse> {
        let params = StarAddRequest {
            channel: channel.map(|s| s.to_string()),
            timestamp: timestamp.map(|s| s.to_string()),
            file: file.map(|s| s.to_string()),
        };

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

    /// Remove a star from a message, file, or channel
    ///
    /// # Arguments
    ///
    /// * `channel` - Channel ID (for messages)
    /// * `timestamp` - Message timestamp (optional)
    /// * `file` - File ID (optional)
    pub async fn remove(
        &self,
        channel: Option<&str>,
        timestamp: Option<&str>,
        file: Option<&str>,
    ) -> Result<StarRemoveResponse> {
        let params = StarRemoveRequest {
            channel: channel.map(|s| s.to_string()),
            timestamp: timestamp.map(|s| s.to_string()),
            file: file.map(|s| s.to_string()),
        };

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

    /// List starred items
    pub async fn list(&self) -> Result<StarListResponse> {
        let params = StarListRequest {
            count: Some(100),
            page: None,
        };

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

// Request/Response types

#[derive(Debug, Serialize)]
pub struct StarAddRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub channel: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
}

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

#[derive(Debug, Serialize)]
pub struct StarRemoveRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub channel: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
}

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

#[derive(Debug, Serialize)]
pub struct StarListRequest {
    #[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 StarListResponse {
    pub items: Vec<StarredItem>,
    pub paging: StarPaging,
}

#[derive(Debug, Deserialize)]
pub struct StarredItem {
    #[serde(rename = "type")]
    pub item_type: String,
    pub channel: Option<String>,
    pub date_create: i64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<serde_json::Value>,
}

#[derive(Debug, Deserialize)]
pub struct StarPaging {
    pub count: u32,
    pub total: u32,
    pub page: u32,
    pub pages: u32,
}