feat #14740: link to the euvino admin backend
- Settings section "Backend": backend URL, login status checked live (logged in as / until, not logged in, backend unreachable), Anmelden / Neu anmelden, Abmelden and the link to the key management page - login window "backend-login": the backend's own login page in an incognito webview without any Tauri capability; after a page load behind the login, its cookies create a key (one request, never stored or logged), the key goes to the keyring, the window closes; closing it cancels; one login at a time, later requests wait for the same result - call detail: "Transkript hochladen" / "Erneut hochladen" (with a confirmation), "wird hochgeladen…", "Hochgeladen am … (ID …)" and inline errors; logs in first when there is no usable key - saving a different backend URL discards the key of the old backend Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,430 @@
|
||||
//! Link to the euvino admin backend: the login window that turns the
|
||||
//! admin's browser session into an API key, the login status for the
|
||||
//! settings, and the upload of a call's transcript.
|
||||
//!
|
||||
//! The login window shows the backend's own login page, a remote origin: it
|
||||
//! has no Tauri capability (see `capabilities/default.json`), so the page
|
||||
//! cannot invoke any command. It runs in incognito mode, so the session
|
||||
//! never outlives the window. After each page load on the backend the app
|
||||
//! reads the window's cookies for the backend and uses them for the one
|
||||
//! request that creates a key. Neither the cookies nor the key are ever
|
||||
//! logged; the key is stored only in the keyring.
|
||||
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::Mutex;
|
||||
|
||||
use async_trait::async_trait;
|
||||
use chrono::{DateTime, Local};
|
||||
use recorder_core::backend::{self, BackendClient, KeyCheck, Login, LoginStep, NewKey};
|
||||
use recorder_core::model::CallId;
|
||||
use serde::Serialize;
|
||||
use tauri::webview::PageLoadEvent;
|
||||
use tauri::{
|
||||
AppHandle, Emitter, Manager, Url, WebviewUrl, WebviewWindow, WebviewWindowBuilder, WindowEvent,
|
||||
};
|
||||
use tauri_plugin_opener::OpenerExt;
|
||||
use tokio::sync::oneshot;
|
||||
|
||||
use crate::processing;
|
||||
use crate::state::AppState;
|
||||
|
||||
/// Label of the login window.
|
||||
pub const LOGIN_WINDOW: &str = "backend-login";
|
||||
const CANCELLED: &str = "Anmeldung abgebrochen";
|
||||
|
||||
type CmdResult<T> = Result<T, String>;
|
||||
/// A login's outcome: the new key, or the message why there is none.
|
||||
type LoginResult = Result<String, String>;
|
||||
|
||||
/// Everyone waiting for the login that runs in the login window. Only one
|
||||
/// login runs at a time; later requests wait for the same result.
|
||||
#[derive(Default)]
|
||||
pub struct LoginWaiters {
|
||||
waiters: Mutex<Vec<oneshot::Sender<LoginResult>>>,
|
||||
/// Set while a key is being created, so page loads in quick succession
|
||||
/// do not create several.
|
||||
creating: AtomicBool,
|
||||
}
|
||||
|
||||
impl LoginWaiters {
|
||||
/// Waits for the login. `true` if no login was running yet, so the
|
||||
/// caller has to start one.
|
||||
fn join(&self) -> (oneshot::Receiver<LoginResult>, bool) {
|
||||
let (tx, rx) = oneshot::channel();
|
||||
let mut waiters = lock(&self.waiters);
|
||||
let first = waiters.is_empty();
|
||||
waiters.push(tx);
|
||||
(rx, first)
|
||||
}
|
||||
|
||||
/// Whether anyone waits for a login.
|
||||
fn waiting(&self) -> bool {
|
||||
!lock(&self.waiters).is_empty()
|
||||
}
|
||||
|
||||
/// Ends the login with `result` for everyone waiting.
|
||||
fn finish(&self, result: LoginResult) {
|
||||
for waiter in lock(&self.waiters).drain(..) {
|
||||
let _ = waiter.send(result.clone());
|
||||
}
|
||||
}
|
||||
|
||||
/// Claims the right to create a key; `None` while another page load
|
||||
/// is already creating one.
|
||||
fn claim_creating(&self) -> Option<CreatingClaim<'_>> {
|
||||
(!self.creating.swap(true, Ordering::SeqCst)).then_some(CreatingClaim(&self.creating))
|
||||
}
|
||||
}
|
||||
|
||||
/// Releases [`LoginWaiters::creating`] when dropped.
|
||||
struct CreatingClaim<'a>(&'a AtomicBool);
|
||||
|
||||
impl Drop for CreatingClaim<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.store(false, Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
|
||||
/// Answer of `backend_status`.
|
||||
#[derive(Serialize, Clone, Debug, PartialEq)]
|
||||
pub struct BackendStatus {
|
||||
pub logged_in: bool,
|
||||
pub username: Option<String>,
|
||||
pub expires_at: Option<DateTime<Local>>,
|
||||
/// `false` if the stored key could not be checked; username and expiry
|
||||
/// are then the stored ones.
|
||||
pub reachable: bool,
|
||||
/// Where the admin manages their keys.
|
||||
pub keys_url: String,
|
||||
}
|
||||
|
||||
/// Payload of `backend-login-error`: creating the key failed, the login
|
||||
/// window stays open for another try.
|
||||
#[derive(Serialize, Clone)]
|
||||
struct LoginError {
|
||||
message: String,
|
||||
}
|
||||
|
||||
/// Whether a backend key is stored, and whose it is: checked with the
|
||||
/// backend. A key the backend refuses is discarded.
|
||||
#[tauri::command]
|
||||
pub async fn backend_status(app: AppHandle) -> CmdResult<BackendStatus> {
|
||||
let state = app.state::<AppState>();
|
||||
let client = state.backend_client();
|
||||
let stored = blocking(&app, |state| Ok(state.backend_key())).await?;
|
||||
let mut status = BackendStatus {
|
||||
logged_in: false,
|
||||
username: None,
|
||||
expires_at: None,
|
||||
reachable: true,
|
||||
keys_url: client.keys_page_url(),
|
||||
};
|
||||
let Some(stored) = stored else {
|
||||
return Ok(status);
|
||||
};
|
||||
match client.check_key(&stored.key).await {
|
||||
KeyCheck::Valid(info) => {
|
||||
state.refresh_backend_login(&info)?;
|
||||
status.logged_in = true;
|
||||
status.username = Some(info.username);
|
||||
status.expires_at = Some(info.expires_at);
|
||||
}
|
||||
KeyCheck::Invalid => {
|
||||
log::info!("backend: the stored key was refused, discarding it");
|
||||
blocking(&app, |state| state.discard_backend_key()).await?;
|
||||
}
|
||||
KeyCheck::Unknown(e) => {
|
||||
log::info!(
|
||||
"backend: could not check the stored key: {}",
|
||||
e.user_message()
|
||||
);
|
||||
let settings = state.settings();
|
||||
status.logged_in = true;
|
||||
status.username = settings.backend_username;
|
||||
status.expires_at = settings.backend_key_expires_at;
|
||||
status.reachable = false;
|
||||
}
|
||||
}
|
||||
Ok(status)
|
||||
}
|
||||
|
||||
/// "Anmelden": runs the login in the login window (a new key replaces the
|
||||
/// stored one).
|
||||
#[tauri::command]
|
||||
pub async fn backend_login(app: AppHandle) -> CmdResult<()> {
|
||||
login(&app).await.map(|_key| ())
|
||||
}
|
||||
|
||||
/// "Abmelden": forgets the key locally (it stays valid on the server until
|
||||
/// the admin deletes it there or it expires).
|
||||
#[tauri::command]
|
||||
pub async fn backend_logout(app: AppHandle) -> CmdResult<()> {
|
||||
blocking(&app, |state| state.discard_backend_key()).await?;
|
||||
emit_changed(&app);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Opens the backend's key management page in the system browser.
|
||||
#[tauri::command]
|
||||
pub fn open_backend_keys_page(app: AppHandle) -> CmdResult<()> {
|
||||
let url = app.state::<AppState>().backend_client().keys_page_url();
|
||||
app.opener()
|
||||
.open_url(url, None::<&str>)
|
||||
.map_err(|e| format!("Browser konnte nicht geöffnet werden: {e}"))
|
||||
}
|
||||
|
||||
/// "Transkript hochladen": uploads the call's transcript as the user sees
|
||||
/// it, logging in first if needed, and records the CRM's id on the call.
|
||||
#[tauri::command]
|
||||
pub async fn upload_transcript(app: AppHandle, id: CallId) -> CmdResult<()> {
|
||||
let state = app.state::<AppState>();
|
||||
let detail = state.call_detail(id)?;
|
||||
if detail.call.transcribed_at.is_none() {
|
||||
return Err("Das Gespräch ist noch nicht transkribiert".to_string());
|
||||
}
|
||||
let text = detail.upload_text()?;
|
||||
let client = state.backend_client();
|
||||
let stored = blocking(&app, |state| Ok(state.backend_key())).await?;
|
||||
let login = AppLogin { app: app.clone() };
|
||||
let crm_id = backend::upload_with_login(&client, &login, stored, Local::now(), &text)
|
||||
.await
|
||||
.inspect_err(|e| log::warn!("call {id}: upload failed: {e}"))?;
|
||||
log::info!("call {id}: transcript uploaded (CRM id {crm_id})");
|
||||
state.mark_uploaded(id, &crm_id)?;
|
||||
processing::emit_updated(&app, id);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// [`Login`] through the login window, for the upload.
|
||||
struct AppLogin {
|
||||
app: AppHandle,
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl Login for AppLogin {
|
||||
async fn login(&self) -> Result<String, String> {
|
||||
login(&self.app).await
|
||||
}
|
||||
|
||||
async fn discard_key(&self) {
|
||||
log::info!("backend: the key was refused, discarding it");
|
||||
if let Err(e) = blocking(&self.app, |state| state.discard_backend_key()).await {
|
||||
log::error!("backend: {e}");
|
||||
}
|
||||
emit_changed(&self.app);
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs the login in the login window, or waits for the one already
|
||||
/// running (and brings its window to the front). Returns the new key,
|
||||
/// already stored.
|
||||
pub async fn login(app: &AppHandle) -> LoginResult {
|
||||
let waiters = app.state::<LoginWaiters>();
|
||||
let (result, first) = waiters.join();
|
||||
match app.get_webview_window(LOGIN_WINDOW) {
|
||||
Some(window) => {
|
||||
let _ = window.unminimize();
|
||||
let _ = window.set_focus();
|
||||
}
|
||||
None if first => {
|
||||
if let Err(e) = open_login_window(app) {
|
||||
log::error!("backend: could not open the login window: {e}");
|
||||
waiters.finish(Err(format!(
|
||||
"Anmeldefenster konnte nicht geöffnet werden: {e}"
|
||||
)));
|
||||
}
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
result.await.unwrap_or_else(|_| Err(CANCELLED.to_string()))
|
||||
}
|
||||
|
||||
fn open_login_window(app: &AppHandle) -> tauri::Result<()> {
|
||||
let client = app.state::<AppState>().backend_client();
|
||||
let url = Url::parse(&client.login_url()).map_err(tauri::Error::InvalidUrl)?;
|
||||
let window = WebviewWindowBuilder::new(app, LOGIN_WINDOW, WebviewUrl::External(url))
|
||||
.title("Anmeldung euvino Admin")
|
||||
.inner_size(1000.0, 760.0)
|
||||
.incognito(true)
|
||||
.on_page_load(move |window, payload| {
|
||||
if payload.event() == PageLoadEvent::Finished
|
||||
&& client.is_logged_in_page(payload.url().as_str())
|
||||
{
|
||||
create_key(window, client.clone());
|
||||
}
|
||||
})
|
||||
.build()?;
|
||||
let app = app.clone();
|
||||
window.on_window_event(move |event| {
|
||||
if let WindowEvent::Destroyed = event {
|
||||
// Closed by the user: the login is cancelled. After a
|
||||
// finished login nobody waits any more.
|
||||
app.state::<LoginWaiters>()
|
||||
.finish(Err(CANCELLED.to_string()));
|
||||
}
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The login window shows a backend page behind the login: creates a key
|
||||
/// with the window's session, in the background. `client` is the backend
|
||||
/// the window was opened for.
|
||||
fn create_key(window: WebviewWindow, client: BackendClient) {
|
||||
tauri::async_runtime::spawn(async move {
|
||||
let app = window.app_handle().clone();
|
||||
let waiters = app.state::<LoginWaiters>();
|
||||
if !waiters.waiting() {
|
||||
return;
|
||||
}
|
||||
let Some(_claim) = waiters.claim_creating() else {
|
||||
return;
|
||||
};
|
||||
match try_create_key(&client, &window).await {
|
||||
LoginStep::Done(key) => {
|
||||
let result = store_key(&app, &client, &key).await.map(|()| key.key);
|
||||
waiters.finish(result);
|
||||
emit_changed(&app);
|
||||
let _ = window.destroy();
|
||||
}
|
||||
LoginStep::Wait => {}
|
||||
LoginStep::Fail(message) => {
|
||||
log::warn!("backend: the login cannot create a key: {message}");
|
||||
waiters.finish(Err(message));
|
||||
let _ = window.destroy();
|
||||
}
|
||||
LoginStep::Retry(message) => {
|
||||
log::warn!("backend: creating the key failed: {message}");
|
||||
let _ = app.emit_to("main", "backend-login-error", LoginError { message });
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Creates a key with the cookies the login window holds for the backend.
|
||||
/// The cookies are used for this one request and dropped.
|
||||
async fn try_create_key(client: &BackendClient, window: &WebviewWindow) -> LoginStep {
|
||||
let Ok(url) = Url::parse(&client.keys_page_url()) else {
|
||||
return LoginStep::Wait;
|
||||
};
|
||||
// Off the async runtime: on Windows reading cookies blocks until the
|
||||
// main thread answers.
|
||||
let reader = window.clone();
|
||||
let cookies = tauri::async_runtime::spawn_blocking(move || reader.cookies_for_url(url)).await;
|
||||
let cookies = match cookies {
|
||||
Ok(Ok(cookies)) => cookies,
|
||||
Ok(Err(e)) => return LoginStep::Retry(format!("Anmeldedaten nicht lesbar: {e}")),
|
||||
Err(e) => return LoginStep::Retry(format!("Anmeldedaten nicht lesbar: {e}")),
|
||||
};
|
||||
if cookies.is_empty() {
|
||||
return LoginStep::Wait;
|
||||
}
|
||||
let cookie_header = cookies
|
||||
.iter()
|
||||
.map(|cookie| format!("{}={}", cookie.name(), cookie.value()))
|
||||
.collect::<Vec<_>>()
|
||||
.join("; ");
|
||||
let label = backend::key_label(hostname().as_deref());
|
||||
LoginStep::of(client.create_key(&cookie_header, &label).await)
|
||||
}
|
||||
|
||||
/// Stores a new key with whose it is (asked from the backend; left empty if
|
||||
/// that fails) and its expiry.
|
||||
async fn store_key(app: &AppHandle, client: &BackendClient, key: &NewKey) -> Result<(), String> {
|
||||
let username = match client.key_info(&key.key).await {
|
||||
Ok(info) => Some(info.username),
|
||||
Err(e) => {
|
||||
log::warn!(
|
||||
"backend: could not ask whose the new key is: {}",
|
||||
e.user_message()
|
||||
);
|
||||
None
|
||||
}
|
||||
};
|
||||
let key = key.clone();
|
||||
blocking(app, move |state| state.store_backend_key(&key, username)).await?;
|
||||
log::info!("backend: logged in, key stored");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The computer's name, for the key's label.
|
||||
fn hostname() -> Option<String> {
|
||||
std::env::var("COMPUTERNAME")
|
||||
.ok()
|
||||
.or_else(|| std::fs::read_to_string("/etc/hostname").ok())
|
||||
.or_else(|| std::env::var("HOSTNAME").ok())
|
||||
.map(|name| name.trim().to_string())
|
||||
.filter(|name| !name.is_empty())
|
||||
}
|
||||
|
||||
/// Tells the settings that the login changed (`backend-changed`).
|
||||
fn emit_changed(app: &AppHandle) {
|
||||
if let Err(e) = app.emit_to("main", "backend-changed", ()) {
|
||||
log::error!("could not emit backend-changed: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs `f` with the app state on the blocking pool (keyring access).
|
||||
async fn blocking<T, F>(app: &AppHandle, f: F) -> CmdResult<T>
|
||||
where
|
||||
T: Send + 'static,
|
||||
F: FnOnce(&AppState) -> CmdResult<T> + Send + 'static,
|
||||
{
|
||||
let app = app.clone();
|
||||
tauri::async_runtime::spawn_blocking(move || f(&app.state::<AppState>()))
|
||||
.await
|
||||
.map_err(|e| e.to_string())?
|
||||
}
|
||||
|
||||
fn lock<T>(mutex: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
|
||||
mutex
|
||||
.lock()
|
||||
.unwrap_or_else(|poisoned| poisoned.into_inner())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn everyone_waiting_gets_the_one_login_result() {
|
||||
let waiters = LoginWaiters::default();
|
||||
assert!(!waiters.waiting());
|
||||
|
||||
let (first, starts) = waiters.join();
|
||||
let (second, starts_again) = waiters.join();
|
||||
assert!(starts);
|
||||
assert!(!starts_again);
|
||||
assert!(waiters.waiting());
|
||||
|
||||
waiters.finish(Ok("euv_k".into()));
|
||||
|
||||
assert_eq!(first.blocking_recv().unwrap(), Ok("euv_k".to_string()));
|
||||
assert_eq!(second.blocking_recv().unwrap(), Ok("euv_k".to_string()));
|
||||
assert!(!waiters.waiting());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_finished_login_leaves_the_next_one_to_start_anew() {
|
||||
let waiters = LoginWaiters::default();
|
||||
let (first, _) = waiters.join();
|
||||
waiters.finish(Err(CANCELLED.into()));
|
||||
// A late "window destroyed" reaches nobody.
|
||||
waiters.finish(Err("ignored".into()));
|
||||
assert_eq!(first.blocking_recv().unwrap(), Err(CANCELLED.to_string()));
|
||||
|
||||
let (next, starts) = waiters.join();
|
||||
assert!(starts);
|
||||
waiters.finish(Ok("euv_new".into()));
|
||||
assert_eq!(next.blocking_recv().unwrap(), Ok("euv_new".to_string()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_one_key_is_created_at_a_time() {
|
||||
let waiters = LoginWaiters::default();
|
||||
let claim = waiters.claim_creating();
|
||||
assert!(claim.is_some());
|
||||
assert!(waiters.claim_creating().is_none());
|
||||
drop(claim);
|
||||
assert!(waiters.claim_creating().is_some());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user