133 lines
3.8 KiB
Rust
133 lines
3.8 KiB
Rust
use std::convert::TryFrom;
|
|
use std::collections::BTreeMap;
|
|
|
|
use plugin::PluginProxy;
|
|
use event::{Event, Priority, Propagation};
|
|
use error::Error;
|
|
use jid::Jid;
|
|
|
|
use plugins::stanza::Message;
|
|
use xmpp_parsers::message::{MessagePayload, MessageType};
|
|
use xmpp_parsers::chatstates::ChatState;
|
|
use xmpp_parsers::receipts::Receipt;
|
|
use xmpp_parsers::stanza_id::StanzaId;
|
|
|
|
// TODO: use the id (maybe even stanza-id) to identify every message.
|
|
#[derive(Debug)]
|
|
pub struct MessageEvent {
|
|
pub from: Jid,
|
|
pub body: String,
|
|
pub subject: Option<String>,
|
|
pub thread: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct ChatStateEvent {
|
|
pub from: Jid,
|
|
pub chat_state: ChatState,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct ReceiptRequestEvent {
|
|
pub from: Jid,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct ReceiptReceivedEvent {
|
|
pub from: Jid,
|
|
pub id: String,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct StanzaIdEvent {
|
|
pub from: Jid,
|
|
pub stanza_id: StanzaId,
|
|
pub message: Message,
|
|
}
|
|
|
|
impl Event for MessageEvent {}
|
|
impl Event for ChatStateEvent {}
|
|
impl Event for ReceiptRequestEvent {}
|
|
impl Event for ReceiptReceivedEvent {}
|
|
impl Event for StanzaIdEvent {}
|
|
|
|
pub struct MessagingPlugin {
|
|
proxy: PluginProxy,
|
|
}
|
|
|
|
impl MessagingPlugin {
|
|
pub fn new() -> MessagingPlugin {
|
|
MessagingPlugin {
|
|
proxy: PluginProxy::new(),
|
|
}
|
|
}
|
|
|
|
pub fn send_message(&self, to: &Jid, body: &str) -> Result<(), Error> {
|
|
let message = Message {
|
|
from: None,
|
|
to: Some(to.clone()),
|
|
type_: MessageType::Chat,
|
|
// TODO: always use an id.
|
|
id: None,
|
|
bodies: {
|
|
let mut bodies = BTreeMap::new();
|
|
bodies.insert(String::new(), String::from(body));
|
|
bodies
|
|
},
|
|
subjects: BTreeMap::new(),
|
|
thread: None,
|
|
payloads: vec!(),
|
|
};
|
|
self.proxy.send(message.into());
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_message(&self, message: &Message) -> Propagation {
|
|
let from = message.from.clone().unwrap();
|
|
for payload in message.payloads.clone() {
|
|
let payload = match MessagePayload::try_from(payload) {
|
|
Ok(payload) => payload,
|
|
Err(err) => {
|
|
println!("MessagePayload: {:?}", err);
|
|
continue;
|
|
}
|
|
};
|
|
match payload {
|
|
// XEP-0085
|
|
MessagePayload::ChatState(chat_state) => self.proxy.dispatch(ChatStateEvent {
|
|
from: from.clone(),
|
|
chat_state: chat_state,
|
|
}),
|
|
// XEP-0184
|
|
MessagePayload::Receipt(Receipt::Request) => self.proxy.dispatch(ReceiptRequestEvent {
|
|
from: from.clone(),
|
|
}),
|
|
// XEP-0184
|
|
MessagePayload::Receipt(Receipt::Received(id)) => self.proxy.dispatch(ReceiptReceivedEvent {
|
|
from: from.clone(),
|
|
id: id.unwrap(),
|
|
}),
|
|
// XEP-0359
|
|
MessagePayload::StanzaId(stanza_id) => self.proxy.dispatch(StanzaIdEvent {
|
|
from: from.clone(),
|
|
stanza_id: stanza_id,
|
|
message: message.clone(),
|
|
}),
|
|
payload => println!("Unhandled payload: {:?}", payload),
|
|
}
|
|
}
|
|
if message.bodies.contains_key("") {
|
|
self.proxy.dispatch(MessageEvent {
|
|
from: from,
|
|
body: message.bodies[""].clone(),
|
|
subject: if message.subjects.contains_key("") { Some(message.subjects[""].clone()) } else { None },
|
|
thread: message.thread.clone(),
|
|
});
|
|
}
|
|
Propagation::Stop
|
|
}
|
|
}
|
|
|
|
impl_plugin!(MessagingPlugin, proxy, [
|
|
(Message, Priority::Default) => handle_message,
|
|
]);
|