feat #14740: merge speakers and name calls

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
hauke
2026-11-06 11:17:40 +01:00
co-authored by Claude Opus 5.5
parent 5dfe1d9357
commit 345dd01147
12 changed files with 1213 additions and 29 deletions
+144 -5
View File
@@ -7,7 +7,7 @@ use chrono::{DateTime, Local};
use serde::Serialize;
use crate::merge;
use crate::model::{Call, CallId, CallStatus, Segment};
use crate::model::{Call, CallId, CallStatus, Segment, Speaker};
/// A row of the call list.
#[derive(Serialize, Clone, Debug, PartialEq)]
@@ -19,6 +19,8 @@ pub struct CallListItem {
pub duration_secs: i64,
pub status: CallStatus,
pub interrupted: bool,
/// The name the user gave the call, if any.
pub title: Option<String>,
}
impl CallListItem {
@@ -30,6 +32,7 @@ impl CallListItem {
duration_secs: duration_secs(call),
status: call.status,
interrupted: call.interrupted,
title: call.title.clone(),
}
}
}
@@ -62,19 +65,43 @@ pub struct SegmentView {
pub text: String,
}
/// A merged speaker: "Sprecher 2 → Frau Beispiel zusammengeführt".
#[derive(Serialize, Clone, Debug, PartialEq)]
pub struct MergeView {
pub from_key: String,
/// The source's default label: its own rename is not in effect while
/// it is merged.
pub from_label: String,
/// The speaker the source's lines now belong to (the end of a chain of
/// merges).
pub into_key: String,
pub into_label: String,
}
/// Everything the detail pane shows about one call.
#[derive(Serialize, Clone, Debug, PartialEq)]
pub struct CallDetail {
pub call: CallHeader,
/// The transcript with speaker merges applied
/// ([`merge::apply_merges`]).
pub segments: Vec<SegmentView>,
/// Renamed speakers by key; speakers not in here keep their default
/// label.
pub speaker_names: BTreeMap<String, String>,
/// The call's speaker merges, by source speaker number.
pub merges: Vec<MergeView>,
}
impl CallDetail {
pub fn of(call: &Call, segments: &[Segment], speaker_names: BTreeMap<String, String>) -> Self {
let segments = segments
/// `segments` are the stored ones; `merges` the stored speaker merges
/// (source key → target key).
pub fn of(
call: &Call,
segments: &[Segment],
speaker_names: BTreeMap<String, String>,
merges: &BTreeMap<String, String>,
) -> Self {
let segments = merge::apply_merges(segments, merges)
.iter()
.map(|segment| SegmentView {
speaker_key: segment.speaker.key(),
@@ -91,11 +118,37 @@ impl CallDetail {
account_id: call.account_id.clone(),
},
segments,
merges: merge_views(merges, &speaker_names),
speaker_names,
}
}
}
fn merge_views(
merges: &BTreeMap<String, String>,
speaker_names: &BTreeMap<String, String>,
) -> Vec<MergeView> {
let mut views: Vec<(u32, MergeView)> = merge::resolve_merges(merges)
.into_iter()
.filter_map(|(from_key, into_key)| {
let (Some(Speaker::Remote(n)), Some(into)) =
(Speaker::from_key(&from_key), Speaker::from_key(&into_key))
else {
return None;
};
let view = MergeView {
from_label: Speaker::Remote(n).default_label(),
into_label: merge::label(&into, speaker_names),
from_key,
into_key,
};
Some((n, view))
})
.collect();
views.sort_by_key(|(n, _)| *n);
views.into_iter().map(|(_, view)| view).collect()
}
#[cfg(test)]
mod tests {
use std::path::PathBuf;
@@ -124,6 +177,7 @@ mod tests {
transcribed_at: None,
audio_deleted: false,
account_id: None,
title: None,
}
}
@@ -161,8 +215,12 @@ mod tests {
duration_secs: 60,
status: CallStatus::AwaitingDecision,
interrupted: true,
title: None,
}
);
c.title = Some("Angebot Rioja".into());
assert_eq!(CallListItem::of(&c).title.as_deref(), Some("Angebot Rioja"));
}
#[test]
@@ -176,7 +234,12 @@ mod tests {
names.insert("remote:1".to_string(), "Frau Beispiel".to_string());
names.insert("remote:2".to_string(), " ".to_string());
let detail = CallDetail::of(&call(Some(at(10, 15, 0))), &segments, names.clone());
let detail = CallDetail::of(
&call(Some(at(10, 15, 0))),
&segments,
names.clone(),
&BTreeMap::new(),
);
let lines: Vec<_> = detail
.segments
@@ -194,6 +257,72 @@ mod tests {
assert_eq!(detail.segments[1].start, 2.5);
assert_eq!(detail.segments[1].end, 4.5);
assert_eq!(detail.speaker_names, names);
assert_eq!(detail.merges, []);
}
fn keys(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
pairs
.iter()
.map(|(a, b)| (a.to_string(), b.to_string()))
.collect()
}
#[test]
fn detail_shows_merged_speakers_under_their_target() {
let segments = [
segment(Speaker::Remote(1), 0.0, "Guten Tag,"),
segment(Speaker::Remote(2), 2.5, "hier Weingut Beispiel."),
segment(Speaker::Me, 5.0, "Hallo."),
segment(Speaker::Remote(3), 7.5, "Zur Lieferung:"),
segment(Speaker::Remote(4), 10.0, "Moin."),
];
let names = keys(&[("remote:1", "Frau Beispiel"), ("remote:2", "Herr Probe")]);
let merges = keys(&[
("remote:3", "remote:2"),
("remote:2", "remote:1"),
("remote:10", "remote:4"),
]);
let detail = CallDetail::of(&call(Some(at(10, 15, 0))), &segments, names, &merges);
let lines: Vec<_> = detail
.segments
.iter()
.map(|s| (s.speaker_key.as_str(), s.label.as_str(), s.text.as_str()))
.collect();
assert_eq!(
lines,
[
(
"remote:1",
"Frau Beispiel",
"Guten Tag, hier Weingut Beispiel."
),
("me", "Ich", "Hallo."),
("remote:1", "Frau Beispiel", "Zur Lieferung:"),
("remote:4", "Sprecher 4", "Moin."),
]
);
let merge_lines: Vec<_> = detail
.merges
.iter()
.map(|m| {
(
m.from_key.as_str(),
m.from_label.as_str(),
m.into_key.as_str(),
m.into_label.as_str(),
)
})
.collect();
assert_eq!(
merge_lines,
[
("remote:2", "Sprecher 2", "remote:1", "Frau Beispiel"),
("remote:3", "Sprecher 3", "remote:1", "Frau Beispiel"),
("remote:10", "Sprecher 10", "remote:4", "Sprecher 4"),
]
);
}
#[test]
@@ -202,8 +331,11 @@ mod tests {
c.status = CallStatus::Failed;
c.error = Some("Netzwerkfehler".into());
c.account_id = Some("mock-2".into());
c.title = Some("Reklamation".into());
let merges = keys(&[("remote:2", "remote:1")]);
let value = serde_json::to_value(CallDetail::of(&c, &[], BTreeMap::new())).unwrap();
let value =
serde_json::to_value(CallDetail::of(&c, &[], BTreeMap::new(), &merges)).unwrap();
assert_eq!(
value,
@@ -215,11 +347,18 @@ mod tests {
"duration_secs": 60,
"status": "failed",
"interrupted": false,
"title": "Reklamation",
"error": "Netzwerkfehler",
"account_id": "mock-2",
},
"segments": [],
"speaker_names": {},
"merges": [{
"from_key": "remote:2",
"from_label": "Sprecher 2",
"into_key": "remote:1",
"into_label": "Sprecher 1",
}],
})
);
}
+234
View File
@@ -7,6 +7,8 @@
use std::cmp::Ordering;
use std::collections::BTreeMap;
use thiserror::Error;
use crate::model::{Segment, Speaker, Word};
/// Longest gap, in seconds, that still belongs to the same segment. A gap
@@ -94,6 +96,103 @@ pub fn label(speaker: &Speaker, names: &BTreeMap<String, String>) -> String {
}
}
/// Why a speaker merge (`from` → `into`) was refused.
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum MergeError {
#[error("Unbekannter Sprecher: {0}")]
UnknownSpeaker(String),
#[error("„Ich“ kann nicht zusammengeführt werden")]
Me,
#[error("Ein Sprecher kann nicht mit sich selbst zusammengeführt werden")]
SameSpeaker,
#[error("Diese Zuordnung würde eine Schleife ergeben")]
Cycle,
}
/// Checks whether `from_key` may be merged into `into_key` on top of the
/// call's existing `merges` (source key → target key): both must be
/// distinct remote speakers, and with the new merge in place (replacing
/// `from_key`'s own, if any) following the targets must not run in a loop.
pub fn check_merge(
merges: &BTreeMap<String, String>,
from_key: &str,
into_key: &str,
) -> Result<(), MergeError> {
for key in [from_key, into_key] {
match Speaker::from_key(key) {
Some(Speaker::Remote(_)) => {}
Some(Speaker::Me) => return Err(MergeError::Me),
None => return Err(MergeError::UnknownSpeaker(key.to_string())),
}
}
if from_key == into_key {
return Err(MergeError::SameSpeaker);
}
let mut proposed: BTreeMap<&str, &str> = merges
.iter()
.map(|(from, into)| (from.as_str(), into.as_str()))
.collect();
proposed.insert(from_key, into_key);
match final_target(&proposed, from_key) {
Some(_) => Ok(()),
None => Err(MergeError::Cycle),
}
}
/// Resolves stored merges (source key → target key) to each source's final
/// target, following chains (3 → 2 and 2 → 1 give 3 → 1). Merges involving
/// anything but two remote speakers, and merges caught in a cycle, are
/// ignored; [`check_merge`] keeps both from being stored.
pub fn resolve_merges(merges: &BTreeMap<String, String>) -> BTreeMap<String, String> {
let is_remote = |key: &str| matches!(Speaker::from_key(key), Some(Speaker::Remote(_)));
let usable: BTreeMap<&str, &str> = merges
.iter()
.filter(|(from, into)| is_remote(from) && is_remote(into))
.map(|(from, into)| (from.as_str(), into.as_str()))
.collect();
usable
.keys()
.filter_map(|&from| Some((from.to_string(), final_target(&usable, from)?.to_string())))
.collect()
}
/// Follows `merges` from `key` to a speaker that is not merged itself, or
/// `None` if the chain runs in a cycle.
fn final_target<'a>(merges: &BTreeMap<&'a str, &'a str>, key: &'a str) -> Option<&'a str> {
let mut current = key;
for _ in 0..=merges.len() {
match merges.get(current) {
Some(&next) => current = next,
None => return Some(current),
}
}
None
}
/// The call's transcript as the user sees it after merging speakers:
/// every segment of a merged source is attributed to its final target (see
/// [`resolve_merges`]), then segments left adjacent with the same speaker
/// are joined under the same 1.5 s gap rule as step 4 of [`merge`]. The
/// stored segments stay untouched, so removing a merge restores them.
pub fn apply_merges(segments: &[Segment], merges: &BTreeMap<String, String>) -> Vec<Segment> {
let resolved = resolve_merges(merges);
let mapped = segments
.iter()
.map(|segment| {
let speaker = resolved
.get(&segment.speaker.key())
.and_then(|target| Speaker::from_key(target))
.unwrap_or(segment.speaker);
Segment {
speaker,
..segment.clone()
}
})
.collect();
merge_adjacent(mapped)
}
/// Orders by `start` (NaN treated as `0.0`), then — for ties — puts the mic
/// first and orders remote speakers by ascending number.
fn cmp_for_merge_order(a: &Segment, b: &Segment) -> Ordering {
@@ -238,6 +337,141 @@ fn join_text(a: &str, b: &str) -> String {
}
}
#[cfg(test)]
mod speaker_merge_tests {
use super::{apply_merges, check_merge, label, resolve_merges, MergeError};
use crate::model::{Segment, Speaker};
use std::collections::BTreeMap;
fn merges(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
pairs
.iter()
.map(|(from, into)| (from.to_string(), into.to_string()))
.collect()
}
fn seg(speaker: Speaker, start: f64, end: f64, text: &str) -> Segment {
Segment {
speaker,
start,
end,
text: text.to_string(),
}
}
#[test]
fn chains_resolve_to_the_final_speaker() {
let resolved = resolve_merges(&merges(&[
("remote:3", "remote:2"),
("remote:2", "remote:1"),
]));
assert_eq!(
resolved,
merges(&[("remote:2", "remote:1"), ("remote:3", "remote:1")])
);
}
#[test]
fn a_stored_cycle_or_a_mapping_involving_me_is_ignored() {
let resolved = resolve_merges(&merges(&[
("remote:1", "remote:2"),
("remote:2", "remote:1"),
("remote:3", "me"),
("me", "remote:4"),
("remote:5", "remote:4"),
]));
assert_eq!(resolved, merges(&[("remote:5", "remote:4")]));
}
#[test]
fn a_merge_that_closes_a_cycle_is_rejected() {
let existing = merges(&[("remote:3", "remote:2"), ("remote:2", "remote:1")]);
assert_eq!(
check_merge(&existing, "remote:1", "remote:3"),
Err(MergeError::Cycle)
);
assert_eq!(
MergeError::Cycle.to_string(),
"Diese Zuordnung würde eine Schleife ergeben"
);
assert_eq!(check_merge(&existing, "remote:4", "remote:3"), Ok(()));
// Re-pointing an existing merge replaces it instead of chaining.
assert_eq!(check_merge(&existing, "remote:2", "remote:4"), Ok(()));
}
#[test]
fn me_is_never_merged() {
let none = BTreeMap::new();
assert_eq!(check_merge(&none, "me", "remote:1"), Err(MergeError::Me));
assert_eq!(check_merge(&none, "remote:1", "me"), Err(MergeError::Me));
}
#[test]
fn a_speaker_is_not_merged_into_itself_or_an_unknown_key() {
let none = BTreeMap::new();
assert_eq!(
check_merge(&none, "remote:1", "remote:1"),
Err(MergeError::SameSpeaker)
);
assert_eq!(
check_merge(&none, "remote:x", "remote:1"),
Err(MergeError::UnknownSpeaker("remote:x".into()))
);
assert_eq!(
MergeError::UnknownSpeaker("remote:x".into()).to_string(),
"Unbekannter Sprecher: remote:x"
);
}
#[test]
fn applied_merges_rejoin_adjacent_segments_and_keep_others_apart() {
let segments = [
seg(Speaker::Remote(1), 0.0, 2.0, "Guten Tag,"),
seg(Speaker::Remote(2), 2.5, 4.0, "hier ist das Weingut."),
seg(Speaker::Me, 4.5, 6.0, "Hallo."),
seg(Speaker::Remote(2), 6.5, 7.0, "Also,"),
// 2 s after the previous line: adjacent, but too far apart.
seg(Speaker::Remote(1), 9.0, 10.0, "die Lieferung."),
];
let merged = apply_merges(&segments, &merges(&[("remote:2", "remote:1")]));
assert_eq!(
merged,
[
seg(
Speaker::Remote(1),
0.0,
4.0,
"Guten Tag, hier ist das Weingut."
),
seg(Speaker::Me, 4.5, 6.0, "Hallo."),
seg(Speaker::Remote(1), 6.5, 7.0, "Also,"),
seg(Speaker::Remote(1), 9.0, 10.0, "die Lieferung."),
]
);
}
#[test]
fn merged_speakers_take_the_targets_name_and_undo_restores_them() {
let segments = [
seg(Speaker::Remote(1), 0.0, 1.0, "Eins."),
seg(Speaker::Me, 1.5, 2.0, "Ja."),
seg(Speaker::Remote(2), 2.5, 3.0, "Zwei."),
];
let names = merges(&[("remote:1", "Frau Beispiel"), ("remote:2", "Herr Probe")]);
let merged = apply_merges(&segments, &merges(&[("remote:2", "remote:1")]));
let labels: Vec<_> = merged.iter().map(|s| label(&s.speaker, &names)).collect();
assert_eq!(labels, ["Frau Beispiel", "Ich", "Frau Beispiel"]);
// Undo: without the merge, the original segments and names return.
let restored = apply_merges(&segments, &BTreeMap::new());
assert_eq!(restored, segments);
assert_eq!(label(&restored[2].speaker, &names), "Herr Probe");
}
}
#[cfg(test)]
mod tests {
use super::{label, merge};
+2
View File
@@ -38,6 +38,8 @@ pub struct Call {
pub transcribed_at: Option<DateTime<Local>>,
pub audio_deleted: bool,
pub account_id: Option<String>,
/// The name the user gave the call, if any.
pub title: Option<String>,
}
/// A single transcribed word with its timing and speaker attribution.
+1
View File
@@ -89,6 +89,7 @@ mod tests {
transcribed_at: None,
audio_deleted: false,
account_id: None,
title: None,
}
}
+345 -13
View File
@@ -6,11 +6,15 @@ use std::path::{Path, PathBuf};
use std::sync::Mutex;
use chrono::{DateTime, Local};
use rusqlite::{params, Connection, Row};
use rusqlite::{params, Connection, Row, TransactionBehavior};
use thiserror::Error;
use crate::merge::{self, MergeError};
use crate::model::{Call, CallId, CallStatus, Segment, Speaker, Summary};
/// Longest call title, in characters.
const MAX_TITLE_CHARS: usize = 120;
/// Errors a [`Store`] operation can fail with.
#[derive(Debug, Error)]
pub enum StoreError {
@@ -22,6 +26,13 @@ pub enum StoreError {
/// speaker key or malformed summary JSON.
#[error("corrupt stored value: {0}")]
Corrupt(String),
/// A speaker merge that [`merge::check_merge`] refused.
#[error(transparent)]
Merge(#[from] MergeError),
#[error("Titel zu lang (max. 120 Zeichen)")]
TitleTooLong,
}
pub type Result<T> = std::result::Result<T, StoreError>;
@@ -40,7 +51,8 @@ pub struct RecoveryReport {
pub failed: Vec<CallId>,
}
const SCHEMA_SQL: &str = "
/// Version 1: the first release.
const SCHEMA_V1_SQL: &str = "
CREATE TABLE IF NOT EXISTS calls (
id INTEGER PRIMARY KEY AUTOINCREMENT,
app TEXT NOT NULL,
@@ -88,6 +100,22 @@ CREATE TABLE IF NOT EXISTS remote_jobs (
);
";
/// Version 2: call titles and reversible speaker merges.
const SCHEMA_V2_SQL: &str = "
ALTER TABLE calls ADD COLUMN title TEXT;
CREATE TABLE speaker_merges (
call_id INTEGER NOT NULL REFERENCES calls(id) ON DELETE CASCADE,
from_key TEXT NOT NULL,
into_key TEXT NOT NULL,
PRIMARY KEY (call_id, from_key)
);
";
/// 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];
/// SQLite-backed store for calls and everything derived from them.
pub struct Store {
conn: Mutex<Connection>,
@@ -106,15 +134,9 @@ impl Store {
Self::init(conn)
}
fn init(conn: Connection) -> Result<Store> {
fn init(mut conn: Connection) -> Result<Store> {
conn.execute_batch("PRAGMA foreign_keys = ON;")?;
let user_version: i64 = conn.query_row("PRAGMA user_version", [], |row| row.get(0))?;
if user_version < 1 {
conn.execute_batch(SCHEMA_SQL)?;
conn.execute_batch("PRAGMA user_version = 1;")?;
}
migrate(&mut conn)?;
Ok(Store {
conn: Mutex::new(conn),
})
@@ -309,6 +331,55 @@ impl Store {
Ok(names)
}
/// Merges remote speaker `from_key` into `into_key` for call `id`,
/// replacing an earlier merge of `from_key`. Refused (see
/// [`merge::check_merge`]) for "me", a speaker merged into itself, and a
/// merge that would make the call's merges loop.
pub fn set_speaker_merge(&self, id: CallId, from_key: &str, into_key: &str) -> Result<()> {
let mut conn = self.conn.lock().unwrap();
let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
merge::check_merge(&merges_of(&tx, id)?, from_key, into_key)?;
tx.execute(
"INSERT INTO speaker_merges (call_id, from_key, into_key) VALUES (?1, ?2, ?3) \
ON CONFLICT(call_id, from_key) DO UPDATE SET into_key = excluded.into_key",
params![id, from_key, into_key],
)?;
tx.commit()?;
Ok(())
}
/// Undoes the merge of `from_key`. Not an error if it was not merged.
pub fn remove_speaker_merge(&self, id: CallId, from_key: &str) -> Result<()> {
let conn = self.conn.lock().unwrap();
conn.execute(
"DELETE FROM speaker_merges WHERE call_id = ?1 AND from_key = ?2",
params![id, from_key],
)?;
Ok(())
}
/// The call's speaker merges, source key → target key as stored (chains
/// are resolved by [`merge::resolve_merges`]).
pub fn speaker_merges(&self, id: CallId) -> Result<BTreeMap<String, String>> {
let conn = self.conn.lock().unwrap();
merges_of(&conn, id)
}
/// Names the call. The title is trimmed; an empty or missing one clears
/// it. Longer than 120 characters is refused.
pub fn set_title(&self, id: CallId, title: Option<&str>) -> Result<()> {
let title = title.map(str::trim).filter(|t| !t.is_empty());
if title.is_some_and(|t| t.chars().count() > MAX_TITLE_CHARS) {
return Err(StoreError::TitleTooLong);
}
let conn = self.conn.lock().unwrap();
conn.execute(
"UPDATE calls SET title = ?1 WHERE id = ?2",
params![title, id],
)?;
Ok(())
}
pub fn mark_transcribed(&self, id: CallId, at: DateTime<Local>) -> Result<()> {
let conn = self.conn.lock().unwrap();
conn.execute(
@@ -328,13 +399,14 @@ impl Store {
}
/// Deletes a call and every row derived from it (segments, summary,
/// speaker names, remote jobs).
/// speaker names and merges, remote jobs).
pub fn delete_call(&self, id: CallId) -> Result<()> {
let mut conn = self.conn.lock().unwrap();
let tx = conn.transaction()?;
tx.execute("DELETE FROM segments WHERE call_id = ?1", params![id])?;
tx.execute("DELETE FROM summaries WHERE call_id = ?1", params![id])?;
tx.execute("DELETE FROM speaker_names WHERE call_id = ?1", params![id])?;
tx.execute("DELETE FROM speaker_merges WHERE call_id = ?1", params![id])?;
tx.execute("DELETE FROM remote_jobs WHERE call_id = ?1", params![id])?;
tx.execute("DELETE FROM calls WHERE id = ?1", params![id])?;
tx.commit()?;
@@ -436,6 +508,34 @@ impl Store {
}
}
/// Brings the schema to the newest version in one transaction, so a failed
/// upgrade leaves the database as it was. Running it on an up-to-date
/// database changes nothing.
fn migrate(conn: &mut Connection) -> Result<()> {
let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
let version: i64 = tx.query_row("PRAGMA user_version", [], |row| row.get(0))?;
let done = usize::try_from(version).unwrap_or(0);
if done < MIGRATIONS.len() {
for step in &MIGRATIONS[done..] {
tx.execute_batch(step)?;
}
tx.execute_batch(&format!("PRAGMA user_version = {};", MIGRATIONS.len()))?;
}
tx.commit()?;
Ok(())
}
fn merges_of(conn: &Connection, id: CallId) -> Result<BTreeMap<String, String>> {
let mut stmt =
conn.prepare("SELECT from_key, into_key FROM speaker_merges WHERE call_id = ?1")?;
let mut rows = stmt.query(params![id])?;
let mut merges = BTreeMap::new();
while let Some(row) = rows.next()? {
merges.insert(row.get(0)?, row.get(1)?);
}
Ok(merges)
}
/// Ids of calls currently in `status`, ordered by id (insertion order).
fn ids_with_status(conn: &rusqlite::Connection, status: CallStatus) -> Result<Vec<CallId>> {
let mut stmt = conn.prepare("SELECT id FROM calls WHERE status = ?1 ORDER BY id ASC")?;
@@ -447,9 +547,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, account_id 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, account_id, title 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, account_id 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, account_id, title FROM calls WHERE id = ?1";
fn row_to_call(row: &Row) -> Result<Call> {
let id: CallId = row.get(0)?;
@@ -464,6 +564,7 @@ fn row_to_call(row: &Row) -> Result<Call> {
let transcribed_at: Option<String> = row.get(9)?;
let audio_deleted: bool = row.get(10)?;
let account_id: Option<String> = row.get(11)?;
let title: Option<String> = row.get(12)?;
Ok(Call {
id,
@@ -478,6 +579,7 @@ fn row_to_call(row: &Row) -> Result<Call> {
transcribed_at: opt_dt_from_str(transcribed_at)?,
audio_deleted,
account_id,
title,
})
}
@@ -540,6 +642,234 @@ mod tests {
};
use crate::store::Store;
/// The schema of user_version 1, exactly as the first release created
/// it, so the upgrade runs against what users have on disk.
const RELEASED_V1_SCHEMA_SQL: &str = "
CREATE TABLE IF NOT EXISTS calls (
id INTEGER PRIMARY KEY AUTOINCREMENT,
app TEXT NOT NULL,
started_at TEXT NOT NULL,
ended_at TEXT,
status TEXT NOT NULL,
interrupted INTEGER NOT NULL,
error TEXT,
mic_path TEXT NOT NULL,
out_path TEXT NOT NULL,
transcribed_at TEXT,
audio_deleted INTEGER NOT NULL,
account_id TEXT
);
CREATE TABLE IF NOT EXISTS segments (
id INTEGER PRIMARY KEY AUTOINCREMENT,
call_id INTEGER NOT NULL REFERENCES calls(id) ON DELETE CASCADE,
seq INTEGER NOT NULL,
speaker TEXT NOT NULL,
start_ts REAL NOT NULL,
end_ts REAL NOT NULL,
text TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS segments_call_id_idx ON segments(call_id);
CREATE TABLE IF NOT EXISTS summaries (
call_id INTEGER PRIMARY KEY REFERENCES calls(id) ON DELETE CASCADE,
json TEXT NOT NULL,
edited INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS speaker_names (
call_id INTEGER NOT NULL REFERENCES calls(id) ON DELETE CASCADE,
speaker_key TEXT NOT NULL,
name TEXT NOT NULL,
PRIMARY KEY (call_id, speaker_key)
);
CREATE TABLE IF NOT EXISTS remote_jobs (
call_id INTEGER NOT NULL REFERENCES calls(id) ON DELETE CASCADE,
track TEXT NOT NULL,
remote_id TEXT NOT NULL,
PRIMARY KEY (call_id, track, remote_id)
);
";
fn user_version(path: &Path) -> i64 {
rusqlite::Connection::open(path)
.unwrap()
.query_row("PRAGMA user_version", [], |row| row.get(0))
.unwrap()
}
fn new_call(store: &Store) -> CallId {
store
.create_call("teams.exe", Local::now(), Path::new(""), Path::new(""))
.unwrap()
}
fn merge_map(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
pairs
.iter()
.map(|(from, into)| (from.to_string(), into.to_string()))
.collect()
}
#[test]
fn a_new_database_starts_at_version_2() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("calls.sqlite");
let store = Store::open(&path).unwrap();
let id = new_call(&store);
store.set_title(id, Some("Angebot")).unwrap();
store.set_speaker_merge(id, "remote:2", "remote:1").unwrap();
drop(store);
assert_eq!(user_version(&path), 2);
}
#[test]
fn a_version_1_database_is_upgraded_keeping_its_data() {
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("PRAGMA user_version = 1;").unwrap();
conn.execute(
"INSERT INTO calls (app, started_at, ended_at, status, interrupted, error, mic_path, out_path, transcribed_at, audio_deleted, account_id) \
VALUES ('Microsoft Teams', ?1, ?1, 'done', 0, NULL, '/rec/1-mic.wav', '/rec/1-out.wav', ?1, 0, 'mock-2')",
rusqlite::params![started],
)
.unwrap();
conn.execute_batch(
"INSERT INTO segments (call_id, seq, speaker, start_ts, end_ts, text) VALUES \
(1, 0, 'me', 0.0, 1.5, 'Guten Tag.'), \
(1, 1, 'remote:2', 2.0, 3.0, 'Hallo.'); \
INSERT INTO speaker_names (call_id, speaker_key, name) VALUES (1, 'remote:2', 'Frau Probe');",
)
.unwrap();
}
let store = Store::open(&path).unwrap();
let call = store.get_call(1).unwrap().expect("call kept");
assert_eq!(call.app, "Microsoft Teams");
assert_eq!(call.status, CallStatus::Done);
assert_eq!(call.account_id.as_deref(), Some("mock-2"));
assert_eq!(call.mic_path, PathBuf::from("/rec/1-mic.wav"));
assert_eq!(call.title, None);
let texts: Vec<_> = store
.segments(1)
.unwrap()
.into_iter()
.map(|s| (s.speaker, s.text))
.collect();
assert_eq!(
texts,
[
(Speaker::Me, "Guten Tag.".to_string()),
(Speaker::Remote(2), "Hallo.".to_string())
]
);
assert_eq!(
store.speaker_names(1).unwrap(),
merge_map(&[("remote:2", "Frau Probe")])
);
assert_eq!(store.speaker_merges(1).unwrap(), BTreeMap::new());
// The new column and table work, and opening again changes nothing.
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), 2);
let store = Store::open(&path).unwrap();
let call = store.get_call(1).unwrap().unwrap();
assert_eq!(call.title.as_deref(), Some("Lieferung März"));
assert_eq!(
store.speaker_merges(1).unwrap(),
merge_map(&[("remote:2", "remote:1")])
);
assert_eq!(store.list_calls().unwrap().len(), 1);
}
#[test]
fn speaker_merges_are_set_replaced_and_removed() {
let store = Store::open_in_memory().unwrap();
let id = new_call(&store);
let other = new_call(&store);
assert_eq!(store.speaker_merges(id).unwrap(), BTreeMap::new());
store.set_speaker_merge(id, "remote:3", "remote:2").unwrap();
store.set_speaker_merge(id, "remote:2", "remote:1").unwrap();
store
.set_speaker_merge(other, "remote:1", "remote:2")
.unwrap();
assert_eq!(
store.speaker_merges(id).unwrap(),
merge_map(&[("remote:2", "remote:1"), ("remote:3", "remote:2")])
);
store.set_speaker_merge(id, "remote:3", "remote:1").unwrap();
store.remove_speaker_merge(id, "remote:2").unwrap();
store.remove_speaker_merge(id, "remote:9").unwrap(); // never merged
assert_eq!(
store.speaker_merges(id).unwrap(),
merge_map(&[("remote:3", "remote:1")])
);
assert_eq!(
store.speaker_merges(other).unwrap(),
merge_map(&[("remote:1", "remote:2")])
);
}
#[test]
fn a_merge_that_would_loop_or_involve_me_is_not_stored() {
let store = Store::open_in_memory().unwrap();
let id = new_call(&store);
store.set_speaker_merge(id, "remote:2", "remote:1").unwrap();
let err = store
.set_speaker_merge(id, "remote:1", "remote:2")
.unwrap_err();
assert_eq!(
err.to_string(),
"Diese Zuordnung würde eine Schleife ergeben"
);
assert!(store.set_speaker_merge(id, "me", "remote:1").is_err());
assert!(store.set_speaker_merge(id, "remote:1", "me").is_err());
assert_eq!(
store.speaker_merges(id).unwrap(),
merge_map(&[("remote:2", "remote:1")])
);
}
#[test]
fn the_title_is_trimmed_cleared_when_empty_and_limited_to_120_chars() {
let store = Store::open_in_memory().unwrap();
let id = new_call(&store);
let title = |store: &Store| store.get_call(id).unwrap().unwrap().title;
assert_eq!(title(&store), None);
store.set_title(id, Some(" Angebot Rioja ")).unwrap();
assert_eq!(title(&store).as_deref(), Some("Angebot Rioja"));
assert_eq!(
store.list_calls().unwrap()[0].title.as_deref(),
Some("Angebot Rioja")
);
store.set_title(id, Some(" ")).unwrap();
assert_eq!(title(&store), None);
store.set_title(id, Some("Angebot")).unwrap();
store.set_title(id, None).unwrap();
assert_eq!(title(&store), None);
let longest = "ä".repeat(120);
store.set_title(id, Some(&longest)).unwrap();
assert_eq!(title(&store), Some(longest.clone()));
let err = store.set_title(id, Some(&"ä".repeat(121))).unwrap_err();
assert_eq!(err.to_string(), "Titel zu lang (max. 120 Zeichen)");
assert_eq!(title(&store), Some(longest));
}
#[test]
fn create_and_finish_call() {
let store = Store::open_in_memory().unwrap();
@@ -853,6 +1183,7 @@ mod tests {
)
.unwrap();
store.set_speaker_name(id, "me", "Ich").unwrap();
store.set_speaker_merge(id, "remote:2", "remote:1").unwrap();
store
.record_remote_job(id, "deepscript", "job-123")
.unwrap();
@@ -864,6 +1195,7 @@ mod tests {
assert_eq!(store.summary(id).unwrap(), None);
assert_eq!(store.speaker_names(id).unwrap(), BTreeMap::new());
assert_eq!(store.remote_jobs(id).unwrap(), Vec::new());
assert_eq!(store.speaker_merges(id).unwrap(), BTreeMap::new());
}
#[test]