1use super::utils::*;
2use serde::Serialize;
3
4pub trait SendSegmentData: Clone + Serialize {
5 fn into_send_segment(self) -> SendSegment;
6}
7
8impl<T: SendSegmentData> From<T> for SendSegment {
9 fn from(value: T) -> Self {
10 value.into_send_segment()
11 }
12}
13
14#[derive(Serialize, Debug, Clone)]
15#[serde(tag = "type")]
16pub enum SendSegment {
17 #[serde(rename = "text")]
18 Text { data: TextData },
19
20 #[serde(rename = "face")]
21 Face { data: FaceData },
22
23 #[serde(rename = "image")]
24 Image { data: ImageData },
25
26 #[serde(rename = "record")]
27 Record { data: RecordData },
28
29 #[serde(rename = "video")]
30 Video { data: VideoData },
31
32 #[serde(rename = "at")]
33 At { data: AtData },
34
35 #[serde(rename = "rps")]
36 Rps { data: RpsData },
37
38 #[serde(rename = "dice")]
39 Dice { data: DiceData },
40
41 #[serde(rename = "shake")]
42 Shake { data: ShakeData },
43
44 #[serde(rename = "poke")]
45 Poke { data: PokeData },
46
47 #[serde(rename = "anonymous")]
48 Anonymous { data: AnonymousData },
49
50 #[serde(rename = "share")]
51 Share { data: ShareData },
52
53 #[serde(rename = "contact")]
54 Contact { data: ContactData },
55
56 #[serde(rename = "location")]
57 Location { data: LocationData },
58
59 #[serde(rename = "music")]
60 Music { data: MusicData },
61
62 #[serde(rename = "reply")]
63 Reply { data: ReplyData },
64
65 #[serde(rename = "forward")]
66 Forward { data: ForwardData },
67
68 #[serde(rename = "node")]
69 Node { data: NodeData },
70
71 #[serde(rename = "xml")]
72 Xml { data: XmlData },
73
74 #[serde(rename = "json")]
75 Json { data: JsonData },
76}
77
78#[derive(Serialize, Debug, Clone)]
79pub struct TextData {
80 pub text: String,
83}
84
85impl SendSegmentData for TextData {
86 fn into_send_segment(self) -> SendSegment {
87 SendSegment::Text { data: self }
88 }
89}
90
91#[derive(Serialize, Debug, Clone)]
92pub struct FaceData {
93 pub id: String,
98}
99
100impl SendSegmentData for FaceData {
101 fn into_send_segment(self) -> SendSegment {
102 SendSegment::Face { data: self }
103 }
104}
105
106#[derive(Serialize, Debug, Clone)]
107pub struct ImageData {
108 pub file: String,
116 #[serde(rename = "type")]
117 pub image_type: Option<ImageType>,
122 pub cache: Option<bool>,
127 pub proxy: Option<bool>,
132 pub timeout: Option<i32>,
135}
136
137impl SendSegmentData for ImageData {
138 fn into_send_segment(self) -> SendSegment {
139 SendSegment::Image { data: self }
140 }
141}
142
143#[derive(Serialize, Debug, Clone)]
144pub struct RecordData {
145 pub file: String,
150 pub magic: Option<String>,
155 pub cache: Option<bool>,
160 pub proxy: Option<bool>,
165 pub timeout: Option<i32>,
168}
169
170impl SendSegmentData for RecordData {
171 fn into_send_segment(self) -> SendSegment {
172 SendSegment::Record { data: self }
173 }
174}
175
176#[derive(Serialize, Debug, Clone)]
177pub struct VideoData {
178 pub file: String,
183 pub cache: Option<bool>,
188 pub proxy: Option<bool>,
193 pub timeout: Option<i32>,
196}
197
198impl SendSegmentData for VideoData {
199 fn into_send_segment(self) -> SendSegment {
200 SendSegment::Video { data: self }
201 }
202}
203
204#[derive(Serialize, Debug, Clone)]
205pub struct AtData {
206 pub qq: AtType,
211}
212
213impl SendSegmentData for AtData {
214 fn into_send_segment(self) -> SendSegment {
215 SendSegment::At { data: self }
216 }
217}
218
219#[derive(Serialize, Debug, Clone)]
220pub struct RpsData {}
221
222impl SendSegmentData for RpsData {
223 fn into_send_segment(self) -> SendSegment {
224 SendSegment::Rps { data: self }
225 }
226}
227
228#[derive(Serialize, Debug, Clone)]
229pub struct DiceData {}
230
231impl SendSegmentData for DiceData {
232 fn into_send_segment(self) -> SendSegment {
233 SendSegment::Dice { data: self }
234 }
235}
236
237#[derive(Serialize, Debug, Clone)]
238pub struct ShakeData {}
239
240impl SendSegmentData for ShakeData {
241 fn into_send_segment(self) -> SendSegment {
242 SendSegment::Shake { data: self }
243 }
244}
245
246#[derive(Serialize, Debug, Clone)]
247pub struct PokeData {
248 #[serde(rename = "type")]
249 pub poke_type: String,
254 pub id: String,
259}
260
261impl SendSegmentData for PokeData {
262 fn into_send_segment(self) -> SendSegment {
263 SendSegment::Poke { data: self }
264 }
265}
266
267#[derive(Serialize, Debug, Clone)]
268pub struct AnonymousData {
269 pub ignore: Option<bool>,
274}
275
276impl SendSegmentData for AnonymousData {
277 fn into_send_segment(self) -> SendSegment {
278 SendSegment::Anonymous { data: self }
279 }
280}
281
282#[derive(Serialize, Debug, Clone)]
283pub struct ShareData {
284 pub url: String,
287 pub title: String,
290 pub content: String,
293 pub image: String,
296}
297
298impl SendSegmentData for ShareData {
299 fn into_send_segment(self) -> SendSegment {
300 SendSegment::Share { data: self }
301 }
302}
303
304#[derive(Serialize, Debug, Clone)]
305pub struct ContactData {
306 #[serde(rename = "type")]
307 pub contact_type: ContactType,
310 pub id: String,
313}
314
315impl SendSegmentData for ContactData {
316 fn into_send_segment(self) -> SendSegment {
317 SendSegment::Contact { data: self }
318 }
319}
320
321#[derive(Serialize, Debug, Clone)]
322pub struct LocationData {
323 pub lat: String,
326 pub lon: String,
329 pub title: Option<String>,
332 pub content: Option<String>,
335}
336
337impl SendSegmentData for LocationData {
338 fn into_send_segment(self) -> SendSegment {
339 SendSegment::Location { data: self }
340 }
341}
342
343#[derive(Serialize, Debug, Clone)]
344pub struct MusicData {
345 #[serde(rename = "type")]
346 pub music_type: MusicType,
351 pub id: Option<String>,
354 pub url: Option<String>,
357 pub audio: Option<String>,
360 pub title: Option<String>,
363 pub content: Option<String>,
366 pub image: Option<String>,
369}
370
371impl SendSegmentData for MusicData {
372 fn into_send_segment(self) -> SendSegment {
373 SendSegment::Music { data: self }
374 }
375}
376
377#[derive(Serialize, Debug, Clone)]
378pub struct ReplyData {
379 pub id: String,
382}
383
384impl SendSegmentData for ReplyData {
385 fn into_send_segment(self) -> SendSegment {
386 SendSegment::Reply { data: self }
387 }
388}
389
390#[derive(Serialize, Debug, Clone)]
391pub struct ForwardData {}
392
393impl SendSegmentData for ForwardData {
394 fn into_send_segment(self) -> SendSegment {
395 SendSegment::Forward { data: self }
396 }
397}
398
399#[derive(Serialize, Debug, Clone)]
400pub struct NodeData {
401 pub id: Option<String>,
404 pub user_id: Option<String>,
407 pub nickname: Option<String>,
410 pub content: Option<Vec<SendSegment>>,
413}
414
415impl SendSegmentData for NodeData {
416 fn into_send_segment(self) -> SendSegment {
417 SendSegment::Node { data: self }
418 }
419}
420
421#[derive(Serialize, Debug, Clone)]
422pub struct XmlData {
423 pub data: String,
426}
427
428impl SendSegmentData for XmlData {
429 fn into_send_segment(self) -> SendSegment {
430 SendSegment::Xml { data: self }
431 }
432}
433
434#[derive(Serialize, Debug, Clone)]
435pub struct JsonData {
436 pub data: String,
439}
440
441impl SendSegmentData for JsonData {
442 fn into_send_segment(self) -> SendSegment {
443 SendSegment::Json { data: self }
444 }
445}