Skip to main content

kovi_plugin_webhooker/
lib.rs

1mod config;
2mod consts;
3
4use std::collections::HashMap;
5
6use anyhow::Context;
7use axum::{
8    Json, Router, http::StatusCode, response::IntoResponse, routing::post,
9};
10use axum_auth::AuthBearer;
11use json_dotpath::DotPaths;
12use kovi::{
13    PluginBuilder as plugin, log::{error, info, warn}, serde_json::Value, tokio,
14};
15use kovi_onebot::*;
16
17use consts::*;
18use strfmt::strfmt;
19
20use crate::config::CONFIG;
21
22#[kovi::plugin]
23async fn main() {
24    let bot = plugin::get_runtime_bot();
25    let config = config::init(&bot)
26        .await
27        .with_context(|| format!("[{PLUGIN_HEAD}] Error when parsing config"))
28        .unwrap();
29
30    if let Some(webhooks) = &config.webhooks {
31        let mut router: Router<()> = Router::new();
32        let webhooks = webhooks.clone();
33        for w in webhooks {
34            let bot = bot.clone();
35            let endpoint = w.endpoint.clone();
36            router = router.clone().route(
37                &endpoint,
38                post(async move |AuthBearer(token): AuthBearer, Json(payload): Json<Value>| {
39                    
40                    if let Some(auth) = CONFIG.get().unwrap().auth.clone() && auth != token {
41                        warn!("[{PLUGIN_HEAD}] Auth failed triggered by {}", w.endpoint);
42                        return (StatusCode::UNAUTHORIZED, "Token validation failed").into_response()
43                    }
44
45                    let mut map: HashMap<String, String> = HashMap::new();
46                    if let Some(vars) = w.values {
47                        for var in vars {
48                            let value = payload.dot_get::<Value>(&var.dotpath);
49                            if let Err(e) = value {
50                                error!(
51                                    "[{PLUGIN_HEAD}] Extract value from dotpath '{}' failed: {e} ",
52                                    var.dotpath
53                                );
54                                return StatusCode::OK.into_response();
55                            }
56                            let value = value.unwrap().map_or("".to_string(), |v| match v {
57                                Value::String(s) => s,
58                                _ => v.to_string(),
59                            });
60                            info!(
61                                "[{PLUGIN_HEAD}] Extract value from dotpath '{}' = {value}",
62                                var.dotpath
63                            );
64                            map.insert(var.name, value);
65                        }
66                    }
67
68                    let msg = strfmt(&w.message, &map);
69                    if let Err(e) = msg {
70                        error!("[{PLUGIN_HEAD}] Error when formatting message: {e}");
71                        return StatusCode::OK.into_response();
72                    }
73                    let msg = msg.unwrap();
74
75                    let bot = bot.clone();
76                    if let Some(groups) = &w.groups {
77                        for group in groups {
78                            bot.send_group_msg(group.try_as_i64_or_panic(), &msg);
79                        }
80                    }
81
82                    if let Some(users) = &w.users {
83                        for user in users {
84                            bot.send_private_msg(user.try_as_i64_or_panic(), &msg);
85                        }
86                    }
87                    info!("[{PLUGIN_HEAD}] Message sent!");
88                    StatusCode::OK.into_response()
89                }),
90            );
91        }
92        let app = Router::new().nest("/webhook", router);
93        let listener = tokio::net::TcpListener::bind(format!("{}:{}", config.listen, config.port))
94            .await
95            .unwrap();
96        kovi::spawn(async {
97            axum::serve(listener, app).await.unwrap();
98        });
99    } else {
100        bot.set_plugin_access_control(PLUGIN_NAME, false).unwrap();
101    }
102
103    info!("[webhooker] Ready to relay!");
104}