474 lines
15 KiB
Rust
474 lines
15 KiB
Rust
use std::sync::Arc;
|
|
|
|
use matrix_sdk::{
|
|
config::ClientConfig,
|
|
media::MediaEventContent,
|
|
room::{Joined, Room},
|
|
ruma::{
|
|
api,
|
|
events::{
|
|
self,
|
|
room::{
|
|
message::{
|
|
FormattedBody, MessageEventContent, MessageFormat, MessageType, Relation,
|
|
Replacement,
|
|
},
|
|
redaction::{RedactionEventContent, SyncRedactionEvent},
|
|
},
|
|
AnyMessageEvent, AnyMessageEventContent, AnyRoomEvent, AnySyncRoomEvent,
|
|
SyncMessageEvent,
|
|
},
|
|
UserId,
|
|
},
|
|
};
|
|
pub use matrix_sdk::{
|
|
config::SyncSettings,
|
|
ruma::{EventId, RoomId},
|
|
Client,
|
|
};
|
|
|
|
use log::info;
|
|
use tokio::sync::mpsc;
|
|
use url::Url;
|
|
|
|
use crate::{
|
|
message_ast::{
|
|
convert_matrix, convert_plain, format_discord, format_matrix, MessageComponent,
|
|
MessageContent,
|
|
},
|
|
messages::{
|
|
DeletedMessage, EditedMessage, MessageAuthor, MessageEvent, MessageReference,
|
|
SentImageMessage, 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<MessageEvent>,
|
|
}
|
|
|
|
impl MatrixHandler {
|
|
async fn get_message_author(&self, room: &Joined, user_id: &UserId) -> Option<MessageAuthor> {
|
|
if let Ok(Some(sender)) = room.get_member(user_id).await {
|
|
Some(MessageAuthor {
|
|
display_name: sender
|
|
.display_name()
|
|
.unwrap_or_else(|| sender.name())
|
|
.to_string(),
|
|
avatar_url: sender
|
|
.avatar_url()
|
|
.map(|u| {
|
|
format!(
|
|
"https://matrix.org/_matrix/media/r0/thumbnail/{}?width=500&height=500",
|
|
u.as_str().to_string().replace("mxc://", "")
|
|
)
|
|
})
|
|
.unwrap_or_else(|| {
|
|
"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="
|
|
.to_string()
|
|
}),
|
|
service_name: "matrix".to_string(),
|
|
display_color: None,
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn get_content(&self, body: &str, formatted_body: &Option<FormattedBody>) -> MessageContent {
|
|
if let Some(html) = formatted_body
|
|
.as_ref()
|
|
.filter(|f| f.format == MessageFormat::Html)
|
|
.map(|f| &f.body)
|
|
{
|
|
convert_matrix(html)
|
|
} else {
|
|
convert_plain(body)
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn get_room_message_event(
|
|
room: &Joined,
|
|
event_id: &EventId,
|
|
) -> Option<events::MessageEvent<MessageEventContent>> {
|
|
let event = room
|
|
.event(api::client::r0::room::get_room_event::Request::new(
|
|
room.room_id(),
|
|
event_id,
|
|
))
|
|
.await
|
|
.ok()?
|
|
.event
|
|
.deserialize()
|
|
.ok()?;
|
|
|
|
if let AnyRoomEvent::Message(AnyMessageEvent::RoomMessage(message_event)) = event {
|
|
Some(message_event)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
async fn on_room_message_event(
|
|
ctx: Arc<MatrixHandler>,
|
|
event: SyncMessageEvent<MessageEventContent>,
|
|
room: Room,
|
|
) {
|
|
if let Room::Joined(room) = room {
|
|
if let Some(Relation::Replacement(replacement)) = &event.content.relates_to {
|
|
on_message_edited(ctx, &event, room, replacement).await;
|
|
} else {
|
|
on_message_sent(ctx, &event, room).await;
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn on_message_sent(
|
|
ctx: Arc<MatrixHandler>,
|
|
event: &SyncMessageEvent<MessageEventContent>,
|
|
room: Joined,
|
|
) {
|
|
let message_ref = MessageReference::from((room.room_id(), &event.event_id));
|
|
|
|
if let Some(author) = ctx.get_message_author(&room, &event.sender).await {
|
|
let message_event = match &event.content.msgtype {
|
|
MessageType::Text(text) => {
|
|
let content = ctx.get_content(&text.body, &text.formatted);
|
|
|
|
let replies_to =
|
|
if let Some(Relation::Reply { in_reply_to }) = &event.content.relates_to {
|
|
Some(MessageReference::from((
|
|
room.room_id(),
|
|
&in_reply_to.event_id,
|
|
)))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
Some(MessageEvent::SendText(Box::new(SentMessage {
|
|
source: message_ref,
|
|
content,
|
|
author,
|
|
replies_to,
|
|
})))
|
|
}
|
|
|
|
MessageType::Emote(emote) => {
|
|
let mut content = ctx.get_content(&emote.body, &emote.formatted);
|
|
content.insert(0, MessageComponent::Plain("* ".to_string()));
|
|
|
|
Some(MessageEvent::SendText(Box::new(SentMessage {
|
|
source: message_ref,
|
|
content,
|
|
author,
|
|
replies_to: None,
|
|
})))
|
|
}
|
|
|
|
MessageType::Image(content) => {
|
|
if let Some(file) = content.file() {
|
|
match file {
|
|
matrix_sdk::media::MediaType::Uri(uri) => {
|
|
if let Some((server_name, hash)) = uri.parts() {
|
|
let server_name = server_name.as_str();
|
|
|
|
let image_url = format!(
|
|
"https://{}/_matrix/media/r0/download/{}/{}",
|
|
server_name, server_name, hash
|
|
);
|
|
|
|
Some(MessageEvent::SendImage(Box::new(SentImageMessage {
|
|
source: message_ref,
|
|
author,
|
|
image_url,
|
|
})))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
// TODO: Handle encrypted image uploads (we will have to decrypt it and upload it somewhere)
|
|
matrix_sdk::media::MediaType::Encrypted(_encrypted_file) => None,
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
// TODO: Handle reactions, more uploads (audio, video, file), and any other types of event
|
|
_ => None,
|
|
};
|
|
|
|
if let Some(e) = message_event {
|
|
let _ = ctx.message_tx.send(e);
|
|
}
|
|
}
|
|
|
|
let _ = room.read_receipt(&event.event_id).await;
|
|
}
|
|
|
|
async fn on_message_edited(
|
|
ctx: Arc<MatrixHandler>,
|
|
event: &SyncMessageEvent<MessageEventContent>,
|
|
room: Joined,
|
|
replacement: &Replacement,
|
|
) {
|
|
let message_ref = MessageReference::from((room.room_id(), &replacement.event_id));
|
|
|
|
if let MessageType::Text(text) = &replacement.new_content.msgtype {
|
|
let content = ctx.get_content(&text.body, &text.formatted);
|
|
|
|
if let Some(author) = ctx.get_message_author(&room, &event.sender).await {
|
|
let _ = ctx
|
|
.message_tx
|
|
.send(MessageEvent::EditText(Box::new(EditedMessage {
|
|
replacing: message_ref,
|
|
content,
|
|
author,
|
|
})));
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn on_redact_event(ctx: Arc<MatrixHandler>, event: SyncRedactionEvent, room: Room) {
|
|
let message_ref = MessageReference::from((room.room_id(), &event.redacts));
|
|
|
|
let _ = ctx
|
|
.message_tx
|
|
.send(MessageEvent::Delete(Box::new(DeletedMessage {
|
|
reference: message_ref,
|
|
})));
|
|
}
|
|
|
|
fn generate_html_content(content: &[MessageComponent], author: &MessageAuthor) -> (String, String) {
|
|
let plaintext_message = format!(
|
|
"{} ({}): {}",
|
|
&author.display_name,
|
|
&author.service_name,
|
|
format_discord(content)
|
|
);
|
|
|
|
let html_message = format!(
|
|
r##"<strong><font data-mx-color="#{}">{} <small>({})</small></font>:</strong> {}"##,
|
|
author.display_color.as_deref().unwrap_or("ffffff"),
|
|
&author.display_name,
|
|
&author.service_name,
|
|
format_matrix(content),
|
|
);
|
|
|
|
(plaintext_message, html_message)
|
|
}
|
|
|
|
fn generate_event_content_struct(
|
|
replied_message_event: Option<&events::MessageEvent<MessageEventContent>>,
|
|
plaintext_content: String,
|
|
html_content: String,
|
|
) -> MessageEventContent {
|
|
if let Some(replied_message_event) = replied_message_event {
|
|
MessageEventContent::text_reply_html(plaintext_content, html_content, replied_message_event)
|
|
} else {
|
|
MessageEventContent::text_html(plaintext_content, html_content)
|
|
}
|
|
}
|
|
|
|
pub async fn forward_to_matrix(
|
|
client: &Client,
|
|
room_id: RoomId,
|
|
message: &SentMessage,
|
|
replying_to: Option<EventId>,
|
|
) -> Option<MessageReference> {
|
|
if let Some(room) = client.get_joined_room(&room_id) {
|
|
let replied_message_event = if let Some(event_id) = replying_to {
|
|
get_room_message_event(&room, &event_id).await
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let (plaintext_content, html_content) =
|
|
generate_html_content(&message.content, &message.author);
|
|
|
|
let content = generate_event_content_struct(
|
|
replied_message_event.as_ref(),
|
|
plaintext_content,
|
|
html_content,
|
|
);
|
|
|
|
let event = room
|
|
.send(AnyMessageEventContent::RoomMessage(content), None)
|
|
.await
|
|
.ok()?;
|
|
|
|
return Some(MessageReference::from((&room_id, &event.event_id)));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub async fn forward_image_to_matrix(
|
|
client: &Client,
|
|
room_id: RoomId,
|
|
message: &SentImageMessage,
|
|
) -> Option<MessageReference> {
|
|
if let Some(room) = client.get_joined_room(&room_id) {
|
|
let image_url = message.image_url.clone();
|
|
let mut response = tokio::task::spawn_blocking(|| reqwest::blocking::get(image_url).ok())
|
|
.await
|
|
.ok()
|
|
.flatten()?;
|
|
|
|
let event = room
|
|
.send_attachment(
|
|
&message.image_url,
|
|
&mime_guess::from_path(&message.image_url).first_or_octet_stream(),
|
|
&mut response,
|
|
None,
|
|
)
|
|
.await
|
|
.ok()?;
|
|
|
|
return Some(MessageReference::from((&room_id, &event.event_id)));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub async fn edit_on_matrix(
|
|
client: &Client,
|
|
room_id: RoomId,
|
|
event_id: EventId,
|
|
message: &EditedMessage,
|
|
) -> Option<MessageReference> {
|
|
if let Some(room) = client.get_joined_room(&room_id) {
|
|
if let Some(original_message_event) = get_room_message_event(&room, &event_id).await {
|
|
if let Some(Relation::Replacement(_)) = &original_message_event.content.relates_to {
|
|
return None;
|
|
}
|
|
|
|
let replied_message_event = if let Some(Relation::Reply { in_reply_to }) =
|
|
&original_message_event.content.relates_to
|
|
{
|
|
get_room_message_event(&room, &in_reply_to.event_id).await
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let (plaintext_content, html_content) =
|
|
generate_html_content(&message.content, &message.author);
|
|
|
|
let mut edit_content = generate_event_content_struct(
|
|
replied_message_event.as_ref(),
|
|
format!("* {}", &plaintext_content),
|
|
format!("* {}", &html_content),
|
|
);
|
|
|
|
let basic_content = generate_event_content_struct(
|
|
replied_message_event.as_ref(),
|
|
plaintext_content,
|
|
html_content,
|
|
);
|
|
|
|
edit_content.relates_to = Some(Relation::Replacement(Replacement::new(
|
|
event_id,
|
|
Box::new(basic_content),
|
|
)));
|
|
|
|
let new_event = room
|
|
.send(AnyMessageEventContent::RoomMessage(edit_content), None)
|
|
.await
|
|
.ok()?;
|
|
|
|
return Some(MessageReference::from((&room_id, &new_event.event_id)));
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub async fn delete_on_matrix(
|
|
client: &Client,
|
|
room_id: RoomId,
|
|
event_id: EventId,
|
|
_message: &DeletedMessage,
|
|
) -> bool {
|
|
if let Some(room) = client.get_joined_room(&room_id) {
|
|
room.redact(&event_id, None, None).await.is_ok()
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
pub async fn create_matrix_client(
|
|
homeserver_url: String,
|
|
username: String,
|
|
password: String,
|
|
message_tx: mpsc::UnboundedSender<MessageEvent>,
|
|
) -> Client {
|
|
let client_config = ClientConfig::new().store_path("./data/matrix_state");
|
|
|
|
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();
|
|
|
|
info!("Matrix logging in…");
|
|
client
|
|
.login(&username, &password, None, Some("phoebe"))
|
|
.await
|
|
.expect("Failed to log in");
|
|
|
|
info!("Matrix starting…");
|
|
client.sync_once(SyncSettings::default()).await.unwrap();
|
|
|
|
let event_handler = Arc::new(MatrixHandler { message_tx });
|
|
|
|
let on_msg_ctx = event_handler.clone();
|
|
client
|
|
.register_event_handler(move |ev, room| on_room_message_event(on_msg_ctx.clone(), ev, room))
|
|
.await;
|
|
|
|
let on_redact_ctx = event_handler.clone();
|
|
client
|
|
.register_event_handler(move |ev, room| on_redact_event(on_redact_ctx.clone(), ev, room))
|
|
.await;
|
|
|
|
client
|
|
}
|