Files
call-recorder/src-tauri/src/backend.rs
T
haukeandClaude Opus 5.5 d0ece263a2 feat #14740: release builds use the production backend
Release builds talk to https://backend.euvinopro.eu, debug builds keep
https://test.euvinopro.eu. A key bound to the test backend is discarded
in a release build (fresh login).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-09 10:51:09 +01:00

522 lines
19 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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, State, Url, WebviewUrl, WebviewWindow, WebviewWindowBuilder,
WindowEvent,
};
use tauri_plugin_opener::OpenerExt;
use tokio::sync::oneshot;
use crate::processing;
use crate::state::AppState;
// The backend this build talks to: the one place to change it. It is not a
// setting; a key created on one backend is never sent to another.
/// Release builds: the production euvino admin backend.
pub(crate) const RELEASE_BACKEND_URL: &str = "https://backend.euvinopro.eu";
/// Debug builds (`cargo tauri dev`) always use the test backend, never the
/// production one. `pub(crate)`: `state.rs` tests the exact test-backend →
/// release-backend transition against this value (a key bound to one must
/// never work for the other).
pub(crate) const DEV_BACKEND_URL: &str = "https://test.euvinopro.eu";
/// The backend of this build (no trailing slash).
pub const BACKEND_URL: &str = if cfg!(debug_assertions) {
DEV_BACKEND_URL
} else {
RELEASE_BACKEND_URL
};
/// 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_server`: the backend of this build.
#[derive(Serialize, Clone, Debug, PartialEq)]
pub struct BackendServer {
pub base_url: String,
/// Where the admin manages their keys.
pub keys_url: String,
}
/// 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,
}
/// Payload of `backend-login-error`: creating the key failed, the login
/// window stays open for another try.
#[derive(Serialize, Clone)]
struct LoginError {
message: String,
}
/// The backend this build talks to, for the settings (no network).
#[tauri::command]
pub fn backend_server(state: State<'_, AppState>) -> BackendServer {
BackendServer {
base_url: state.backend_url().to_string(),
keys_url: state.backend_client().keys_page_url(),
}
}
/// Whether a backend key is stored, and whose it is: checked with the
/// backend. A key the backend refuses, or one of another backend, 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,
};
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");
let refused = stored.key;
blocking(&app, move |state| {
state.discard_refused_backend_key(&refused)
})
.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.
/// One upload per call at a time; `call-updated` tells the views when it
/// starts and ends.
#[tauri::command]
pub async fn upload_transcript(app: AppHandle, id: CallId) -> CmdResult<()> {
let state = app.state::<AppState>();
let claim = state.claim_upload(id)?;
processing::emit_updated(&app, id);
let result = upload(&app, &state, id).await;
drop(claim);
processing::emit_updated(&app, id);
result
}
async fn upload(app: &AppHandle, state: &AppState, id: CallId) -> CmdResult<()> {
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})");
if let Err(e) = state.mark_uploaded(id, &crm_id) {
// The CRM already has it: a retry must never send it again, even
// though the row itself still shows no crm_transcript_id.
state.note_upload_confirmed_but_unsaved(id);
log::error!("call {id}: uploaded (CRM id {crm_id}) but could not save locally: {e}");
return Err(unsaved_upload_message(&crm_id, &e));
}
Ok(())
}
/// Message for an upload that reached the CRM (`crm_id`) but whose local
/// record (`mark_uploaded`) failed with `e`: names the CRM id so the user
/// can find it there, and says plainly not to upload the call again (the
/// app also refuses on its own, see `AppState::note_upload_confirmed_but_unsaved`).
fn unsaved_upload_message(crm_id: &str, e: &str) -> String {
format!("Hochgeladen (ID {crm_id}), aber lokal nicht gespeichert: {e} – nicht erneut hochladen")
}
/// [`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, refused: &str) {
let refused = refused.to_string();
match blocking(&self.app, move |state| {
state.discard_refused_backend_key(&refused)
})
.await
{
Ok(true) => {
log::info!("backend: the key was refused, discarded it");
emit_changed(&self.app);
}
Ok(false) => log::info!("backend: the refused key was already replaced"),
Err(e) => log::error!("backend: {e}"),
}
}
}
/// 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 message = format!("{message} – bitte die Seite im Anmeldefenster neu laden");
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, base_url) = (key.clone(), client.base_url().to_string());
blocking(app, move |state| {
state.store_backend_key(&key, &base_url, 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 backend_urls_have_no_trailing_slash_and_use_https() {
for url in [RELEASE_BACKEND_URL, DEV_BACKEND_URL] {
assert!(!url.ends_with('/'), "{url}");
assert!(url.starts_with("https://"), "{url}");
}
// Release and dev talk to different backends: a key from one must
// never be usable on the other (see AppState::backend_key).
assert_ne!(RELEASE_BACKEND_URL, DEV_BACKEND_URL);
}
#[test]
fn the_unsaved_upload_message_names_the_crm_id_and_warns_against_retrying() {
assert_eq!(
unsaved_upload_message("4711", "disk full"),
"Hochgeladen (ID 4711), aber lokal nicht gespeichert: disk full – nicht erneut hochladen"
);
}
#[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());
}
}