74 lines
2.0 KiB
Rust
74 lines
2.0 KiB
Rust
use log::info;
|
|
use serenity::{async_trait, model::prelude::*, prelude::*};
|
|
use tokio::sync::mpsc;
|
|
|
|
use crate::{
|
|
message_ast,
|
|
messages::{MessageAuthor, MessageReference, SentMessage},
|
|
};
|
|
|
|
pub use serenity::client::Context;
|
|
|
|
impl From<&Message> for MessageReference {
|
|
fn from(message: &Message) -> Self {
|
|
Self::Discord(message.channel_id.0, message.id.0)
|
|
}
|
|
}
|
|
|
|
// TODO: Some way to emit messages for matrix,
|
|
// and some way to receive messages from matrix.
|
|
struct DiscordHandler {
|
|
ctx_tx: mpsc::UnboundedSender<Context>,
|
|
message_tx: mpsc::UnboundedSender<SentMessage>,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl EventHandler for DiscordHandler {
|
|
async fn ready(&self, ctx: Context, _ready: Ready) {
|
|
let _ = self.ctx_tx.send(ctx);
|
|
info!("Discord ready!");
|
|
|
|
// TODO: Scan for channels to link
|
|
}
|
|
|
|
async fn message(&self, ctx: Context, message: Message) {
|
|
if message.author.id == ctx.cache.current_user_id().await {
|
|
return;
|
|
}
|
|
|
|
let message_ref = MessageReference::from(&message);
|
|
// TODO: Store this message ref & associations in the DB
|
|
|
|
let content = discord_message_format::parse(&message.content);
|
|
let content = message_ast::convert_discord(&content);
|
|
|
|
let _ = self.message_tx.send(SentMessage {
|
|
source: message_ref,
|
|
content,
|
|
author: MessageAuthor {
|
|
display_name: message
|
|
.author_nick(&ctx.http)
|
|
.await
|
|
.unwrap_or(message.author.name),
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
pub async fn create_discord_client(
|
|
ctx_tx: mpsc::UnboundedSender<Context>,
|
|
message_tx: mpsc::UnboundedSender<SentMessage>,
|
|
token: &str,
|
|
) -> Client {
|
|
let handler = DiscordHandler { ctx_tx, message_tx };
|
|
|
|
info!("Discord logging in…");
|
|
let client = Client::builder(token)
|
|
.event_handler(handler)
|
|
.await
|
|
.expect("Failed to create discord client");
|
|
info!("Discord starting…");
|
|
|
|
client
|
|
}
|