VNOX-Client/src/ui/webhooks.rs
2026-10-24 16:51:15 +02:00

287 lines
10 KiB
Rust

//! Native, authenticated channel integration management. Credentials are never persisted.
use crate::ui::{
i18n,
slint::{MainWindow, Theme, WebhookRow, WebhookWindow},
};
use slint::{ComponentHandle, ModelRc, VecModel};
use std::{
cell::RefCell,
rc::Rc,
time::{Duration, Instant},
};
use vnox_client::{
net::{NetCommand, wire::WebhookInfo},
webhooks::{Controller, Error, Form, Kind, Scope},
};
type Send = Rc<dyn Fn(NetCommand)>;
/// Keep this bridge alive for the lifetime of the application. The caller feeds correlated network responses.
pub struct WebhookUi {
window: WebhookWindow,
controller: Rc<RefCell<Controller>>,
send: Send,
_timer: slint::Timer,
}
impl WebhookUi {
pub fn new(send: Send) -> Result<Self, slint::PlatformError> {
let window = WebhookWindow::new()?;
let controller = Rc::new(RefCell::new(Controller::default()));
for action in [0, 1, 2] {
let weak = window.as_weak();
let model = controller.clone();
let send = send.clone();
let callback = move || {
if let Some(window) = weak.upgrade() {
let result = match action {
0 => model.borrow_mut().refresh(),
1 => {
let kind = Kind::from_index(window.get_new_kind());
if let Some(kind) = kind {
model.borrow_mut().create(Form {
name: window.get_new_name().to_string(),
kind,
endpoint: window.get_new_endpoint().to_string(),
})
} else {
model.borrow_mut().show_error(Error::RequestFailed);
Err(Error::RequestFailed)
}
}
_ => model.borrow_mut().confirm(),
};
if let Ok(command) = result {
send(command)
}
render(&window, &model.borrow());
}
};
match action {
0 => window.on_refresh(callback),
1 => window.on_create(callback),
_ => window.on_confirm(callback),
}
}
for revoke in [false, true] {
let weak = window.as_weak();
let model = controller.clone();
let callback = move |id: slint::SharedString| {
if let Some(window) = weak.upgrade() {
let _ = if revoke {
model.borrow_mut().ask_revoke(&id)
} else {
model.borrow_mut().ask_rotate(&id)
};
render(&window, &model.borrow());
}
};
if revoke {
window.on_revoke(callback)
} else {
window.on_rotate(callback)
}
}
{
let weak = window.as_weak();
let model = controller.clone();
window.on_hide_secret(move || {
model.borrow_mut().hide_secret();
if let Some(window) = weak.upgrade() {
render(&window, &model.borrow())
}
});
}
{
let weak = window.as_weak();
let model = controller.clone();
window.on_cancel_confirmation(move || {
model.borrow_mut().cancel_confirmation();
if let Some(window) = weak.upgrade() {
render(&window, &model.borrow())
}
});
}
{
let weak = window.as_weak();
let model = controller.clone();
window.on_dismiss(move || {
model.borrow_mut().close();
if let Some(window) = weak.upgrade() {
render(&window, &model.borrow());
let _ = window.hide();
}
});
}
{
let weak = window.as_weak();
let model = controller.clone();
window.window().on_close_requested(move || {
model.borrow_mut().close();
if let Some(window) = weak.upgrade() {
render(&window, &model.borrow())
}
slint::CloseRequestResponse::HideWindow
});
}
let timer = slint::Timer::default();
{
let weak = window.as_weak();
let model = controller.clone();
timer.start(
slint::TimerMode::Repeated,
Duration::from_millis(250),
move || {
if model.borrow_mut().expire(Instant::now())
&& let Some(window) = weak.upgrade()
{
render(&window, &model.borrow());
}
},
);
}
Ok(Self {
window,
controller,
send,
_timer: timer,
})
}
pub fn open(
&self,
main: &MainWindow,
scope: Scope,
connected: bool,
) -> Result<(), slint::PlatformError> {
sync_palette(main, &self.window);
self.window.set_new_name("".into());
self.window.set_new_endpoint("".into());
self.window.set_new_kind(0);
if let Ok(command) = self.controller.borrow_mut().open(scope, connected) {
(self.send)(command)
}
render(&self.window, &self.controller.borrow());
self.window.show()
}
pub fn receive_list(&self, request_id: &str, hooks: Vec<WebhookInfo>) {
if self.controller.borrow_mut().receive_list(request_id, hooks) {
render(&self.window, &self.controller.borrow())
}
}
pub fn receive_result(&self, request_id: &str, hook: Option<WebhookInfo>, secret: String) {
if self
.controller
.borrow_mut()
.receive_result(request_id, hook, secret)
{
self.window.set_new_name("".into());
self.window.set_new_endpoint("".into());
render(&self.window, &self.controller.borrow())
}
}
pub fn receive_error(&self, request_id: &str, code: u32) {
if self.controller.borrow_mut().receive_error(request_id, code) {
render(&self.window, &self.controller.borrow())
}
}
pub fn disconnected(&self) {
self.controller.borrow_mut().disconnected();
render(&self.window, &self.controller.borrow())
}
}
fn render(window: &WebhookWindow, controller: &Controller) {
window.set_channel_name(
controller
.scope()
.map(|s| format!("# {}", s.channel_name))
.unwrap_or_default()
.into(),
);
window.set_allowed(controller.allowed());
window.set_busy(controller.busy());
window.set_error(
controller
.error()
.map(|e| i18n::text(e.message()))
.unwrap_or_default()
.into(),
);
window.set_secret(controller.secret().into());
window.set_secret_name(
controller
.secret_hook()
.map(|h| h.name.as_str())
.unwrap_or_default()
.into(),
);
window.set_secret_outgoing(
controller
.secret_hook()
.is_some_and(|h| h.direction == "outgoing"),
);
window.set_secret_path(
controller
.secret_hook()
.filter(|h| h.direction == "incoming")
.map(|h| format!("POST /v1/webhooks/{}", h.id))
.unwrap_or_default()
.into(),
);
let confirmation = controller.confirmation();
window.set_confirming(confirmation.is_some());
window.set_confirming_revoke(confirmation.is_some_and(|(revoke, _)| revoke));
window.set_confirmation_name(
confirmation
.and_then(|(_, id)| controller.hooks().iter().find(|h| h.id == id))
.map(|h| h.name.as_str())
.unwrap_or_default()
.into(),
);
let rows = controller
.hooks()
.iter()
.map(|h| {
let mode = i18n::text(if h.direction == "outgoing" {
"Outgoing events"
} else if h.provider == "github" {
"GitHub updates"
} else {
"Incoming message"
});
let paused = !h.suspended_reason.is_empty();
let detail = if paused {
i18n::text("Paused: delivery queue full. Rotate the secret to resume.")
} else if h.direction == "outgoing" {
format!("{mode} · {}", h.endpoint)
} else {
mode
};
WebhookRow {
id: h.id.as_str().into(),
name: h.name.as_str().into(),
detail: detail.into(),
paused,
}
})
.collect::<Vec<_>>();
window.set_hooks(ModelRc::from(Rc::new(VecModel::from(rows))));
}
fn sync_palette(main: &MainWindow, dialog: &WebhookWindow) {
let source = main.global::<Theme>();
let target = dialog.global::<Theme>();
target.set_bg_base(source.get_bg_base());
target.set_bg_surface(source.get_bg_surface());
target.set_bg_rail(source.get_bg_rail());
target.set_bg_hover(source.get_bg_hover());
target.set_bg_interactive(source.get_bg_interactive());
target.set_bg_elevated(source.get_bg_elevated());
target.set_selected(source.get_selected());
target.set_border(source.get_border());
target.set_accent(source.get_accent());
target.set_text_primary(source.get_text_primary());
target.set_text_secondary(source.get_text_secondary());
target.set_text_muted(source.get_text_muted());
target.set_text_disabled(source.get_text_disabled());
target.set_danger(source.get_danger());
target.set_success(source.get_success());
target.set_font_size(source.get_font_size());
target.set_on_accent(source.get_on_accent());
}