287 lines
10 KiB
Rust
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());
|
|
}
|