25 Commits
Author SHA1 Message Date
hauke e4562e44df chore #14740: update feed 0.4.0 2026-11-18 11:48:47 +01:00
hauke 1d3e0add86 chore #14740: release 0.4.0 2026-11-18 11:48:39 +01:00
haukeandClaude Opus 5.5 24cebd7e71 fix #14740: language picker follows a language set elsewhere
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-18 11:44:28 +01:00
haukeandClaude Opus 5.5 9e53d0b390 feat #14740: language picker before transcribing
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-18 11:39:41 +01:00
haukeandClaude Opus 5.5 48000f47eb feat #14740: choose the language when starting a transcription
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-18 11:37:24 +01:00
haukeandClaude Opus 5.5 79e31d5331 feat #14740: allowed call languages and per-call corrections
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-18 11:34:32 +01:00
haukeandClaude Opus 5.5 20eb53af4b feat #14740: store the language per call
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-18 11:32:41 +01:00
hauke 6183feaf82 chore #14740: update feed 0.3.1 2026-11-10 14:23:50 +01:00
hauke f38550f3aa chore #14740: release 0.3.1 2026-11-10 14:23:42 +01:00
haukeandClaude Opus 5.5 ad73e901a0 fix #14740: re-check retention eligibility and validate retention_days
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-10 14:20:16 +01:00
haukeandClaude Opus 5.5 0b735b2e98 feat #14740: scheduled retention
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-10 14:10:36 +01:00
haukeandClaude Opus 5.5 9ded4f14d4 fix #14740: revoke the playback blob on a failed retry
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-10 14:10:36 +01:00
hauke 5751684ef8 chore #14740: update feed 0.3.0 2026-11-10 13:54:34 +01:00
hauke 6a14f50e4c chore #14740: release 0.3.0 2026-11-10 13:54:25 +01:00
haukeandClaude Opus 5.5 8c47388eee fix #14740: serve playback only to the main window
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-10 13:52:26 +01:00
haukeandClaude Opus 5.5 a74cfa5864 feat #14740: play back calls
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-10 13:37:47 +01:00
haukeandClaude Sonnet 5 8d757fd639 feat #14740: transcription model choice, vocabulary and short-word corrections
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-11-10 13:10:50 +01:00
hauke c57eb9511d chore #14740: update feed 0.2.4 2026-11-10 12:54:21 +01:00
hauke 7a45d20f46 chore #14740: release 0.2.4 2026-11-10 12:54:12 +01:00
haukeandClaude Opus 5.5 802a6f81fd fix #14740: compact open-count badge in the sidebar header
Review found two bugs in 0ae6ed3: the " · N offen" suffix lost its
leading space to Svelte's whitespace trimming, and the header wrapped
the record button + gear onto a second line whenever N > 0, at both
the ~288px default and the 260px sidebar floor.

Replaces the text suffix with a small rounded count badge (same blue
as the row dots) right after "Gespräche", with title/aria-label "N
offen", and tightens the header so it fits on one line even at the
260px floor with a two-digit count. Also gives the row dot a thin
white ring so it stays visible on the selected row's tinted
background.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-10 12:20:57 +01:00
haukeandClaude Opus 5.5 0ae6ed304f feat #14740: done only once uploaded
A done call only shows "fertig" once its transcript reached this
build's backend (uploaded_here); otherwise it's "bereit zum
Hochladen". The list row gets a blue dot for anything needing action
(ready to upload or not transcribed yet), and the sidebar header shows
"Gespräche · N offen".

Adds ListState/needs_action to CallListItem, computed in
recorder-core so the UI doesn't re-implement the rule.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-10 12:09:08 +01:00
hauke 183c135b1d chore #14740: update feed 0.2.3 2026-11-09 15:08:10 +01:00
hauke 299c93f8d6 chore #14740: release 0.2.3 2026-11-09 15:08:00 +01:00
haukeandClaude Opus 5.5 36cefaab5f feat #14740: delete transcribed calls
Transcribed (Done) calls get a "Löschen" button next to the upload
control, with a confirmation dialog in the app's style instead of
window.confirm. Deleting reuses discard_call (not a parallel path),
which now also refuses while the call's transcript is being uploaded,
consistent with the existing refusals for recording/processing/
CleanupPending.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-09 14:45:17 +01:00
hauke 697f13e13a chore #14740: update feed 0.2.2 2026-11-09 12:06:37 +01:00
34 changed files with 4068 additions and 109 deletions
Generated
+8 -1
View File
@@ -445,10 +445,11 @@ dependencies = [
[[package]]
name = "call-recorder"
version = "0.2.2"
version = "0.4.0"
dependencies = [
"async-trait",
"chrono",
"http-range",
"log",
"recorder-audio",
"recorder-core",
@@ -1803,6 +1804,12 @@ dependencies = [
"pin-project-lite",
]
[[package]]
name = "http-range"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2149c4b4b83390c71fab669730347d578ec6bdf759f2160c581ad8b8819733b4"
[[package]]
name = "httparse"
version = "1.10.1"
+352
View File
@@ -0,0 +1,352 @@
//! Mixes the two 16 kHz mono tracks of a call into one mono track for
//! playback.
//!
//! The tracks are summed at full level and passed through a soft clipper,
//! so a passage where only one side speaks keeps its original loudness
//! while both sides speaking loudly at once never wraps around or clips
//! hard. [`mix_wavs`] streams both files in chunks, so even a long call
//! never sits in memory.
use std::fs::{self, File};
use std::io::{self, BufReader, ErrorKind};
use std::path::Path;
use hound::{SampleFormat, WavReader, WavSpec, WavWriter};
use super::wav::SAMPLE_RATE;
/// Samples read per track and step in [`mix_wavs`] (about one second).
const CHUNK_SAMPLES: usize = 16_384;
/// Up to this level (half of full scale) the sum passes unchanged; above,
/// the soft clipper compresses it towards full scale.
const KNEE: f32 = 0.5;
/// The format of both tracks and of the mixed file.
fn spec() -> WavSpec {
WavSpec {
channels: 1,
sample_rate: SAMPLE_RATE,
bits_per_sample: 16,
sample_format: SampleFormat::Int,
}
}
/// Mixes `a` and `b` sample by sample and appends the result to `out`.
/// The output is as long as the longer input; the shorter one counts as
/// silence after its end. Never clips hard: see [`soft_clip`].
pub fn mix_samples(a: &[i16], b: &[i16], out: &mut Vec<i16>) {
let len = a.len().max(b.len());
out.reserve(len);
for i in 0..len {
let sum = to_f32(a.get(i).copied().unwrap_or(0)) + to_f32(b.get(i).copied().unwrap_or(0));
out.push(to_i16(soft_clip(sum)));
}
}
fn to_f32(sample: i16) -> f32 {
sample as f32 / i16::MAX as f32
}
fn to_i16(sample: f32) -> i16 {
(sample.clamp(-1.0, 1.0) * i16::MAX as f32).round() as i16
}
/// Linear up to [`KNEE`]; above, `tanh` bends the level smoothly (same
/// slope at the knee) towards, but never beyond, full scale.
fn soft_clip(x: f32) -> f32 {
let level = x.abs();
if level <= KNEE {
return x;
}
let room = 1.0 - KNEE;
x.signum() * (KNEE + room * ((level - KNEE) / room).tanh())
}
/// One source track; `None` if the file is missing or holds no audio.
type Track = Option<hound::WavIntoSamples<BufReader<File>, i16>>;
/// Whether the WAV at `path` holds audio to play: it is a 16 kHz mono
/// 16-bit PCM track whose header counts at least one sample. The one rule
/// both [`mix_wavs`] and the detail view's "audio available" go by.
pub fn has_audio(path: &Path) -> bool {
open_track(path).is_some()
}
/// Opens a track for [`mix_wavs`]; `None` unless it [has audio](has_audio).
/// Why an existing file is left out is logged.
fn open_track(path: &Path) -> Track {
if path.as_os_str().is_empty() {
return None;
}
let reader = match WavReader::open(path) {
Ok(reader) => reader,
Err(hound::Error::IoError(e)) if e.kind() == ErrorKind::NotFound => return None,
Err(e) => {
log::warn!("left out {}: {e}", path.display());
return None;
}
};
if reader.spec() != spec() {
log::warn!("left out {}: not 16 kHz mono 16-bit PCM", path.display());
return None;
}
if reader.len() == 0 {
return None;
}
Some(reader.into_samples())
}
/// Reads up to [`CHUNK_SAMPLES`] samples of `track` into `buf` (cleared
/// first).
fn read_chunk(track: &mut Track, buf: &mut Vec<i16>) -> io::Result<()> {
buf.clear();
let Some(samples) = track else {
return Ok(());
};
for sample in samples.take(CHUNK_SAMPLES) {
buf.push(sample.map_err(|e| io::Error::new(ErrorKind::InvalidData, e))?);
}
Ok(())
}
/// Mixes the WAV tracks at `a` and `b` (16 kHz mono 16-bit PCM, as written
/// by [`super::TrackWriter`]) into a new WAV at `dest` and returns its
/// length in samples. A track without audio ([`has_audio`]: missing,
/// empty or not in that format) is left out; with neither track holding
/// audio nothing is written and the error is [`ErrorKind::NotFound`].
///
/// Writes `dest` with a `.part` suffix first and renames it at the end, so
/// `dest` is never a half-written file.
pub fn mix_wavs(a: &Path, b: &Path, dest: &Path) -> io::Result<u64> {
let mut track_a = open_track(a);
let mut track_b = open_track(b);
if track_a.is_none() && track_b.is_none() {
return Err(io::Error::new(
ErrorKind::NotFound,
"no audio in either track",
));
}
let mut part = dest.as_os_str().to_owned();
part.push(".part");
let part = Path::new(&part);
let result = write_mix(&mut track_a, &mut track_b, part);
match result {
Ok(samples) => {
fs::rename(part, dest)?;
Ok(samples)
}
Err(e) => {
let _ = fs::remove_file(part);
Err(e)
}
}
}
fn write_mix(a: &mut Track, b: &mut Track, path: &Path) -> io::Result<u64> {
let mut writer = WavWriter::create(path, spec()).map_err(hound_to_io)?;
let (mut buf_a, mut buf_b, mut mixed) = (Vec::new(), Vec::new(), Vec::new());
let mut written = 0u64;
loop {
read_chunk(a, &mut buf_a)?;
read_chunk(b, &mut buf_b)?;
if buf_a.is_empty() && buf_b.is_empty() {
break;
}
mixed.clear();
mix_samples(&buf_a, &buf_b, &mut mixed);
for &sample in &mixed {
writer.write_sample(sample).map_err(hound_to_io)?;
}
written += mixed.len() as u64;
}
writer.finalize().map_err(hound_to_io)?;
Ok(written)
}
fn hound_to_io(e: hound::Error) -> io::Error {
match e {
hound::Error::IoError(e) => e,
other => io::Error::other(other),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::audio::TrackWriter;
fn mix(a: &[i16], b: &[i16]) -> Vec<i16> {
let mut out = Vec::new();
mix_samples(a, b, &mut out);
out
}
#[test]
fn quiet_samples_of_equal_length_are_summed() {
assert_eq!(mix(&[100, -200, 0], &[50, 300, -7]), vec![150, 100, -7]);
}
#[test]
fn the_longer_track_continues_alone() {
assert_eq!(mix(&[1, 2], &[10, 20, 30, 40]), vec![11, 22, 30, 40]);
assert_eq!(mix(&[10, 20, 30], &[1]), vec![11, 20, 30]);
}
#[test]
fn an_empty_track_leaves_the_other_unchanged_up_to_the_knee() {
let half = (KNEE * i16::MAX as f32) as i16;
let track = [0, 1234, -1234, half, -half, i16::MIN + 1];
let mut expected = track.to_vec();
// Beyond the knee even a single track is compressed (but stays
// loud and keeps its sign).
let last = mix(&[], &track)[5];
expected[5] = last;
assert!(last < -28_000, "{last}");
assert_eq!(mix(&[], &track), expected);
assert_eq!(mix(&track, &[]), expected);
assert_eq!(mix(&[], &[]), Vec::<i16>::new());
}
#[test]
fn full_scale_on_both_sides_stays_within_full_scale() {
let out = mix(
&[i16::MAX, i16::MIN, i16::MAX],
&[i16::MAX, i16::MIN, i16::MIN],
);
// Loud, with the right sign, and softly short of full scale.
assert!(out[0] > 30_000 && out[0] < i16::MAX, "{}", out[0]);
assert!(out[1] < -30_000 && out[1] > -i16::MAX, "{}", out[1]);
// Opposite full-scale samples cancel instead of wrapping around.
assert!(out[2].abs() <= 1, "{}", out[2]);
}
#[test]
fn the_soft_clip_is_monotonic_and_bounded() {
let mut last = -1.0f32;
for step in -400..=400 {
let x = step as f32 / 200.0; // -2.0 ..= 2.0
let y = soft_clip(x);
assert!(y >= last, "not monotonic at {x}");
assert!(y.abs() < 1.0, "{x} -> {y}");
last = y;
}
}
fn write_track(path: &Path, samples: &[f32]) {
let mut writer = TrackWriter::create(path).unwrap();
writer.write(samples).unwrap();
writer.finalize().unwrap();
}
fn read(path: &Path) -> Vec<i16> {
WavReader::open(path)
.unwrap()
.into_samples::<i16>()
.map(Result::unwrap)
.collect()
}
#[test]
fn two_files_are_mixed_across_several_chunks() {
let dir = tempfile::tempdir().unwrap();
let (a, b, dest) = (
dir.path().join("a.wav"),
dir.path().join("b.wav"),
dir.path().join("m.wav"),
);
let long = CHUNK_SAMPLES * 2 + 100;
write_track(&a, &vec![0.1; long]);
write_track(&b, &vec![0.2; CHUNK_SAMPLES + 7]);
assert_eq!(mix_wavs(&a, &b, &dest).unwrap(), long as u64);
let mixed = read(&dest);
assert_eq!(mixed.len(), long);
let both = to_i16(0.1) + to_i16(0.2);
assert!((mixed[0] - both).abs() <= 1);
assert!((mixed[CHUNK_SAMPLES + 6] - both).abs() <= 1);
assert_eq!(mixed[CHUNK_SAMPLES + 7], to_i16(0.1));
assert_eq!(mixed[long - 1], to_i16(0.1));
assert!(!dir.path().join("m.wav.part").exists());
}
#[test]
fn a_missing_or_empty_file_is_left_out() {
let dir = tempfile::tempdir().unwrap();
let (a, empty, dest) = (
dir.path().join("a.wav"),
dir.path().join("e.wav"),
dir.path().join("m.wav"),
);
write_track(&a, &[0.25; 10]);
write_track(&empty, &[]);
assert_eq!(
mix_wavs(&dir.path().join("gone.wav"), &a, &dest).unwrap(),
10
);
assert_eq!(read(&dest), vec![to_i16(0.25); 10]);
assert_eq!(mix_wavs(&a, &empty, &dest).unwrap(), 10);
assert_eq!(read(&dest), vec![to_i16(0.25); 10]);
}
#[test]
fn without_audio_in_either_file_nothing_is_written() {
let dir = tempfile::tempdir().unwrap();
let (empty, dest) = (dir.path().join("e.wav"), dir.path().join("m.wav"));
write_track(&empty, &[]);
let err = mix_wavs(&empty, &dir.path().join("gone.wav"), &dest).unwrap_err();
assert_eq!(err.kind(), ErrorKind::NotFound);
assert!(!dest.exists());
}
#[test]
fn a_file_that_is_not_a_track_is_left_out() {
let dir = tempfile::tempdir().unwrap();
let (a, junk, other, dest) = (
dir.path().join("a.wav"),
dir.path().join("j.wav"),
dir.path().join("o.wav"),
dir.path().join("m.wav"),
);
write_track(&a, &[0.25; 10]);
fs::write(&junk, b"not a wav file at all").unwrap();
let stereo = WavSpec {
channels: 2,
..spec()
};
let mut writer = WavWriter::create(&other, stereo).unwrap();
writer.write_sample(1i16).unwrap();
writer.write_sample(1i16).unwrap();
writer.finalize().unwrap();
assert_eq!(mix_wavs(&a, &junk, &dest).unwrap(), 10);
assert_eq!(mix_wavs(&other, &a, &dest).unwrap(), 10);
let err = mix_wavs(&junk, &other, &dest).unwrap_err();
assert_eq!(err.kind(), ErrorKind::NotFound);
}
#[test]
fn a_track_has_audio_only_with_samples_in_the_track_format() {
let dir = tempfile::tempdir().unwrap();
let path = |name: &str| dir.path().join(name);
assert!(!has_audio(&path("gone.wav")), "missing");
assert!(!has_audio(Path::new("")), "no path");
write_track(&path("empty.wav"), &[]);
assert!(!has_audio(&path("empty.wav")), "header only");
// Larger than a header, but its header says it holds nothing.
let mut bytes = fs::read(path("empty.wav")).unwrap();
bytes.extend([0u8; 100]);
fs::write(path("unrepaired.wav"), bytes).unwrap();
assert!(
!has_audio(&path("unrepaired.wav")),
"data not in the header"
);
fs::write(path("junk.wav"), vec![7u8; 100]).unwrap();
assert!(!has_audio(&path("junk.wav")), "not a wav");
write_track(&path("one.wav"), &[0.1]);
assert!(has_audio(&path("one.wav")));
}
}
+3 -1
View File
@@ -11,10 +11,12 @@ mod conditioner;
mod flac;
mod gap;
mod level;
mod mix;
mod wav;
pub use conditioner::Conditioner;
pub use flac::encode_flac;
pub use gap::GapFiller;
pub use level::rms_level;
pub use wav::{repair_wav, TrackWriter};
pub use mix::{has_audio, mix_samples, mix_wavs};
pub use wav::{repair_wav, TrackWriter, SAMPLE_RATE};
+232 -5
View File
@@ -6,6 +6,7 @@ use std::collections::BTreeMap;
use chrono::{DateTime, Local};
use serde::Serialize;
use crate::corrections::correct_segment_text;
use crate::merge;
use crate::model::{Call, CallId, CallStatus, Segment, Speaker};
@@ -18,6 +19,15 @@ pub struct CallListItem {
/// Whole seconds from start to end; 0 while recording.
pub duration_secs: i64,
pub status: CallStatus,
/// What the status pill shows and whether the row needs the user's
/// attention — see [`ListState`]. Computed from `status` and
/// [`uploaded_here`] so the UI does not re-implement the rule.
pub list_state: ListState,
/// Whether this row needs the user to act on it (the dot in
/// `CallList.svelte` and the sidebar header's "N offen" count). Equal
/// to `list_state.needs_action()`, kept as its own field so the UI
/// does not need to know `ListState`'s variants to filter by it.
pub needs_action: bool,
pub interrupted: bool,
/// The name the user gave the call, if any.
pub title: Option<String>,
@@ -35,12 +45,15 @@ impl CallListItem {
/// row. Nothing is deleted; the fields are just not shown as set.
pub fn of(call: &Call, backend_url: &str) -> Self {
let uploaded = uploaded_here(call, backend_url);
let list_state = ListState::of(call.status, uploaded);
Self {
id: call.id,
app: call.app.clone(),
started_at: call.started_at,
duration_secs: duration_secs(call),
status: call.status,
list_state,
needs_action: list_state.needs_action(),
interrupted: call.interrupted,
title: call.title.clone(),
crm_transcript_id: if uploaded {
@@ -53,6 +66,45 @@ impl CallListItem {
}
}
/// What the call list row (and the detail header's pill) shows about a
/// call's status. Mirrors [`CallStatus`] one-to-one, except that `Done`
/// splits in two: a call is only ever shown as done ("fertig") once its
/// transcript has actually reached *this build's* backend ([`uploaded_here`]);
/// otherwise — never uploaded, or uploaded to a different backend — it is
/// `ReadyToUpload` ("bereit zum Hochladen"), because from this build's
/// point of view the CRM has not seen it yet.
#[derive(Serialize, Clone, Copy, Debug, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum ListState {
Recording,
AwaitingDecision,
Processing,
Failed,
Done,
ReadyToUpload,
}
impl ListState {
fn of(status: CallStatus, uploaded_here: bool) -> Self {
match status {
CallStatus::Recording => ListState::Recording,
CallStatus::AwaitingDecision => ListState::AwaitingDecision,
CallStatus::Processing => ListState::Processing,
CallStatus::Failed => ListState::Failed,
CallStatus::Done if uploaded_here => ListState::Done,
CallStatus::Done => ListState::ReadyToUpload,
}
}
/// Whether a row in this state needs the user to act on it: not yet
/// transcribed, or transcribed but not uploaded here. Excludes
/// `Failed` (already shown in red) and the transient
/// `Recording`/`Processing` states.
pub fn needs_action(self) -> bool {
matches!(self, ListState::AwaitingDecision | ListState::ReadyToUpload)
}
}
/// Whole seconds from `started_at` to `ended_at`; 0 while the call has not
/// ended (and never negative).
pub fn duration_secs(call: &Call) -> i64 {
@@ -120,19 +172,46 @@ pub struct CallDetail {
/// Whether the transcript is being uploaded right now. Set by the app,
/// which tracks its uploads; `false` from [`CallDetail::of`].
pub uploading: bool,
/// Whether the call's audio is still on disk to be played
/// ([`crate::playback::audio_available`]). Set by the app; `false` from
/// [`CallDetail::of`], which does not look at the files.
pub audio_available: bool,
/// Whether retention deleted the call's audio (as opposed to the files
/// being missing for another reason).
pub audio_deleted: bool,
/// The call's language, or the last-used one for a call without its
/// own yet ([`preselect_language`]): what the language picker next to
/// "Transkribieren"/"Erneut versuchen" starts on.
pub language: String,
}
/// The language the picker starts on for `call`: the one it was
/// transcribed in, else `last_used` (the settings' `language`).
pub fn preselect_language(call: &Call, last_used: &str) -> String {
call.language
.clone()
.unwrap_or_else(|| last_used.to_string())
}
impl CallDetail {
/// `segments` are the stored ones; `merges` the stored speaker merges
/// (source key → target key); `backend_url` is this build's backend
/// (see [`CallListItem::of`]).
/// (see [`CallListItem::of`]); `last_used_language` is the settings'
/// `language` (see [`preselect_language`]). The call's language picks
/// the [`correct_segment_text`] applied to each segment's text —
/// non-destructively, so it also corrects transcripts from before the
/// correction existed.
pub fn of(
call: &Call,
segments: &[Segment],
speaker_names: BTreeMap<String, String>,
merges: &BTreeMap<String, String>,
backend_url: &str,
last_used_language: &str,
) -> Self {
// A call with segments always has its language (see the store's
// schema v5); the fallback only covers a call not transcribed yet.
let language = preselect_language(call, last_used_language);
let segments = merge::apply_merges(segments, merges)
.iter()
.map(|segment| SegmentView {
@@ -140,7 +219,7 @@ impl CallDetail {
label: merge::label(&segment.speaker, &speaker_names),
start: segment.start,
end: segment.end,
text: segment.text.clone(),
text: correct_segment_text(&segment.text, &language),
})
.collect();
Self {
@@ -152,7 +231,10 @@ impl CallDetail {
segments,
merges: merge_views(merges, &speaker_names),
uploading: false,
audio_available: false,
audio_deleted: call.audio_deleted,
speaker_names,
language,
}
}
}
@@ -281,6 +363,7 @@ mod tests {
title: None,
crm_transcript_id: None,
crm_base_url: None,
language: None,
uploaded_at: None,
}
}
@@ -318,6 +401,8 @@ mod tests {
started_at: at(10, 14, 0),
duration_secs: 60,
status: CallStatus::AwaitingDecision,
list_state: ListState::AwaitingDecision,
needs_action: true,
interrupted: true,
title: None,
crm_transcript_id: None,
@@ -351,6 +436,64 @@ mod tests {
assert!(uploaded_here(&c, BACKEND));
}
#[test]
fn done_is_fertig_only_once_uploaded_to_this_backend() {
let mut c = call(Some(at(10, 15, 0)));
c.status = CallStatus::Done;
// Never uploaded.
assert_eq!(
CallListItem::of(&c, BACKEND).list_state,
ListState::ReadyToUpload
);
// Uploaded, but to a different backend.
c.crm_transcript_id = Some("4711".into());
c.crm_base_url = Some(OTHER_BACKEND.into());
assert_eq!(
CallListItem::of(&c, BACKEND).list_state,
ListState::ReadyToUpload
);
// Uploaded to this build's backend.
c.crm_base_url = Some(BACKEND.into());
assert_eq!(CallListItem::of(&c, BACKEND).list_state, ListState::Done);
}
#[test]
fn needs_action_marks_awaiting_and_ready_to_upload_only() {
let mut c = call(Some(at(10, 15, 0)));
c.status = CallStatus::AwaitingDecision;
assert!(CallListItem::of(&c, BACKEND).needs_action, "awaiting");
c.status = CallStatus::Done;
assert!(
CallListItem::of(&c, BACKEND).needs_action,
"done, never uploaded"
);
for status in [
CallStatus::Processing,
CallStatus::Failed,
CallStatus::Recording,
] {
c.status = status;
assert!(
!CallListItem::of(&c, BACKEND).needs_action,
"{status:?} must not show the dot"
);
}
c.status = CallStatus::Done;
c.crm_transcript_id = Some("4711".into());
c.crm_base_url = Some(BACKEND.into());
assert!(
!CallListItem::of(&c, BACKEND).needs_action,
"done and uploaded here"
);
}
#[test]
fn an_upload_to_another_backend_is_hidden_from_the_list_item() {
// Uploaded to OTHER_BACKEND; this build's backend is BACKEND: the
@@ -389,6 +532,7 @@ mod tests {
names.clone(),
&BTreeMap::new(),
BACKEND,
"de",
);
let lines: Vec<_> = detail
@@ -439,6 +583,7 @@ mod tests {
names,
&merges,
BACKEND,
"de",
);
let lines: Vec<_> = detail
@@ -490,9 +635,15 @@ mod tests {
c.transcribed_at = Some(at(10, 20, 0));
let merges = keys(&[("remote:2", "remote:1")]);
let value =
serde_json::to_value(CallDetail::of(&c, &[], BTreeMap::new(), &merges, BACKEND))
.unwrap();
let value = serde_json::to_value(CallDetail::of(
&c,
&[],
BTreeMap::new(),
&merges,
BACKEND,
"de",
))
.unwrap();
assert_eq!(
value,
@@ -503,6 +654,8 @@ mod tests {
"started_at": serde_json::to_value(at(10, 14, 0)).unwrap(),
"duration_secs": 60,
"status": "failed",
"list_state": "failed",
"needs_action": false,
"interrupted": false,
"title": "Reklamation",
"crm_transcript_id": null,
@@ -519,17 +672,32 @@ mod tests {
"into_label": "Sprecher 1",
}],
"uploading": false,
"audio_available": false,
"audio_deleted": false,
"language": "de",
})
);
}
/// With German as the last-used language (what matters for a call
/// without its own, see `CallDetail::of`).
fn detail_with(c: &Call, segments: &[Segment], names: &[(&str, &str)]) -> CallDetail {
detail_last_used(c, segments, names, "de")
}
fn detail_last_used(
c: &Call,
segments: &[Segment],
names: &[(&str, &str)],
last_used_language: &str,
) -> CallDetail {
CallDetail::of(
c,
segments,
keys(names),
&keys(&[("remote:2", "remote:1")]),
BACKEND,
last_used_language,
)
}
@@ -591,4 +759,63 @@ mod tests {
}
assert_eq!(NO_TRANSCRIPT, "Kein Transkript zum Hochladen");
}
#[test]
fn a_whole_segment_mistranscribed_as_english_is_corrected_in_the_detail_view() {
let c = call(Some(at(10, 15, 0)));
let segments = [
segment(Speaker::Me, 0.0, "Cheers!"),
segment(Speaker::Remote(3), 3.0, "Perfect."),
segment(Speaker::Remote(1), 6.0, "Cheers, see you later."),
];
let detail = detail_with(&c, &segments, &[]);
let texts: Vec<_> = detail.segments.iter().map(|s| s.text.as_str()).collect();
assert_eq!(texts, ["Tschüss!", "Perfekt.", "Cheers, see you later."]);
}
#[test]
fn corrections_are_not_applied_outside_german_calls() {
let mut c = call(Some(at(10, 15, 0)));
c.language = Some("en".into());
let segments = [segment(Speaker::Me, 0.0, "Cheers!")];
// German was used last, but this call is English.
let detail = detail_last_used(&c, &segments, &[], "de");
assert_eq!(detail.segments[0].text, "Cheers!");
}
#[test]
fn corrections_follow_the_calls_language_not_the_last_used_one() {
let mut c = call(Some(at(10, 15, 0)));
c.language = Some("de".into());
let segments = [segment(Speaker::Me, 0.0, "Cheers!")];
let detail = detail_last_used(&c, &segments, &[], "en");
assert_eq!(detail.segments[0].text, "Tschüss!");
assert_eq!(detail.language, "de");
}
#[test]
fn the_preselected_language_is_the_calls_own_else_the_last_used() {
let mut c = call(None);
assert_eq!(preselect_language(&c, "fr"), "fr");
c.language = Some("it".into());
assert_eq!(preselect_language(&c, "fr"), "it");
assert_eq!(detail_last_used(&c, &[], &[], "fr").language, "it");
}
#[test]
fn the_upload_text_uses_the_corrected_segment_text() {
let c = call(Some(at(10, 46, 0)));
let segments = [segment(Speaker::Me, 0.0, "Cheers!")];
let text = detail_with(&c, &segments, &[]).upload_text().unwrap();
assert!(text.ends_with("Ich: Tschüss!"), "upload text was: {text}");
}
}
+81
View File
@@ -0,0 +1,81 @@
//! A short, hard-coded list of German short utterances that the
//! transcription service sometimes mistranscribes as English when they
//! stand alone in an otherwise German call ("Tschüss" → "Cheers!",
//! "Perfekt" → "Perfect."). Applied non-destructively wherever a segment's
//! text is shown or uploaded (see [`crate::call_view::CallDetail::of`]),
//! never to the stored segments themselves — fixing the list later fixes
//! already-transcribed calls too.
//!
//! Not user-editable (yet): a fixed code constant, checked only against a
//! segment's *entire* text, so it never touches a short mistranscription
//! embedded in a longer sentence.
/// (mistranscribed English word, correct German word) pairs.
const CORRECTIONS: &[(&str, &str)] = &[("Cheers", "Tschüss"), ("Perfect", "Perfekt")];
/// Returns `text`'s correction if the call's `language` is German (`"de"`)
/// and `text` — ignoring surrounding whitespace and one run of trailing
/// `. ! ? ,` — case-insensitively equals one of [`CORRECTIONS`]'s source
/// words in full; the original trailing punctuation, if any, is kept (e.g.
/// "Cheers!" → "Tschüss!"). Otherwise `text` is returned unchanged,
/// including when it merely *contains* a source word ("Cheers, see you").
pub fn correct_segment_text(text: &str, language: &str) -> String {
if language != "de" {
return text.to_string();
}
let trimmed = text.trim();
let core = trimmed.trim_end_matches(['.', '!', '?', ',']);
let punctuation = &trimmed[core.len()..];
match CORRECTIONS
.iter()
.find(|(wrong, _)| core.eq_ignore_ascii_case(wrong))
{
Some((_, right)) => format!("{right}{punctuation}"),
None => text.to_string(),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_whole_mistranscribed_utterance_is_corrected_case_insensitively() {
assert_eq!(correct_segment_text("Cheers!", "de"), "Tschüss!");
assert_eq!(correct_segment_text("cheers", "de"), "Tschüss");
assert_eq!(correct_segment_text("CHEERS!", "de"), "Tschüss!");
assert_eq!(correct_segment_text("Perfect.", "de"), "Perfekt.");
assert_eq!(correct_segment_text("perfect?", "de"), "Perfekt?");
}
#[test]
fn surrounding_whitespace_is_ignored_for_matching() {
assert_eq!(correct_segment_text(" Cheers! ", "de"), "Tschüss!");
}
#[test]
fn a_mistranscription_inside_a_longer_sentence_is_untouched() {
assert_eq!(
correct_segment_text("Cheers, see you", "de"),
"Cheers, see you"
);
assert_eq!(
correct_segment_text("That was perfect.", "de"),
"That was perfect."
);
}
#[test]
fn not_applied_outside_german_calls() {
assert_eq!(correct_segment_text("Cheers!", "en"), "Cheers!");
assert_eq!(correct_segment_text("Cheers!", "auto"), "Cheers!");
}
#[test]
fn text_without_a_match_is_returned_unchanged() {
assert_eq!(
correct_segment_text("Hallo zusammen.", "de"),
"Hallo zusammen."
);
}
}
+2
View File
@@ -8,11 +8,13 @@ pub mod audio;
pub mod backend;
pub mod call_view;
pub mod capture;
pub mod corrections;
pub mod detect;
pub mod http;
pub mod merge;
pub mod model;
pub mod pipeline;
pub mod playback;
pub mod recorder;
pub mod retention;
pub mod secrets;
+3
View File
@@ -48,6 +48,9 @@ pub struct Call {
pub crm_base_url: Option<String>,
/// When the transcript was last uploaded.
pub uploaded_at: Option<DateTime<Local>>,
/// The language (ISO 639-1 code) the call is transcribed in, chosen
/// when its transcription was started; `None` before that.
pub language: Option<String>,
}
/// A single transcribed word with its timing and speaker attribution.
+28 -1
View File
@@ -22,9 +22,12 @@ use crate::transcribe::{TranscribeError, TranscribeOptions, Transcriber};
/// Settings a pipeline run uses.
#[derive(Debug, Clone, PartialEq)]
pub struct PipelineOptions {
/// ISO 639-1 code, or `"auto"`.
/// The call's language, one of [`crate::settings::CALL_LANGUAGES`].
pub language: String,
pub deepscript_model: String,
/// Custom words/names submitted with both tracks (DeepScript's
/// `vocabulary` field).
pub vocabulary: Vec<String>,
}
/// Everything a pipeline run can fail with.
@@ -140,6 +143,7 @@ async fn transcribe(
language: opts.language.clone(),
model: opts.deepscript_model.clone(),
single_speaker,
vocabulary: opts.vocabulary.clone(),
};
let (mic_opts, out_opts) = (track_opts(true), track_opts(false));
let (mic_job, out_job) = tokio::join!(
@@ -431,6 +435,7 @@ mod tests {
PipelineOptions {
language: "de".to_string(),
deepscript_model: "premium".to_string(),
vocabulary: Vec::new(),
}
}
@@ -547,6 +552,7 @@ mod tests {
language: "de".to_string(),
model: "premium".to_string(),
single_speaker,
vocabulary: Vec::new(),
};
assert_eq!(
fake.submitted(),
@@ -557,6 +563,27 @@ mod tests {
);
}
#[tokio::test]
async fn pipeline_forwards_the_vocabulary_to_both_tracks() {
let f = fixture();
let fake = FakeTranscriber::returning(vec![], vec![]);
let opts = PipelineOptions {
vocabulary: vec!["Tschüss".to_string(), "Euvino".to_string()],
..opts()
};
process_call(&f.store, &fake, f.id, &opts, &f.work_dir())
.await
.unwrap();
for (_, submitted) in fake.submitted() {
assert_eq!(
submitted.vocabulary,
vec!["Tschüss".to_string(), "Euvino".to_string()]
);
}
}
#[tokio::test]
async fn pipeline_transcription_failure_sets_failed_keeps_audio() {
let f = fixture();
+357
View File
@@ -0,0 +1,357 @@
//! Playback of a call in the detail view while its audio is still on disk:
//! both tracks are mixed into one cached mono WAV
//! (`<playback dir>/<id>.wav`), which the app serves to the main window
//! only (its `playback` URI scheme). The cache is rebuilt only when a track
//! is newer than it, and removed with the call's audio and when the player
//! lets go of it.
use std::fs;
use std::io::{self, ErrorKind};
use std::path::{Path, PathBuf};
use std::time::SystemTime;
use serde::Serialize;
use crate::audio::{has_audio, mix_wavs, SAMPLE_RATE};
use crate::model::{Call, CallId, CallStatus};
/// The call's audio was deleted (by retention).
pub const AUDIO_GONE: &str = "Audio nicht mehr vorhanden";
/// Neither track holds audio (files missing or empty), though nothing
/// deleted them.
pub const AUDIO_MISSING: &str = "Audio nicht vorhanden";
/// Mixing failed; the details (with file paths) only go to the log.
pub const PREPARE_FAILED: &str = "Audio konnte nicht vorbereitet werden.";
pub const RECORDING: &str = "Das Gespräch wird gerade aufgenommen";
pub const PROCESSING: &str = "Das Gespräch wird gerade verarbeitet – Wiedergabe danach möglich";
/// What the UI needs besides the call id (from which it builds the
/// `playback` URL): the mix's length.
#[derive(Serialize, Clone, Copy, Debug, PartialEq)]
pub struct PlaybackInfo {
pub duration_secs: f64,
}
/// Why `call` cannot be played, if it cannot: its tracks are still being
/// written (recording) or read for transcription (processing), or its
/// audio was deleted.
pub fn refusal(call: &Call) -> Option<&'static str> {
match call.status {
CallStatus::Recording => Some(RECORDING),
CallStatus::Processing => Some(PROCESSING),
_ if call.audio_deleted => Some(AUDIO_GONE),
_ => None,
}
}
/// Whether `call` still has audio to play: not deleted, and at least one
/// track [has audio](has_audio) — the same rule the mix goes by.
pub fn audio_available(call: &Call) -> bool {
!call.audio_deleted && (has_audio(&call.mic_path) || has_audio(&call.out_path))
}
/// Whether a cached mix last written at `cache` can be reused for tracks
/// last written at `sources` (`None`: that track does not exist). It can if
/// it exists and is newer than every existing track; with no track left
/// there is nothing it could still stand for.
pub fn is_fresh(cache: Option<SystemTime>, sources: &[Option<SystemTime>]) -> bool {
let Some(cache) = cache else {
return false;
};
let mut any = false;
for source in sources.iter().flatten() {
if *source >= cache {
return false;
}
any = true;
}
any
}
/// Where call `id`'s mix is cached in the playback directory `dir`.
pub fn cache_path(dir: &Path, id: CallId) -> PathBuf {
dir.join(format!("{id}.wav"))
}
/// Returns call `call`'s mix in the playback directory `dir`, building it
/// first unless a fresh one is cached ([`is_fresh`]). Refused (see
/// [`refusal`]) while the call records or is processed and once its audio
/// is gone; a cached mix of a call whose audio is gone is removed. Errors
/// are fit for the UI: they never contain a file path.
pub fn prepare(call: &Call, dir: &Path) -> Result<PlaybackInfo, String> {
let path = cache_path(dir, call.id);
if let Some(msg) = refusal(call) {
if msg == AUDIO_GONE {
remove_cached(dir, call.id);
}
return Err(msg.to_string());
}
let sources = [modified(&call.mic_path), modified(&call.out_path)];
if is_fresh(modified(&path), &sources) {
match duration_secs(&path) {
Ok(duration_secs) => return Ok(PlaybackInfo { duration_secs }),
Err(e) => log::warn!("call {}: rebuilding unreadable playback file: {e}", call.id),
}
}
let mixed =
fs::create_dir_all(dir).and_then(|()| mix_wavs(&call.mic_path, &call.out_path, &path));
match mixed {
Ok(samples) => Ok(PlaybackInfo {
duration_secs: samples as f64 / SAMPLE_RATE as f64,
}),
Err(e) if e.kind() == ErrorKind::NotFound => {
remove_cached(dir, call.id);
Err(AUDIO_MISSING.to_string())
}
Err(e) => {
log::error!("call {}: could not mix for playback: {e}", call.id);
Err(PREPARE_FAILED.to_string())
}
}
}
/// Removes call `id`'s cached mix, if any (with the call or its audio).
/// Failures are logged: the playback directory is emptied at every start.
pub fn remove_cached(dir: &Path, id: CallId) {
let path = cache_path(dir, id);
match fs::remove_file(&path) {
Ok(()) => {}
Err(e) if e.kind() == ErrorKind::NotFound => {}
Err(e) => log::warn!("could not remove {}: {e}", path.display()),
}
}
/// Removes every cached mix (at startup, so customer audio never lingers
/// in the cache).
pub fn clear_cache(dir: &Path) -> io::Result<()> {
match fs::remove_dir_all(dir) {
Err(e) if e.kind() == ErrorKind::NotFound => Ok(()),
other => other,
}
}
fn modified(path: &Path) -> Option<SystemTime> {
fs::metadata(path).and_then(|m| m.modified()).ok()
}
fn duration_secs(path: &Path) -> Result<f64, hound::Error> {
let reader = hound::WavReader::open(path)?;
Ok(reader.duration() as f64 / reader.spec().sample_rate as f64)
}
#[cfg(test)]
mod tests {
use std::fs::File;
use std::time::Duration;
use chrono::Local;
use super::*;
use crate::audio::TrackWriter;
fn call(dir: &Path, status: CallStatus) -> Call {
Call {
id: 7,
app: "Microsoft Teams".to_string(),
started_at: Local::now(),
ended_at: Some(Local::now()),
status,
interrupted: false,
error: None,
mic_path: dir.join("7-mic.wav"),
out_path: dir.join("7-out.wav"),
transcribed_at: None,
audio_deleted: false,
title: None,
crm_transcript_id: None,
crm_base_url: None,
language: None,
uploaded_at: None,
}
}
fn write_track(path: &Path, samples: &[f32]) {
let mut writer = TrackWriter::create(path).unwrap();
writer.write(samples).unwrap();
writer.finalize().unwrap();
}
/// A call with one second on the mic and half a second on the output.
fn recorded_call(dir: &Path, status: CallStatus) -> Call {
let call = call(dir, status);
write_track(&call.mic_path, &vec![0.1; 16_000]);
write_track(&call.out_path, &vec![0.2; 8_000]);
call
}
fn set_modified(path: &Path, time: SystemTime) {
File::options()
.write(true)
.open(path)
.unwrap()
.set_modified(time)
.unwrap();
}
#[test]
fn a_cache_newer_than_every_track_is_fresh() {
let t = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000);
let s = Duration::from_secs(1);
assert!(is_fresh(Some(t), &[Some(t - s), Some(t - s)]));
assert!(is_fresh(Some(t), &[None, Some(t - s)]));
assert!(!is_fresh(Some(t), &[Some(t - s), Some(t + s)]));
assert!(!is_fresh(Some(t), &[Some(t), Some(t - s)]), "same time");
assert!(!is_fresh(None, &[Some(t - s), Some(t - s)]), "no cache");
assert!(!is_fresh(Some(t), &[None, None]), "no tracks");
}
#[test]
fn recording_processing_and_deleted_calls_are_refused() {
let dir = Path::new("/nonexistent");
assert_eq!(refusal(&call(dir, CallStatus::Recording)), Some(RECORDING));
assert_eq!(
refusal(&call(dir, CallStatus::Processing)),
Some(PROCESSING)
);
let mut deleted = call(dir, CallStatus::Done);
deleted.audio_deleted = true;
assert_eq!(refusal(&deleted), Some(AUDIO_GONE));
for status in [
CallStatus::AwaitingDecision,
CallStatus::Done,
CallStatus::Failed,
] {
assert_eq!(refusal(&call(dir, status)), None, "{status:?}");
}
}
#[test]
fn audio_is_available_while_a_track_holds_audio() {
let dir = tempfile::tempdir().unwrap();
let mut c = call(dir.path(), CallStatus::Done);
assert!(!audio_available(&c), "no files");
write_track(&c.out_path, &[]);
assert!(!audio_available(&c), "header only");
write_track(&c.mic_path, &[0.1; 10]);
assert!(audio_available(&c));
c.audio_deleted = true;
assert!(!audio_available(&c), "deleted by retention");
}
#[test]
fn the_mix_is_built_once_and_reused() {
let dir = tempfile::tempdir().unwrap();
let playback = dir.path().join("playback");
let c = recorded_call(dir.path(), CallStatus::Done);
let info = prepare(&c, &playback).unwrap();
let mix = playback.join("7.wav");
assert!(mix.exists());
assert!((info.duration_secs - 1.0).abs() < 1e-9);
// Marked as written long ago: a rebuild would show a new time.
let old = SystemTime::now() - Duration::from_secs(60);
set_modified(&c.mic_path, old - Duration::from_secs(60));
set_modified(&c.out_path, old - Duration::from_secs(60));
set_modified(&mix, old);
assert_eq!(prepare(&c, &playback).unwrap(), info);
assert_eq!(modified(&mix), Some(old), "reused, not rebuilt");
}
#[test]
fn the_mix_is_rebuilt_when_a_track_is_newer() {
let dir = tempfile::tempdir().unwrap();
let playback = dir.path().join("playback");
let c = recorded_call(dir.path(), CallStatus::AwaitingDecision);
prepare(&c, &playback).unwrap();
let mix = cache_path(&playback, c.id);
let old = SystemTime::now() - Duration::from_secs(60);
set_modified(&mix, old);
// Two seconds now; the file is newer than the cache.
write_track(&c.mic_path, &vec![0.1; 32_000]);
let second = prepare(&c, &playback).unwrap();
assert!((second.duration_secs - 2.0).abs() < 1e-9);
assert_ne!(modified(&mix), Some(old));
}
#[test]
fn a_call_with_one_track_plays_that_track() {
let dir = tempfile::tempdir().unwrap();
let c = call(dir.path(), CallStatus::Failed);
write_track(&c.out_path, &vec![0.2; 4_000]);
let info = prepare(&c, &dir.path().join("playback")).unwrap();
assert!((info.duration_secs - 0.25).abs() < 1e-9);
}
#[test]
fn a_refused_call_builds_nothing() {
let dir = tempfile::tempdir().unwrap();
let playback = dir.path().join("playback");
for status in [CallStatus::Recording, CallStatus::Processing] {
let c = recorded_call(dir.path(), status);
assert!(prepare(&c, &playback).is_err());
assert!(!cache_path(&playback, c.id).exists());
}
}
#[test]
fn deleted_audio_removes_the_cached_mix() {
let dir = tempfile::tempdir().unwrap();
let playback = dir.path().join("playback");
let mut c = recorded_call(dir.path(), CallStatus::Done);
prepare(&c, &playback).unwrap();
let mix = cache_path(&playback, c.id);
// Retention deleted the audio.
fs::remove_file(&c.mic_path).unwrap();
fs::remove_file(&c.out_path).unwrap();
c.audio_deleted = true;
assert_eq!(prepare(&c, &playback), Err(AUDIO_GONE.to_string()));
assert!(!mix.exists());
}
#[test]
fn missing_files_remove_the_cached_mix() {
let dir = tempfile::tempdir().unwrap();
let playback = dir.path().join("playback");
let c = recorded_call(dir.path(), CallStatus::Done);
prepare(&c, &playback).unwrap();
let mix = cache_path(&playback, c.id);
fs::remove_file(&c.mic_path).unwrap();
fs::remove_file(&c.out_path).unwrap();
assert_eq!(prepare(&c, &playback), Err(AUDIO_MISSING.to_string()));
assert!(!mix.exists());
}
#[test]
fn a_failed_mix_reports_no_file_paths() {
let dir = tempfile::tempdir().unwrap();
let c = recorded_call(dir.path(), CallStatus::Done);
// The playback directory cannot be created: a file is in the way.
let blocked = dir.path().join("playback");
fs::write(&blocked, b"").unwrap();
assert_eq!(prepare(&c, &blocked), Err(PREPARE_FAILED.to_string()));
}
#[test]
fn the_cache_is_removed_per_call_and_cleared_as_a_whole() {
let dir = tempfile::tempdir().unwrap();
let playback = dir.path().join("playback");
let c = recorded_call(dir.path(), CallStatus::Done);
prepare(&c, &playback).unwrap();
fs::write(playback.join("8.wav"), b"other").unwrap();
remove_cached(&playback, c.id);
assert!(!cache_path(&playback, c.id).exists());
assert!(playback.join("8.wav").exists());
remove_cached(&playback, c.id); // already gone: no error
clear_cache(&playback).unwrap();
assert!(!playback.exists());
clear_cache(&playback).unwrap(); // already gone: no error
}
}
+1
View File
@@ -91,6 +91,7 @@ mod tests {
title: None,
crm_transcript_id: None,
crm_base_url: None,
language: None,
uploaded_at: None,
}
}
+309 -6
View File
@@ -26,6 +26,43 @@ pub const START_AFTER_SECS: RangeInclusive<u64> = 1..=30;
/// Allowed mic release before a call counts as ended, in seconds. Too short
/// splits a call, e.g. when the headset is switched.
pub const END_AFTER_SECS: RangeInclusive<u64> = 3..=120;
/// Allowed retention period, in days (the settings UI checks the same).
pub const RETENTION_DAYS: RangeInclusive<u32> = 1..=3650;
/// The only `deepscript_model` values the settings UI offers (DeepScript's
/// OpenAPI spec also lists `"standard"`, not offered here). An older
/// settings.json with `"standard"` or anything else falls back to the
/// default on load (see [`Settings::load`]) rather than failing.
pub const DEEPSCRIPT_MODELS: [&str; 2] = ["premium", "premium_jade"];
/// The languages (ISO 639-1) a call can be transcribed in, chosen per call
/// when its transcription is started. All are in DeepScript's
/// `GET /v1/languages`; its `"auto"` is not offered.
pub const CALL_LANGUAGES: [&str; 5] = ["de", "en", "es", "fr", "it"];
/// Checks a call language chosen in the UI; the error is shown as is.
pub fn check_call_language(language: &str) -> Result<(), String> {
if CALL_LANGUAGES.contains(&language) {
Ok(())
} else {
Err(format!("Unbekannte Sprache: {language}"))
}
}
/// Default custom-vocabulary terms: short standalone German words/names
/// DeepScript otherwise tends to mistranscribe or drop.
const DEFAULT_VOCABULARY: [&str; 5] = ["Tschüss", "Perfekt", "Servus", "Moin", "Euvino"];
/// Hard cap on the vocabulary list sent with every DeepScript submission.
/// DeepScript's OpenAPI spec does not document a limit for the
/// per-transcription `vocabulary` field itself (only for its separate,
/// *saved* vocabularies, capped there at 500 words — see
/// `POST /v1/vocabularies`); these two numbers are ours, chosen to keep
/// that field small.
pub const MAX_VOCABULARY_TERMS: usize = 200;
/// Hard cap on one vocabulary term's length (characters), for the same
/// reason as [`MAX_VOCABULARY_TERMS`].
pub const MAX_VOCABULARY_TERM_LEN: usize = 60;
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(default)]
@@ -33,8 +70,17 @@ pub struct Settings {
pub allowlist: Vec<String>,
pub mic_device: Option<String>,
pub output_device: Option<String>,
/// The language of the transcription started last (one of
/// [`CALL_LANGUAGES`]), preselected for the next call. Set by the app
/// when a transcription is started, not by the settings page.
pub language: String,
pub deepscript_model: String,
/// Custom words/names submitted with every transcription (DeepScript's
/// `vocabulary` field), e.g. names and product terms that are often
/// misheard. Normalized on load and on every edit (see
/// [`normalize_vocabulary`]): trimmed, blanks dropped, deduplicated
/// case-insensitively, order kept.
pub vocabulary: Vec<String>,
pub retention_days: u32,
pub autostart: bool,
pub start_after_secs: u64,
@@ -57,6 +103,7 @@ impl Default for Settings {
output_device: None,
language: "de".to_string(),
deepscript_model: "premium".to_string(),
vocabulary: DEFAULT_VOCABULARY.iter().map(|s| s.to_string()).collect(),
retention_days: 7,
autostart: true,
start_after_secs: 3,
@@ -85,14 +132,45 @@ impl Settings {
END_AFTER_SECS.end()
));
}
if !RETENTION_DAYS.contains(&self.retention_days) {
return Err(format!(
"Aufbewahrung: {}–{} Tage",
RETENTION_DAYS.start(),
RETENTION_DAYS.end()
));
}
if !DEEPSCRIPT_MODELS.contains(&self.deepscript_model.as_str()) {
return Err(format!(
"Transkriptionsmodell: nur {} möglich",
DEEPSCRIPT_MODELS.join(" oder ")
));
}
if self.vocabulary.len() > MAX_VOCABULARY_TERMS {
return Err(format!(
"Vokabular: höchstens {MAX_VOCABULARY_TERMS} Begriffe"
));
}
if let Some(term) = self
.vocabulary
.iter()
.find(|term| term.chars().count() > MAX_VOCABULARY_TERM_LEN)
{
return Err(format!(
"Vokabular: „{term}“ ist länger als {MAX_VOCABULARY_TERM_LEN} Zeichen"
));
}
Ok(())
}
/// The settings after the user saved `edited` over these: checked, with
/// the backend login (which only the app changes) kept, so a settings
/// page loaded before a login cannot undo it.
/// The settings after the user saved `edited` over these: normalized
/// (see [`normalize_vocabulary`]), checked, with the backend login and
/// the last-used language (which only the app changes) kept, so a
/// settings page loaded before a login or a transcription cannot undo
/// them.
pub fn edited(&self, mut edited: Settings) -> Result<Settings, String> {
edited.vocabulary = normalize_vocabulary(edited.vocabulary);
edited.validate()?;
edited.language = self.language.clone();
edited.backend_username = self.backend_username.clone();
edited.backend_key_expires_at = self.backend_key_expires_at;
edited.backend_key_base_url = self.backend_key_base_url.clone();
@@ -100,12 +178,29 @@ impl Settings {
}
/// Reads the settings file. A missing or unreadable file yields the
/// defaults; fields missing from the file take their default value.
/// defaults; fields missing from the file take their default value. A
/// `deepscript_model` outside [`DEEPSCRIPT_MODELS`] (e.g. an older
/// file's `"standard"`) falls back to the default instead of failing, and
/// so does a `retention_days` outside [`RETENTION_DAYS`] and a
/// `language` outside [`CALL_LANGUAGES`]; `vocabulary` is normalized
/// (see [`normalize_vocabulary`]).
pub fn load(path: &Path) -> Settings {
fs::read_to_string(path)
let mut settings: Settings = fs::read_to_string(path)
.ok()
.and_then(|json| serde_json::from_str(&json).ok())
.unwrap_or_default()
.unwrap_or_default();
if !DEEPSCRIPT_MODELS.contains(&settings.deepscript_model.as_str()) {
settings.deepscript_model = Settings::default().deepscript_model;
}
if check_call_language(&settings.language).is_err() {
settings.language = Settings::default().language;
}
// 0 would delete all audio on the next pass.
if !RETENTION_DAYS.contains(&settings.retention_days) {
settings.retention_days = Settings::default().retention_days;
}
settings.vocabulary = normalize_vocabulary(settings.vocabulary);
settings
}
/// Writes the settings file (creating its directory), replacing the old
@@ -121,6 +216,23 @@ impl Settings {
}
}
/// Trims each term, drops blanks, and deduplicates case-insensitively while
/// keeping the first occurrence's spelling and order.
fn normalize_vocabulary(terms: Vec<String>) -> Vec<String> {
let mut seen = std::collections::HashSet::new();
terms
.into_iter()
.filter_map(|term| {
let trimmed = term.trim();
if trimmed.is_empty() {
return None;
}
seen.insert(trimmed.to_lowercase())
.then(|| trimmed.to_string())
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
@@ -143,6 +255,10 @@ mod tests {
assert_eq!(s.output_device, None);
assert_eq!(s.language, "de");
assert_eq!(s.deepscript_model, "premium");
assert_eq!(
s.vocabulary,
vec!["Tschüss", "Perfekt", "Servus", "Moin", "Euvino"]
);
assert_eq!(s.retention_days, 7);
assert!(s.autostart);
assert_eq!(s.start_after_secs, 3);
@@ -170,6 +286,77 @@ mod tests {
);
}
#[test]
fn an_older_files_model_and_a_missing_vocabulary_fall_back_to_the_default() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("settings.json");
fs::write(&path, r#"{"deepscript_model": "standard"}"#).unwrap();
assert_eq!(Settings::load(&path), Settings::default());
fs::write(&path, r#"{"deepscript_model": "nonsense"}"#).unwrap();
assert_eq!(Settings::load(&path), Settings::default());
}
#[test]
fn loading_normalizes_the_stored_vocabulary() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("settings.json");
fs::write(
&path,
r#"{"vocabulary": [" Tschüss ", "", "TSCHÜSS", " ", "Euvino"]}"#,
)
.unwrap();
assert_eq!(
Settings::load(&path).vocabulary,
vec!["Tschüss".to_string(), "Euvino".to_string()]
);
}
#[test]
fn the_five_call_languages_are_accepted() {
for language in CALL_LANGUAGES {
assert_eq!(check_call_language(language), Ok(()), "{language}");
}
assert_eq!(CALL_LANGUAGES, ["de", "en", "es", "fr", "it"]);
}
#[test]
fn another_call_language_is_refused() {
assert_eq!(
check_call_language("auto"),
Err("Unbekannte Sprache: auto".to_string())
);
assert_eq!(
check_call_language("pt"),
Err("Unbekannte Sprache: pt".to_string())
);
}
#[test]
fn an_unknown_stored_language_falls_back_to_the_default() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("settings.json");
fs::write(&path, r#"{"language": "auto"}"#).unwrap();
assert_eq!(Settings::load(&path).language, "de");
fs::write(&path, r#"{"language": "it"}"#).unwrap();
assert_eq!(Settings::load(&path).language, "it");
}
#[test]
fn an_edit_keeps_the_last_used_language_which_only_the_app_changes() {
let current = Settings {
language: "fr".into(),
..Settings::default()
};
let edited = Settings {
language: "de".into(),
..Settings::default()
};
assert_eq!(current.edited(edited).unwrap().language, "fr");
}
fn logged_in() -> Settings {
Settings {
backend_username: Some("hinrichs".into()),
@@ -249,6 +436,122 @@ mod tests {
}
}
#[test]
fn validate_checks_the_retention_period() {
for days in [1, 3650] {
let s = Settings {
retention_days: days,
..Settings::default()
};
assert_eq!(s.validate(), Ok(()), "{days} days");
}
for days in [0, 3651] {
let s = Settings {
retention_days: days,
..Settings::default()
};
assert_eq!(
s.validate(),
Err("Aufbewahrung: 1–3650 Tage".to_string()),
"{days} days"
);
}
}
#[test]
fn a_retention_period_out_of_range_falls_back_to_the_default_on_load() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("settings.json");
for days in [0, 3651] {
fs::write(
&path,
format!(
r#"{{"retention_days": {days}, "mic_device": "headset", "backend_key_base_url": "https://crm.example"}}"#
),
)
.unwrap();
assert_eq!(
Settings::load(&path),
Settings {
mic_device: Some("headset".into()),
backend_key_base_url: Some("https://crm.example".into()),
..Settings::default()
},
"{days} days"
);
}
}
#[test]
fn validate_rejects_a_model_outside_the_offered_two() {
for model in ["standard", "nonsense", ""] {
let s = Settings {
deepscript_model: model.to_string(),
..Settings::default()
};
assert_eq!(
s.validate(),
Err("Transkriptionsmodell: nur premium oder premium_jade möglich".to_string())
);
}
for model in ["premium", "premium_jade"] {
let s = Settings {
deepscript_model: model.to_string(),
..Settings::default()
};
assert_eq!(s.validate(), Ok(()));
}
}
#[test]
fn validate_rejects_too_many_vocabulary_terms() {
let s = Settings {
vocabulary: (0..=MAX_VOCABULARY_TERMS).map(|n| n.to_string()).collect(),
..Settings::default()
};
assert_eq!(
s.validate(),
Err(format!(
"Vokabular: höchstens {MAX_VOCABULARY_TERMS} Begriffe"
))
);
}
#[test]
fn validate_rejects_a_too_long_vocabulary_term() {
let s = Settings {
vocabulary: vec!["a".repeat(MAX_VOCABULARY_TERM_LEN + 1)],
..Settings::default()
};
assert_eq!(
s.validate(),
Err(format!(
"Vokabular: „{}“ ist länger als {MAX_VOCABULARY_TERM_LEN} Zeichen",
"a".repeat(MAX_VOCABULARY_TERM_LEN + 1)
))
);
}
#[test]
fn an_edit_normalizes_the_vocabulary_before_validating_and_saving() {
let edited = Settings {
vocabulary: vec![
" Tschüss ".to_string(),
"".to_string(),
"TSCHÜSS".to_string(),
"Kisling".to_string(),
],
..Settings::default()
};
let saved = logged_in().edited(edited).unwrap();
assert_eq!(
saved.vocabulary,
vec!["Tschüss".to_string(), "Kisling".to_string()]
);
}
#[test]
fn settings_load_missing_file_returns_default() {
let dir = tempfile::tempdir().unwrap();
+101 -8
View File
@@ -130,9 +130,25 @@ ALTER TABLE calls ADD COLUMN crm_base_url TEXT;
UPDATE calls SET crm_base_url = 'https://test.euvinopro.eu' WHERE crm_transcript_id IS NOT NULL;
";
/// Version 5: the language a call is transcribed in, chosen per call when
/// its transcription is started. Before this version every transcription
/// used the then default German: backfilled for the calls one was started
/// for, so their corrections (`call_view`) stay as they were; a call still
/// waiting gets its language when the user decides.
const SCHEMA_V5_SQL: &str = "
ALTER TABLE calls ADD COLUMN language TEXT;
UPDATE calls SET language = 'de' WHERE status NOT IN ('recording', 'awaiting_decision');
";
/// Schema steps by `PRAGMA user_version`: entry `i` takes a database from
/// version `i` to `i + 1`. A new database runs all of them.
const MIGRATIONS: &[&str] = &[SCHEMA_V1_SQL, SCHEMA_V2_SQL, SCHEMA_V3_SQL, SCHEMA_V4_SQL];
const MIGRATIONS: &[&str] = &[
SCHEMA_V1_SQL,
SCHEMA_V2_SQL,
SCHEMA_V3_SQL,
SCHEMA_V4_SQL,
SCHEMA_V5_SQL,
];
/// SQLite-backed store for calls and everything derived from them.
pub struct Store {
@@ -390,6 +406,16 @@ impl Store {
Ok(())
}
/// Sets the language (ISO 639-1 code) the call is transcribed in.
pub fn set_language(&self, id: CallId, language: &str) -> Result<()> {
let conn = self.conn.lock().unwrap();
conn.execute(
"UPDATE calls SET language = ?1 WHERE id = ?2",
params![language, id],
)?;
Ok(())
}
pub fn mark_transcribed(&self, id: CallId, at: DateTime<Local>) -> Result<()> {
let conn = self.conn.lock().unwrap();
conn.execute(
@@ -549,9 +575,9 @@ fn ids_with_status(conn: &rusqlite::Connection, status: CallStatus) -> Result<Ve
Ok(ids)
}
const SELECT_ALL_CALLS_SQL: &str = "SELECT id, app, started_at, ended_at, status, interrupted, error, mic_path, out_path, transcribed_at, audio_deleted, title, crm_transcript_id, uploaded_at, crm_base_url FROM calls";
const SELECT_ALL_CALLS_SQL: &str = "SELECT id, app, started_at, ended_at, status, interrupted, error, mic_path, out_path, transcribed_at, audio_deleted, title, crm_transcript_id, uploaded_at, crm_base_url, language FROM calls";
const SELECT_CALL_COLUMNS_SQL: &str = "SELECT id, app, started_at, ended_at, status, interrupted, error, mic_path, out_path, transcribed_at, audio_deleted, title, crm_transcript_id, uploaded_at, crm_base_url FROM calls WHERE id = ?1";
const SELECT_CALL_COLUMNS_SQL: &str = "SELECT id, app, started_at, ended_at, status, interrupted, error, mic_path, out_path, transcribed_at, audio_deleted, title, crm_transcript_id, uploaded_at, crm_base_url, language FROM calls WHERE id = ?1";
fn row_to_call(row: &Row) -> Result<Call> {
let id: CallId = row.get(0)?;
@@ -569,6 +595,7 @@ fn row_to_call(row: &Row) -> Result<Call> {
let crm_transcript_id: Option<String> = row.get(12)?;
let uploaded_at: Option<String> = row.get(13)?;
let crm_base_url: Option<String> = row.get(14)?;
let language: Option<String> = row.get(15)?;
Ok(Call {
id,
@@ -586,6 +613,7 @@ fn row_to_call(row: &Row) -> Result<Call> {
crm_transcript_id,
crm_base_url,
uploaded_at: opt_dt_from_str(uploaded_at)?,
language,
})
}
@@ -715,6 +743,14 @@ CREATE TABLE speaker_merges (
const RELEASED_V3_STEP_SQL: &str = "
ALTER TABLE calls ADD COLUMN crm_transcript_id TEXT;
ALTER TABLE calls ADD COLUMN uploaded_at TEXT;
";
/// The schema of user_version 4, exactly as release 0.2.2 created it
/// (copied from `SCHEMA_V4_SQL` at `HEAD`): version 3 plus these
/// statements.
const RELEASED_V4_STEP_SQL: &str = "
ALTER TABLE calls ADD COLUMN crm_base_url TEXT;
UPDATE calls SET crm_base_url = 'https://test.euvinopro.eu' WHERE crm_transcript_id IS NOT NULL;
";
fn user_version(path: &Path) -> i64 {
@@ -738,7 +774,7 @@ ALTER TABLE calls ADD COLUMN uploaded_at TEXT;
}
#[test]
fn a_new_database_starts_at_version_4() {
fn a_new_database_starts_at_version_5() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("calls.sqlite");
let store = Store::open(&path).unwrap();
@@ -750,7 +786,7 @@ ALTER TABLE calls ADD COLUMN uploaded_at TEXT;
.unwrap();
drop(store);
assert_eq!(user_version(&path), 4);
assert_eq!(user_version(&path), 5);
}
#[test]
@@ -807,7 +843,7 @@ ALTER TABLE calls ADD COLUMN uploaded_at TEXT;
store.set_title(1, Some("Lieferung März")).unwrap();
store.set_speaker_merge(1, "remote:2", "remote:1").unwrap();
drop(store);
assert_eq!(user_version(&path), 4);
assert_eq!(user_version(&path), 5);
let store = Store::open(&path).unwrap();
let call = store.get_call(1).unwrap().unwrap();
assert_eq!(call.title.as_deref(), Some("Lieferung März"));
@@ -861,7 +897,7 @@ ALTER TABLE calls ADD COLUMN uploaded_at TEXT;
.set_uploaded(1, "crm-1", "https://backend.example", uploaded)
.unwrap();
drop(store);
assert_eq!(user_version(&path), 4);
assert_eq!(user_version(&path), 5);
let store = Store::open(&path).unwrap();
let call = store.get_call(1).unwrap().unwrap();
assert_eq!(call.crm_transcript_id.as_deref(), Some("crm-1"));
@@ -915,7 +951,64 @@ ALTER TABLE calls ADD COLUMN uploaded_at TEXT;
assert_eq!(not_uploaded.crm_transcript_id, None);
assert_eq!(not_uploaded.crm_base_url, None);
assert_eq!(user_version(&path), 4);
assert_eq!(user_version(&path), 5);
}
#[test]
fn a_version_4_database_is_upgraded_backfilling_german_for_started_transcriptions() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("calls.sqlite");
let started = "2026-11-05T10:14:00+01:00";
{
let conn = rusqlite::Connection::open(&path).unwrap();
conn.execute_batch(RELEASED_V1_SCHEMA_SQL).unwrap();
conn.execute_batch(RELEASED_V2_STEP_SQL).unwrap();
conn.execute_batch(RELEASED_V3_STEP_SQL).unwrap();
conn.execute_batch(RELEASED_V4_STEP_SQL).unwrap();
conn.execute_batch("PRAGMA user_version = 4;").unwrap();
for (app, status) in [
("Microsoft Teams", "done"),
("Zoom", "failed"),
("MicroSIP", "awaiting_decision"),
] {
conn.execute(
"INSERT INTO calls \
(app, started_at, ended_at, status, interrupted, error, mic_path, out_path, transcribed_at, audio_deleted) \
VALUES (?1, ?2, ?2, ?3, 0, NULL, '/rec/mic.wav', '/rec/out.wav', NULL, 0)",
rusqlite::params![app, started, status],
)
.unwrap();
}
}
let store = Store::open(&path).unwrap();
// Transcriptions started before this version all used the then
// default German; a call still waiting has no language yet.
let languages: Vec<_> = (1..=3)
.map(|id| store.get_call(id).unwrap().unwrap().language)
.collect();
assert_eq!(
languages,
[Some("de".to_string()), Some("de".to_string()), None]
);
assert_eq!(user_version(&path), 5);
}
#[test]
fn the_language_is_stored_per_call() {
let store = Store::open_in_memory().unwrap();
let id = new_call(&store);
let other = new_call(&store);
assert_eq!(store.get_call(id).unwrap().unwrap().language, None);
store.set_language(id, "fr").unwrap();
assert_eq!(
store.get_call(id).unwrap().unwrap().language.as_deref(),
Some("fr")
);
assert_eq!(store.get_call(other).unwrap().unwrap().language, None);
}
#[test]
+61
View File
@@ -201,6 +201,15 @@ impl Transcriber for DeepScript {
value: "1".to_string(),
});
}
if !opts.vocabulary.is_empty() {
parts.push(Part::Text {
name: "vocabulary".to_string(),
// The documented format: "JSON array of custom words, or
// comma-separated string."
value: serde_json::to_string(&opts.vocabulary)
.expect("Vec<String> always serializes"),
});
}
let req = HttpRequest {
method: Method::Post,
@@ -385,6 +394,7 @@ mod tests {
language: language.to_string(),
model: model.to_string(),
single_speaker,
vocabulary: Vec::new(),
}
}
@@ -439,6 +449,57 @@ mod tests {
transport.assert_done();
}
#[tokio::test]
async fn submit_sends_vocabulary_as_a_json_array_string() {
let transport = Arc::new(FakeTransport::new());
transport.expect(
Method::Post,
&format!("{BASE}/transcriptions"),
202,
r#"{"data":{"id":"job-voc","status":"queued","model":"premium","originalFileName":"mic.flac","createdOn":"2026-01-01T00:00:00Z"}}"#,
);
let ds = deep_script(&transport);
let mut vocab_opts = opts("premium", "de", true);
vocab_opts.vocabulary = vec!["Tschüss".to_string(), "Euvino".to_string()];
ds.submit(Path::new("mic.flac"), &vocab_opts).await.unwrap();
let requests = transport.requests();
let HttpBody::Multipart(parts) = &requests[0].body else {
panic!("expected multipart body");
};
assert!(parts.contains(&Part::Text {
name: "vocabulary".to_string(),
value: r#"["Tschüss","Euvino"]"#.to_string(),
}));
transport.assert_done();
}
#[tokio::test]
async fn submit_omits_vocabulary_when_empty() {
let transport = Arc::new(FakeTransport::new());
transport.expect(
Method::Post,
&format!("{BASE}/transcriptions"),
202,
r#"{"data":{"id":"job-novoc","status":"queued","model":"premium","originalFileName":"mic.flac","createdOn":"2026-01-01T00:00:00Z"}}"#,
);
let ds = deep_script(&transport);
ds.submit(Path::new("mic.flac"), &opts("premium", "de", true))
.await
.unwrap();
let requests = transport.requests();
let HttpBody::Multipart(parts) = &requests[0].body else {
panic!("expected multipart body");
};
assert!(!parts
.iter()
.any(|p| matches!(p, Part::Text { name, .. } if name == "vocabulary")));
transport.assert_done();
}
#[tokio::test]
async fn submit_without_hint_for_output_track() {
let transport = Arc::new(FakeTransport::new());
+3
View File
@@ -24,6 +24,9 @@ pub struct TranscribeOptions {
/// the user) — the output track may have several, so this is left
/// unset there.
pub single_speaker: bool,
/// Custom words/names to bias the transcription towards (DeepScript's
/// `vocabulary` field); empty omits the field entirely.
pub vocabulary: Vec<String>,
}
/// Uploads an audio file to a remote speech-to-text service, waits for the
+4 -4
View File
@@ -1,10 +1,10 @@
{
"version": "0.2.1",
"pub_date": "2026-11-06T14:48:27Z",
"version": "0.4.0",
"pub_date": "2026-11-18T10:48:28Z",
"platforms": {
"windows-x86_64": {
"signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUlVUdGpRa1ZvalU2SU9ZeUN6RUpYcjNFQ0VFTTZrZFpEa255SkRib0JtMVE4aEdVOG9ack5valRJdVAwZy9wcHZ2a1JFUHREZmJGT21Yd2hNOTh2TmMwSTVYRlRhQ1NqREFZPQp0cnVzdGVkIGNvbW1lbnQ6IHRpbWVzdGFtcDoxNzkzOTc2NDgwCWZpbGU6R2VzcHLDpGNoc3Jla29yZGVyXzAuMi4xX3g2NC1zZXR1cC5leGUJdmVyc2lvbjowLjIuMQplYUZLR25PZVk0dm4xZUczMElNYlpYeEZ5Um9VbTgwbEJKUmQwU2l1QkZPUE9Bdy9sd1FIUHAyb0MyeEZlemkxaktwM0VBd05PZDBRV3NYWTVOSmlBQT09Cg==",
"url": "https://gitea.euvino.eu/public/call-recorder/releases/download/v0.2.1/Gespraechsrekorder_0.2.1_x64-setup.exe"
"signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUlVUdGpRa1ZvalU2SUZxOUFRY3BBVnphWnBYN2lnZ2xNV0FzQnpWdWt6S1pHcXg2VUovZFF6MmtuODNaWjNwRWRWbTZONDZYVWthYndrR0w5cjJPWVU4MHMwK0pXVnFHVmdVPQp0cnVzdGVkIGNvbW1lbnQ6IHRpbWVzdGFtcDoxNzk0OTk4ODc4CWZpbGU6R2VzcHLDpGNoc3Jla29yZGVyXzAuNC4wX3g2NC1zZXR1cC5leGUJdmVyc2lvbjowLjQuMApVSTh5ejJFcGRsbEJMRC9EVnQzRjBHbWVoZTM5cHh1TXhtemdTd1JUVkZoM0dOZ3FLUmdUSy9zVTN3Szg4ZDRsZHNHL3hBZStOQndKeW9wd1p3dDJDQT09Cg==",
"url": "https://gitea.euvino.eu/public/call-recorder/releases/download/v0.4.0/Gespraechsrekorder_0.4.0_x64-setup.exe"
}
}
}
+2 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "call-recorder"
version = "0.2.2"
version = "0.4.0"
description = "Gesprächsrekorder desktop app"
edition = "2021"
@@ -30,3 +30,4 @@ tauri-plugin-updater = "2"
tauri-plugin-opener = "2"
tokio = { version = "1", features = ["sync"] }
async-trait = "0.1"
http-range = "0.1.6"
+29 -8
View File
@@ -19,7 +19,8 @@ use tauri_plugin_autostart::ManagerExt;
use crate::processing;
use crate::state::{
AppState, CallBrief, DeviceLevels, DiscardError, Ended, PendingPrompt, RecordingState,
AppState, CallBrief, DeviceLevels, DiscardError, Ended, PendingPrompt, PreparedPlayback,
RecordingState,
};
const LEVELS_INTERVAL: Duration = Duration::from_millis(100);
@@ -208,6 +209,25 @@ pub fn rename_call(
Ok(())
}
/// Mixes the call's two tracks into one file to play in the detail view
/// (or reuses the cached mix); the main window plays it from the
/// `playback` scheme ([`crate::playback`]).
#[tauri::command]
pub async fn prepare_playback(app: AppHandle, id: CallId) -> CmdResult<PreparedPlayback> {
blocking(app, move |app| app.state::<AppState>().prepare_playback(id)).await
}
/// The player is done with the mix of `lease`: it is removed from disk
/// unless a newer player of the same call holds it.
#[tauri::command]
pub async fn release_playback(app: AppHandle, id: CallId, lease: u64) -> CmdResult<()> {
blocking(app, move |app| {
app.state::<AppState>().release_playback(id, lease);
Ok(())
})
.await
}
/// Deletes a finished call's audio and row. Closes the prompt if no call
/// waits for it any more; otherwise the prompt reloads and shows the next.
/// While its DeepScript jobs are still on record, nothing is deleted and a
@@ -221,7 +241,7 @@ pub async fn discard_call(app: AppHandle, id: CallId) -> CmdResult<()> {
processing::delete_leftover_jobs(app, vec![id]);
return Err(e.to_string());
}
Err(e @ DiscardError::Other(_)) => return Err(e.to_string()),
Err(e) => return Err(e.to_string()),
}
prompt_queue_changed(app);
Ok(())
@@ -230,16 +250,17 @@ pub async fn discard_call(app: AppHandle, id: CallId) -> CmdResult<()> {
}
/// Transkribieren in the end-of-call prompt: starts processing in the
/// background and returns at once; the call leaves the prompt.
/// background in the chosen `language` and returns at once; the call
/// leaves the prompt.
#[tauri::command]
pub async fn transcribe_call(app: AppHandle, id: CallId) -> CmdResult<()> {
blocking(app, move |app| processing::start(app, id, false)).await
pub async fn transcribe_call(app: AppHandle, id: CallId, language: String) -> CmdResult<()> {
blocking(app, move |app| processing::start(app, id, false, language)).await
}
/// Processes a failed (or still undecided) call again.
/// Processes a failed (or still undecided) call again, in `language`.
#[tauri::command]
pub async fn retry_call(app: AppHandle, id: CallId) -> CmdResult<()> {
blocking(app, move |app| processing::start(app, id, true)).await
pub async fn retry_call(app: AppHandle, id: CallId, language: String) -> CmdResult<()> {
blocking(app, move |app| processing::start(app, id, true, language)).await
}
/// After a call left the prompt queue: hides the prompt if no call waits
+27
View File
@@ -1,7 +1,9 @@
mod backend;
mod commands;
mod detection;
mod playback;
mod processing;
mod retention;
mod state;
mod tray;
mod updater;
@@ -43,6 +45,21 @@ pub fn run() {
.open_js_links_on_click(false)
.build(),
)
// A call's mix for the player: only for the main window, whatever
// other webviews (the remote backend login) ask for.
.register_asynchronous_uri_scheme_protocol(playback::SCHEME, |ctx, request, responder| {
let webview = ctx.webview_label().to_string();
let dir = ctx
.app_handle()
.try_state::<AppState>()
.map(|state| state.playback_dir().to_path_buf());
tauri::async_runtime::spawn_blocking(move || {
responder.respond(match dir {
Some(dir) => playback::respond(&webview, &request, &dir),
None => playback::unavailable(),
})
});
})
.setup(|app| {
// Release builds log to a file in the app log directory (on
// Windows %LOCALAPPDATA%\eu.euvino.callrecorder\logs), debug
@@ -72,6 +89,8 @@ pub fn run() {
let data_dir = app.path().app_data_dir()?;
let config_dir = app.path().app_config_dir()?;
// Served to the main window only, by the `playback` scheme.
let playback_dir = app.path().app_cache_dir()?.join("playback");
std::fs::create_dir_all(&data_dir)?;
let store = Store::open(&data_dir.join("calls.sqlite"))?;
let recovery = pipeline::recover_on_startup(&store)?;
@@ -82,6 +101,7 @@ pub fn run() {
Box::new(KeyringSecrets),
config_dir.join("settings.json"),
data_dir.join("recordings"),
playback_dir,
);
let leftover_jobs = state.store.calls_with_remote_jobs().unwrap_or_else(|e| {
log::error!("could not read leftover remote jobs: {e}");
@@ -96,6 +116,8 @@ pub fn run() {
std::thread::spawn(KeyringSecrets::remove_unused_keys);
// Before anything can start a run.
processing::clear_upload_dir(app.handle());
// Before any window can ask for a mix.
state.clear_playback_cache();
app.manage(state);
app.manage(PendingUpdate::default());
app.manage(UpdateSchedule::default());
@@ -108,6 +130,9 @@ pub fn run() {
create_windows(app.handle())?;
commands::apply_autostart(app.handle(), autostart);
processing::delete_leftover_jobs(app.handle(), leftover_jobs);
// After the startup recovery and the cache clears, with the
// windows there to hear what it deleted.
retention::spawn(app.handle().clone());
tray::create(app.handle())?;
detection::spawn(app.handle().clone());
@@ -154,6 +179,8 @@ pub fn run() {
commands::merge_speakers,
commands::unmerge_speaker,
commands::rename_call,
commands::prepare_playback,
commands::release_playback,
backend::backend_server,
backend::backend_status,
backend::backend_login,
+293
View File
@@ -0,0 +1,293 @@
//! The `playback` URI scheme: serves a call's cached mix
//! ([`recorder_core::playback`]) to the main window, and to no other
//! webview — the backend-login window shows a remote page, which must
//! never read customer audio.
//!
//! The URL carries only the call id: `playback://localhost/<id>` on Linux
//! and macOS, `http://playback.localhost/<id>` on Windows (what the UI's
//! `convertFileSrc(id, 'playback')` builds). Range requests are answered
//! so the player can seek without loading the whole file.
use std::fs::File;
use std::io::{self, ErrorKind, Read, Seek, SeekFrom};
use std::path::Path;
use http_range::HttpRange;
use recorder_core::model::CallId;
use recorder_core::playback::cache_path;
use tauri::http::header::{
ACCEPT_RANGES, ACCESS_CONTROL_ALLOW_ORIGIN, ACCESS_CONTROL_EXPOSE_HEADERS, CACHE_CONTROL,
CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, RANGE,
};
use tauri::http::{response, Method, Request, Response, StatusCode};
/// The scheme's name (see the module docs for its URLs).
pub const SCHEME: &str = "playback";
/// The only webview the scheme answers.
pub const PLAYER_WEBVIEW: &str = "main";
/// The most bytes one range response carries (like Tauri's asset protocol).
const MAX_RANGE_LEN: u64 = 1024 * 1024;
/// Answers `request` from webview `webview` with call `<id>`'s mix in the
/// playback directory `dir`: 403 for any webview but the main window, 404
/// for anything but a plain numeric id or a mix that is not there, 206 for
/// a satisfiable range (at most [`MAX_RANGE_LEN`] bytes), 416 otherwise.
pub fn respond(webview: &str, request: &Request<Vec<u8>>, dir: &Path) -> Response<Vec<u8>> {
if webview != PLAYER_WEBVIEW {
log::warn!("playback refused to webview {webview}");
return empty(StatusCode::FORBIDDEN);
}
let method = request.method();
if method != Method::GET && method != Method::HEAD {
return empty(StatusCode::METHOD_NOT_ALLOWED);
}
let Some(id) = call_id(request.uri().path()) else {
return empty(StatusCode::NOT_FOUND);
};
let range = request
.headers()
.get(RANGE)
.map(|value| value.to_str().unwrap_or_default());
match serve(&cache_path(dir, id), range, method == Method::HEAD) {
Ok(response) => response,
Err(e) if e.kind() == ErrorKind::NotFound => empty(StatusCode::NOT_FOUND),
Err(e) => {
log::error!("call {id}: could not serve the playback file: {e}");
empty(StatusCode::INTERNAL_SERVER_ERROR)
}
}
}
/// The answer while the app state is not set up yet (no window can play
/// before it is, so this is never expected).
pub fn unavailable() -> Response<Vec<u8>> {
empty(StatusCode::SERVICE_UNAVAILABLE)
}
/// The call id of a request path: exactly `/<digits>`.
fn call_id(path: &str) -> Option<CallId> {
let digits = path.strip_prefix('/')?;
if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
digits.parse().ok()
}
fn serve(path: &Path, range: Option<&str>, head: bool) -> io::Result<Response<Vec<u8>>> {
let mut file = File::open(path)?;
let len = file.metadata()?.len();
let builder = headers();
let Some(range) = range else {
let mut body = Vec::new();
if !head {
file.read_to_end(&mut body)?;
}
return Ok(build(builder.header(CONTENT_LENGTH, len), body));
};
// A media element asks for one range at a time; of several, the first.
let Some(range) = HttpRange::parse(range, len)
.ok()
.and_then(|r| r.first().copied())
else {
return Ok(build(
builder
.status(StatusCode::RANGE_NOT_SATISFIABLE)
.header(CONTENT_RANGE, format!("bytes */{len}")),
Vec::new(),
));
};
let start = range.start;
let count = range.length.min(MAX_RANGE_LEN);
let mut body = Vec::new();
if !head {
file.seek(SeekFrom::Start(start))?;
file.take(count).read_to_end(&mut body)?;
}
Ok(build(
builder
.status(StatusCode::PARTIAL_CONTENT)
.header(
CONTENT_RANGE,
format!("bytes {start}-{}/{len}", start + count - 1),
)
.header(CONTENT_LENGTH, count),
body,
))
}
/// Headers of every answer that carries the mix. Any origin may read it:
/// only the main window's own page can reach the scheme at all (the
/// webview check above), and on Linux it fetches the mix cross-origin.
fn headers() -> response::Builder {
Response::builder()
.header(CONTENT_TYPE, "audio/wav")
.header(CACHE_CONTROL, "no-store")
.header(ACCEPT_RANGES, "bytes")
.header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
.header(ACCESS_CONTROL_EXPOSE_HEADERS, "content-range")
}
fn build(builder: response::Builder, body: Vec<u8>) -> Response<Vec<u8>> {
builder
.body(body)
.unwrap_or_else(|_| empty(StatusCode::INTERNAL_SERVER_ERROR))
}
fn empty(status: StatusCode) -> Response<Vec<u8>> {
let mut response = Response::new(Vec::new());
*response.status_mut() = status;
response
.headers_mut()
.insert(CACHE_CONTROL, "no-store".parse().unwrap());
response
}
#[cfg(test)]
mod tests {
use std::fs;
use super::*;
/// A playback directory with a 10-byte "mix" for call 7.
fn dir() -> tempfile::TempDir {
let dir = tempfile::tempdir().unwrap();
fs::write(cache_path(dir.path(), 7), b"0123456789").unwrap();
dir
}
fn get(uri: &str, range: Option<&str>) -> Request<Vec<u8>> {
let mut builder = Request::builder().uri(uri);
if let Some(range) = range {
builder = builder.header(RANGE, range);
}
builder.body(Vec::new()).unwrap()
}
#[test]
fn only_the_main_window_gets_the_mix() {
let dir = dir();
let request = get("playback://localhost/7", None);
for webview in ["backend-login", "prompt", "recorder", "", "Main"] {
let response = respond(webview, &request, dir.path());
assert_eq!(response.status(), StatusCode::FORBIDDEN, "{webview}");
assert!(response.body().is_empty());
}
let response = respond("main", &request, dir.path());
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.body(), b"0123456789");
assert_eq!(response.headers()[CONTENT_TYPE], "audio/wav");
assert_eq!(response.headers()[CACHE_CONTROL], "no-store");
assert_eq!(response.headers()[CONTENT_LENGTH], "10");
}
#[test]
fn both_platform_url_forms_name_the_call() {
let dir = dir();
for uri in ["playback://localhost/7", "http://playback.localhost/7"] {
let response = respond("main", &get(uri, None), dir.path());
assert_eq!(response.status(), StatusCode::OK, "{uri}");
}
}
#[test]
fn nothing_but_a_numeric_call_id_is_served() {
let dir = dir();
fs::write(dir.path().join("secret.wav"), b"x").unwrap();
fs::write(dir.path().join("7.wav.part"), b"x").unwrap();
for path in [
"/",
"/7.wav",
"/secret",
"/../7",
"/%2e%2e%2f7",
"/7/",
"/7.wav.part",
"/-7",
"/+7",
"/%EF%BC%97",
"/99999999999999999999999",
"/8",
] {
let request = get(&format!("playback://localhost{path}"), None);
let response = respond("main", &request, dir.path());
assert_eq!(response.status(), StatusCode::NOT_FOUND, "{path}");
}
assert_eq!(call_id("/7"), Some(7));
assert_eq!(call_id("/0012"), Some(12));
}
#[test]
fn a_range_is_served_partially() {
let dir = dir();
let response = respond(
"main",
&get("playback://localhost/7", Some("bytes=2-5")),
dir.path(),
);
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
assert_eq!(response.body(), b"2345");
assert_eq!(response.headers()[CONTENT_RANGE], "bytes 2-5/10");
assert_eq!(response.headers()[CONTENT_LENGTH], "4");
let open_ended = respond(
"main",
&get("playback://localhost/7", Some("bytes=8-")),
dir.path(),
);
assert_eq!(open_ended.body(), b"89");
assert_eq!(open_ended.headers()[CONTENT_RANGE], "bytes 8-9/10");
}
#[test]
fn a_range_beyond_the_end_is_not_satisfiable() {
let dir = dir();
let response = respond(
"main",
&get("playback://localhost/7", Some("bytes=20-30")),
dir.path(),
);
assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
assert_eq!(response.headers()[CONTENT_RANGE], "bytes */10");
assert!(response.body().is_empty());
}
#[test]
fn a_long_range_is_cut_to_the_maximum() {
let dir = tempfile::tempdir().unwrap();
let len = MAX_RANGE_LEN as usize * 2 + 3;
fs::write(cache_path(dir.path(), 1), vec![1u8; len]).unwrap();
let response = respond(
"main",
&get("playback://localhost/1", Some("bytes=1-")),
dir.path(),
);
assert_eq!(response.body().len(), MAX_RANGE_LEN as usize);
assert_eq!(
response.headers()[CONTENT_RANGE],
format!("bytes 1-{}/{len}", MAX_RANGE_LEN).as_str()
);
}
#[test]
fn head_has_no_body_and_other_methods_are_refused() {
let dir = dir();
let head = Request::builder()
.method(Method::HEAD)
.uri("playback://localhost/7")
.body(Vec::new())
.unwrap();
let response = respond("main", &head, dir.path());
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.headers()[CONTENT_LENGTH], "10");
assert!(response.body().is_empty());
let post = Request::builder()
.method(Method::POST)
.uri("playback://localhost/7")
.body(Vec::new())
.unwrap();
let response = respond("main", &post, dir.path());
assert_eq!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
}
}
+17 -6
View File
@@ -9,6 +9,7 @@ use std::path::PathBuf;
use recorder_core::model::{CallId, CallStatus};
use recorder_core::pipeline::{self, PipelineOptions};
use recorder_core::secrets::Service;
use recorder_core::settings::check_call_language;
use recorder_core::transcribe::deepscript::DeepScript;
use recorder_core::transcribe::TranscribeError;
use serde::Serialize;
@@ -57,13 +58,22 @@ impl Drop for Claim {
}
}
/// Starts processing call `id` in the background and returns at once; the
/// call leaves the end-of-call prompt. `retry` also allows failed calls.
/// Without a DeepScript key nothing starts: the call is marked failed and
/// the error returned. Reads the keyring, so call it off the UI thread.
pub fn start(app: &AppHandle, id: CallId, retry: bool) -> Result<(), String> {
/// Starts processing call `id` in `language` in the background and returns
/// at once; the call leaves the end-of-call prompt. `retry` also allows
/// failed calls. The language is stored with the call and remembered for
/// the next one; one outside `CALL_LANGUAGES` is refused before anything
/// changes. Without a DeepScript key nothing starts: the call is marked
/// failed and the error returned. Reads the keyring, so call it off the UI
/// thread.
pub fn start(app: &AppHandle, id: CallId, retry: bool, language: String) -> Result<(), String> {
check_call_language(&language)?;
let claim = Claim::take(app, id, retry)?;
let state = app.state::<AppState>();
state
.store
.set_language(id, &language)
.map_err(|e| format!("Interner Fehler: {e}"))?;
state.remember_language(&language);
let Some(key) = deepscript_key(&state) else {
let msg = TranscribeError::MissingKey.user_message();
@@ -76,8 +86,9 @@ pub fn start(app: &AppHandle, id: CallId, retry: bool) -> Result<(), String> {
let work_dir = upload_dir(app)?;
let settings = state.settings();
let opts = PipelineOptions {
language: settings.language,
language,
deepscript_model: settings.deepscript_model,
vocabulary: settings.vocabulary,
};
// A fresh client per run, so a key changed in the settings applies to
// the next run.
+504
View File
@@ -0,0 +1,504 @@
//! The scheduled retention job: once at startup and then every hour (by the
//! wall clock, so also right after standby) it deletes what the retention
//! period (`retention_days` in the settings, read anew for every pass) has
//! run out for, as planned by [`plan_retention`]: the audio of transcribed
//! calls N days after the transcription (transcript, title, speaker names
//! and merges, CRM upload stay), and undecided recordings with their row N
//! days after the call ended. Failed calls keep their audio. A call that is
//! in use (recorded, processed, uploaded, played, or its DeepScript jobs
//! still on record) is skipped and tried again by the next pass; errors are
//! logged, never fatal.
use std::panic::{self, AssertUnwindSafe};
use std::slice;
use std::thread;
use std::time::{Duration, SystemTime};
use chrono::{DateTime, Local};
use recorder_core::model::{Call, CallId};
use recorder_core::retention::{plan_retention, RetentionAction};
use tauri::{AppHandle, Manager};
use crate::commands;
use crate::processing;
use crate::state::{AppState, AudioDeleteError, DiscardError};
/// How often a pass runs.
const PASS_INTERVAL: Duration = Duration::from_secs(60 * 60);
/// How often the job looks at the wall clock to see whether a pass is due.
const WAKE_INTERVAL: Duration = Duration::from_secs(60);
/// What one pass did, per call.
#[derive(Debug, Default, PartialEq)]
pub struct PassReport {
pub audio_deleted: Vec<CallId>,
pub calls_deleted: Vec<CallId>,
/// In use or changed since planned; tried again by the next pass.
pub skipped: Vec<CallId>,
/// Those of `skipped` whose DeepScript jobs are still on record.
pub cleanup_pending: Vec<CallId>,
pub failed: Vec<CallId>,
}
impl PassReport {
/// The calls whose row or audio changed.
fn changed(&self) -> impl Iterator<Item = CallId> + '_ {
self.audio_deleted
.iter()
.chain(&self.calls_deleted)
.copied()
}
fn is_empty(&self) -> bool {
self == &PassReport::default()
}
/// "2 audio deleted, 1 call deleted, 1 skipped, 0 failed" for the log.
fn summary(&self) -> String {
let calls = self.calls_deleted.len();
format!(
"{} audio deleted, {calls} {} deleted, {} skipped, {} failed",
self.audio_deleted.len(),
if calls == 1 { "call" } else { "calls" },
self.skipped.len(),
self.failed.len()
)
}
}
/// Starts the job: a pass right away and then every [`PASS_INTERVAL`].
/// Call once the startup recovery, the cache clears and the windows are
/// done. One thread runs every pass, so two never run at once.
pub fn spawn(app: AppHandle) {
let started = thread::Builder::new()
.name("retention".into())
.spawn(move || {
let mut last_pass = None;
loop {
let now = SystemTime::now();
if pass_due(last_pass, now) {
last_pass = Some(now);
// A panic must not end the job: the next pass retries.
if panic::catch_unwind(AssertUnwindSafe(|| run(&app))).is_err() {
log::error!("retention: the pass panicked");
}
}
thread::sleep(WAKE_INTERVAL);
}
});
if let Err(e) = started {
log::error!("retention: could not start the job: {e}");
}
}
/// One pass, and tells the UI what changed: `call-updated` per call (the
/// list and an open detail refresh; the player shows the retention note),
/// and the prompt, if an undecided call it waits for was deleted.
fn run(app: &AppHandle) {
let report = run_pass(&app.state::<AppState>(), Local::now());
for id in report.changed() {
processing::emit_updated(app, id);
}
if !report.calls_deleted.is_empty() {
commands::prompt_queue_changed(app);
}
// As "Verwerfen" does: once their jobs are gone, a later pass can
// delete them.
processing::delete_leftover_jobs(app, report.cleanup_pending.clone());
if !report.is_empty() {
log::info!("retention: {}", report.summary());
}
}
/// Runs one pass over all calls as of `now`, with the retention period
/// currently set.
pub fn run_pass(state: &AppState, now: DateTime<Local>) -> PassReport {
let calls = match state.store.list_calls() {
Ok(calls) => calls,
Err(e) => {
log::error!("retention: could not list the calls: {e}");
return PassReport::default();
}
};
let retention_days = state.settings().retention_days;
let plan = plan_retention(&calls, now, retention_days);
execute(state, &plan, now, retention_days)
}
/// Carries out `plan`, made as of `now` for `retention_days`. Each call is
/// planned again from its row as it is when the action runs, while nothing
/// else can take it: a call that changed since (e.g. a "Transkribieren"
/// that failed meanwhile, so it keeps its audio) is skipped. A call deleted
/// meanwhile is ignored.
fn execute(
state: &AppState,
plan: &[RetentionAction],
now: DateTime<Local>,
retention_days: u32,
) -> PassReport {
let mut report = PassReport::default();
for &action in plan {
let still_planned =
|call: &Call| plan_retention(slice::from_ref(call), now, retention_days) == [action];
match action {
RetentionAction::DeleteAudio(id) => match state.delete_audio(id, still_planned) {
Ok(()) => report.audio_deleted.push(id),
Err(AudioDeleteError::Busy(why)) => {
log::info!("retention: call {id}: audio kept for now: {why}");
report.skipped.push(id);
}
Err(AudioDeleteError::NotFound) => {
log::info!("retention: call {id}: already deleted");
}
Err(AudioDeleteError::Failed(e)) => {
log::error!("retention: call {id}: audio not deleted: {e}");
report.failed.push(id);
}
},
// The same path, and refusals, as "Verwerfen".
RetentionAction::DeleteCall(id) => match state.discard_call_if(id, still_planned) {
Ok(_) => report.calls_deleted.push(id),
Err(e @ DiscardError::Busy(_)) => {
log::info!("retention: call {id}: kept for now: {e}");
report.skipped.push(id);
}
Err(e @ DiscardError::CleanupPending) => {
log::info!("retention: call {id}: kept for now: {e}");
report.skipped.push(id);
report.cleanup_pending.push(id);
}
Err(DiscardError::NotFound) => {
log::info!("retention: call {id}: already deleted");
}
Err(DiscardError::Other(e)) => {
log::error!("retention: call {id}: not deleted: {e}");
report.failed.push(id);
}
},
}
}
report
}
/// Whether the next pass is due at `now`, given when the last one started
/// (`None`: none yet). Uses the wall clock, which keeps running in standby;
/// a clock that went back makes the pass due.
fn pass_due(last: Option<SystemTime>, now: SystemTime) -> bool {
let Some(last) = last else {
return true;
};
now.duration_since(last)
.map_or(true, |elapsed| elapsed >= PASS_INTERVAL)
}
#[cfg(test)]
mod tests {
use std::fs;
use std::path::PathBuf;
use chrono::Duration as Days;
use recorder_core::model::CallStatus;
use recorder_core::secrets::MemorySecrets;
use recorder_core::store::Store;
use super::*;
struct Fixture {
state: AppState,
dir: tempfile::TempDir,
}
fn fixture() -> Fixture {
let dir = tempfile::tempdir().unwrap();
let state = AppState::new(
Store::open_in_memory().unwrap(),
Box::new(MemorySecrets::default()),
dir.path().join("settings.json"),
dir.path().join("recordings"),
dir.path().join("playback"),
);
Fixture { state, dir }
}
/// A call with both track files that ended `ended_days_ago` and, if
/// `transcribed_days_ago` is given, was transcribed then (status
/// `Done`); otherwise it awaits the decision.
fn call(
f: &Fixture,
name: &str,
now: DateTime<Local>,
ended_days_ago: i64,
transcribed_days_ago: Option<i64>,
) -> CallId {
let mic = f.dir.path().join(format!("{name}-mic.wav"));
let out = f.dir.path().join(format!("{name}-out.wav"));
fs::write(&mic, b"mic").unwrap();
fs::write(&out, b"out").unwrap();
let store = &f.state.store;
let ended = now - Days::days(ended_days_ago);
let id = store
.create_call("Microsoft Teams", ended - Days::minutes(5), &mic, &out)
.unwrap();
store.finish_recording(id, ended, false).unwrap();
if let Some(days) = transcribed_days_ago {
store.set_status(id, CallStatus::Done, None).unwrap();
store.mark_transcribed(id, now - Days::days(days)).unwrap();
}
id
}
fn tracks(f: &Fixture, id: CallId) -> [PathBuf; 2] {
let call = f.state.store.get_call(id).unwrap().unwrap();
[call.mic_path, call.out_path]
}
fn has_audio(f: &Fixture, id: CallId) -> bool {
let call = f.state.store.get_call(id).unwrap().unwrap();
!call.audio_deleted && tracks(f, id).iter().all(|p| p.exists())
}
fn sorted(mut ids: Vec<CallId>) -> Vec<CallId> {
ids.sort();
ids
}
#[test]
fn a_pass_does_exactly_what_the_plan_says_and_skips_calls_in_use() {
let f = fixture();
let now = Local::now();
let done_old = call(&f, "done-old", now, 9, Some(8));
let done_new = call(&f, "done-new", now, 3, Some(2));
let undecided_old = call(&f, "undecided-old", now, 8, None);
let undecided_new = call(&f, "undecided-new", now, 6, None);
let failed_old = call(&f, "failed-old", now, 30, None);
f.state
.store
.set_status(failed_old, CallStatus::Failed, Some("Fehler"))
.unwrap();
let uploading = call(&f, "uploading", now, 9, Some(8));
let upload = f.state.claim_upload(uploading).unwrap();
// Its DeepScript jobs are still on record: not deleted yet.
let cleanup = call(&f, "cleanup", now, 8, None);
f.state
.store
.record_remote_job(cleanup, "mic", "job-1")
.unwrap();
let undecided_old_tracks = tracks(&f, undecided_old);
let store = &f.state.store;
store.set_speaker_name(done_old, "me", "Hauke").unwrap();
store
.set_speaker_merge(done_old, "remote:2", "remote:1")
.unwrap();
store.set_title(done_old, Some("Bestellung")).unwrap();
let report = run_pass(&f.state, now);
assert_eq!(
PassReport {
audio_deleted: sorted(report.audio_deleted),
calls_deleted: report.calls_deleted,
skipped: sorted(report.skipped),
cleanup_pending: report.cleanup_pending,
failed: report.failed,
},
PassReport {
audio_deleted: vec![done_old],
calls_deleted: vec![undecided_old],
skipped: sorted(vec![uploading, cleanup]),
cleanup_pending: vec![cleanup],
failed: vec![],
}
);
assert!(!has_audio(&f, done_old));
let kept = store.get_call(done_old).unwrap().unwrap();
assert_eq!(kept.title.as_deref(), Some("Bestellung"));
assert_eq!(
store
.speaker_names(done_old)
.unwrap()
.get("me")
.map(String::as_str),
Some("Hauke")
);
assert_eq!(
store
.speaker_merges(done_old)
.unwrap()
.get("remote:2")
.map(String::as_str),
Some("remote:1")
);
assert_eq!(f.state.store.get_call(undecided_old).unwrap(), None);
assert!(undecided_old_tracks.iter().all(|p| !p.exists()));
for kept in [done_new, undecided_new, failed_old, uploading, cleanup] {
assert!(has_audio(&f, kept), "call {kept} keeps its audio");
}
assert_eq!(f.state.store.remote_jobs(cleanup).unwrap().len(), 1);
// The next pass tries the skipped call again; nothing is done twice.
drop(upload);
let report = run_pass(&f.state, now);
assert_eq!(report.audio_deleted, vec![uploading]);
assert_eq!(report.calls_deleted, Vec::<CallId>::new());
assert_eq!(report.skipped, vec![cleanup]);
assert!(!has_audio(&f, uploading));
}
/// The plan for the calls as they are now, with 7 days.
fn plan(f: &Fixture, now: DateTime<Local>) -> Vec<RetentionAction> {
plan_retention(&f.state.store.list_calls().unwrap(), now, 7)
}
#[test]
fn an_undecided_call_that_changed_after_planning_is_kept() {
let f = fixture();
let now = Local::now();
let failed = call(&f, "failed", now, 8, None);
let processing = call(&f, "processing", now, 8, None);
let transcribed = call(&f, "transcribed", now, 8, None);
let plan = plan(&f, now);
assert_eq!(plan.len(), 3);
// "Transkribieren" without a key marks the call failed (and lets go
// of it) between planning and the delete.
let store = &f.state.store;
store
.set_status(failed, CallStatus::Failed, Some("Kein API-Schlüssel"))
.unwrap();
store
.set_status(processing, CallStatus::Processing, None)
.unwrap();
store
.set_status(transcribed, CallStatus::Done, None)
.unwrap();
store.mark_transcribed(transcribed, now).unwrap();
let report = execute(&f.state, &plan, now, 7);
assert_eq!(report.calls_deleted, Vec::<CallId>::new());
assert_eq!(
sorted(report.skipped),
sorted(vec![failed, processing, transcribed])
);
for id in [failed, processing, transcribed] {
assert!(has_audio(&f, id), "call {id} keeps its audio");
}
}
#[test]
fn a_transcribed_call_that_changed_after_planning_keeps_its_audio() {
let f = fixture();
let now = Local::now();
let failed = call(&f, "failed", now, 9, Some(8));
let undecided = call(&f, "undecided", now, 9, Some(8));
let plan = plan(&f, now);
assert_eq!(plan.len(), 2);
assert!(plan
.iter()
.all(|action| matches!(action, RetentionAction::DeleteAudio(_))));
let store = &f.state.store;
store
.set_status(failed, CallStatus::Failed, Some("Fehler"))
.unwrap();
store
.set_status(undecided, CallStatus::AwaitingDecision, None)
.unwrap();
let report = execute(&f.state, &plan, now, 7);
assert_eq!(report.audio_deleted, Vec::<CallId>::new());
assert_eq!(sorted(report.skipped), sorted(vec![failed, undecided]));
assert!(has_audio(&f, failed));
assert!(has_audio(&f, undecided));
}
#[test]
fn a_call_deleted_after_planning_is_ignored() {
let f = fixture();
let now = Local::now();
let done = call(&f, "done", now, 9, Some(8));
let undecided = call(&f, "undecided", now, 8, None);
let plan = plan(&f, now);
f.state.discard_call(done).unwrap();
f.state.discard_call(undecided).unwrap();
assert_eq!(execute(&f.state, &plan, now, 7), PassReport::default());
}
#[test]
fn a_call_that_fails_does_not_stop_the_pass() {
let f = fixture();
let now = Local::now();
let broken = call(&f, "broken", now, 9, Some(8));
// A directory where the mic track should be: removing it fails.
let [mic, _] = tracks(&f, broken);
fs::remove_file(&mic).unwrap();
fs::create_dir(&mic).unwrap();
let fine = call(&f, "fine", now, 9, Some(8));
let report = run_pass(&f.state, now);
assert_eq!(report.failed, vec![broken]);
assert_eq!(report.audio_deleted, vec![fine]);
assert!(
!f.state
.store
.get_call(broken)
.unwrap()
.unwrap()
.audio_deleted
);
}
#[test]
fn a_changed_retention_period_applies_to_the_next_pass() {
let f = fixture();
let now = Local::now();
let id = call(&f, "a", now, 4, Some(3));
assert_eq!(run_pass(&f.state, now), PassReport::default());
let mut settings = f.state.settings();
settings.retention_days = 2;
f.state.save_settings(settings).unwrap();
assert_eq!(run_pass(&f.state, now).audio_deleted, vec![id]);
}
#[test]
fn the_summary_counts_each_outcome() {
let report = PassReport {
audio_deleted: vec![1, 2],
calls_deleted: vec![3],
skipped: vec![4],
cleanup_pending: vec![],
failed: vec![],
};
assert_eq!(
report.summary(),
"2 audio deleted, 1 call deleted, 1 skipped, 0 failed"
);
}
const MIN: Duration = Duration::from_secs(60);
fn t0() -> SystemTime {
SystemTime::UNIX_EPOCH + Duration::from_secs(1_800_000_000)
}
#[test]
fn the_first_pass_is_due_at_once() {
assert!(pass_due(None, t0()));
}
#[test]
fn the_next_pass_is_due_an_hour_later() {
assert!(!pass_due(Some(t0()), t0() + 59 * MIN));
assert!(pass_due(Some(t0()), t0() + 60 * MIN));
}
#[test]
fn a_pass_is_due_after_standby_by_the_wall_clock() {
assert!(pass_due(Some(t0()), t0() + 48 * 60 * MIN));
}
#[test]
fn a_pass_is_due_when_the_clock_went_back() {
assert!(pass_due(Some(t0()), t0() - 60 * MIN));
}
}
+781 -22
View File
@@ -2,11 +2,12 @@
//!
//! Holds the store, the settings, the secret store, the HTTP transport, the
//! recording that is currently running, the call detector, the calls
//! awaiting a decision in the end-of-call prompt and the calls being
//! processed. Everything here is independent of windows and
//! events; the command layer turns results into UI updates.
//! awaiting a decision in the end-of-call prompt, the calls being
//! processed and the cached mixes for playback. Everything here is
//! independent of windows and events; the command layer turns results into
//! UI updates.
use std::collections::{HashSet, VecDeque};
use std::collections::{HashMap, HashSet, VecDeque};
use std::fs;
use std::io::ErrorKind;
use std::path::{Path, PathBuf};
@@ -23,6 +24,7 @@ use recorder_core::capture::{CaptureSource, OutputTarget};
use recorder_core::detect::{CallDetector, DetectorEvent, MicSession};
use recorder_core::http::{HttpTransport, ReqwestTransport};
use recorder_core::model::{Call, CallId, CallStatus, Speaker};
use recorder_core::playback;
use recorder_core::recorder::Recorder;
use recorder_core::secrets::{SecretStore, Service};
use recorder_core::settings::Settings;
@@ -37,6 +39,11 @@ const MANUAL_APP: &str = "Manuell";
const TEST_DURATION: Duration = Duration::from_secs(5);
const TEST_POLL: Duration = Duration::from_millis(50);
const ALREADY_PROCESSING: &str = "Wird bereits verarbeitet";
const ALREADY_UPLOADING: &str = "Wird bereits hochgeladen";
const BEING_RECORDED: &str = "Das Gespräch wird gerade aufgenommen";
const PLAYING: &str = "Das Gespräch wird gerade abgespielt";
const CHANGED: &str = "Das Gespräch hat sich inzwischen geändert";
const NOT_FOUND: &str = "Gespräch nicht gefunden";
/// Why [`AppState::discard_call`] refused.
#[derive(Debug, Clone, PartialEq)]
@@ -44,6 +51,10 @@ pub enum DiscardError {
/// DeepScript jobs of the call are still on record; their delete has to
/// succeed first, or the cascade would forget them.
CleanupPending,
/// The call is recorded, processed or uploaded right now, or no longer
/// what the caller expected ([`AppState::discard_call_if`]).
Busy(&'static str),
NotFound,
Other(String),
}
@@ -53,6 +64,8 @@ impl std::fmt::Display for DiscardError {
DiscardError::CleanupPending => f.write_str(
"Daten bei DeepScript werden noch gelöscht – bitte später erneut versuchen.",
),
DiscardError::Busy(msg) => f.write_str(msg),
DiscardError::NotFound => f.write_str(NOT_FOUND),
DiscardError::Other(msg) => f.write_str(msg),
}
}
@@ -64,6 +77,16 @@ impl From<String> for DiscardError {
}
}
/// Why [`AppState::delete_audio`] did not delete a call's audio.
#[derive(Debug, Clone, PartialEq)]
pub enum AudioDeleteError {
/// The call is in use, or no longer what the caller expected; the next
/// retention pass tries again.
Busy(&'static str),
NotFound,
Failed(String),
}
/// Payload of the `recording-state` event.
#[derive(Serialize, Clone, Debug)]
#[serde(tag = "state", rename_all = "lowercase")]
@@ -99,16 +122,21 @@ pub struct CallBrief {
pub started_at: DateTime<Local>,
pub ended_at: Option<DateTime<Local>>,
pub duration_secs: i64,
/// What the language picker starts on
/// ([`call_view::preselect_language`]).
pub language: String,
}
impl CallBrief {
fn of(call: &Call) -> Self {
/// `last_used_language` is the settings' `language`.
fn of(call: &Call, last_used_language: &str) -> Self {
Self {
id: call.id,
app: call.app.clone(),
started_at: call.started_at,
ended_at: call.ended_at,
duration_secs: call_view::duration_secs(call),
language: call_view::preselect_language(call, last_used_language),
}
}
}
@@ -146,6 +174,12 @@ pub struct AppState {
settings: Mutex<Settings>,
settings_path: PathBuf,
recordings_dir: PathBuf,
/// Where the mixes for playback are cached (`<app cache>/playback`),
/// served to the main window by [`crate::playback`].
playback_dir: PathBuf,
/// The leases on cached mixes. Held while a mix is built or removed,
/// so a call deleted meanwhile never leaves its mix behind.
playback: Mutex<PlaybackLeases>,
current: Mutex<Option<CurrentRecording>>,
detector: Mutex<CallDetector>,
/// Stopped calls awaiting the end-of-call prompt's decision, oldest
@@ -172,6 +206,23 @@ pub struct AppState {
upload_confirmed_unsaved: Mutex<HashSet<CallId>>,
}
/// A mix ready to play, from [`AppState::prepare_playback`].
#[derive(Serialize, Clone, Copy, Debug, PartialEq)]
pub struct PreparedPlayback {
pub duration_secs: f64,
/// Hand back to [`AppState::release_playback`] when the player is done.
pub lease: u64,
}
/// Which player holds each cached mix: the lease of the latest
/// [`AppState::prepare_playback`] per call. A player that lets go of an
/// older lease (it was replaced by a newer one meanwhile) removes nothing.
#[derive(Default)]
struct PlaybackLeases {
next: u64,
latest: HashMap<CallId, u64>,
}
/// An upload reserved with [`AppState::claim_upload`]; released when
/// dropped, also if the upload fails or panics.
pub struct UploadClaim<'a> {
@@ -200,6 +251,7 @@ impl AppState {
secrets: Box<dyn SecretStore>,
settings_path: PathBuf,
recordings_dir: PathBuf,
playback_dir: PathBuf,
) -> Self {
let settings = Settings::load(&settings_path);
let detector = CallDetector::new(detector_config(&settings));
@@ -210,6 +262,8 @@ impl AppState {
settings: Mutex::new(settings),
settings_path,
recordings_dir,
playback_dir,
playback: Mutex::new(PlaybackLeases::default()),
current: Mutex::new(None),
detector: Mutex::new(detector),
pending_prompts: Mutex::new(VecDeque::new()),
@@ -362,7 +416,7 @@ impl AppState {
pub fn claim_upload(&self, id: CallId) -> Result<UploadClaim<'_>, String> {
let mut uploading = lock(&self.uploading);
if uploading.contains(&id) {
return Err("Wird bereits hochgeladen".to_string());
return Err(ALREADY_UPLOADING.to_string());
}
if lock(&self.upload_confirmed_unsaved).contains(&id) {
return Err("Bereits hochgeladen".to_string());
@@ -390,6 +444,15 @@ impl AppState {
lock(&self.upload_confirmed_unsaved).insert(id);
}
/// Remembers `language` as the last used one, preselected for the next
/// call. Not saving it is only logged: the transcription it was chosen
/// for goes ahead regardless.
pub fn remember_language(&self, language: &str) {
if let Err(e) = self.update_settings(|s| s.language = language.to_string()) {
log::error!("could not remember the call language: {e}");
}
}
/// Changes and saves settings the app manages itself; saves only if
/// something changed.
fn update_settings(&self, change: impl FnOnce(&mut Settings)) -> Result<(), String> {
@@ -597,7 +660,7 @@ impl AppState {
match self.store.get_call(id) {
Ok(Some(call)) => {
return Some(PendingPrompt {
brief: CallBrief::of(&call),
brief: CallBrief::of(&call, &self.settings().language),
more_waiting: queue.len() - 1,
})
}
@@ -627,7 +690,10 @@ impl AppState {
}
pub fn call_brief(&self, id: CallId) -> Result<CallBrief, String> {
Ok(CallBrief::of(&self.find_call(id)?))
Ok(CallBrief::of(
&self.find_call(id)?,
&self.settings().language,
))
}
/// All calls for the main window's list, newest first.
@@ -646,11 +712,77 @@ impl AppState {
let segments = self.store.segments(id).map_err(|e| e.to_string())?;
let names = self.store.speaker_names(id).map_err(|e| e.to_string())?;
let merges = self.store.speaker_merges(id).map_err(|e| e.to_string())?;
let mut detail = CallDetail::of(&call, &segments, names, &merges, &self.backend_url);
let mut detail = CallDetail::of(
&call,
&segments,
names,
&merges,
&self.backend_url,
&self.settings().language,
);
detail.uploading = self.is_uploading(id);
detail.audio_available = playback::audio_available(&call);
Ok(detail)
}
/// Mixes call `id`'s tracks for playback (or reuses the cached mix,
/// see [`playback::prepare`]) under a new lease. Refused while the call
/// is recorded or processed, and once its audio is gone.
pub fn prepare_playback(&self, id: CallId) -> Result<PreparedPlayback, String> {
if lock(&self.current)
.as_ref()
.is_some_and(|cur| cur.call_id == id)
{
return Err(playback::RECORDING.to_string());
}
let mut leases = lock(&self.playback);
// Read under the lock: a call deleted before it is not mixed, one
// deleted meanwhile has its mix removed once the lock is free.
let call = self.find_call(id)?;
let info = playback::prepare(&call, &self.playback_dir)?;
leases.next += 1;
let lease = leases.next;
leases.latest.insert(id, lease);
Ok(PreparedPlayback {
duration_secs: info.duration_secs,
lease,
})
}
/// The player of `lease` is done with call `id`'s mix: removes it,
/// unless a newer lease (another player of the same call) holds it.
pub fn release_playback(&self, id: CallId, lease: u64) {
let mut leases = lock(&self.playback);
if leases.latest.get(&id) == Some(&lease) {
leases.latest.remove(&id);
playback::remove_cached(&self.playback_dir, id);
}
}
/// Removes call `id`'s cached mix whoever holds it: with the call, and
/// once its audio is deleted ([`AppState::delete_audio`] does the same
/// while it holds the leases).
pub fn remove_playback(&self, id: CallId) {
let mut leases = lock(&self.playback);
leases.latest.remove(&id);
playback::remove_cached(&self.playback_dir, id);
}
/// Where the mixes are cached ([`crate::playback`] serves them).
pub fn playback_dir(&self) -> &Path {
&self.playback_dir
}
/// Empties the playback cache (at startup), so mixed customer audio
/// never lingers from an earlier run.
pub fn clear_playback_cache(&self) {
let dir = &self.playback_dir;
match playback::clear_cache(dir) {
Ok(()) => log::info!("cleared the playback cache {}", dir.display()),
Err(e) => log::warn!("could not empty {}: {e}", dir.display()),
}
}
/// Renames a speaker of call `id`; a blank `name` restores the default
/// label ("Ich", "Sprecher N").
pub fn rename_speaker(&self, id: CallId, speaker_key: &str, name: &str) -> Result<(), String> {
@@ -712,37 +844,62 @@ impl AppState {
.ok_or_else(|| "Gespräch nicht gefunden".to_string())
}
/// Deletes a finished call: both audio files and the row, and takes it
/// out of the prompt queue. Returns how many calls still wait for the
/// prompt. A call that is being processed, or whose DeepScript jobs
/// are still on record ([`DiscardError::CleanupPending`]), is not
/// deleted.
/// Deletes a finished (or still undecided/failed) call: both audio files
/// and the row, cascading to its segments, speaker names, merges and
/// recorded remote jobs — this is also how a transcribed (`Done`) call's
/// "Löschen" removes it. Takes it out of the prompt queue and returns how
/// many calls still wait for it. Refused while the call is being
/// recorded, processed ([`AppState::claim_processing`]/
/// [`AppState::reserve_processing`] or status `Processing`), uploaded
/// ([`AppState::claim_upload`]), or while its DeepScript jobs are still
/// on record ([`DiscardError::CleanupPending`]).
pub fn discard_call(&self, id: CallId) -> Result<usize, DiscardError> {
self.discard_call_if(id, |_| true)
}
/// Like [`AppState::discard_call`], but only if the call, read while
/// nothing else can take it, still passes `still_wanted`; otherwise
/// nothing is deleted ([`DiscardError::Busy`]).
pub fn discard_call_if(
&self,
id: CallId,
still_wanted: impl FnOnce(&Call) -> bool,
) -> Result<usize, DiscardError> {
if lock(&self.current)
.as_ref()
.is_some_and(|cur| cur.call_id == id)
{
return Err("Das Gespräch wird gerade aufgenommen".to_string().into());
return Err(DiscardError::Busy(BEING_RECORDED));
}
// Held until the call is gone, so no run can claim it meanwhile.
// Both held until the call is gone, so neither a pipeline run nor an
// upload can claim it meanwhile (same uploading -> store lock order
// as `claim_upload`, so this can never deadlock against it).
let processing = lock(&self.processing);
if processing.contains(&id) {
return Err(ALREADY_PROCESSING.to_string().into());
return Err(DiscardError::Busy(ALREADY_PROCESSING));
}
let uploading = lock(&self.uploading);
if uploading.contains(&id) {
return Err(DiscardError::Busy(ALREADY_UPLOADING));
}
let call = self
.store
.get_call(id)
.map_err(|e| e.to_string())?
.ok_or_else(|| "Gespräch nicht gefunden".to_string())?;
.ok_or(DiscardError::NotFound)?;
if call.status == CallStatus::Processing {
return Err(ALREADY_PROCESSING.to_string().into());
return Err(DiscardError::Busy(ALREADY_PROCESSING));
}
if !still_wanted(&call) {
return Err(DiscardError::Busy(CHANGED));
}
let remote_jobs = self.store.remote_jobs(id).map_err(|e| e.to_string())?;
if !remote_jobs.is_empty() {
return Err(DiscardError::CleanupPending);
}
// Files first: if one cannot be deleted, the row stays so the user
// can try again instead of leaving orphaned audio behind.
// can try again instead of leaving orphaned audio behind. Already
// gone (e.g. removed by retention) is not an error.
for path in [&call.mic_path, &call.out_path] {
if path.as_os_str().is_empty() {
continue;
@@ -768,10 +925,85 @@ impl AppState {
}
return Err(format!("Gespräch konnte nicht gelöscht werden: {e}").into());
}
drop(uploading);
drop(processing);
self.remove_playback(id);
Ok(self.prompts_waiting())
}
/// Deletes a transcribed (`Done`) call's audio for the retention job:
/// both track files and its cached mix, then marks the row
/// (`audio_deleted`). Transcript, title, speaker names and merges and the
/// CRM upload stay. Refused ([`AudioDeleteError::Busy`]) while the call
/// is recorded, processed (or its remote jobs cleaned up), uploaded or a
/// player holds its mix, and unless the row, read while nothing else can
/// take the call, is `Done` with its audio not yet deleted and passes
/// `still_due`.
/// Already missing files are fine; a file that cannot be deleted leaves
/// the row unmarked, so the next pass tries again.
pub fn delete_audio(
&self,
id: CallId,
still_due: impl FnOnce(&Call) -> bool,
) -> Result<(), AudioDeleteError> {
if lock(&self.current)
.as_ref()
.is_some_and(|cur| cur.call_id == id)
{
return Err(AudioDeleteError::Busy(BEING_RECORDED));
}
// All held until the row is marked, so no run, upload or player can
// take the call meanwhile (same processing -> uploading -> playback
// -> store lock order as `discard_call` and `prepare_playback`).
let processing = lock(&self.processing);
if processing.contains(&id) {
return Err(AudioDeleteError::Busy(ALREADY_PROCESSING));
}
let uploading = lock(&self.uploading);
if uploading.contains(&id) {
return Err(AudioDeleteError::Busy(ALREADY_UPLOADING));
}
let mut leases = lock(&self.playback);
if leases.latest.contains_key(&id) {
return Err(AudioDeleteError::Busy(PLAYING));
}
let call = self
.store
.get_call(id)
.map_err(|e| AudioDeleteError::Failed(e.to_string()))?
.ok_or(AudioDeleteError::NotFound)?;
match call.status {
CallStatus::Recording => return Err(AudioDeleteError::Busy(BEING_RECORDED)),
CallStatus::Processing => return Err(AudioDeleteError::Busy(ALREADY_PROCESSING)),
// Failed and undecided calls keep their audio.
CallStatus::Done if !call.audio_deleted && still_due(&call) => {}
_ => return Err(AudioDeleteError::Busy(CHANGED)),
}
// Every file is tried, so as little audio as possible stays behind.
let mut failed = None;
for path in [&call.mic_path, &call.out_path] {
if path.as_os_str().is_empty() {
continue;
}
match fs::remove_file(path) {
Ok(()) => {}
Err(e) if e.kind() == ErrorKind::NotFound => {}
Err(e) => {
log::error!("call {id}: could not delete {}: {e}", path.display());
failed = Some(format!("Audiodatei konnte nicht gelöscht werden: {e}"));
}
}
}
if let Some(msg) = failed {
return Err(AudioDeleteError::Failed(msg));
}
leases.latest.remove(&id);
playback::remove_cached(&self.playback_dir, id);
self.store
.mark_audio_deleted(id)
.map_err(|e| AudioDeleteError::Failed(format!("Löschen nicht vermerkt: {e}")))
}
/// Reserves `id` for one pipeline run; release it with
/// [`AppState::release_processing`] when the run ends. A call that waits
/// for the decision can be processed; a failed one only on `retry`, or
@@ -947,6 +1179,7 @@ mod tests {
Box::new(MemorySecrets::default()),
dir.path().join("settings.json"),
dir.path().join("recordings"),
dir.path().join("playback"),
);
Fixture { state, dir }
}
@@ -982,11 +1215,36 @@ mod tests {
started_at: at(10, 14, 0),
ended_at: Some(at(10, 46, 30)),
duration_secs: 32 * 60 + 30,
language: "de".into(),
}
);
assert!(f.state.call_brief(id + 1).is_err());
}
#[test]
fn call_brief_preselects_the_calls_language_else_the_last_used() {
let f = fixture();
let (id, _, _) = finished_call(&f, "a");
f.state.remember_language("fr");
assert_eq!(f.state.call_brief(id).unwrap().language, "fr");
f.state.store.set_language(id, "it").unwrap();
assert_eq!(f.state.call_brief(id).unwrap().language, "it");
}
#[test]
fn the_last_used_language_is_remembered_across_restarts() {
let f = fixture();
f.state.remember_language("es");
assert_eq!(f.state.settings().language, "es");
assert_eq!(
Settings::load(&f.dir.path().join("settings.json")).language,
"es"
);
}
fn queued(f: &Fixture) -> Option<(CallId, usize)> {
f.state
.pending_prompt()
@@ -1103,7 +1361,7 @@ mod tests {
assert_eq!(
f.state.discard_call(id),
Err(DiscardError::Other("Wird bereits verarbeitet".to_string()))
Err(DiscardError::Busy("Wird bereits verarbeitet"))
);
f.state.release_processing(id);
f.state
@@ -1112,7 +1370,7 @@ mod tests {
.unwrap();
assert_eq!(
f.state.discard_call(id),
Err(DiscardError::Other("Wird bereits verarbeitet".to_string()))
Err(DiscardError::Busy("Wird bereits verarbeitet"))
);
assert!(mic.exists());
@@ -1147,6 +1405,60 @@ mod tests {
assert!(f.state.reserve_processing(id));
}
#[test]
fn a_transcribed_call_is_deleted_like_any_other() {
let f = fixture();
let (id, mic, out) = finished_call(&f, "a");
f.state
.store
.set_status(id, CallStatus::Done, None)
.unwrap();
assert_eq!(f.state.discard_call(id), Ok(0));
assert!(!mic.exists());
assert!(!out.exists());
assert_eq!(f.state.store.get_call(id).unwrap(), None);
}
#[test]
fn a_call_being_uploaded_is_not_discarded() {
let f = fixture();
let (id, mic, out) = finished_call(&f, "a");
f.state
.store
.set_status(id, CallStatus::Done, None)
.unwrap();
let claim = f.state.claim_upload(id).unwrap();
assert_eq!(
f.state.discard_call(id),
Err(DiscardError::Busy("Wird bereits hochgeladen"))
);
assert!(mic.exists());
assert!(out.exists());
assert!(f.state.store.get_call(id).unwrap().is_some());
// Once the upload is done, the delete goes through.
drop(claim);
assert_eq!(f.state.discard_call(id), Ok(0));
}
#[test]
fn a_call_already_uploaded_here_is_deleted_without_touching_the_crm() {
let f = fixture();
let (id, mic, out) = finished_call(&f, "a");
f.state
.store
.set_status(id, CallStatus::Done, None)
.unwrap();
f.state.mark_uploaded(id, "4711").unwrap();
assert_eq!(f.state.discard_call(id), Ok(0));
assert!(!mic.exists());
assert!(!out.exists());
assert_eq!(f.state.store.get_call(id).unwrap(), None);
}
#[test]
fn a_cleanup_reserves_a_call_of_any_status() {
let f = fixture();
@@ -1823,4 +2135,451 @@ mod tests {
OutputTarget::Device("id-Lautsprecher".into())
);
}
/// A finished call whose tracks hold real audio: one second on the mic,
/// half a second on the output.
fn playable_call(f: &Fixture, name: &str) -> CallId {
let (id, mic, out) = finished_call(f, name);
for (path, samples) in [(&mic, 16_000), (&out, 8_000)] {
let mut writer = recorder_core::audio::TrackWriter::create(path).unwrap();
writer.write(&vec![0.1; samples]).unwrap();
writer.finalize().unwrap();
}
id
}
fn playback_file(f: &Fixture, id: CallId) -> PathBuf {
f.dir.path().join("playback").join(format!("{id}.wav"))
}
#[test]
fn a_finished_call_is_mixed_into_the_playback_cache() {
let f = fixture();
let id = playable_call(&f, "a");
assert!(f.state.call_detail(id).unwrap().audio_available);
let prepared = f.state.prepare_playback(id).unwrap();
assert!((prepared.duration_secs - 1.0).abs() < 1e-9);
assert!(playback_file(&f, id).exists());
}
#[test]
fn the_player_holding_the_latest_lease_removes_the_mix() {
let f = fixture();
let id = playable_call(&f, "a");
let first = f.state.prepare_playback(id).unwrap().lease;
// The call was shown again before the first player let go.
let second = f.state.prepare_playback(id).unwrap().lease;
assert_ne!(first, second);
f.state.release_playback(id, first);
assert!(
playback_file(&f, id).exists(),
"the second player still plays"
);
f.state.release_playback(id, second);
assert!(!playback_file(&f, id).exists());
f.state.release_playback(id, second); // already gone: no error
// A lease of one call never removes another call's mix.
let other = playable_call(&f, "b");
let lease = f.state.prepare_playback(other).unwrap().lease;
f.state.release_playback(id, lease);
assert!(playback_file(&f, other).exists());
}
#[test]
fn missing_files_are_no_audio_but_not_deleted_audio() {
let f = fixture();
let (id, mic, out) = finished_call(&f, "a"); // a few junk bytes each
let detail = f.state.call_detail(id).unwrap();
assert!(!detail.audio_available);
assert!(!detail.audio_deleted);
fs::remove_file(mic).unwrap();
fs::remove_file(out).unwrap();
assert_eq!(
f.state.prepare_playback(id),
Err(playback::AUDIO_MISSING.to_string())
);
}
#[test]
fn recording_and_processing_calls_are_not_played() {
let f = fixture();
let dir = f.dir.path();
let recording = f
.state
.store
.create_call(
"Microsoft Teams",
at(10, 0, 0),
&dir.join("r-mic.wav"),
&dir.join("r-out.wav"),
)
.unwrap();
assert_eq!(
f.state.prepare_playback(recording),
Err(playback::RECORDING.to_string())
);
let processing = playable_call(&f, "p");
f.state
.store
.set_status(processing, CallStatus::Processing, None)
.unwrap();
assert_eq!(
f.state.prepare_playback(processing),
Err(playback::PROCESSING.to_string())
);
assert!(!playback_file(&f, processing).exists());
assert_eq!(
f.state.prepare_playback(999),
Err("Gespräch nicht gefunden".to_string())
);
}
#[test]
fn deleted_audio_is_not_played_and_its_mix_is_removed() {
let f = fixture();
let id = playable_call(&f, "a");
f.state.prepare_playback(id).unwrap();
// What the retention sweep does to a transcribed call's audio.
let call = f.state.store.get_call(id).unwrap().unwrap();
fs::remove_file(&call.mic_path).unwrap();
fs::remove_file(&call.out_path).unwrap();
f.state.store.mark_audio_deleted(id).unwrap();
let detail = f.state.call_detail(id).unwrap();
assert!(!detail.audio_available);
assert!(detail.audio_deleted);
assert_eq!(
f.state.prepare_playback(id),
Err(playback::AUDIO_GONE.to_string())
);
assert!(!playback_file(&f, id).exists());
}
#[test]
fn deleting_a_call_removes_its_mix() {
let f = fixture();
let id = playable_call(&f, "a");
let other = playable_call(&f, "b");
f.state.prepare_playback(id).unwrap();
f.state.prepare_playback(other).unwrap();
f.state.discard_call(id).unwrap();
assert!(!playback_file(&f, id).exists());
assert!(playback_file(&f, other).exists());
assert_eq!(
f.state.prepare_playback(id),
Err("Gespräch nicht gefunden".to_string())
);
}
#[test]
fn the_playback_cache_is_emptied_at_startup() {
let f = fixture();
let id = playable_call(&f, "a");
f.state.prepare_playback(id).unwrap();
f.state.clear_playback_cache();
assert!(!f.dir.path().join("playback").exists());
f.state.clear_playback_cache(); // nothing left: no error
}
/// A transcribed (`Done`) call with both tracks, a transcript, a title,
/// a CRM upload and a cached mix nobody holds.
fn transcribed_call_with_audio(f: &Fixture) -> CallId {
let id = transcribed_call(f);
let store = &f.state.store;
store.set_status(id, CallStatus::Done, None).unwrap();
store.mark_transcribed(id, at(11, 0, 0)).unwrap();
store.set_title(id, Some("Weinbestellung")).unwrap();
f.state.mark_uploaded(id, "4711").unwrap();
fs::create_dir_all(f.dir.path().join("playback")).unwrap();
fs::write(playback_file(f, id), b"mix").unwrap();
id
}
/// Asserts that `delete_audio` left call `id` (`mic`, `out`) untouched.
fn assert_audio_kept(f: &Fixture, id: CallId) {
let call = f.state.store.get_call(id).unwrap().unwrap();
assert!(call.mic_path.exists());
assert!(call.out_path.exists());
assert!(!call.audio_deleted);
}
#[test]
fn deleting_audio_keeps_the_transcript_title_and_upload() {
let f = fixture();
let id = transcribed_call_with_audio(&f);
let before = f.state.store.get_call(id).unwrap().unwrap();
assert_eq!(f.state.delete_audio(id, |_| true), Ok(()));
let after = f.state.store.get_call(id).unwrap().unwrap();
assert!(!before.mic_path.exists());
assert!(!before.out_path.exists());
assert!(!playback_file(&f, id).exists());
assert!(after.audio_deleted);
assert_eq!(after.status, CallStatus::Done);
assert_eq!(after.title.as_deref(), Some("Weinbestellung"));
assert_eq!(after.crm_transcript_id.as_deref(), Some("4711"));
assert_eq!(after.transcribed_at, before.transcribed_at);
assert_eq!(f.state.store.segments(id).unwrap().len(), 3);
let detail = f.state.call_detail(id).unwrap();
assert!(detail.audio_deleted);
assert!(!detail.audio_available);
}
#[test]
fn audio_already_missing_is_still_marked_deleted() {
let f = fixture();
let id = transcribed_call_with_audio(&f);
let call = f.state.store.get_call(id).unwrap().unwrap();
fs::remove_file(&call.mic_path).unwrap();
fs::remove_file(&call.out_path).unwrap();
assert_eq!(f.state.delete_audio(id, |_| true), Ok(()));
assert!(f.state.store.get_call(id).unwrap().unwrap().audio_deleted);
}
#[test]
fn audio_is_not_deleted_while_the_call_is_uploaded() {
let f = fixture();
let id = transcribed_call_with_audio(&f);
// Another backend's upload, so this build can upload it again.
f.state
.store
.set_uploaded(id, "1", "https://other.example", at(12, 0, 0))
.unwrap();
let claim = f.state.claim_upload(id).unwrap();
assert_eq!(
f.state.delete_audio(id, |_| true),
Err(AudioDeleteError::Busy(ALREADY_UPLOADING))
);
assert_audio_kept(&f, id);
drop(claim);
assert_eq!(f.state.delete_audio(id, |_| true), Ok(()));
}
#[test]
fn audio_is_not_deleted_while_the_call_is_processed() {
let f = fixture();
let id = transcribed_call_with_audio(&f);
// A cleanup of its remote jobs reserves a call of any status.
assert!(f.state.reserve_processing(id));
assert_eq!(
f.state.delete_audio(id, |_| true),
Err(AudioDeleteError::Busy(ALREADY_PROCESSING))
);
assert_audio_kept(&f, id);
f.state.release_processing(id);
f.state
.store
.set_status(id, CallStatus::Processing, None)
.unwrap();
assert_eq!(
f.state.delete_audio(id, |_| true),
Err(AudioDeleteError::Busy(ALREADY_PROCESSING))
);
assert_audio_kept(&f, id);
}
#[test]
fn audio_is_not_deleted_while_the_call_is_recorded() {
let f = fixture();
let dir = f.dir.path();
let (mic, out) = (dir.join("r-mic.wav"), dir.join("r-out.wav"));
fs::write(&mic, b"mic").unwrap();
fs::write(&out, b"out").unwrap();
let id = f
.state
.store
.create_call("Microsoft Teams", at(10, 0, 0), &mic, &out)
.unwrap();
assert_eq!(
f.state.delete_audio(id, |_| true),
Err(AudioDeleteError::Busy(BEING_RECORDED))
);
assert_audio_kept(&f, id);
}
#[test]
fn audio_is_not_deleted_while_a_player_holds_its_mix() {
let f = fixture();
let id = playable_call(&f, "a");
f.state
.store
.set_status(id, CallStatus::Done, None)
.unwrap();
let lease = f.state.prepare_playback(id).unwrap().lease;
assert_eq!(
f.state.delete_audio(id, |_| true),
Err(AudioDeleteError::Busy(PLAYING))
);
assert_audio_kept(&f, id);
assert!(playback_file(&f, id).exists());
f.state.release_playback(id, lease);
assert_eq!(f.state.delete_audio(id, |_| true), Ok(()));
}
#[test]
fn audio_that_cannot_be_deleted_stays_unmarked() {
let f = fixture();
let dir = f.dir.path();
// A directory where the mic track should be: removing it fails.
let mic = dir.join("x-mic.wav");
fs::create_dir(&mic).unwrap();
let out = dir.join("x-out.wav");
fs::write(&out, b"out").unwrap();
let store = &f.state.store;
let id = store
.create_call("Microsoft Teams", at(10, 0, 0), &mic, &out)
.unwrap();
store.finish_recording(id, at(10, 5, 0), false).unwrap();
store.set_status(id, CallStatus::Done, None).unwrap();
assert!(matches!(
f.state.delete_audio(id, |_| true),
Err(AudioDeleteError::Failed(_))
));
assert!(!f.state.store.get_call(id).unwrap().unwrap().audio_deleted);
// What could be deleted is gone.
assert!(!out.exists());
fs::remove_dir(&mic).unwrap();
assert_eq!(f.state.delete_audio(id, |_| true), Ok(()));
assert!(f.state.store.get_call(id).unwrap().unwrap().audio_deleted);
}
#[test]
fn an_unknown_call_is_not_found() {
let f = fixture();
assert_eq!(
f.state.delete_audio(999, |_| true),
Err(AudioDeleteError::NotFound)
);
assert_eq!(f.state.discard_call(999), Err(DiscardError::NotFound));
assert_eq!(
DiscardError::NotFound.to_string(),
"Gespräch nicht gefunden"
);
}
/// A capture source that starts and then delivers nothing.
struct SilentSource;
impl CaptureSource for SilentSource {
fn start(
&mut self,
_on_data: recorder_core::capture::DataCallback,
) -> Result<recorder_core::capture::StreamFormat, recorder_core::capture::CaptureError>
{
Ok(recorder_core::capture::StreamFormat {
rate: 16_000,
channels: 1,
})
}
fn stop(&mut self) {}
fn failure(&self) -> Option<String> {
None
}
}
#[test]
fn audio_of_the_running_recording_is_not_deleted() {
let f = fixture();
// A row that looks deletable: only `current` says it records.
let id = transcribed_call_with_audio(&f);
let dir = f.dir.path();
let recorder = Recorder::start(
Box::new(SilentSource),
Box::new(SilentSource),
&dir.join("live-mic.wav"),
&dir.join("live-out.wav"),
)
.unwrap();
*lock(&f.state.current) = Some(CurrentRecording {
call_id: id,
app: "Microsoft Teams".into(),
started_at: at(10, 0, 0),
detected: false,
recorder,
});
assert_eq!(
f.state.delete_audio(id, |_| true),
Err(AudioDeleteError::Busy(BEING_RECORDED))
);
assert_audio_kept(&f, id);
lock(&f.state.current).take().unwrap().recorder.discard();
}
#[test]
fn only_the_audio_of_a_transcribed_call_is_deleted() {
let f = fixture();
let (undecided, _, _) = finished_call(&f, "u");
let (failed, _, _) = finished_call(&f, "f");
f.state
.store
.set_status(failed, CallStatus::Failed, Some("Fehler"))
.unwrap();
for id in [undecided, failed] {
assert_eq!(
f.state.delete_audio(id, |_| true),
Err(AudioDeleteError::Busy(CHANGED))
);
assert_audio_kept(&f, id);
}
}
#[test]
fn audio_the_caller_no_longer_wants_deleted_is_kept() {
let f = fixture();
let id = transcribed_call_with_audio(&f);
let mut seen = None;
assert_eq!(
f.state.delete_audio(id, |call| {
seen = Some(call.id);
false
}),
Err(AudioDeleteError::Busy(CHANGED))
);
assert_eq!(seen, Some(id));
assert_audio_kept(&f, id);
assert!(playback_file(&f, id).exists());
}
#[test]
fn a_call_the_caller_no_longer_wants_deleted_is_kept() {
let f = fixture();
let (id, mic, out) = finished_call(&f, "a");
f.state.queue_prompt(id);
assert_eq!(
f.state
.discard_call_if(id, |call| call.status == CallStatus::Failed),
Err(DiscardError::Busy(CHANGED))
);
assert!(mic.exists());
assert!(out.exists());
assert!(f.state.store.get_call(id).unwrap().is_some());
assert_eq!(f.state.prompts_waiting(), 1);
assert_eq!(
f.state
.discard_call_if(id, |call| call.status == CallStatus::AwaitingDecision),
Ok(0)
);
assert_eq!(f.state.store.get_call(id).unwrap(), None);
}
}
+2 -2
View File
@@ -1,7 +1,7 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "Gesprächsrekorder",
"version": "0.2.2",
"version": "0.4.0",
"identifier": "eu.euvino.callrecorder",
"build": {
"frontendDist": "../ui/dist",
@@ -36,7 +36,7 @@
"label": "prompt",
"title": "Gespräch beendet",
"url": "index.html#/prompt",
"width": 340,
"width": 400,
"height": 180,
"alwaysOnTop": true,
"visible": false,
+1 -1
View File
@@ -1,7 +1,7 @@
{
"name": "ui",
"private": true,
"version": "0.2.2",
"version": "0.4.0",
"type": "module",
"scripts": {
"dev": "vite",
+20 -2
View File
@@ -28,12 +28,15 @@
aria-current={call.id === selectedId}
onclick={() => onselect(call.id)}
>
{#if call.needs_action}
<span class="dot" title="Offen" aria-label="Offen"></span>
{/if}
<span class="title">{call.title ?? appLine(call)}</span>
<span class="meta">
<span class="muted">
{call.title ? `${appLine(call)} · ` : ''}{formatListTime(call.started_at)}
</span>
<StatusPill status={call.status} interrupted={call.interrupted} />
<StatusPill state={call.list_state} interrupted={call.interrupted} />
</span>
</button>
</li>
@@ -53,11 +56,12 @@
}
.row {
position: relative;
display: flex;
flex-direction: column;
gap: 3px;
width: 100%;
padding: 9px 10px;
padding: 9px 10px 9px 18px;
border: none;
border-radius: 8px;
background: none;
@@ -67,6 +71,20 @@
cursor: pointer;
}
.dot {
position: absolute;
left: 7px;
top: 50%;
transform: translateY(-50%);
width: 7px;
height: 7px;
border-radius: 50%;
background: var(--primary);
/* A thin ring so the dot stays visible against the selected row's
primary-soft background (and the hover background). */
box-shadow: 0 0 0 2px var(--surface);
}
.row:hover {
background: var(--bg);
}
+13
View File
@@ -0,0 +1,13 @@
<script lang="ts">
import { CALL_LANGUAGES } from './api'
// The language a call is transcribed in, picked next to "Transkribieren"
// and "Erneut versuchen".
let { value = $bindable(), disabled = false }: { value: string; disabled?: boolean } = $props()
</script>
<select bind:value {disabled} title="Sprache des Gesprächs" aria-label="Sprache des Gesprächs">
{#each CALL_LANGUAGES as language (language.code)}
<option value={language.code}>{language.label}</option>
{/each}
</select>
+251
View File
@@ -0,0 +1,251 @@
<script lang="ts">
import { onDestroy } from 'svelte'
import { errorText, playbackUrl, preparePlayback, releasePlayback, type CallId } from './api'
import { formatOffset } from './format'
let {
callId,
estimate,
ontime,
onplaying,
}: {
callId: CallId
/** The call's length from its times, shown until the mix is ready. */
estimate: number
/** The playback position, once the mix is loaded (also while paused). */
ontime?: (secs: number) => void
onplaying?: (playing: boolean) => void
} = $props()
let audio: HTMLAudioElement
/** Resolves once the mix is loaded; `false` if preparing it failed. */
let loading: Promise<boolean> | null = null
let preparing = $state(false)
let playing = $state(false)
// svelte-ignore state_referenced_locally
let duration = $state(estimate)
let position = $state(0)
/** While the slider is dragged it shows the drag, not the audio. */
let dragging = $state(false)
let error = $state('')
/** The mix held in memory where the webview cannot stream it (Linux). */
let blobUrl: string | null = null
/** This player's hold on the mix on disk (see `releasePlayback`). */
let lease: number | null = null
/** Set once the player is gone: a load still under way stops at the next
* step and keeps nothing (no blob, no mix on disk). */
let destroyed = false
const abort = new AbortController()
const LOAD_FAILED = 'Audio konnte nicht geladen werden.'
/** Lets go of the mix on disk (once). */
function release() {
if (lease === null) return
releasePlayback(callId, lease).catch(() => {})
lease = null
}
/** Mixes the call (first use only) and loads the mix into the player. */
function load(): Promise<boolean> {
loading ??= (async () => {
preparing = true
error = ''
try {
const prepared = await preparePlayback(callId)
lease = prepared.lease
if (destroyed) return false
duration = prepared.duration_secs
const url = playbackUrl(callId)
try {
await loadSource(url)
} catch (err) {
if (destroyed) return false
if (!(err instanceof MediaError) || err.code !== MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED) {
throw err
}
// WebKitGTK (Linux) plays no media from a custom scheme such as
// playback:// (WebView2 gets http://playback.localhost instead),
// but fetches it fine: there the mix is played from memory, and
// the file is not needed any more.
const response = await fetch(url, { signal: abort.signal })
if (!response.ok) throw new Error(LOAD_FAILED)
const blob = await response.blob()
if (destroyed) return false
blobUrl = URL.createObjectURL(blob)
release()
await loadSource(blobUrl)
}
return !destroyed
} catch (err) {
// A retry creates a new blob: this one is of no use any more.
if (blobUrl) URL.revokeObjectURL(blobUrl)
blobUrl = null
if (destroyed) return false
error = err instanceof MediaError ? LOAD_FAILED : errorText(err)
loading = null // a later click tries again
return false
} finally {
if (destroyed) release()
preparing = false
}
})()
return loading
}
/** Loads `src` into the player; rejects with its `MediaError`. */
function loadSource(src: string): Promise<void> {
const ready = new Promise<void>((resolve, reject) => {
const ok = () => {
audio.removeEventListener('error', fail)
resolve()
}
const fail = () => {
audio.removeEventListener('loadedmetadata', ok)
reject(audio.error)
}
audio.addEventListener('loadedmetadata', ok, { once: true })
audio.addEventListener('error', fail, { once: true })
})
audio.src = src
return ready
}
async function start() {
try {
await audio.play()
} catch (err) {
error = `Wiedergabe nicht möglich: ${errorText(err)}`
}
}
async function toggle() {
if (playing) {
audio.pause()
} else if (await load()) {
await start()
}
}
/** Jumps to `secs` and plays from there (a click on a transcript line). */
export async function playFrom(secs: number) {
if (!(await load())) return
audio.currentTime = Math.min(secs, duration)
position = audio.currentTime
if (audio.paused) await start()
}
async function seekTo(secs: number) {
dragging = false
position = secs
if (!(await load())) return
audio.currentTime = secs
}
function ontimeupdate() {
if (!dragging) position = audio.currentTime
ontime?.(audio.currentTime)
}
function setPlaying(value: boolean) {
playing = value
onplaying?.(value)
}
onDestroy(() => {
destroyed = true
abort.abort()
// Lets go of the file and the memory, so the call can be deleted right
// away and no customer audio stays behind.
audio?.pause()
audio?.removeAttribute('src')
audio?.load()
if (blobUrl) URL.revokeObjectURL(blobUrl)
blobUrl = null
release()
onplaying?.(false)
})
</script>
<div class="player">
<audio
bind:this={audio}
preload="metadata"
{ontimeupdate}
onplay={() => setPlaying(true)}
onpause={() => setPlaying(false)}
onended={() => setPlaying(false)}
></audio>
<button
class="play"
disabled={preparing}
title={playing ? 'Pause' : 'Abspielen'}
aria-label={playing ? 'Pause' : 'Abspielen'}
onclick={toggle}
>
{#if preparing}…{:else if playing}❚❚{:else}▶{/if}
</button>
<input
class="timeline"
type="range"
min="0"
max={duration || 1}
step="0.1"
value={position}
disabled={preparing}
aria-label="Position"
oninput={(e) => {
dragging = true
position = Number(e.currentTarget.value)
}}
onchange={(e) => seekTo(Number(e.currentTarget.value))}
/>
<span class="time">{formatOffset(position)} / {formatOffset(duration)}</span>
{#if preparing}
<span class="muted">Audio wird vorbereitet…</span>
{:else if error}
<span class="error">{error}</span>
{/if}
</div>
<style>
.player {
display: flex;
align-items: center;
flex-wrap: wrap;
gap: 6px 10px;
min-width: 0;
flex: 1;
}
.play {
flex-shrink: 0;
width: 30px;
height: 30px;
border-radius: 50%;
border: none;
background: var(--primary);
color: #fff;
font-size: 11px;
line-height: 1;
cursor: pointer;
}
.play:disabled {
opacity: 0.6;
cursor: default;
}
.timeline {
flex: 1 1 160px;
min-width: 120px;
accent-color: var(--primary);
}
.time {
color: var(--muted);
font-size: 12px;
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
</style>
+11 -5
View File
@@ -1,21 +1,22 @@
<script lang="ts">
import type { CallStatus } from './api'
import type { ListState } from './api'
let { status, interrupted = false }: { status: CallStatus; interrupted?: boolean } = $props()
let { state, interrupted = false }: { state: ListState; interrupted?: boolean } = $props()
const pills: Record<CallStatus, { text: string; kind: string }> = {
const pills: Record<ListState, { text: string; kind: string }> = {
done: { text: 'fertig', kind: 'done' },
ready_to_upload: { text: 'bereit zum Hochladen', kind: 'ready' },
processing: { text: 'wird verarbeitet…', kind: 'processing' },
awaiting_decision: { text: 'nicht transkribiert', kind: 'awaiting' },
failed: { text: 'fehlgeschlagen', kind: 'failed' },
recording: { text: 'Aufnahme läuft', kind: 'recording' },
}
let pill = $derived(pills[status])
let pill = $derived(pills[state])
</script>
<span class="pill status {pill.kind}">
{pill.text}{#if interrupted && status === 'awaiting_decision'}, unterbrochen{/if}
{pill.text}{#if interrupted && state === 'awaiting_decision'}, unterbrochen{/if}
</span>
<style>
@@ -28,6 +29,11 @@
color: var(--ok);
}
.ready {
background: var(--primary-soft);
color: var(--primary);
}
.processing {
background: #fff4d6;
color: #8a6100;
+101 -5
View File
@@ -8,6 +8,9 @@
onrename,
onmerge,
onunmerge,
activeIndex = null,
follow = false,
onseek,
}: {
/** The transcript with merges applied: merged speakers no longer appear. */
segments: SegmentView[]
@@ -18,8 +21,45 @@
onmerge: (fromKey: string, intoKey: string) => Promise<void>
/** Undoes the merge of `fromKey`. */
onunmerge: (fromKey: string) => Promise<void>
/** The line being heard; it is highlighted. */
activeIndex?: number | null
/** Scrolls the line being heard into view when it leaves the view. */
follow?: boolean
/** Plays from `secs`, a line's start (only while the audio is there). */
onseek?: (secs: number) => void
} = $props()
let lineElements: HTMLElement[] = $state([])
/** A click on a line's text plays from it, unless text was selected. */
function lineClick(start: number) {
if (window.getSelection()?.toString()) return
onseek?.(start)
}
/** The nearest ancestor that scrolls vertically. */
function scrollParent(node: HTMLElement): HTMLElement | null {
for (let el = node.parentElement; el; el = el.parentElement) {
if (/(auto|scroll)/.test(getComputedStyle(el).overflowY)) return el
}
return null
}
// Following the playback scrolls only once the line has left the view
// (also when it hides under the sticky player), and then centres it.
$effect(() => {
if (!follow || activeIndex === null) return
const line = lineElements[activeIndex]
const parent = line && scrollParent(line)
if (!line || !parent) return
const view = parent.getBoundingClientRect()
const box = line.getBoundingClientRect()
const covered = parseFloat(getComputedStyle(line).scrollMarginTop) || 0
if (box.top < view.top + covered || box.bottom > view.bottom) {
line.scrollIntoView({ block: 'center' })
}
})
// "Ich" is always the primary blue; remote speakers cycle through the rest.
const ME_COLOR = '#3b5bdb'
const REMOTE_COLORS = ['#2b8a3e', '#c2255c', '#e8590c', '#7048e8', '#0c8599', '#5c940d']
@@ -186,8 +226,27 @@
<div class="lines">
{#each segments as segment, i (i)}
<div class="line">
<span class="time">{formatOffset(segment.start)}</span>
<!-- The time is the keyboard-accessible way to play a line. -->
<!-- svelte-ignore a11y_click_events_have_key_events, a11y_no_static_element_interactions -->
<div
class="line"
class:active={i === activeIndex}
class:seekable={onseek !== undefined}
bind:this={lineElements[i]}
onclick={() => lineClick(segment.start)}
>
{#if onseek}
<button
class="time"
title="Ab hier abspielen"
onclick={(e) => {
e.stopPropagation()
onseek(segment.start)
}}>{formatOffset(segment.start)}</button
>
{:else}
<span class="time">{formatOffset(segment.start)}</span>
{/if}
<span class="speaker" style:color={speakerColor(segment.speaker_key)}>{segment.label}</span>
<span class="text">{segment.text}</span>
</div>
@@ -324,12 +383,33 @@
.lines {
display: grid;
grid-template-columns: auto auto 1fr;
gap: 8px 12px;
margin-top: 14px;
column-gap: 12px;
margin: 10px -8px 0;
}
/* One row of the transcript grid that can be highlighted as a whole. */
.line {
display: contents;
display: grid;
grid-column: 1 / -1;
grid-template-columns: subgrid;
padding: 4px 8px;
border-radius: 6px;
/* Room for the sticky player when the line is scrolled into view. */
scroll-margin-top: 64px;
}
.line.seekable {
cursor: pointer;
}
.line.seekable:hover {
background: var(--bg);
}
.line.active,
.line.active:hover {
background: var(--primary-soft);
box-shadow: inset 3px 0 0 var(--primary);
}
.time {
@@ -339,6 +419,22 @@
padding-top: 1px;
}
button.time {
align-self: start;
border: none;
background: none;
padding: 1px 0 0;
font-family: inherit;
line-height: inherit;
text-align: left;
cursor: pointer;
}
button.time:hover {
color: var(--primary);
text-decoration: underline;
}
.speaker {
font-weight: 600;
max-width: 160px;
+59 -3
View File
@@ -1,16 +1,28 @@
// Typed wrappers around the Tauri commands and events of the app shell.
import { invoke } from '@tauri-apps/api/core'
import { convertFileSrc, invoke } from '@tauri-apps/api/core'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
export type CallId = number
/** The languages a call can be transcribed in (the backend's `CALL_LANGUAGES`). */
export const CALL_LANGUAGES = [
{ code: 'de', label: 'Deutsch' },
{ code: 'en', label: 'Englisch' },
{ code: 'es', label: 'Spanisch' },
{ code: 'fr', label: 'Französisch' },
{ code: 'it', label: 'Italienisch' },
] as const
export interface Settings {
allowlist: string[]
mic_device: string | null
output_device: string | null
/** Language of the transcription started last; set by the app, not the settings page. */
language: string
deepscript_model: string
/** Custom words/names submitted with every transcription. */
vocabulary: string[]
retention_days: number
autostart: boolean
start_after_secs: number
@@ -70,6 +82,8 @@ export interface CallBrief {
started_at: string
ended_at: string | null
duration_secs: number
/** What the language picker starts on: the call's own language, else the last used. */
language: string
}
/** The call the end-of-call prompt shows, and how many wait behind it. */
@@ -79,6 +93,18 @@ export interface PendingPrompt extends CallBrief {
export type CallStatus = 'recording' | 'awaiting_decision' | 'processing' | 'done' | 'failed'
/** What the status pill shows and whether the row needs the user's
* attention. Mirrors `CallStatus`, except `done` splits into `done`
* (uploaded to this build's backend — "fertig") and `ready_to_upload`
* (not uploaded here yet — "bereit zum Hochladen"). */
export type ListState =
| 'recording'
| 'awaiting_decision'
| 'processing'
| 'failed'
| 'done'
| 'ready_to_upload'
/** A row of the main window's call list. Times are RFC 3339. */
export interface CallListItem {
id: CallId
@@ -87,6 +113,10 @@ export interface CallListItem {
/** 0 while recording. */
duration_secs: number
status: CallStatus
list_state: ListState
/** Whether this row needs the user to act on it (the dot in the list,
* counted in the sidebar header's "N offen"). */
needs_action: boolean
interrupted: boolean
/** The name the user gave the call, if any. */
title: string | null
@@ -122,6 +152,20 @@ export interface CallDetail {
merges: SpeakerMerge[]
/** The transcript is being uploaded right now. */
uploading: boolean
/** The call's audio is still on this PC and can be played. */
audio_available: boolean
/** Retention deleted the call's audio (not just: the files are missing). */
audio_deleted: boolean
/** What the language picker starts on: the call's own language, else the last used. */
language: string
}
/** A call's two tracks mixed into one file, ready to play from
* `playbackUrl`. */
export interface PreparedPlayback {
duration_secs: number
/** Hand back with `releasePlayback` once the player is done. */
lease: number
}
/** A newer version the release feed offers. */
@@ -167,9 +211,21 @@ export const stopRecording = () => invoke<void>('stop_recording')
export const discardCurrentRecording = () => invoke<void>('discard_current_recording')
export const getPendingPrompt = () => invoke<PendingPrompt | null>('get_pending_prompt')
export const getCallBrief = (id: CallId) => invoke<CallBrief>('get_call_brief', { id })
export const transcribeCall = (id: CallId) => invoke<void>('transcribe_call', { id })
export const retryCall = (id: CallId) => invoke<void>('retry_call', { id })
export const transcribeCall = (id: CallId, language: string) =>
invoke<void>('transcribe_call', { id, language })
export const retryCall = (id: CallId, language: string) =>
invoke<void>('retry_call', { id, language })
export const discardCall = (id: CallId) => invoke<void>('discard_call', { id })
/** Mixes the call's tracks (or reuses the cached mix); refused while the
* call is recorded or processed and once its audio is gone. */
export const preparePlayback = (id: CallId) =>
invoke<PreparedPlayback>('prepare_playback', { id })
/** The player is done with the mix: it is removed from disk. */
export const releasePlayback = (id: CallId, lease: number) =>
invoke<void>('release_playback', { id, lease })
/** Where the main window plays a prepared mix from (the app's `playback`
* scheme; other windows are refused). */
export const playbackUrl = (id: CallId) => convertFileSrc(String(id), 'playback')
export const listCalls = () => invoke<CallListItem[]>('list_calls')
export const getCall = (id: CallId) => invoke<CallDetail>('get_call', { id })
/** An empty name restores the default label. */
+21
View File
@@ -0,0 +1,21 @@
// Couples playback to the transcript: which line is being heard.
/** The part of a transcript line the lookup needs. */
export interface Timed {
start: number
end: number
}
/** Index of the line heard at `secs`: the one whose `[start, end)` holds
* it — of overlapping lines (both sides talking at once) the one that
* started last. `null` before the first line, in a pause between lines and
* after the last one. */
export function segmentAt(segments: readonly Timed[], secs: number): number | null {
let found: number | null = null
segments.forEach((segment, i) => {
if (segment.start <= secs && secs < segment.end) {
if (found === null || segment.start >= segments[found].start) found = i
}
})
return found
}
+317 -18
View File
@@ -5,6 +5,7 @@
errorText,
getCall,
getRecordingState,
getSettings,
listCalls,
mergeSpeakers,
onBackendLoginError,
@@ -27,6 +28,9 @@
} from '../lib/api'
import CallList from '../lib/CallList.svelte'
import { formatDateTime, formatDetailTime, formatMinutes } from '../lib/format'
import LanguageSelect from '../lib/LanguageSelect.svelte'
import Player from '../lib/Player.svelte'
import { segmentAt } from '../lib/playback'
import StatusPill from '../lib/StatusPill.svelte'
import TranscriptView from '../lib/TranscriptView.svelte'
import UpdateBanner from '../lib/UpdateBanner.svelte'
@@ -42,14 +46,33 @@
let selectedId = $state<CallId | null>(null)
let detail = $state<CallDetail | null>(null)
let detailError = $state('')
/** The language picked for the shown call's transcription. */
let language = $state('de')
let actionError = $state('')
let busy = $state(false)
// "Löschen" (transcribed calls): confirmed with a dialog instead of
// running straight away like the other actions.
let deleteDialogOpen = $state(false)
let deleteBusy = $state(false)
let deleteError = $state('')
// Uploads run per call and may outlive the selection (the login can
// take a while); their errors are kept per call too.
let uploading = $state<CallId[]>([])
let uploadErrors = $state<Record<CallId, string>>({})
// Playback of the shown call (the player itself lives in `Player`).
let player = $state<ReturnType<typeof Player>>()
/** The playback position once the mix is loaded, else `null`. */
let playerTime = $state<number | null>(null)
let playing = $state(false)
/** Whether the transcript scrolls along; scrolling by hand ends it. */
let follow = $state(true)
/** For "… werden N Tage nach der Transkription gelöscht". */
let retentionDays = $state<number | null>(null)
let retentionPeriod = $derived(retentionDays === 1 ? '1 Tag' : `${retentionDays} Tage`)
let editingTitle = $state(false)
let titleDraft = $state('')
let savingTitle = $state(false)
@@ -89,6 +112,12 @@
try {
const next = await getCall(id)
if (request === detailRequest && id === selectedId) {
// A refresh of the same call keeps what the user picked, unless the
// backend's suggestion changed (e.g. it was transcribed from the
// prompt in another language and failed).
if (next.call.id !== detail?.call.id || next.language !== detail?.language) {
language = next.language
}
detail = next
detailError = ''
}
@@ -97,24 +126,36 @@
}
}
function resetPlayback() {
playerTime = null
playing = false
follow = true
}
function select(id: CallId) {
if (id === selectedId) return
selectedId = id
resetPlayback()
detail = null
detailError = ''
actionError = ''
editingTitle = false
titleError = ''
deleteDialogOpen = false
deleteError = ''
refreshDetail()
}
function clearSelection() {
selectedId = null
resetPlayback()
detail = null
detailError = ''
actionError = ''
editingTitle = false
titleError = ''
deleteDialogOpen = false
deleteError = ''
}
onMount(() => {
@@ -135,6 +176,12 @@
}),
]
refreshList()
// Read on every visit: the settings page is a route of this window, so
// a changed retention period is shown on the way back. Without it the
// "no audio" line just leaves the period out.
getSettings()
.then((settings) => (retentionDays = settings.retention_days))
.catch((err) => console.warn('settings not read:', errorText(err)))
getRecordingState()
.then((state) => (recordingState = state))
.catch((err) => (recordError = errorText(err)))
@@ -181,14 +228,57 @@
}
}
const transcribe = () => run(transcribeCall)
const retry = () => run(retryCall)
const transcribe = () => run((id) => transcribeCall(id, language))
const retry = () => run((id) => retryCall(id, language))
const discard = () =>
run(discardCall, () => {
clearSelection()
refreshList()
})
/** "Löschen" on a transcribed call: asks for confirmation first. */
function askDelete() {
deleteError = ''
deleteDialogOpen = true
}
function cancelDelete() {
deleteDialogOpen = false
deleteError = ''
}
/** Confirmed delete: same backend path as "Verwerfen" (`discard_call`).
* On success the selection moves to the next call in the list, or clears
* if none is left. */
async function confirmDelete() {
if (!detail) return
const id = detail.call.id
deleteBusy = true
try {
await discardCall(id)
deleteDialogOpen = false
selectAfterDelete(id)
refreshList()
} catch (err) {
deleteError = errorText(err)
} finally {
deleteBusy = false
}
}
/** Selects the call that took `deletedId`'s place in the list (or the one
* before it, if `deletedId` was last), else clears the selection. */
function selectAfterDelete(deletedId: CallId) {
const index = calls.findIndex((c) => c.id === deletedId)
const remaining = calls.filter((c) => c.id !== deletedId)
if (remaining.length === 0) {
clearSelection()
return
}
const next = remaining[Math.min(Math.max(index, 0), remaining.length - 1)]
select(next.id)
}
/** Uploads the shown call's transcript (logging in first if needed). A
* call already uploaded has no button any more: the CRM never gets a
* duplicate. */
@@ -257,6 +347,28 @@
node.select()
}
/** A click on a transcript line: plays from there and follows again. */
function playFrom(secs: number) {
follow = true
player?.playFrom(secs)
}
const SCROLL_KEYS = ['ArrowUp', 'ArrowDown', 'PageUp', 'PageDown', 'Home', 'End', ' ']
/** Scrolling the detail by hand while playing stops following the
* playback (until "folgen" or a click on a line). Only user input counts:
* the transcript's own scrolling raises none of these events. */
function manualScroll(event: Event) {
if (!playing) return
if (event instanceof KeyboardEvent) {
const target = event.target as HTMLElement
if (!SCROLL_KEYS.includes(event.key) || target.closest('input, textarea, button')) return
}
// A press on the scroll bar (not on the content).
if (event instanceof PointerEvent && event.target !== event.currentTarget) return
follow = false
}
/** "Microsoft Teams · heute 10:14 · 32 min" (no duration while recording). */
function defaultTitle(call: CallListItem): string {
const parts = [call.app, formatDetailTime(call.started_at)]
@@ -273,13 +385,22 @@
// A failed start (e.g. missing key) also marks the call failed; its
// error is then shown once, in the failure box.
let shownActionError = $derived(actionError !== detail?.call.error ? actionError : '')
// Calls that still need the user's attention (not transcribed, or
// transcribed but not uploaded here) — shown as "Gespräche · N offen".
let openCount = $derived(calls.filter((c) => c.needs_action).length)
/** The transcript line being heard, highlighted while the mix is loaded. */
let activeIndex = $derived(
detail && playerTime !== null ? segmentAt(detail.segments, playerTime) : null,
)
</script>
<main class="main">
<UpdateBanner />
<aside class="sidebar">
<header class="sidebar-header">
<h1>Gespräche</h1>
<h1>Gespräche{#if openCount > 0}<span class="open-count" title="{openCount} offen" aria-label="{openCount} offen">{openCount}</span>{/if}</h1>
<div class="header-actions">
<button
class="btn small record-btn"
@@ -307,7 +428,15 @@
</div>
</aside>
<section class="detail">
<!-- The handlers only watch for scrolling by hand (see manualScroll). -->
<!-- svelte-ignore a11y_no_static_element_interactions -->
<section
class="detail"
onwheel={manualScroll}
ontouchmove={manualScroll}
onkeydown={manualScroll}
onpointerdown={manualScroll}
>
{#if detail}
{@const call = detail.call}
<header class="detail-header">
@@ -328,7 +457,7 @@
<button class="edit-title" title="Titel ändern" onclick={startTitleEdit}>✎</button>
</h1>
{/if}
<StatusPill status={call.status} interrupted={call.interrupted} />
<StatusPill state={call.list_state} interrupted={call.interrupted} />
</div>
{#if editingTitle}
<p class="muted subline">Enter speichert, Esc bricht ab. Leer = Standardtitel.</p>
@@ -346,19 +475,26 @@
{/if}
<span class="actions">
{#if call.status === 'awaiting_decision'}
<LanguageSelect bind:value={language} disabled={busy} />
<button class="btn primary" disabled={busy} onclick={transcribe}>Transkribieren</button>
<button class="btn danger" disabled={busy} onclick={discard}>Verwerfen</button>
{:else if call.status === 'failed'}
<LanguageSelect bind:value={language} disabled={busy} />
<button class="btn primary" disabled={busy} onclick={retry}>Erneut versuchen</button>
<button class="btn danger" disabled={busy} onclick={discard}>Verwerfen</button>
{:else if call.status === 'done' && !call.uploaded_at}
<button
class="btn primary"
disabled={!call.transcribed_at || isUploading}
title={call.transcribed_at ? 'Transkript ins CRM hochladen' : 'Noch kein Transkript'}
onclick={upload}
>
{isUploading ? 'wird hochgeladen…' : 'Transkript hochladen'}
{:else if call.status === 'done'}
{#if !call.uploaded_at}
<button
class="btn primary"
disabled={!call.transcribed_at || isUploading}
title={call.transcribed_at ? 'Transkript ins CRM hochladen' : 'Noch kein Transkript'}
onclick={upload}
>
{isUploading ? 'wird hochgeladen…' : 'Transkript hochladen'}
</button>
{/if}
<button class="btn danger" disabled={deleteBusy || isUploading} onclick={askDelete}>
Löschen
</button>
{/if}
</span>
@@ -371,6 +507,40 @@
{/if}
</header>
{#if call.status !== 'recording' && call.status !== 'processing'}
{#if detail.audio_available}
<div class="playback-bar">
{#key call.id}
<Player
bind:this={player}
callId={call.id}
estimate={call.duration_secs}
ontime={(secs) => (playerTime = secs)}
onplaying={(value) => (playing = value)}
/>
{/key}
{#if call.status === 'done' && detail.segments.length > 0}
<button
class="btn small follow"
class:on={follow}
aria-pressed={follow}
title="Das Transkript scrollt mit der Wiedergabe mit"
onclick={() => (follow = !follow)}>folgen</button
>
{/if}
</div>
{:else if detail.audio_deleted && retentionDays !== null}
<p class="muted no-audio">
Audio nicht mehr vorhanden – Aufnahmen werden {retentionPeriod} nach der
Transkription gelöscht (<a href="#/settings">Einstellungen</a>).
</p>
{:else if detail.audio_deleted}
<p class="muted no-audio">Audio nicht mehr vorhanden.</p>
{:else}
<p class="muted no-audio">Audio nicht vorhanden.</p>
{/if}
{/if}
<div class="body">
{#if call.status === 'recording'}
<p class="state rec">● Aufnahme läuft</p>
@@ -394,9 +564,46 @@
onrename={rename}
onmerge={merge}
onunmerge={unmerge}
{activeIndex}
follow={follow && playing}
onseek={detail.audio_available ? playFrom : undefined}
/>
{/if}
</div>
{#if deleteDialogOpen}
<div
class="dialog-backdrop"
onclick={cancelDelete}
onkeydown={(e) => e.key === 'Escape' && cancelDelete()}
role="presentation"
>
<div
class="dialog"
role="alertdialog"
aria-modal="true"
aria-labelledby="delete-dialog-title"
tabindex="-1"
onclick={(e) => e.stopPropagation()}
onkeydown={(e) => e.stopPropagation()}
>
<p class="dialog-title" id="delete-dialog-title">Gespräch löschen?</p>
<p>Audio und Transkript werden unwiderruflich von diesem PC gelöscht.</p>
{#if call.uploaded_at}
<p>Die Kopie im CRM bleibt erhalten.</p>
{/if}
{#if deleteError}
<p class="error">{deleteError}</p>
{/if}
<div class="dialog-actions">
<button class="btn danger" disabled={deleteBusy} onclick={confirmDelete}>
Löschen
</button>
<button class="btn" disabled={deleteBusy} onclick={cancelDelete}>Abbrechen</button>
</div>
</div>
</div>
{/if}
{:else if detailError}
<p class="error pad">{detailError}</p>
{:else if loaded && selectedId === null && calls.length > 0}
@@ -435,21 +642,47 @@
display: flex;
align-items: center;
justify-content: space-between;
padding: 14px 12px 10px 16px;
gap: 4px;
padding: 12px 6px 8px 10px;
border-bottom: 1px solid var(--border);
}
.sidebar-header h1 {
font-size: 16px;
flex: 0 1 auto;
min-width: 0;
font-size: 15px;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.open-count {
display: inline-flex;
align-items: center;
justify-content: center;
margin-left: 4px;
min-width: 14px;
height: 14px;
padding: 0 3px;
border-radius: 999px;
background: var(--primary-soft);
color: var(--primary);
font-size: 10px;
font-weight: 700;
line-height: 1;
vertical-align: middle;
}
.header-actions {
display: flex;
flex-shrink: 0;
align-items: center;
gap: 6px;
gap: 3px;
}
.record-btn {
padding: 2px 6px;
font-size: 11px;
white-space: nowrap;
}
@@ -466,9 +699,9 @@
.gear {
color: var(--muted);
font-size: 18px;
font-size: 15px;
line-height: 1;
padding: 4px 6px;
padding: 3px 4px;
border-radius: 6px;
text-decoration: none;
}
@@ -559,6 +792,36 @@
margin: 10px 0 0;
}
/* Stays at the top while the transcript scrolls under it. */
.playback-bar {
position: sticky;
top: -18px; /* the detail's top padding: flush with its edge */
z-index: 2;
display: flex;
align-items: center;
gap: 10px;
margin: 0 -24px 14px;
padding: 8px 24px;
background: var(--bg);
border-bottom: 1px solid var(--border);
}
.follow {
flex-shrink: 0;
color: var(--muted);
font-weight: 600;
}
.follow.on {
border-color: var(--primary);
background: var(--primary-soft);
color: var(--primary);
}
.no-audio {
margin: 0 0 14px;
}
.state {
color: var(--muted);
}
@@ -574,4 +837,40 @@
background: var(--rec-soft);
color: var(--rec);
}
.dialog-backdrop {
position: fixed;
inset: 0;
background: rgba(29, 35, 48, 0.4);
display: flex;
align-items: center;
justify-content: center;
z-index: 10;
}
.dialog {
background: var(--surface);
border: 1px solid var(--border);
border-radius: 10px;
box-shadow: 0 12px 32px rgba(29, 35, 48, 0.25);
padding: 20px;
width: min(420px, calc(100vw - 32px));
}
.dialog-title {
font-size: 16px;
font-weight: 600;
margin: 0 0 8px;
}
.dialog p {
margin: 0 0 8px;
}
.dialog-actions {
display: flex;
justify-content: flex-end;
gap: 8px;
margin-top: 16px;
}
</style>
+12 -1
View File
@@ -11,13 +11,21 @@
type PendingPrompt,
} from '../lib/api'
import { formatMinutes, formatTimeRange } from '../lib/format'
import LanguageSelect from '../lib/LanguageSelect.svelte'
let brief = $state<PendingPrompt | null>(null)
let busy = $state(false)
let error = $state('')
let language = $state('de')
function show(next: PendingPrompt | null) {
if (next?.id !== brief?.id) error = ''
// A refresh of the same call keeps what the user picked, unless the
// backend's suggestion changed (e.g. a transcription started from the
// main window in another language).
if (next && (next.id !== brief?.id || next.language !== brief?.language)) {
language = next.language
}
brief = next
}
@@ -54,6 +62,8 @@
busy = false
}
}
const transcribe = () => run((id) => transcribeCall(id, language))
</script>
<main class="prompt">
@@ -64,7 +74,8 @@
<div class="muted">Weitere Gespräche warten: {brief.more_waiting}</div>
{/if}
<div class="actions">
<button class="btn primary" disabled={busy} onclick={() => run(transcribeCall)}>
<LanguageSelect bind:value={language} disabled={busy} />
<button class="btn primary" disabled={busy} onclick={transcribe}>
Transkribieren
</button>
<button class="btn danger" disabled={busy} onclick={() => run(discardCall)}>Verwerfen</button>
+62 -9
View File
@@ -43,6 +43,10 @@
]
let settings = $state<Settings | null>(null)
/** The vocabulary textarea's raw text, one term per line; converted
* to/from `settings.vocabulary` on load/save (the backend trims, drops
* blanks and deduplicates — see `Settings::edited`). */
let vocabularyText = $state('')
let devices = $state<Devices>({ inputs: [], outputs: [] })
let keySaved = $state<Record<Service, boolean>>({ deepscript: false })
let keyInput = $state<Record<Service, string>>({ deepscript: '' })
@@ -207,6 +211,7 @@
async function load() {
try {
settings = await getSettings()
vocabularyText = settings.vocabulary.join('\n')
for (const { id } of services) keySaved[id] = await hasApiKey(id)
devices = await listDevices()
} catch (err) {
@@ -261,14 +266,29 @@
settings ? delayError(settings.start_after_secs, 1, 30, 'Start nach') : '',
)
let endError = $derived(settings ? delayError(settings.end_after_secs, 3, 120, 'Ende nach') : '')
/** The range the backend accepts (`RETENTION_DAYS`). */
function retentionValid(days: number | null | undefined): days is number {
return typeof days === 'number' && Number.isInteger(days) && days >= 1 && days <= 3650
}
/** The retention period in the hint ("7 Tage", "1 Tag"; "N Tage" while
* the field holds no valid value). */
let retentionShown = $derived.by(() => {
const days = settings?.retention_days
if (!retentionValid(days)) return 'N Tage'
return days === 1 ? '1 Tag' : `${days} Tage`
})
async function persist() {
if (!settings) return
if (startError || endError) throw startError || endError
if (!Number.isInteger(settings.retention_days) || settings.retention_days < 1) {
throw 'Aufbewahrung: bitte eine ganze Zahl ab 1 eingeben'
}
if (!retentionValid(settings.retention_days)) throw 'Aufbewahrung: 1–3650 Tage'
settings.vocabulary = vocabularyText.split('\n')
await saveSettings($state.snapshot(settings))
// Re-read: the backend trims/dedupes the vocabulary, so the textarea
// should show the cleaned-up list, not what was just typed.
settings = await getSettings()
vocabularyText = settings.vocabulary.join('\n')
}
async function runTest() {
@@ -462,18 +482,36 @@
<section class="card">
<h2>Allgemein</h2>
<div class="grid">
<label for="language">Sprache der Gespräche</label>
<select id="language" bind:value={settings.language}>
<option value="de">Deutsch</option>
<option value="en">Englisch</option>
</select>
<label for="retention">Aufbewahrung der Audiodateien</label>
<span><input id="retention" type="number" min="1" bind:value={settings.retention_days} /> Tage</span>
<span><input id="retention" type="number" min="1" max="3650" bind:value={settings.retention_days} /> Tage</span>
<span></span>
<span class="muted">
Audio wird {retentionShown} nach der Transkription gelöscht, nicht transkribierte
Aufnahmen {retentionShown} nach dem Gespräch; das Transkript bleibt.
</span>
<label for="autostart">Beim Anmelden starten</label>
<input id="autostart" type="checkbox" bind:checked={settings.autostart} />
</div>
</section>
<section class="card">
<h2>Transkription</h2>
<div class="grid">
<label for="deepscript-model">Modell</label>
<select id="deepscript-model" bind:value={settings.deepscript_model}>
<option value="premium">Premium</option>
<option value="premium_jade">Premium Jade</option>
</select>
<span></span>
<span class="muted">Gilt für neue Transkriptionen.</span>
</div>
<label for="vocabulary" class="vocabulary-label">Vokabular (ein Begriff pro Zeile)</label>
<textarea id="vocabulary" rows="6" bind:value={vocabularyText}></textarea>
<p class="muted">
Namen, Firmen- und Produktbegriffe, die oft falsch erkannt werden.
</p>
</section>
<section class="card">
<h2>Updates</h2>
<div class="grid">
@@ -575,6 +613,21 @@
justify-self: start;
}
.vocabulary-label {
display: block;
margin-top: 12px;
font-weight: 600;
}
textarea#vocabulary {
width: 100%;
max-width: 420px;
margin-top: 6px;
font-family: inherit;
font-size: 13px;
resize: vertical;
}
.hint {
margin: 12px 0;
padding: 8px 10px;