1use serde::{Serialize, Deserialize};
2
3use crate::session::{Session, CommonResponse};
4use crate::error::{Result, assert};
5use crate::Target;
6
7#[derive(Serialize, Deserialize, Clone, Debug)]
8pub struct GroupConfig {
9 pub name: String,
10 pub announcement: String,
11 #[serde(rename = "confessTalk")]
12 pub confess_talk: bool,
13 #[serde(rename = "allowMemberInvite")]
14 pub allow_member_invite: bool,
15 #[serde(rename = "autoApprove")]
16 pub auto_approve: bool,
17 #[serde(rename = "anonymousChat")]
18 pub anonymous_chat: bool,
19}
20
21#[derive(Serialize, Deserialize, Clone, Debug)]
22pub struct MemberInfo {
23 name: String,
24 #[serde(rename = "specialTitle")]
25 special_title: String,
26}
27
28impl Session {
29 async fn do_mute_all(&self, target: Target, mute: bool) -> Result<()> {
30 let path = if mute { "muteAll" } else { "unmuteAll" };
31
32 #[derive(Serialize)]
33 struct Request {
34 #[serde(rename = "sessionKey")]
35 session_key: String,
36 target: Target,
37 }
38
39 let req = Request {
40 session_key: self.key.clone(),
41 target,
42 };
43
44 let resp: CommonResponse = self.client.post(&(self.url("/") + path))
45 .json(&req).send().await?
46 .json().await?;
47
48 assert(resp.code, if mute { "MuteAll" } else { "UnmuteAll" })
49 }
50
51 pub async fn mute_all(&self, target: Target) -> Result<()> {
52 self.do_mute_all(target, true).await
53 }
54
55 pub async fn unmute_all(&self, target: Target) -> Result<()> {
56 self.do_mute_all(target, false).await
57 }
58
59 pub async fn mute(&self, group_id: Target, target: Target, seconds: u32) -> Result<()> {
60 #[derive(Serialize)]
61 struct Request {
62 #[serde(rename = "sessionKey")]
63 session_key: String,
64 target: Target,
65 #[serde(rename = "memberId")]
66 member_id: Target,
67 time: u32,
68 }
69
70 let req = Request {
71 session_key: self.key.clone(),
72 target: group_id,
73 member_id: target,
74 time: seconds,
75 };
76
77 let resp: CommonResponse = self.client.post(&self.url("/mute"))
78 .json(&req).send().await?
79 .json().await?;
80
81 assert(resp.code, "Mute")
82 }
83
84 pub async fn unmute(&self, group_id: Target, target: Target) -> Result<()> {
85 #[derive(Serialize)]
86 struct Request {
87 #[serde(rename = "sessionKey")]
88 session_key: String,
89 target: Target,
90 #[serde(rename = "memberId")]
91 member_id: Target,
92 }
93
94 let req = Request {
95 session_key: self.key.clone(),
96 target: group_id,
97 member_id: target,
98 };
99
100 let resp: CommonResponse = self.client.post(&self.url("/unmute"))
101 .json(&req).send().await?
102 .json().await?;
103
104 assert(resp.code, "Unmute")
105 }
106
107 pub async fn kick(&self, group_id: Target, target: Target, msg: &str) -> Result<()> {
108 #[derive(Serialize)]
109 struct Request {
110 #[serde(rename = "sessionKey")]
111 session_key: String,
112 target: Target,
113 #[serde(rename = "memberId")]
114 member_id: Target,
115 msg: String,
116 }
117
118 let req = Request {
119 session_key: self.key.clone(),
120 target: group_id,
121 member_id: target,
122 msg: msg.to_string(),
123 };
124
125 let resp: CommonResponse = self.client.post(&self.url("/kick"))
126 .json(&req).send().await?
127 .json().await?;
128
129 assert(resp.code, "Kick")
130 }
131
132 pub async fn quit(&self, group_id: Target) -> Result<()> {
133 #[derive(Serialize)]
134 struct Request {
135 #[serde(rename = "sessionKey")]
136 session_key: String,
137 target: Target,
138 }
139
140 let req = Request {
141 session_key: self.key.clone(),
142 target: group_id,
143 };
144
145 let resp: CommonResponse = self.client.post(&self.url("/quit"))
146 .json(&req).send().await?
147 .json().await?;
148
149 assert(resp.code, "Quit")
150 }
151
152 pub async fn modify_group_config(&self, group_id: Target, config: &GroupConfig) -> Result<()> {
153 #[derive(Serialize)]
154 struct Request {
155 #[serde(rename = "sessionKey")]
156 session_key: String,
157 target: Target,
158 config: GroupConfig,
159 }
160
161 let req = Request {
162 session_key: self.key.clone(),
163 target: group_id,
164 config: config.clone(),
165 };
166
167 let resp: CommonResponse = self.client.post(&self.url("/groupConfig"))
168 .json(&req).send().await?
169 .json().await?;
170
171 assert(resp.code, "ModifyGroupConfig")
172 }
173
174 pub async fn get_group_config(&self, group_id: Target) -> Result<GroupConfig> {
175 let config: GroupConfig = self.client.get(&self.url(&format!("/groupConfig?sessionKey={}&target={}", self.key, group_id)))
176 .send().await?
177 .json().await?;
178
179 Ok(config)
180 }
181
182 pub async fn modify_member_info(&self, group_id: Target, target: Target, info: &MemberInfo) -> Result<()> {
183 #[derive(Serialize)]
184 struct Request {
185 #[serde(rename = "sessionKey")]
186 session_key: String,
187 target: Target,
188 #[serde(rename = "memberId")]
189 member_id: Target,
190 info: MemberInfo,
191 }
192
193 let req = Request {
194 session_key: self.key.clone(),
195 target: group_id,
196 member_id: target,
197 info: info.clone(),
198 };
199
200 let resp: CommonResponse = self.client.post(&self.url("/groupConfig"))
201 .json(&req).send().await?
202 .json().await?;
203
204 assert(resp.code, "ModifyGroupConfig")
205 }
206
207 pub async fn get_member_info(&self, group_id: Target, target: Target) -> Result<MemberInfo> {
208 let info: MemberInfo = self.client.get(&self.url(&format!("/memberInfo?sessionKey={}&target={}&memberId={}", self.key, group_id, target)))
209 .send().await?
210 .json().await?;
211
212 Ok(info)
213 }
214}