puniyu_adapter_server 0.3.4

puniyu的server适配器
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use crate::api;
use actix_ws::Session;
use puniyu_adapter::prelude::*;
use puniyu_protocol::event::message::{MessageEventReceive, message_event_receive};
use puniyu_protocol::event::{EventReceive, event_receive};
use std::sync::Arc;
use tokio::sync::Mutex;

#[inline]
pub(crate) fn handle_event(event: EventReceive, session: &Arc<Mutex<Session>>) {
	if let Some(event) = event.event {
		match event {
			event_receive::Event::MessageEvent(message) => handel_message_event(message, session),
		};
	};
}

fn create_message_api(
	adapter: Arc<AdapterInfo>,
	account: Arc<AccountInfo>,
	session: &Arc<Mutex<Session>>,
	event: crate::bot::Event,
) -> Arc<api::ServerMessageApi> {
	Arc::new(api::ServerMessageApi {
		bot: Some(Arc::new(crate::bot::Bot {
			adapter,
			account,
			session: Arc::clone(session),
			event,
		})),
	})
}

fn create_adapter_bot(
	adapter: Arc<AdapterInfo>,
	account: Arc<AccountInfo>,
	message_api: Arc<api::ServerMessageApi>,
) -> Arc<Bot> {
	let group_api = Arc::new(api::ServerGroupApi);
	let friend_api = Arc::new(api::ServerFriendApi);
	let account_api = Arc::new(api::ServerAccountApi);

	Arc::new(Bot {
		adapter: (*adapter).clone(),
		api: AdapterApi::new(group_api, friend_api, account_api, message_api),
		account: (*account).clone(),
	})
}

fn handel_message_event(message: MessageEventReceive, session: &Arc<Mutex<Session>>) {
	if let Some(message) = message.message_event {
		match message {
			message_event_receive::MessageEvent::FriendMessage(message) => {
				let bot = message.friend_message_bot.unwrap_or_default();
				let adapter = Arc::new(bot.adapter.unwrap().into());
				let account = Arc::new(bot.account.unwrap().into());
				let event_id: Arc<str> = Arc::from(message.event_id.as_str());
				let self_id: Arc<str> = Arc::from(message.self_id.as_str());
				let user_id: Arc<str> = Arc::from(message.user_id.as_str());
				let time = message.time;
				let message_id: Arc<str> = Arc::from(message.message_id.as_str());
				let contact = message.contact.unwrap_or_default();
				let sender = message.sender.unwrap_or_default();
				let elements: Vec<_> =
					message.elements.into_iter().map(|element| element.into()).collect();

				let event = crate::bot::Event {
					event_id: Arc::clone(&event_id),
					self_id: Arc::clone(&self_id),
					user_id: Arc::clone(&user_id),
					contact: contact.clone().into(),
					sender: sender.clone().into(),
					time,
					message_id: Arc::clone(&message_id),
					elements: elements.clone(),
				};

				let message_api =
					create_message_api(Arc::clone(&adapter), Arc::clone(&account), session, event);
				let bot = create_adapter_bot(adapter, account, message_api);

				create_message_event!(Friend,
					{
						bot: bot,
						event_id: event_id.to_string(),
						self_id: self_id.to_string(),
						user_id: user_id.to_string(),
						contact: contact.into(),
						sender: sender.into(),
						time: time,
						message_id: message_id.to_string(),
						elements: elements,
					}
				)
			}
			message_event_receive::MessageEvent::GroupMessage(message) => {
				let bot = message.group_message_bot.unwrap_or_default();
				let adapter = Arc::new(bot.adapter.unwrap().into());
				let account = Arc::new(bot.account.unwrap().into());
				let event_id: Arc<str> = Arc::from(message.event_id.as_str());
				let self_id: Arc<str> = Arc::from(message.self_id.as_str());
				let user_id: Arc<str> = Arc::from(message.user_id.as_str());
				let time = message.time;
				let message_id: Arc<str> = Arc::from(message.message_id.as_str());
				let contact = message.contact.unwrap_or_default();
				let sender = message.sender.unwrap_or_default();
				let elements: Vec<_> =
					message.elements.into_iter().map(|element| element.into()).collect();

				let event = crate::bot::Event {
					event_id: Arc::clone(&event_id),
					self_id: Arc::clone(&self_id),
					user_id: Arc::clone(&user_id),
					contact: contact.clone().into(),
					sender: sender.clone().into(),
					time,
					message_id: Arc::clone(&message_id),
					elements: elements.clone(),
				};

				let message_api =
					create_message_api(Arc::clone(&adapter), Arc::clone(&account), session, event);
				let bot = create_adapter_bot(adapter, account, message_api);

				create_message_event!(Group,
					{
						bot: bot,
						event_id: event_id.to_string(),
						self_id: self_id.to_string(),
						user_id: user_id.to_string(),
						contact: contact.into(),
						sender: sender.into(),
						time: time,
						message_id: message_id.to_string(),
						elements: elements,
					}
				)
			}
		}
	};
}