onebot_api/communication/
utils.rs

1use crate::api::APISender as APISenderTrait;
2use crate::api::arg_type::MessageType;
3use crate::api::return_type::*;
4use crate::error::{APIRequestError, APIResult, ServiceRuntimeError, ServiceStartResult};
5pub use crate::event::Event as NormalEvent;
6use crate::event::EventReceiver as EventReceiverTrait;
7use crate::event::EventTrait;
8use crate::event::message::GroupMessageAnonymous;
9use crate::message::receive_segment::ReceiveSegment;
10use crate::message::send_segment::SendSegment;
11use async_trait::async_trait;
12pub use flume::Receiver as FlumeReceiver;
13use flume::SendError;
14pub use flume::Sender as FlumeSender;
15use serde::de::DeserializeOwned;
16use serde::{Deserialize, Serialize};
17use serde_json::{Value as JsonValue, json};
18use std::sync::Arc;
19use std::time::Duration;
20use strum::EnumIs;
21use tokio::select;
22use tokio::sync::broadcast;
23pub use tokio::sync::broadcast::Receiver as BroadcastReceiver;
24pub use tokio::sync::broadcast::Sender as BroadcastSender;
25
26/// `Client` 与具体 `CommunicationService` 中  
27/// API请求的发送通道  
28/// 应由 `Client` 持有
29pub type InternalAPISender = FlumeSender<APIRequest>;
30/// `Client` 与具体 `CommunicationService` 中  
31/// API请求的接收通道  
32/// 应由 `CommunicationService` 持有
33pub type InternalAPIReceiver = FlumeReceiver<APIRequest>;
34
35/// `Client` 与具体 `CommunicationService` 中  
36/// 原始事件的发送通道  
37/// 应由 `CommunicationService` 持有
38pub type InternalEventSender = FlumeSender<DeserializedEvent>;
39/// `Client` 与具体 `CommunicationService` 中  
40/// 原始事件的接收通道  
41/// 应由 `Client` 持有
42pub type InternalEventReceiver = FlumeReceiver<DeserializedEvent>;
43
44/// `Client` 与具体使用者之间  
45/// API响应的发送通道  
46/// 应由 `Client` 持有
47pub type PublicAPIResponseSender = BroadcastSender<ArcAPIResponse>;
48/// `Client` 与具体使用者之间  
49/// API响应的接收通道  
50/// 公开，任何人都可持有
51pub type PublicAPIResponseReceiver = BroadcastReceiver<ArcAPIResponse>;
52
53/// `Client` 与具体使用者之间  
54/// 事件（除去API响应）的发送通道  
55/// 应由 `Client` 持有
56pub type PublicEventSender = BroadcastSender<ArcNormalEvent>;
57/// `Client` 与具体使用者之间  
58/// 事件（除去API响应）的接收通道  
59/// 公开，任何人都可持有
60pub type PublicEventReceiver = BroadcastReceiver<ArcNormalEvent>;
61
62pub type ServiceRuntimeResult<T> = Result<T, ServiceRuntimeError>;
63
64pub type ArcServiceRuntimeError = Arc<ServiceRuntimeError>;
65pub type ArcAPIResponse = Arc<APIResponse>;
66pub type ArcNormalEvent = Arc<NormalEvent>;
67
68pub const DEFAULT_CHANNEL_CAP: usize = 16;
69
70impl EventTrait for APIResponse {}
71impl EventTrait for ArcAPIResponse {}
72impl EventTrait for ArcNormalEvent {}
73
74#[derive(Deserialize, Clone, Debug, EnumIs)]
75#[serde(untagged)]
76/// 经由 `CommunicationService` 初步反序列化后的原始事件
77pub enum DeserializedEvent {
78	APIResponse(APIResponse),
79	Event(JsonValue),
80}
81
82#[derive(Serialize, Clone, Debug)]
83/// 由 `Client` 发出的API请求
84pub struct APIRequest {
85	pub action: String,
86	pub params: JsonValue,
87	pub echo: Option<String>,
88}
89
90#[derive(Deserialize, Clone, Debug)]
91/// 由 `CommunicationService` 返回的API响应
92pub struct APIResponse {
93	pub status: String,
94	pub retcode: i32,
95	pub data: JsonValue,
96	pub echo: Option<String>,
97}
98
99impl APIResponse {
100	pub fn verify(&self) -> bool {
101		self.status == "ok"
102	}
103
104	pub fn parse_data<T: DeserializeOwned>(&self) -> APIResult<T> {
105		if !self.verify() {
106			return Err(APIRequestError::HttpError { code: self.retcode });
107		}
108		Ok(serde_json::from_value(self.data.clone())?)
109	}
110}
111
112#[async_trait]
113pub trait APIResponseListener {
114	async fn listen(&mut self, echo: String, timeout: Option<Duration>) -> Option<ArcAPIResponse>;
115	async fn listen_without_timeout(&mut self, echo: String) -> Option<ArcAPIResponse>;
116	async fn listen_with_timeout(
117		&mut self,
118		echo: String,
119		timeout: Duration,
120	) -> Option<ArcAPIResponse>;
121}
122
123#[async_trait]
124impl APIResponseListener for PublicAPIResponseReceiver {
125	async fn listen(&mut self, echo: String, timeout: Option<Duration>) -> Option<ArcAPIResponse> {
126		match timeout {
127			Some(timeout) => self.listen_with_timeout(echo, timeout).await,
128			None => self.listen_without_timeout(echo).await,
129		}
130	}
131	async fn listen_without_timeout(&mut self, echo: String) -> Option<ArcAPIResponse> {
132		loop {
133			if let Ok(api_response) = self.recv().await
134				&& api_response
135					.echo
136					.as_ref()
137					.map(|target_echo| target_echo == &echo)
138					.unwrap_or(false)
139			{
140				return Some(api_response);
141			}
142			if self.is_closed() {
143				return None;
144			}
145		}
146	}
147
148	async fn listen_with_timeout(
149		&mut self,
150		echo: String,
151		timeout: Duration,
152	) -> Option<ArcAPIResponse> {
153		tokio::time::timeout(timeout, self.listen_without_timeout(echo))
154			.await
155			.ok()?
156	}
157}
158
159#[async_trait]
160pub trait CommunicationService: Sync + Send {
161	/// 安装服务  
162	/// 该方法仅进行服务的依赖注入，并不真正创建任务  
163	/// **应具备幂等性**
164	fn install(&mut self, api_receiver: InternalAPIReceiver, event_sender: InternalEventSender);
165
166	/// 卸载服务  
167	/// 服务应回收安装后产生的一切副作用和安装时注入的依赖  
168	/// **应具备幂等性**
169	fn uninstall(&mut self);
170
171	/// 停止服务  
172	/// 不同于 `uninstall` 方法 ，`stop` 方法仅需要回收安装后产生的副作用，并不需要回收安装时注入的依赖  
173	/// **应具备幂等性**
174	fn stop(&self);
175
176	/// 开始服务  
177	/// 服务内应保证任务在服务的生命周期内最多存在一个  
178	/// 由于在服务生命周期内最多存在一个任务，所以该方法 **应具备幂等性**
179	async fn start(&self) -> ServiceStartResult<()>;
180
181	/// 重启服务  
182	/// **不具备幂等性**
183	async fn restart(&self) -> ServiceStartResult<()> {
184		self.stop();
185		self.start().await
186	}
187}
188
189#[async_trait]
190impl CommunicationService for Box<dyn CommunicationService> {
191	fn install(&mut self, api_receiver: InternalAPIReceiver, event_sender: InternalEventSender) {
192		(**self).install(api_receiver, event_sender);
193	}
194
195	fn uninstall(&mut self) {
196		(**self).uninstall();
197	}
198
199	fn stop(&self) {
200		(**self).stop();
201	}
202
203	async fn start(&self) -> ServiceStartResult<()> {
204		(**self).start().await
205	}
206
207	async fn restart(&self) -> ServiceStartResult<()> {
208		(**self).restart().await
209	}
210}
211
212pub trait IntoService {
213	fn into(self) -> impl CommunicationService + 'static;
214}
215
216impl<T: CommunicationService + 'static> IntoService for T {
217	fn into(self) -> impl CommunicationService + 'static {
218		self
219	}
220}
221
222/// 对于Onebot V11协议API调用和事件接收的高层抽象  
223/// 需要具体实现 [`CommunicationService`] 的底层服务支持
224///
225/// # Examples
226/// ```rust
227/// use std::time::Duration;
228/// use onebot_api::communication::utils::Client;
229/// use onebot_api::communication::ws::WsService;
230///
231/// let ws_service = WsService::new_with_options("wss://example.com", Some("example_token".to_string())).unwrap();
232/// let client = Client::new_with_options(ws_service, Duration::from_secs(5), None, None);
233/// client.start_service().await.unwrap();
234/// ```
235pub struct Client {
236	service: Box<dyn CommunicationService>,
237	internal_api_sender: InternalAPISender,
238	internal_api_receiver: InternalAPIReceiver,
239	internal_event_sender: InternalEventSender,
240	// internal_event_receiver: InternalEventReceiver,
241	public_api_response_sender: PublicAPIResponseSender,
242	public_event_sender: PublicEventSender,
243	timeout: Option<Duration>,
244	echo_generator: Box<dyn Fn() -> String + Send + Sync>,
245	close_signal_sender: broadcast::Sender<()>,
246}
247
248pub struct ClientBuilder {
249	service: Box<dyn CommunicationService>,
250	timeout: Option<Duration>,
251	public_api_response_channel_cap: Option<usize>,
252	public_event_channel_cap: Option<usize>,
253	internal_api_channel_cap: Option<usize>,
254	internal_event_channel_cap: Option<usize>,
255	echo_generator: Option<Box<dyn Fn() -> String + Send + Sync>>,
256}
257
258impl ClientBuilder {
259	pub fn new(service: impl IntoService) -> Self {
260		Self {
261			service: Box::new(service.into()),
262			timeout: None,
263			public_event_channel_cap: None,
264			public_api_response_channel_cap: None,
265			internal_event_channel_cap: None,
266			internal_api_channel_cap: None,
267			echo_generator: None,
268		}
269	}
270
271	pub fn build(self) -> Client {
272		Client::new_with_options(
273			self.service,
274			self.timeout,
275			self.public_api_response_channel_cap,
276			self.public_event_channel_cap,
277			self.internal_api_channel_cap,
278			self.internal_event_channel_cap,
279			self.echo_generator,
280		)
281	}
282
283	pub fn timeout(mut self, timeout: Duration) -> Self {
284		self.timeout = Some(timeout);
285		self
286	}
287
288	pub fn public_event_channel_cap(mut self, cap: usize) -> Self {
289		self.public_event_channel_cap = Some(cap);
290		self
291	}
292
293	pub fn public_api_response_channel_cap(mut self, cap: usize) -> Self {
294		self.public_api_response_channel_cap = Some(cap);
295		self
296	}
297
298	pub fn internal_event_channel_cap(mut self, cap: usize) -> Self {
299		self.internal_event_channel_cap = Some(cap);
300		self
301	}
302
303	pub fn internal_api_channel_cap(mut self, cap: usize) -> Self {
304		self.internal_api_channel_cap = Some(cap);
305		self
306	}
307
308	pub fn union_channel_cap(self, cap: usize) -> Self {
309		self
310			.public_event_channel_cap(cap)
311			.public_api_response_channel_cap(cap)
312			.internal_event_channel_cap(cap)
313			.internal_api_channel_cap(cap)
314	}
315
316	pub fn public_union_channel_cap(self, cap: usize) -> Self {
317		self
318			.public_event_channel_cap(cap)
319			.public_api_response_channel_cap(cap)
320	}
321
322	pub fn internal_union_channel_cap(self, cap: usize) -> Self {
323		self
324			.internal_event_channel_cap(cap)
325			.internal_api_channel_cap(cap)
326	}
327
328	pub fn echo_generator(mut self, generator: Box<dyn Fn() -> String + Send + Sync>) -> Self {
329		self.echo_generator = Some(generator);
330		self
331	}
332}
333
334impl Drop for Client {
335	fn drop(&mut self) {
336		self.service.uninstall();
337		let _ = self.close_signal_sender.send(());
338	}
339}
340
341impl Client {
342	pub fn subscribe_api_response(&self) -> PublicAPIResponseReceiver {
343		self.public_api_response_sender.subscribe()
344	}
345
346	pub fn subscribe_normal_event(&self) -> PublicEventReceiver {
347		self.public_event_sender.subscribe()
348	}
349}
350
351impl EventReceiverTrait<ArcNormalEvent> for Client {
352	fn subscribe(&self) -> PublicEventReceiver {
353		self.subscribe_normal_event()
354	}
355}
356
357impl EventReceiverTrait<ArcAPIResponse> for Client {
358	fn subscribe(&self) -> PublicAPIResponseReceiver {
359		self.subscribe_api_response()
360	}
361}
362
363impl<T: IntoService> From<T> for Client {
364	fn from(value: T) -> Self {
365		Self::new(value)
366	}
367}
368
369impl Client {
370	/// 创建一个 [`Client`] 实例
371	///
372	/// # Params
373	/// - `service` 实现 [`IntoService`] 特征或 [`CommunicationService`] 特征的对象
374	/// - `timeout` API请求超时时间，若为 `None` 则一直等待
375	/// - `public_api_response_channel_cap` API响应通道容量，默认为`16`
376	/// - `public_event_channel_cap` Event事件通道容量，默认为`16`
377	/// - `internal_api_channel_cap` API请求通道容量，默认为`16`
378	/// - `internal_event_channel_cap` 原始事件通道容量，默认为`16`
379	pub fn new_with_options(
380		service: impl IntoService,
381		timeout: Option<Duration>,
382		public_api_response_channel_cap: Option<usize>,
383		public_event_channel_cap: Option<usize>,
384		internal_api_channel_cap: Option<usize>,
385		internal_event_channel_cap: Option<usize>,
386		echo_generator: Option<Box<dyn Fn() -> String + Send + Sync>>,
387	) -> Self {
388		let get_cap = |v: Option<usize>| v.unwrap_or(DEFAULT_CHANNEL_CAP);
389
390		let mut service = Box::new(service.into());
391		let (internal_api_sender, internal_api_receiver) =
392			flume::bounded(get_cap(internal_api_channel_cap));
393		let (internal_event_sender, internal_event_receiver) =
394			flume::bounded(get_cap(internal_event_channel_cap));
395		let (public_api_response_sender, _) =
396			broadcast::channel(get_cap(public_api_response_channel_cap));
397		let (public_event_sender, _) = broadcast::channel(get_cap(public_event_channel_cap));
398		service.install(internal_api_receiver.clone(), internal_event_sender.clone());
399
400		let (close_signal_sender, _) = broadcast::channel(1);
401
402		tokio::spawn(Self::raw_event_processor(
403			close_signal_sender.subscribe(),
404			internal_event_receiver.clone(),
405			public_api_response_sender.clone(),
406			public_event_sender.clone(),
407		));
408
409		Self {
410			service,
411			timeout,
412			internal_api_receiver,
413			internal_api_sender,
414			// internal_event_receiver,
415			internal_event_sender,
416			public_event_sender,
417			public_api_response_sender,
418			echo_generator: echo_generator.unwrap_or(Box::new(Self::generate_id)),
419			close_signal_sender,
420		}
421	}
422
423	pub fn new_with_union_channel_cap(
424		service: impl IntoService,
425		timeout: Option<Duration>,
426		channel_cap: Option<usize>,
427	) -> Self {
428		Self::new_with_options(
429			service,
430			timeout,
431			channel_cap,
432			channel_cap,
433			channel_cap,
434			channel_cap,
435			None,
436		)
437	}
438
439	pub fn new_with_timeout(service: impl IntoService, timeout: Option<Duration>) -> Self {
440		Self::new_with_union_channel_cap(service, timeout, None)
441	}
442
443	pub fn new(service: impl IntoService) -> Self {
444		Self::new_with_timeout(service, Some(Duration::from_secs(5)))
445	}
446
447	pub fn builder(service: impl IntoService) -> ClientBuilder {
448		ClientBuilder::new(service)
449	}
450}
451
452impl Client {
453	async fn raw_event_processor(
454		mut close_signal: broadcast::Receiver<()>,
455		internal_event_receiver: InternalEventReceiver,
456		public_api_response_sender: PublicAPIResponseSender,
457		public_event_sender: PublicEventSender,
458	) -> anyhow::Result<()> {
459		loop {
460			select! {
461				_ = close_signal.recv() => return Err(anyhow::anyhow!("close")),
462				event = internal_event_receiver.recv_async() => {
463					match event {
464						Ok(DeserializedEvent::APIResponse(v)) => {
465							let _ = public_api_response_sender.send(Arc::new(v));
466						},
467						Ok(DeserializedEvent::Event(v)) => {
468							let v = serde_json::from_value(v);
469							if v.is_err() {
470								continue
471							}
472							let _ = public_event_sender.send(Arc::new(v?));
473						},
474						_ => ()
475					}
476				}
477			}
478		}
479	}
480
481	/// 启动服务  
482	/// 在 `Client` 实例构造完成或调用 `change_service` 后都需要调用该方法启动服务
483	pub async fn start_service(&self) -> ServiceStartResult<()> {
484		self.service.start().await
485	}
486
487	pub fn stop_service(&self) {
488		self.service.stop();
489	}
490
491	pub async fn restart_service(&self) -> ServiceStartResult<()> {
492		self.service.restart().await
493	}
494
495	/// 更换服务  
496	/// 即使在原服务启动后也可以更换服务
497	///
498	/// # Examples
499	/// ```rust
500	/// use std::time::Duration;
501	/// use onebot_api::communication::utils::Client;
502	/// use onebot_api::communication::ws::WsService;
503	/// use onebot_api::communication::ws_reverse::WsReverseService;
504	///
505	/// let ws_service = WsService::new_with_options("wss://example.com", Some("example_token".to_string())).unwrap();
506	/// let mut client = Client::new_with_options(ws_service, Duration::from_secs(5), None, None);
507	/// client.start_service().await.unwrap();
508	///
509	/// let ws_reverse_service = WsReverseService::new("0.0.0.0:8080", Some("example_token".to_string()));
510	/// client.change_service(ws_reverse_service);
511	/// client.start_service().await.unwrap();
512	/// ```
513	pub fn change_service(&mut self, service: impl IntoService) -> Box<dyn CommunicationService> {
514		let mut service = Box::new(service.into());
515		service.install(
516			self.internal_api_receiver.clone(),
517			self.internal_event_sender.clone(),
518		);
519		self.service.uninstall();
520		std::mem::replace(&mut self.service, service)
521	}
522
523	/// 获取当前服务的引用
524	pub fn get_service(&self) -> &dyn CommunicationService {
525		&*self.service
526	}
527
528	/// 获取当前服务的可变引用
529	pub fn get_service_mut(&mut self) -> &mut dyn CommunicationService {
530		&mut *self.service
531	}
532}
533
534impl Client {
535	/// 随机生成uuid格式的id  
536	/// 用于echo的生成  
537	/// ---
538	/// 不要说用uuid有几率冲突  
539	/// 一个请求就那么点时间  
540	/// 这么点时间能产生一个uuid冲突建议你直接去买彩票
541	pub fn generate_id() -> String {
542		uuid::Uuid::new_v4().to_string()
543	}
544
545	/// 自动获取 `receiver` 并监听带有指定 `echo` 的API调用结果
546	///
547	/// # Returns
548	/// - `Some(api_response)` 成功获取API调用结果
549	/// - `None` 监听过程中事件通道被关闭或监听超时
550	pub async fn get_response(&self, echo: String) -> Option<ArcAPIResponse> {
551		let mut receiver = self.subscribe_api_response();
552		receiver.listen(echo, self.timeout).await
553	}
554
555	pub fn parse_response<T: DeserializeOwned>(response: ArcAPIResponse) -> APIResult<T> {
556		response.parse_data()
557	}
558
559	pub async fn send_request(
560		&self,
561		action: String,
562		params: JsonValue,
563		echo: String,
564	) -> Result<(), SendError<APIRequest>> {
565		self
566			.internal_api_sender
567			.send_async(APIRequest {
568				action,
569				params,
570				echo: Some(echo),
571			})
572			.await
573	}
574
575	/// 生成echo并发送API请求  
576	/// 同时等待API响应并自动解析
577	///
578	/// # Params
579	/// - `action` 要调用的 `action` 的名称
580	/// - `params` 调用 `action` 所需要的参数
581	///
582	/// # Examples
583	/// ```rust
584	/// use std::time::Duration;
585	/// use serde_json::{json, Value};
586	/// use onebot_api::communication::utils::Client;
587	/// use onebot_api::communication::ws::WsService;
588	///
589	/// let client: Client = Client::new_with_options(WsService::new_with_options("ws://localhost:8080", None).unwrap(), Some(Duration::from_secs(5)), None, None);
590	/// let response: Value =  client.send_and_parse("send_like", json!({})).await.unwrap();
591	/// ```
592	pub async fn send_and_parse<T: DeserializeOwned>(
593		&self,
594		action: impl ToString,
595		params: JsonValue,
596	) -> APIResult<T> {
597		let echo = (self.echo_generator)();
598		self
599			.send_request(action.to_string(), params, echo.clone())
600			.await?;
601		let response = self.get_response(echo).await;
602		if response.is_none() {
603			return Err(APIRequestError::Timeout);
604		}
605		let response = response.unwrap();
606		Self::parse_response(response)
607	}
608}
609
610// APISender START
611
612#[async_trait]
613impl APISenderTrait for Client {
614	async fn send_private_msg(
615		&self,
616		user_id: i64,
617		message: Vec<SendSegment>,
618		auto_escape: Option<bool>,
619	) -> APIResult<i32> {
620		let params = json!({
621			"user_id": user_id,
622			"message": message,
623			"auto_escape": auto_escape
624		});
625		let response: SendMsgResponse = self.send_and_parse("send_private_msg", params).await?;
626		Ok(response.message_id)
627	}
628
629	async fn send_group_msg(
630		&self,
631		group_id: i64,
632		message: Vec<SendSegment>,
633		auto_escape: Option<bool>,
634	) -> APIResult<i32> {
635		let params = json!({
636			"group_id": group_id,
637			"message": message,
638			"auto_escape": auto_escape
639		});
640		let response: SendMsgResponse = self.send_and_parse("send_group_msg", params).await?;
641		Ok(response.message_id)
642	}
643
644	async fn send_msg(
645		&self,
646		message_type: Option<MessageType>,
647		user_id: i64,
648		group_id: i64,
649		message: Vec<SendSegment>,
650		auto_escape: Option<bool>,
651	) -> APIResult<i32> {
652		let params = json!({
653			"message_type": message_type,
654			"user_id": user_id,
655			"group_id": group_id,
656			"message": message,
657			"auto_escape": auto_escape
658		});
659		let response: SendMsgResponse = self.send_and_parse("send_msg", params).await?;
660		Ok(response.message_id)
661	}
662
663	async fn delete_msg(&self, message_id: i32) -> APIResult<()> {
664		let params = json!({
665			"message_id": message_id
666		});
667		self.send_and_parse("delete_msg", params).await
668	}
669
670	async fn get_msg(&self, message_id: i32) -> APIResult<GetMsgResponse> {
671		let params = json!({
672			"message_id": message_id
673		});
674		self.send_and_parse("get_msg", params).await
675	}
676
677	async fn get_forward_msg(&self, id: String) -> APIResult<Vec<ReceiveSegment>> {
678		let params = json!({
679			"id": id
680		});
681		let response: GetForwardMsgResponse = self.send_and_parse("get_forward_msg", params).await?;
682		Ok(response.message)
683	}
684
685	async fn send_like(&self, user_id: i64, times: Option<i32>) -> APIResult<()> {
686		let params = json!({
687			"user_id": user_id,
688			"times": times
689		});
690		self.send_and_parse("send_like", params).await
691	}
692
693	async fn set_group_kick(
694		&self,
695		group_id: i32,
696		user_id: i32,
697		reject_add_request: Option<bool>,
698	) -> APIResult<()> {
699		let params = json!({
700			"group_id": group_id,
701			"user_id": user_id,
702			"reject_add_request": reject_add_request
703		});
704		self.send_and_parse("set_group_kick", params).await
705	}
706
707	async fn set_group_ban(
708		&self,
709		group_id: i32,
710		user_id: i32,
711		duration: Option<i32>,
712	) -> APIResult<()> {
713		let params = json!({
714			"group_id": group_id,
715			"user_id": user_id,
716			"duration": duration
717		});
718		self.send_and_parse("set_group_ban", params).await
719	}
720
721	async fn set_group_anonymous_ban(
722		&self,
723		group_id: i32,
724		anonymous: Option<GroupMessageAnonymous>,
725		flag: Option<String>,
726		duration: Option<i32>,
727	) -> APIResult<()> {
728		let params = json!({
729			"group_id": group_id,
730			"anonymous": anonymous,
731			"flag": flag,
732			"duration": duration
733		});
734		self.send_and_parse("set_group_anonymous_ban", params).await
735	}
736
737	async fn set_group_whole_ban(&self, group_id: i32, enable: Option<bool>) -> APIResult<()> {
738		let params = json!({
739			"group_id": group_id,
740			"enable": enable
741		});
742		self.send_and_parse("set_group_whole_ban", params).await
743	}
744
745	async fn set_group_admin(
746		&self,
747		group_id: i32,
748		user_id: i32,
749		enable: Option<bool>,
750	) -> APIResult<()> {
751		let params = json!({
752			"group_id": group_id,
753			"user_id": user_id,
754			"enable": enable
755		});
756		self.send_and_parse("set_group_admin", params).await
757	}
758
759	async fn set_group_anonymous(&self, group_id: i32, enable: Option<bool>) -> APIResult<()> {
760		let params = json!({
761			"group_id": group_id,
762			"enable": enable
763		});
764		self.send_and_parse("set_group_anonymous", params).await
765	}
766
767	async fn set_group_card(
768		&self,
769		group_id: i32,
770		user_id: i32,
771		card: Option<String>,
772	) -> APIResult<()> {
773		let params = json!({
774			"group_id": group_id,
775			"user_id": user_id,
776			"card": card
777		});
778		self.send_and_parse("set_group_card", params).await
779	}
780
781	async fn set_group_name(&self, group_id: i32, group_name: String) -> APIResult<()> {
782		let params = json!({
783			"group_id": group_id,
784			"group_name": group_name
785		});
786		self.send_and_parse("set_group_name", params).await
787	}
788
789	async fn set_group_leave(&self, group_id: i32, is_dismiss: Option<bool>) -> APIResult<()> {
790		let params = json!({
791			"group_id": group_id,
792			"is_dismiss": is_dismiss
793		});
794		self.send_and_parse("set_group_leave", params).await
795	}
796
797	async fn set_group_special_title(
798		&self,
799		group_id: i32,
800		user_id: i32,
801		special_title: Option<String>,
802		duration: Option<i32>,
803	) -> APIResult<()> {
804		let params = json!({
805			"group_id": group_id,
806			"user_id": user_id,
807			"special_title": special_title,
808			"duration": duration
809		});
810		self.send_and_parse("set_group_special_title", params).await
811	}
812
813	async fn set_friend_add_request(
814		&self,
815		flag: String,
816		approve: Option<bool>,
817		remark: Option<String>,
818	) -> APIResult<()> {
819		let params = json!({
820			"flag": flag,
821			"approve": approve,
822			"remark": remark
823		});
824		self.send_and_parse("set_friend_add_request", params).await
825	}
826
827	async fn set_group_add_request(
828		&self,
829		flag: String,
830		sub_type: String,
831		approve: Option<bool>,
832		reason: Option<String>,
833	) -> APIResult<()> {
834		let params = json!({
835			"flag": flag,
836			"sub_type": sub_type,
837			"approve": approve,
838			"reason": reason
839		});
840		self.send_and_parse("set_group_add_request", params).await
841	}
842
843	async fn get_login_info(&self) -> APIResult<GetLoginInfoResponse> {
844		let params = json!({});
845		self.send_and_parse("get_login_info", params).await
846	}
847
848	async fn get_stranger_info(
849		&self,
850		user_id: i32,
851		no_cache: Option<bool>,
852	) -> APIResult<GetStrangerInfoResponse> {
853		let params = json!({
854			"user_id": user_id,
855			"no_cache": no_cache
856		});
857		self.send_and_parse("get_stranger_info", params).await
858	}
859
860	async fn get_friend_list(&self) -> APIResult<Vec<GetFriendListResponse>> {
861		let params = json!({});
862		self.send_and_parse("get_friend_list", params).await
863	}
864
865	async fn get_group_info(
866		&self,
867		group_id: i32,
868		no_cache: Option<bool>,
869	) -> APIResult<GetGroupInfoResponse> {
870		let params = json!({
871			"group_id": group_id,
872			"no_cache": no_cache
873		});
874		self.send_and_parse("get_group_info", params).await
875	}
876
877	async fn get_group_list(&self) -> APIResult<Vec<GetGroupInfoResponse>> {
878		let params = json!({});
879		self.send_and_parse("get_group_list", params).await
880	}
881
882	async fn get_group_member_info(
883		&self,
884		group_id: i32,
885		user_id: i32,
886		no_cache: Option<bool>,
887	) -> APIResult<GetGroupMemberInfoResponse> {
888		let params = json!({
889			"group_id": group_id,
890			"user_id": user_id,
891			"no_cache": no_cache
892		});
893		self.send_and_parse("get_group_member_info", params).await
894	}
895
896	async fn get_group_member_list(
897		&self,
898		group_id: i32,
899	) -> APIResult<Vec<GetGroupMemberInfoResponse>> {
900		let params = json!({
901			"group_id": group_id
902		});
903		self.send_and_parse("get_group_member_list", params).await
904	}
905
906	async fn get_group_honor_info(
907		&self,
908		group_id: i64,
909		honor_type: String,
910	) -> APIResult<GetGroupMemberInfoResponse> {
911		let params = json!({
912			"group_id": group_id,
913			"type": honor_type
914		});
915		self.send_and_parse("get_group_honor_info", params).await
916	}
917
918	async fn get_cookies(&self, domain: Option<String>) -> APIResult<String> {
919		let params = json!({
920			"domain": domain
921		});
922		let response: GetCookiesResponse = self.send_and_parse("get_cookies", params).await?;
923		Ok(response.cookies)
924	}
925
926	async fn get_csrf_token(&self) -> APIResult<i32> {
927		let params = json!({});
928		let response: GetCsrfTokenResponse = self.send_and_parse("get_csrf_token", params).await?;
929		Ok(response.token)
930	}
931
932	async fn get_credentials(&self, domain: Option<String>) -> APIResult<GetCredentialsResponse> {
933		let params = json!({
934			"domain": domain
935		});
936		self.send_and_parse("get_credentials", params).await
937	}
938
939	async fn get_record(&self, file: String, out_format: String) -> APIResult<String> {
940		let params = json!({
941			"file": file,
942			"out_format": out_format
943		});
944		let response: GetDataResponse = self.send_and_parse("get_record", params).await?;
945		Ok(response.file)
946	}
947
948	async fn get_image(&self, file: String) -> APIResult<String> {
949		let params = json!({
950			"file": file
951		});
952		let response: GetDataResponse = self.send_and_parse("get_image", params).await?;
953		Ok(response.file)
954	}
955
956	async fn can_send_image(&self) -> APIResult<bool> {
957		let params = json!({});
958		let response: CanSendResponse = self.send_and_parse("can_send_image", params).await?;
959		Ok(response.yes)
960	}
961
962	async fn can_send_record(&self) -> APIResult<bool> {
963		let params = json!({});
964		let response: CanSendResponse = self.send_and_parse("can_send_record", params).await?;
965		Ok(response.yes)
966	}
967
968	async fn get_status(&self) -> APIResult<GetStatusResponse> {
969		let params = json!({});
970		self.send_and_parse("get_status", params).await
971	}
972
973	async fn get_version_info(&self) -> APIResult<GetVersionInfoResponse> {
974		let params = json!({});
975		self.send_and_parse("get_version_info", params).await
976	}
977
978	async fn set_restart(&self, delay: Option<i32>) -> APIResult<()> {
979		let params = json!({
980			"delay": delay
981		});
982		self.send_and_parse("set_restart", params).await
983	}
984
985	async fn clean_cache(&self) -> APIResult<()> {
986		let params = json!({});
987		self.send_and_parse("clean_cache", params).await
988	}
989}
onebot_api/communication/utils.rs

onebot_api/communication/
utils.rs
