1use async_trait::async_trait;
2use serde_json::json;
3
4use crate::{
5 base::context::Context,
6 error::FlowError,
7 event::{message::GroupAnonymousInfo, request::GroupRequestSubType},
8 message::IntoMessage,
9};
10
11use super::{
12 BotStatus, CanSendResponse, FriendInfo, GetCookiesResponse, GetCredentialsResponse,
13 GetCsrfTokenResponse, GetFileResponse, GetForwardResponse, GetMessageResponse, GroupHonorInfo,
14 GroupHonorType, GroupInfoResponse, LoginInfo, RecordFormat, SendMessageResponse, VersionInfo,
15 api_ext::ApiExt,
16};
17
18macro_rules! impl_api {
19
20 ($s:ident,$name:ident) => {{
21 let resp = $s.send_obj(stringify!($name).to_string(), json!({})).await;
22 resp.map(|r| r.data)
23 }};
24
25 ($s:ident,$name:ident, $($params:ident),*) => {{
26 let params_json = json!({
27 $(
28 stringify!($params): $params,
29 )*
30 });
31 let resp = $s.send_obj(stringify!($name).to_string(), params_json).await;
32 resp.map(|r| r.data)
33 }};
34}
35
36#[async_trait]
37impl ApiExt for Context {
38 type Error = FlowError;
39
40 async fn send_private_message<M>(
41 &self,
42 user_id: i64,
43 message: M,
44 auto_escape: Option<bool>,
45 ) -> Result<SendMessageResponse, Self::Error>
46 where
47 M: IntoMessage + Send,
48 {
49 let message = message.into_message();
50 let params_json = json!({
51 "user_id": user_id,
52 "message": message,
53 "auto_escape": auto_escape,
54 });
55 let resp = self
56 .send_obj("send_private_msg".to_string(), params_json)
57 .await;
58 resp.map(|r| r.data)
59 }
60
61 async fn send_group_message<M>(
62 &self,
63 group_id: i64,
64 message: M,
65 auto_escape: Option<bool>,
66 ) -> Result<SendMessageResponse, Self::Error>
67 where
68 M: IntoMessage + Send,
69 {
70 let message = message.into_message();
71 let params_json = json!({
72 "group_id": group_id,
73 "message": message,
74 "auto_escape": auto_escape,
75 });
76 let resp = self
77 .send_obj("send_group_msg".to_string(), params_json)
78 .await;
79 resp.map(|r| r.data)
80 }
81
82 async fn delete_message(&self, message_id: i64) -> Result<(), Self::Error> {
83 impl_api!(self, delete_message, message_id)
84 }
85
86 async fn get_message(&self, message_id: i64) -> Result<GetMessageResponse, Self::Error> {
87 impl_api!(self, get_msg, message_id)
88 }
89
90 async fn get_forward_message(
91 &self,
92 message_id: i64,
93 ) -> Result<GetForwardResponse, Self::Error> {
94 impl_api!(self, get_forward_msg, message_id)
95 }
96
97 async fn send_like(&self, user_id: i64, times: Option<i32>) -> Result<(), Self::Error> {
98 impl_api!(self, send_like, user_id, times)
99 }
100
101 async fn set_group_kick(
102 &self,
103 group_id: i64,
104 user_id: i64,
105 reject_add_request: Option<bool>,
106 ) -> Result<(), Self::Error> {
107 impl_api!(self, set_group_kick, group_id, user_id, reject_add_request)
108 }
109
110 async fn set_group_ban(
111 &self,
112 group_id: i64,
113 user_id: i64,
114 duration: Option<i64>,
115 ) -> Result<(), Self::Error> {
116 impl_api!(self, set_group_ban, group_id, user_id, duration)
117 }
118
119 async fn set_group_anonymous_ban(
120 &self,
121 group_id: i64,
122 anonymous: Option<GroupAnonymousInfo>,
123 flag: Option<String>,
124 duration: Option<i64>,
125 ) -> Result<(), Self::Error> {
126 impl_api!(
127 self,
128 set_group_anonymous_ban,
129 group_id,
130 anonymous,
131 flag,
132 duration
133 )
134 }
135
136 async fn set_whole_group_ban(
137 &self,
138 group_id: i64,
139 enable: Option<bool>,
140 ) -> Result<(), Self::Error> {
141 impl_api!(self, set_whole_group_ban, group_id, enable)
142 }
143
144 async fn set_group_admin(
145 &self,
146 group_id: i64,
147 user_id: i64,
148 enable: Option<bool>,
149 ) -> Result<(), Self::Error> {
150 impl_api!(self, set_group_admin, group_id, user_id, enable)
151 }
152
153 async fn set_group_anonymous(
154 &self,
155 group_id: i64,
156 enable: Option<bool>,
157 ) -> Result<(), Self::Error> {
158 impl_api!(self, set_group_anonymous, group_id, enable)
159 }
160
161 async fn set_group_card(
162 &self,
163 group_id: i64,
164 user_id: i64,
165 card: Option<String>,
166 ) -> Result<(), Self::Error> {
167 impl_api!(self, set_group_card, group_id, user_id, card)
168 }
169
170 async fn set_group_name(&self, group_id: i64, group_name: String) -> Result<(), Self::Error> {
171 impl_api!(self, set_group_name, group_id, group_name)
172 }
173
174 async fn set_group_leave(
175 &self,
176 group_id: i64,
177 is_dismiss: Option<bool>,
178 ) -> Result<(), Self::Error> {
179 impl_api!(self, set_group_leave, group_id, is_dismiss)
180 }
181
182 async fn set_group_special_title(
183 &self,
184 group_id: i64,
185 user_id: i64,
186 special_title: Option<String>,
187 duration: Option<i64>,
188 ) -> Result<(), Self::Error> {
189 impl_api!(
190 self,
191 set_group_special_title,
192 group_id,
193 user_id,
194 special_title,
195 duration
196 )
197 }
198
199 async fn set_friend_add_request(
200 &self,
201 flag: String,
202 approve: Option<bool>,
203 remark: Option<String>,
204 ) -> Result<(), Self::Error> {
205 impl_api!(self, set_friend_add_request, flag, approve, remark)
206 }
207
208 async fn set_group_add_request(
209 &self,
210 flag: String,
211 sub_type: GroupRequestSubType,
212 approve: Option<bool>,
213 reason: Option<String>,
214 ) -> Result<(), Self::Error> {
215 impl_api!(self, set_group_add_request, flag, sub_type, approve, reason)
216 }
217
218 async fn get_login_info(&self) -> Result<LoginInfo, Self::Error> {
219 impl_api!(self, get_login_info)
220 }
221
222 async fn get_stranger_info(
223 &self,
224 user_id: i64,
225 no_cache: Option<bool>,
226 ) -> Result<crate::api::StrangerInfo, Self::Error> {
227 impl_api!(self, get_stranger_info, user_id, no_cache)
228 }
229
230 async fn get_friend_list(&self) -> Result<Vec<FriendInfo>, Self::Error> {
231 impl_api!(self, get_friend_list)
232 }
233
234 async fn get_group_info(
235 &self,
236 group_id: i64,
237 no_cache: Option<bool>,
238 ) -> Result<crate::api::GroupInfoResponse, Self::Error> {
239 impl_api!(self, get_group_info, group_id, no_cache)
240 }
241
242 async fn get_group_list(&self) -> Result<Vec<GroupInfoResponse>, Self::Error> {
243 impl_api!(self, get_group_list)
244 }
245
246 async fn get_group_member_info(
247 &self,
248 group_id: i64,
249 user_id: i64,
250 no_cache: Option<bool>,
251 ) -> Result<crate::api::GroupInfoResponse, Self::Error> {
252 impl_api!(self, get_group_member_info, group_id, user_id, no_cache)
253 }
254
255 async fn get_group_member_list(
256 &self,
257 group_id: i64,
258 ) -> Result<Vec<crate::api::FriendInfo>, Self::Error> {
259 impl_api!(self, get_group_member_list, group_id)
260 }
261
262 async fn get_group_honor_info(
263 &self,
264 group_id: i64,
265 ty: GroupHonorType,
266 ) -> Result<GroupHonorInfo, Self::Error> {
267 let params_json = json!({
268 "group_id": group_id,
269 "type": ty,
270 });
271 let resp = self
272 .send_obj("get_group_honor_info".to_string(), params_json)
273 .await;
274 resp.map(|r| r.data)
275 }
276
277 async fn get_cookies(&self, domain: Option<String>) -> Result<GetCookiesResponse, Self::Error> {
278 impl_api!(self, get_cookies, domain)
279 }
280
281 async fn get_csrf_token(&self) -> Result<GetCsrfTokenResponse, Self::Error> {
282 impl_api!(self, get_csrf_token)
283 }
284
285 async fn get_credentials(
286 &self,
287 domain: Option<String>,
288 ) -> Result<GetCredentialsResponse, Self::Error> {
289 impl_api!(self, get_credentials, domain)
290 }
291
292 async fn get_record(
293 &self,
294 file: String,
295 out_format: RecordFormat,
296 ) -> Result<GetFileResponse, Self::Error> {
297 impl_api!(self, get_record, file, out_format)
298 }
299
300 async fn get_image(&self, file: String) -> Result<GetFileResponse, Self::Error> {
301 impl_api!(self, get_image, file)
302 }
303
304 async fn can_send_image(&self) -> Result<CanSendResponse, Self::Error> {
305 impl_api!(self, can_send_image)
306 }
307
308 async fn can_send_record(&self) -> Result<CanSendResponse, Self::Error> {
309 impl_api!(self, can_send_record)
310 }
311
312 async fn get_status(&self) -> Result<BotStatus, Self::Error> {
313 impl_api!(self, get_status)
314 }
315
316 async fn get_version_info(&self) -> Result<VersionInfo, Self::Error> {
317 impl_api!(self, get_version_info)
318 }
319
320 async fn set_restart(&self, delay: Option<i32>) -> Result<(), Self::Error> {
321 impl_api!(self, set_restart, delay)
322 }
323
324 async fn clean_cache(&self) -> Result<(), Self::Error> {
325 impl_api!(self, clean_cache)
326 }
327}