- 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>
431 lines
15 KiB
Rust
431 lines
15 KiB
Rust
//! 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());
|
|
}
|
|
}
|