130 lines
3.9 KiB
Rust
130 lines
3.9 KiB
Rust
use matrix_sdk::{
|
|
async_trait,
|
|
room::Room,
|
|
ruma::{
|
|
events::{
|
|
room::{
|
|
message::{MessageEventContent, MessageFormat, MessageType, Relation},
|
|
redaction::RedactionEventContent,
|
|
},
|
|
AnyMessageEventContent, AnySyncRoomEvent, SyncMessageEvent,
|
|
},
|
|
EventId, RoomId,
|
|
},
|
|
ClientConfig, EventHandler, SyncSettings,
|
|
};
|
|
|
|
pub use matrix_sdk::Client;
|
|
use tokio::sync::mpsc;
|
|
use url::Url;
|
|
|
|
use crate::{message_ast::convert_plain, MessageReference, SentMessage};
|
|
|
|
impl From<(&RoomId, &EventId)> for MessageReference {
|
|
fn from((room_id, event_id): (&RoomId, &EventId)) -> Self {
|
|
let room_string = room_id.as_str().to_string();
|
|
let event_string = event_id.as_str().to_string();
|
|
|
|
Self::Matrix(room_string, event_string)
|
|
}
|
|
}
|
|
|
|
fn _find_content(event: &AnySyncRoomEvent) -> Option<AnyMessageEventContent> {
|
|
match event {
|
|
AnySyncRoomEvent::Message(message) => Some(message.content()),
|
|
AnySyncRoomEvent::RedactedMessage(message) => {
|
|
if let Some(ref redaction_event) = message.unsigned().redacted_because {
|
|
Some(AnyMessageEventContent::RoomRedaction(
|
|
redaction_event.content.clone(),
|
|
))
|
|
} else {
|
|
Some(AnyMessageEventContent::RoomRedaction(
|
|
RedactionEventContent::new(),
|
|
))
|
|
}
|
|
}
|
|
AnySyncRoomEvent::RedactedState(state) => {
|
|
if let Some(ref redaction_event) = state.unsigned().redacted_because {
|
|
Some(AnyMessageEventContent::RoomRedaction(
|
|
redaction_event.content.clone(),
|
|
))
|
|
} else {
|
|
Some(AnyMessageEventContent::RoomRedaction(
|
|
RedactionEventContent::new(),
|
|
))
|
|
}
|
|
}
|
|
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
struct MatrixHandler {
|
|
message_tx: mpsc::UnboundedSender<SentMessage>,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl EventHandler for MatrixHandler {
|
|
async fn on_room_message(&self, room: Room, event: &SyncMessageEvent<MessageEventContent>) {
|
|
let message_ref = MessageReference::from((room.room_id(), &event.event_id));
|
|
|
|
let message_type =
|
|
if let Some(Relation::Replacement(replacement)) = &event.content.relates_to {
|
|
&replacement.new_content.msgtype
|
|
} else {
|
|
&event.content.msgtype
|
|
};
|
|
|
|
match message_type {
|
|
MessageType::Text(text) => {
|
|
let content = if let Some(_html) = text
|
|
.formatted
|
|
.as_ref()
|
|
.filter(|f| f.format == MessageFormat::Html)
|
|
.map(|f| &f.body)
|
|
{
|
|
todo!("Parse html_body into MessageContent AST")
|
|
} else {
|
|
convert_plain(&text.body)
|
|
};
|
|
|
|
let _ = self.message_tx.send(SentMessage {
|
|
source: message_ref,
|
|
content,
|
|
});
|
|
}
|
|
|
|
MessageType::Emote(_emote) => {
|
|
// TODO
|
|
}
|
|
|
|
_ => {}
|
|
};
|
|
}
|
|
}
|
|
|
|
pub async fn create_matrix_client(
|
|
homeserver_url: String,
|
|
username: String,
|
|
password: String,
|
|
message_tx: mpsc::UnboundedSender<SentMessage>,
|
|
) -> Client {
|
|
let client_config = ClientConfig::new().store_path("./matrix");
|
|
|
|
let homeserver_url =
|
|
Url::parse(&homeserver_url).expect("Failed to parse the matrix homeserver URL");
|
|
let client = Client::new_with_config(homeserver_url, client_config).unwrap();
|
|
|
|
client
|
|
.login(&username, &password, None, Some("phoebe"))
|
|
.await
|
|
.expect("Failed to log in");
|
|
|
|
client.sync_once(SyncSettings::default()).await.unwrap();
|
|
|
|
let event_handler = MatrixHandler { message_tx };
|
|
client.set_event_handler(Box::new(event_handler)).await;
|
|
|
|
client
|
|
}
|