127 lines
4 KiB
Rust
127 lines
4 KiB
Rust
use std::env;
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use serenity::futures::stream::{SplitSink, SplitStream};
|
|
use serenity::futures::{StreamExt, TryFutureExt};
|
|
use serenity::http::{Http, StatusCode};
|
|
use serenity::model::prelude::*;
|
|
use serenity::prelude::*;
|
|
use serenity::{async_trait, futures::SinkExt};
|
|
use tokio::net::{TcpListener, TcpStream};
|
|
use tokio_tungstenite::tungstenite::handshake::server::{ErrorResponse, Request, Response};
|
|
use tokio_tungstenite::tungstenite::Message as WsMessage;
|
|
use tokio_tungstenite::WebSocketStream;
|
|
|
|
#[derive(Serialize, Deserialize, Clone, Debug)]
|
|
struct ChatMessage {
|
|
user: String,
|
|
user_id: String,
|
|
message: String,
|
|
}
|
|
|
|
impl From<Message> for ChatMessage {
|
|
fn from(value: Message) -> Self {
|
|
Self {
|
|
user: value
|
|
.member
|
|
.and_then(|member| member.nick)
|
|
.unwrap_or(value.author.name),
|
|
user_id: value.author.id.to_string(),
|
|
message: value.content,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Handler(
|
|
Mutex<SplitSink<WebSocketStream<TcpStream>, WsMessage>>,
|
|
ChannelId,
|
|
);
|
|
|
|
#[async_trait]
|
|
impl EventHandler for Handler {
|
|
async fn message(&self, _ctx: Context, new_message: Message) {
|
|
if new_message.webhook_id.is_some() {
|
|
return;
|
|
}
|
|
if new_message.author.bot {
|
|
return;
|
|
}
|
|
if new_message.channel_id != self.1 {
|
|
return;
|
|
}
|
|
self.0
|
|
.lock()
|
|
.await
|
|
.send(WsMessage::Text(
|
|
serde_json::to_string::<ChatMessage>(&new_message.into()).unwrap(),
|
|
))
|
|
.await
|
|
.unwrap();
|
|
}
|
|
}
|
|
|
|
async fn handle_recv(
|
|
mut recv: SplitStream<WebSocketStream<TcpStream>>,
|
|
http: Http,
|
|
webhook: Webhook,
|
|
) -> anyhow::Result<()> {
|
|
while let Some(msg) = recv.next().await {
|
|
if let WsMessage::Text(content) = msg? {
|
|
let message: ChatMessage = serde_json::from_str(&content)?;
|
|
webhook
|
|
.execute(&http, false, |w| {
|
|
w.content(message.message)
|
|
.username(message.user)
|
|
.avatar_url(format!(
|
|
"https://minotar.net/helm/{}/256.png",
|
|
message.user_id
|
|
))
|
|
})
|
|
.await?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> anyhow::Result<()> {
|
|
let http = Http::new("");
|
|
let webhook = Webhook::from_url(&http, &env::var("WEBHOOK_URL").expect("webhook url")).await?;
|
|
let auth_token = env::var("AUTH_TOKEN").expect("auth token");
|
|
|
|
let channel_id = env::var("CHANNEL_ID").expect("channel id").parse()?;
|
|
|
|
let listener = TcpListener::bind(env::var("BIND_ADDR").expect("bind address")).await?;
|
|
let (stream, _) = listener.accept().await?;
|
|
let (send, recv) =
|
|
tokio_tungstenite::accept_hdr_async(stream, |req: &Request, resp: Response| {
|
|
if let Some(header) = req.headers().get("X-Token") {
|
|
if header.as_bytes() == auth_token.as_bytes() {
|
|
Ok(resp)
|
|
} else {
|
|
let mut resp = ErrorResponse::new(None);
|
|
*resp.status_mut() = StatusCode::UNAUTHORIZED;
|
|
Err(resp)
|
|
}
|
|
} else {
|
|
let mut resp = ErrorResponse::new(None);
|
|
*resp.status_mut() = StatusCode::UNAUTHORIZED;
|
|
Err(resp)
|
|
}
|
|
})
|
|
.await?
|
|
.split();
|
|
// Login with a bot token from the environment
|
|
let token = env::var("DISCORD_TOKEN").expect("token");
|
|
let intents = GatewayIntents::non_privileged() | GatewayIntents::MESSAGE_CONTENT;
|
|
let mut client = Client::builder(token, intents)
|
|
.event_handler(Handler(Mutex::new(send), channel_id))
|
|
.await?;
|
|
|
|
// start listening for events by starting a single shard
|
|
tokio::try_join!(
|
|
client.start().map_err(|e| e.into()),
|
|
handle_recv(recv, http, webhook)
|
|
)?;
|
|
Ok(())
|
|
}
|