misskey_api/endpoint/messaging/
messages.rs

1use crate::model::{id::Id, messaging::MessagingMessage, user::User, user_group::UserGroup};
2
3use serde::Serialize;
4use typed_builder::TypedBuilder;
5
6pub mod create;
7pub mod delete;
8pub mod read;
9
10#[derive(Serialize, Debug, Clone, TypedBuilder)]
11#[serde(rename_all = "camelCase")]
12#[builder(doc)]
13pub struct Request {
14    #[serde(skip_serializing_if = "Option::is_none")]
15    #[builder(default, setter(strip_option))]
16    pub mark_as_read: Option<bool>,
17    #[serde(skip_serializing_if = "Option::is_none")]
18    #[builder(default, setter(strip_option))]
19    pub user_id: Option<Id<User>>,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    #[builder(default, setter(strip_option))]
22    pub group_id: Option<Id<UserGroup>>,
23    /// 1 .. 100
24    #[serde(skip_serializing_if = "Option::is_none")]
25    #[builder(default, setter(strip_option))]
26    pub limit: Option<u8>,
27    #[serde(skip_serializing_if = "Option::is_none")]
28    #[builder(default, setter(strip_option))]
29    pub since_id: Option<Id<MessagingMessage>>,
30    #[serde(skip_serializing_if = "Option::is_none")]
31    #[builder(default, setter(strip_option))]
32    pub until_id: Option<Id<MessagingMessage>>,
33}
34
35impl misskey_core::Request for Request {
36    type Response = Vec<MessagingMessage>;
37    const ENDPOINT: &'static str = "messaging/messages";
38}
39
40impl_pagination!(Request, MessagingMessage);
41
42#[cfg(test)]
43mod tests {
44    use super::Request;
45    use crate::test::{ClientExt, TestClient};
46
47    #[tokio::test]
48    async fn request_with_user() {
49        let client = TestClient::new();
50        let admin = client.admin.me().await;
51        client
52            .user
53            .test(Request {
54                mark_as_read: None,
55                user_id: Some(admin.id),
56                group_id: None,
57                limit: None,
58                since_id: None,
59                until_id: None,
60            })
61            .await;
62    }
63
64    #[tokio::test]
65    async fn request_with_group() {
66        let client = TestClient::new();
67        let group = client
68            .test(crate::endpoint::users::groups::create::Request {
69                name: "test".to_string(),
70            })
71            .await;
72        client
73            .test(Request {
74                mark_as_read: None,
75                user_id: None,
76                group_id: Some(group.id),
77                limit: None,
78                since_id: None,
79                until_id: None,
80            })
81            .await;
82    }
83
84    #[tokio::test]
85    async fn request_with_option() {
86        let client = TestClient::new();
87        let admin = client.admin.me().await;
88        client
89            .user
90            .test(Request {
91                mark_as_read: Some(false),
92                user_id: Some(admin.id),
93                group_id: None,
94                limit: None,
95                since_id: None,
96                until_id: None,
97            })
98            .await;
99    }
100
101    #[tokio::test]
102    async fn request_with_limit() {
103        let client = TestClient::new();
104        let admin = client.admin.me().await;
105        client
106            .test(Request {
107                mark_as_read: None,
108                user_id: Some(admin.id),
109                group_id: None,
110                limit: Some(100),
111                since_id: None,
112                until_id: None,
113            })
114            .await;
115    }
116
117    #[tokio::test]
118    async fn request_paginate() {
119        let client = TestClient::new();
120        let admin = client.admin.me().await;
121        let user = client.user.me().await;
122        let message = client
123            .admin
124            .test(crate::endpoint::messaging::messages::create::Request {
125                text: Some("hi".to_string()),
126                user_id: Some(user.id),
127                group_id: None,
128                file_id: None,
129            })
130            .await;
131
132        client
133            .user
134            .test(Request {
135                mark_as_read: None,
136                user_id: Some(admin.id),
137                group_id: None,
138                limit: None,
139                since_id: Some(message.id.clone()),
140                until_id: Some(message.id.clone()),
141            })
142            .await;
143    }
144}