admin/momentry_core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5e896fb509547972b28a8a3eea5357ee36d93831
momentry_core/src/api/person_identity.rs.bak

2773 lines
85 KiB
Rust
Raw Blame History

use axum::{
body::Body,
extract::{Path, Query, State},
http::{header, StatusCode},
response::IntoResponse,
response::Json,
routing::{get, patch, post},
Router,
};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::core::db::{Database, PostgresDb};
use crate::core::person_identity::{
ChunkPersonInfo, CreatePersonIdentityRequest, PersonIdentity, PersonIdentityResponse,
PersonMatch, PersonStatistics, PersonTimelineEntry, PersonTimelineResponse,
UpdatePersonIdentityRequest,
};
#[derive(Debug, Deserialize)]
pub struct IdentifyPersonsRequest {
pub video_uuid: String,
pub auto_match: Option<bool>,
pub match_threshold: Option<f64>,
}
#[derive(Debug, Serialize)]
pub struct IdentifyPersonsResponse {
pub success: bool,
pub message: String,
pub persons: Vec<PersonIdentityResponse>,
}
#[derive(Debug, Deserialize)]
pub struct PersonTimelineQuery {
pub video_uuid: String,
}
#[derive(Debug, Deserialize)]
pub struct FaceThumbnailQuery {
pub video_uuid: String,
#[serde(default)]
pub index: Option<usize>, // Which face detection to use (default: 0)
}
// Structs for parsing face_clustered.json
#[derive(Debug, Deserialize)]
struct FaceDetection {
#[serde(default)]
person_id: Option<String>,
x: i32,
y: i32,
width: i32,
height: i32,
}
#[derive(Debug, Deserialize)]
struct FaceFrame {
timestamp: f64,
faces: Vec<FaceDetection>,
}
#[derive(Debug, Deserialize)]
struct FaceClusteredData {
frames: Vec<FaceFrame>,
}
#[derive(Debug, Serialize)]
pub struct ChunkPersonsResponse {
pub success: bool,
pub chunk_id: String,
pub persons: Vec<ChunkPersonInfo>,
}
#[derive(Debug, Deserialize)]
pub struct MergePersonsRequest {
pub video_uuid: String,
pub target_person_id: String,
pub source_person_ids: Vec<String>,
}
#[derive(Debug, Deserialize)]
pub struct UndoMergeRequest {
pub merge_id: String,
}
#[derive(Debug, Serialize)]
pub struct MergeHistoryEntry {
pub merge_id: String,
pub target_person_id: String,
pub source_person_ids: Vec<String>,
pub original_target_stats: serde_json::Value,
pub original_source_stats: serde_json::Value,
pub merged_at: String,
pub is_undone: bool,
pub undone_at: Option<String>,
}
#[derive(Debug, Serialize)]
pub struct MergeHistoryResponse {
pub success: bool,
pub history: Vec<MergeHistoryEntry>,
}
#[derive(Debug, Deserialize)]
pub struct PersonListQuery {
pub video_uuid: String,
pub limit: Option<i32>,
pub offset: Option<i32>,
pub min_appearances: Option<i32>,
pub has_speaker: Option<bool>,
}
#[derive(Debug, Deserialize)]
pub struct AutoIdentifyRequest {
pub video_uuid: String,
pub min_speaker_confidence: Option<f64>,
}
#[derive(Debug, Deserialize)]
pub struct SimilarPersonsQuery {
pub video_uuid: String,
pub threshold: Option<f64>,
pub limit: Option<i32>,
}
#[derive(Debug, Serialize)]
pub struct NamingSuggestion {
pub person_id: String,
pub current_name: Option<String>,
pub suggested_name: String,
pub confidence: f64,
pub sources: Vec<SuggestionSource>,
pub action: String, // "auto_apply" or "needs_review"
}
#[derive(Debug, Serialize)]
pub struct SuggestionSource {
pub r#type: String, // "speaker_match", "talent_db", "ocr_context", "face_similarity"
pub detail: String,
pub weight: f64,
}
#[derive(Debug, Serialize)]
pub struct MergeSuggestion {
pub person_id: String,
pub merge_with: Vec<String>,
pub confidence: f64,
pub reasons: Vec<String>,
pub action: String, // "auto_apply" or "needs_review"
}
#[derive(Debug, Serialize)]
pub struct SuggestionsResponse {
pub success: bool,
pub naming_suggestions: Vec<NamingSuggestion>,
pub merge_suggestions: Vec<MergeSuggestion>,
pub total_naming: usize,
pub total_merge: usize,
}
#[derive(Debug, Serialize)]
pub struct PersonSummary {
pub person_id: String,
pub name: Option<String>,
pub speaker_id: Option<String>,
pub appearance_count: i32,
pub total_appearance_duration: f64,
pub first_appearance_time: Option<f64>,
pub last_appearance_time: Option<f64>,
pub is_confirmed: bool,
pub speaker_confidence: Option<f64>,
}
#[derive(Debug, Serialize)]
pub struct PersonListResponse {
pub success: bool,
pub persons: Vec<PersonSummary>,
pub total: i64,
}
#[derive(Debug, Serialize)]
pub struct MergePersonsResponse {
pub success: bool,
pub message: String,
pub target_person_id: String,
pub merge_id: String,
}
#[derive(Debug, Serialize)]
pub struct AutoIdentifyResponse {
pub success: bool,
pub message: String,
pub total_persons: i32,
pub matched_speakers: i32,
pub persons: Vec<PersonSummary>,
}
pub fn person_identity_routes() -> Router<crate::api::server::AppState> {
Router::new()
.route("/api/v1/person/identify", post(identify_persons))
.route("/api/v1/person/auto-identify", post(auto_identify_persons))
.route("/api/v1/person/suggest", post(get_person_suggestions))
.route("/api/v1/person/list", get(list_persons))
.route("/api/v1/person/merge", post(merge_persons))
.route("/api/v1/person/merge/undo", post(undo_merge))
.route("/api/v1/person/merge/history", get(get_merge_history))
.route(
"/api/v1/person/:person_id/unbind-speaker",
post(unbind_speaker),
)
.route(
"/api/v1/person/:person_id/reassign-speaker",
post(reassign_speaker),
)
.route(
"/api/v1/person/:person_id/remove-appearance",
post(remove_appearance),
)
.route(
"/api/v1/person/:person_id/reassign-appearance",
post(reassign_appearance),
)
.route("/api/v1/person/:person_id/split", post(split_person))
.route(
"/api/v1/person/:person_id/similar",
get(get_similar_persons),
)
.route(
"/api/v1/person/:person_id/confirm",
patch(confirm_person_suggestion),
)
.route("/api/v1/person/:person_id", get(get_person_details))
.route("/api/v1/person/:person_id", patch(update_person_identity))
.route(
"/api/v1/person/:person_id/timeline",
get(get_person_timeline),
)
.route(
"/api/v1/person/:person_id/appearances",
get(get_person_appearances),
)
.route(
"/api/v1/person/:person_id/thumbnail",
get(get_person_thumbnail),
)
.route("/api/v1/chunks/:chunk_id/persons", get(get_chunk_persons))
}
async fn identify_persons(
State(_state): State<crate::api::server::AppState>,
Json(request): Json<IdentifyPersonsRequest>,
) -> Result<Json<IdentifyPersonsResponse>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to connect to database: {}", e),
))
}
};
tracing::info!(
"[PERSON_IDENTITY] Identifying persons for video: {}",
request.video_uuid
);
let auto_match = request.auto_match.unwrap_or(true);
let threshold = request.match_threshold.unwrap_or(0.5);
if auto_match {
let matches = match auto_match_face_speaker(&db, &request.video_uuid, threshold).await {
Ok(m) => m,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to auto-match: {}", e),
))
}
};
let mut persons = Vec::new();
for match_result in matches {
let person = match create_person_identity(
&db,
CreatePersonIdentityRequest {
video_uuid: request.video_uuid.clone(),
face_identity_id: None,
speaker_id: Some(match_result.speaker_id.clone()),
name: None,
metadata: Some(serde_json::json!({
"auto_matched": true,
"confidence": match_result.confidence,
"match_count": match_result.match_count
})),
},
)
.await
{
Ok(p) => p,
Err(e) => {
tracing::warn!("Failed to create person identity: {}", e);
continue;
}
};
persons.push(PersonIdentityResponse::from(person));
}
Ok(Json(IdentifyPersonsResponse {
success: true,
message: format!("Identified {} persons", persons.len()),
persons,
}))
} else {
Ok(Json(IdentifyPersonsResponse {
success: true,
message: "Auto-match disabled, no persons identified".to_string(),
persons: vec![],
}))
}
}
async fn get_person_details(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to connect to database: {}", e),
))
}
};
let query = r#"
SELECT
person_id, name, face_identity_id, speaker_id,
confidence, appearance_count, total_appearance_duration,
first_appearance_time, last_appearance_time,
is_confirmed, created_at, updated_at
FROM person_identities
WHERE person_id = $1
"#;
let person: Option<(
String,
Option<String>,
Option<i32>,
Option<String>,
f64,
i32,
f64,
Option<f64>,
Option<f64>,
bool,
chrono::DateTime<chrono::Utc>,
chrono::DateTime<chrono::Utc>,
)> = match sqlx::query_as(query)
.bind(&person_id)
.fetch_optional(db.pool())
.await
{
Ok(person) => person,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to fetch person: {}", e),
))
}
};
match person {
Some(person_data) => {
let response = serde_json::json!({
"success": true,
"person_id": person_data.0,
"name": person_data.1,
"face_identity_id": person_data.2,
"speaker_id": person_data.3,
"confidence": person_data.4,
"appearance_count": person_data.5,
"total_appearance_duration": person_data.6,
"first_appearance_time": person_data.7,
"last_appearance_time": person_data.8,
"is_confirmed": person_data.9,
"created_at": person_data.10.to_rfc3339(),
"updated_at": person_data.11.to_rfc3339()
});
Ok(Json(response))
}
None => Err((
StatusCode::NOT_FOUND,
format!("Person not found: {}", person_id),
)),
}
}
async fn update_person_identity(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Json(request): Json<UpdatePersonIdentityRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to connect to database: {}", e),
))
}
};
tracing::info!("[PERSON_IDENTITY] Updating person: {}", person_id);
let query = r#"
UPDATE person_identities
SET
name = COALESCE($2, name),
metadata = COALESCE($3, metadata),
is_confirmed = COALESCE($4, is_confirmed),
updated_at = CURRENT_TIMESTAMP
WHERE person_id = $1
RETURNING person_id, name
"#;
let updated: Option<(String, Option<String>)> = match sqlx::query_as(query)
.bind(&person_id)
.bind(&request.name)
.bind(&request.metadata)
.bind(&request.is_confirmed)
.fetch_optional(db.pool())
.await
{
Ok(result) => result,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to update person: {}", e),
))
}
};
match updated {
Some((id, name)) => {
let response = serde_json::json!({
"success": true,
"message": format!("Person '{}' updated successfully", name.unwrap_or_else(|| id.clone())),
"person_id": id
});
Ok(Json(response))
}
None => Err((
StatusCode::NOT_FOUND,
format!("Person not found: {}", person_id),
)),
}
}
async fn get_person_timeline(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Query(query): Query<PersonTimelineQuery>,
) -> Result<Json<PersonTimelineResponse>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to connect to database: {}", e),
))
}
};
let name_query = "SELECT name FROM person_identities WHERE person_id = $1";
let name: Option<String> = match sqlx::query_scalar(name_query)
.bind(&person_id)
.fetch_optional(db.pool())
.await
{
Ok(name) => name,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to fetch person name: {}", e),
))
}
};
let timeline_query = r#"
SELECT start_time, end_time, duration, confidence
FROM person_appearances
WHERE person_id = $1 AND video_uuid = $2
ORDER BY start_time ASC
"#;
let timeline: Vec<(f64, f64, f64, f64)> = match sqlx::query_as(timeline_query)
.bind(&person_id)
.bind(&query.video_uuid)
.fetch_all(db.pool())
.await
{
Ok(timeline) => timeline,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to fetch timeline: {}", e),
))
}
};
let timeline: Vec<PersonTimelineEntry> = timeline
.into_iter()
.map(|(start, end, duration, confidence)| PersonTimelineEntry {
start_time: start,
end_time: end,
duration,
confidence,
})
.collect();
let stats_query = r#"
SELECT
COUNT(*) as total_appearances,
SUM(duration) as total_duration,
MIN(start_time) as first_appearance,
MAX(end_time) as last_appearance,
AVG(confidence) as average_confidence
FROM person_appearances
WHERE person_id = $1 AND video_uuid = $2
"#;
let stats: (i64, Option<f64>, Option<f64>, Option<f64>, Option<f64>) =
match sqlx::query_as(stats_query)
.bind(&person_id)
.bind(&query.video_uuid)
.fetch_one(db.pool())
.await
{
Ok(stats) => stats,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to fetch statistics: {}", e),
))
}
};
let statistics = PersonStatistics {
total_appearances: stats.0 as i32,
total_duration: stats.1.unwrap_or(0.0),
first_appearance: stats.2,
last_appearance: stats.3,
average_confidence: stats.4.unwrap_or(0.0),
};
Ok(Json(PersonTimelineResponse {
person_id,
name,
timeline,
statistics,
}))
}
async fn get_person_appearances(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to connect to database: {}", e),
))
}
};
let query = r#"
SELECT
person_id, video_uuid, start_time, end_time, duration,
face_detection_id, asrx_segment_start, asrx_segment_end,
confidence, created_at
FROM person_appearances
WHERE person_id = $1
ORDER BY start_time DESC
LIMIT 100
"#;
let appearances: Vec<serde_json::Value> = match sqlx::query(query)
.bind(&person_id)
.fetch_all(db.pool())
.await
{
Ok(rows) => {
rows.iter()
.map(|row| {
use sqlx::Row;
serde_json::json!({
"person_id": row.get::<String, _>("person_id"),
"video_uuid": row.get::<String, _>("video_uuid"),
"start_time": row.get::<f64, _>("start_time"),
"end_time": row.get::<f64, _>("end_time"),
"duration": row.get::<f64, _>("duration"),
"confidence": row.get::<f64, _>("confidence"),
"created_at": row.get::<chrono::DateTime<chrono::Utc>, _>("created_at").to_rfc3339()
})
})
.collect()
}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to fetch appearances: {}", e),
))
}
};
Ok(Json(serde_json::json!({
"success": true,
"person_id": person_id,
"appearances": appearances
})))
}
async fn get_chunk_persons(
State(_state): State<crate::api::server::AppState>,
Path(chunk_id): Path<String>,
) -> Result<Json<ChunkPersonsResponse>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to connect to database: {}", e),
))
}
};
let chunk_query = r#"
SELECT uuid, start_time, end_time, metadata
FROM chunks
WHERE chunk_id = $1
"#;
let chunk: Option<(String, f64, f64, Option<serde_json::Value>)> =
match sqlx::query_as(chunk_query)
.bind(&chunk_id)
.fetch_optional(db.pool())
.await
{
Ok(chunk) => chunk,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to fetch chunk: {}", e),
))
}
};
let chunk = match chunk {
Some(c) => c,
None => {
return Err((
StatusCode::NOT_FOUND,
format!("Chunk not found: {}", chunk_id),
))
}
};
let (video_uuid, start_time, end_time, _metadata) = chunk;
let persons_query = r#"
SELECT
pi.person_id,
pi.name,
pa.confidence,
LEAST(pa.end_time, $3) - GREATEST(pa.start_time, $2) as overlap_duration
FROM person_appearances pa
JOIN person_identities pi ON pa.person_id = pi.person_id
WHERE pa.video_uuid = $1
AND pa.start_time < $3
AND pa.end_time > $2
ORDER BY overlap_duration DESC
"#;
let persons: Vec<ChunkPersonInfo> =
match sqlx::query_as::<_, (String, Option<String>, f64, f64)>(persons_query)
.bind(&video_uuid)
.bind(start_time)
.bind(end_time)
.fetch_all(db.pool())
.await
{
Ok(rows) => rows
.into_iter()
.map(
|(person_id, name, confidence, overlap_duration)| ChunkPersonInfo {
person_id,
name,
confidence,
overlap_duration,
},
)
.collect(),
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to fetch persons: {}", e),
))
}
};
Ok(Json(ChunkPersonsResponse {
success: true,
chunk_id,
persons,
}))
}
/// Extracts a face thumbnail for a given person from the video
async fn get_person_thumbnail(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Query(query): Query<FaceThumbnailQuery>,
) -> Result<impl IntoResponse, (StatusCode, String)> {
// 1. Locate the face_clustered.json file
let json_path = format!(
"output/{}/{}_face_clustered.json",
query.video_uuid, query.video_uuid
);
let json_path2 = format!(
"output/{}/{}.face_clustered.json",
query.video_uuid, query.video_uuid
);
// Fallback path if the naming convention is slightly different
let fallback_path = format!("output/{}/face_clustered.json", query.video_uuid);
let path = if std::path::Path::new(&json_path).exists() {
json_path
} else if std::path::Path::new(&json_path2).exists() {
json_path2
} else if std::path::Path::new(&fallback_path).exists() {
fallback_path
} else {
return Err((
StatusCode::NOT_FOUND,
format!(
"Face data not found for video: {}. Tried: {}, {}, {}",
query.video_uuid, json_path, json_path2, fallback_path
),
));
};
// 2. Parse the JSON to find the person's face
let content = match tokio::fs::read_to_string(&path).await {
Ok(c) => c,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Read error: {}", e),
))
}
};
let data: FaceClusteredData = match serde_json::from_str(&content) {
Ok(d) => d,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Parse error: {}", e),
))
}
};
let mut detections = Vec::new();
for frame in &data.frames {
for face in &frame.faces {
if let Some(pid) = &face.person_id {
if pid == &person_id {
detections.push((frame.timestamp, face));
}
}
}
}
if detections.is_empty() {
return Err((
StatusCode::NOT_FOUND,
format!("No detections found for person: {}", person_id),
));
}
let index = query.index.unwrap_or(0).min(detections.len() - 1);
let (timestamp, face) = detections[index];
// 3. Locate the video file
let video_path = format!("output/{}/{}.mp4", query.video_uuid, query.video_uuid);
if !std::path::Path::new(&video_path).exists() {
return Err((
StatusCode::NOT_FOUND,
format!("Video file not found: {}", video_path),
));
}
// 4. Use ffmpeg to extract and crop the face
// ffmpeg -ss {timestamp} -i {video} -vf "crop=w:h:x:y" -frames:v 1 -f image2pipe -vcodec mjpeg -
let crop_filter = format!("crop={}:{}:{}:{}", face.width, face.height, face.x, face.y);
let output = match tokio::process::Command::new("ffmpeg")
.args(&[
"-ss",
&timestamp.to_string(),
"-i",
&video_path,
"-vf",
&crop_filter,
"-frames:v",
"1",
"-f",
"image2pipe",
"-vcodec",
"mjpeg",
"-",
])
.output()
.await
{
Ok(o) => o,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("ffmpeg error: {}", e),
))
}
};
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("ffmpeg failed: {}", stderr),
));
}
// 5. Return the image
let response = axum::response::Response::builder()
.status(StatusCode::OK)
.header(header::CONTENT_TYPE, "image/jpeg")
.body(Body::from(output.stdout))
.map_err(|e| {
(
StatusCode::INTERNAL_SERVER_ERROR,
format!("Response error: {}", e),
)
})?;
Ok(response)
}
async fn create_person_identity(
db: &PostgresDb,
request: CreatePersonIdentityRequest,
) -> Result<PersonIdentity, anyhow::Error> {
let person_id = format!("person_{}", Uuid::new_v4());
let query = r#"
INSERT INTO person_identities (
person_id, video_uuid, face_identity_id, speaker_id,
name, metadata, confidence
) VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING
id, person_id, face_identity_id, speaker_id,
video_uuid, confidence, name, metadata,
first_appearance_time, last_appearance_time,
total_appearance_duration, appearance_count,
created_at, updated_at, is_confirmed
"#;
let person: PersonIdentity = sqlx::query_as(query)
.bind(&person_id)
.bind(&request.video_uuid)
.bind(&request.face_identity_id)
.bind(&request.speaker_id)
.bind(&request.name)
.bind(&request.metadata.unwrap_or(serde_json::json!({})))
.bind(0.0)
.fetch_one(db.pool())
.await?;
Ok(person)
}
async fn auto_match_face_speaker(
db: &PostgresDb,
video_uuid: &str,
threshold: f64,
) -> Result<Vec<PersonMatch>, anyhow::Error> {
let query = "SELECT * FROM auto_match_face_speaker($1, $2)";
let matches: Vec<PersonMatch> = sqlx::query_as(query)
.bind(video_uuid)
.bind(threshold)
.fetch_all(db.pool())
.await?;
Ok(matches)
}
/// Auto-identify persons from face_clustered.json + ASRX speaker data
async fn auto_identify_persons(
State(_state): State<crate::api::server::AppState>,
Json(request): Json<AutoIdentifyRequest>,
) -> Result<Json<AutoIdentifyResponse>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
// 1. Load face_clustered.json
let clustered_path = format!(
"output/{}/{}.face_clustered.json",
request.video_uuid, request.video_uuid
);
let fallback_path = format!("output/{}/face_clustered.json", request.video_uuid);
let path = if std::path::Path::new(&clustered_path).exists() {
clustered_path
} else if std::path::Path::new(&fallback_path).exists() {
fallback_path
} else {
return Err((
StatusCode::NOT_FOUND,
format!(
"face_clustered.json not found for video: {}",
request.video_uuid
),
));
};
let content = match tokio::fs::read_to_string(&path).await {
Ok(c) => c,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Read error: {}", e),
))
}
};
let clustered: FaceClusteredData = match serde_json::from_str(&content) {
Ok(d) => d,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Parse error: {}", e),
))
}
};
// 2. Build person stats from face_clustered.json
use std::collections::HashMap;
#[derive(Default)]
struct PersonStat {
frame_count: i32,
first_time: Option<f64>,
last_time: Option<f64>,
timestamps: Vec<f64>,
}
let mut person_stats: HashMap<String, PersonStat> = HashMap::new();
for frame in &clustered.frames {
for face in &frame.faces {
if let Some(ref pid) = face.person_id {
let stat = person_stats.entry(pid.clone()).or_default();
stat.frame_count += 1;
stat.timestamps.push(frame.timestamp);
if stat.first_time.is_none() || Some(frame.timestamp) < stat.first_time {
stat.first_time = Some(frame.timestamp);
}
if stat.last_time.is_none() || Some(frame.timestamp) > stat.last_time {
stat.last_time = Some(frame.timestamp);
}
}
}
}
// 3. Load ASRX from chunks
let asrx_query = "SELECT chunk_id, content::text FROM chunks WHERE uuid = $1 AND chunk_type = 'trace' AND chunk_id LIKE 'trace_asrx_%'";
let asrx_chunks: Vec<(String, String)> = match sqlx::query_as(asrx_query)
.bind(&request.video_uuid)
.fetch_all(db.pool())
.await
{
Ok(rows) => rows,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("ASRX query error: {}", e),
))
}
};
// Also check sentence chunks for speaker_id
let sentence_query = "SELECT content::text FROM chunks WHERE uuid = $1 AND chunk_type = 'sentence' AND content ? 'speaker_id'";
let sentence_chunks: Vec<String> = match sqlx::query_scalar(sentence_query)
.bind(&request.video_uuid)
.fetch_all(db.pool())
.await
{
Ok(rows) => rows,
Err(_) => vec![],
};
// 4. Match speakers to persons by time overlap
let mut person_speaker_votes: HashMap<String, HashMap<String, f64>> = HashMap::new();
// Check ASRX trace chunks
for (_, content_text) in &asrx_chunks {
if let Ok(content) = serde_json::from_str::<serde_json::Value>(content_text) {
if let (Some(speaker_id), Some(start)) = (
content.get("speaker_id").and_then(|v| v.as_str()),
content.get("timestamp").and_then(|v| v.as_f64()),
) {
let end = start + 5.0; // Approximate 5s segments
for (pid, stat) in &person_stats {
for ts in &stat.timestamps {
if *ts >= start && *ts <= end {
person_speaker_votes
.entry(pid.clone())
.or_default()
.entry(speaker_id.to_string())
.and_modify(|v| *v += 1.0)
.or_insert(1.0);
}
}
}
}
}
}
// Check sentence chunks for speaker_id
for content_text in &sentence_chunks {
if let Ok(content) = serde_json::from_str::<serde_json::Value>(content_text) {
if let (Some(_speaker_id), Some(_text)) = (
content.get("speaker_id").and_then(|v| v.as_str()),
content.get("text").and_then(|v| v.as_str()),
) {
// Timestamps not directly available in sentence chunks for ASRX matching
// Rely on ASRX trace chunks for precise matching
}
}
}
// 5. Insert/update person_identities
let min_conf = request.min_speaker_confidence.unwrap_or(0.0);
let mut matched_count = 0;
let mut persons_result = Vec::new();
// Sort by frame count descending
let mut sorted_persons: Vec<_> = person_stats.into_iter().collect();
sorted_persons.sort_by(|a, b| b.1.frame_count.cmp(&a.1.frame_count));
for (pid, stat) in sorted_persons {
let speaker_info = person_speaker_votes.get(&pid);
let (speaker_id, confidence) = if let Some(votes) = speaker_info {
let total: f64 = votes.values().sum();
if total > 0.0 {
let (best_speaker, best_votes) = votes
.iter()
.max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
.unwrap();
let conf = best_votes / total;
if conf >= min_conf {
(Some(best_speaker.clone()), Some(conf))
} else {
(None, None)
}
} else {
(None, None)
}
} else {
(None, None)
};
if speaker_id.is_some() {
matched_count += 1;
}
// Upsert into person_identities
let upsert_query = r#"
INSERT INTO person_identities (person_id, name, speaker_id, first_appearance_time, last_appearance_time, appearance_count, metadata)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (person_id) DO UPDATE SET
speaker_id = COALESCE(EXCLUDED.speaker_id, person_identities.speaker_id),
first_appearance_time = EXCLUDED.first_appearance_time,
last_appearance_time = EXCLUDED.last_appearance_time,
appearance_count = EXCLUDED.appearance_count,
metadata = COALESCE(EXCLUDED.metadata, person_identities.metadata),
updated_at = NOW()
RETURNING person_id, name, speaker_id, appearance_count, total_appearance_duration,
first_appearance_time, last_appearance_time, is_confirmed
"#;
let metadata = if let Some(conf) = confidence {
serde_json::json!({"auto_identified": true, "speaker_confidence": conf})
} else {
serde_json::json!({"auto_identified": true})
};
let result: Result<
Option<(
String,
Option<String>,
Option<String>,
i32,
f64,
Option<f64>,
Option<f64>,
bool,
)>,
_,
> = sqlx::query_as(upsert_query)
.bind(&pid)
.bind(&pid) // Use cluster label as initial name
.bind(&speaker_id)
.bind(stat.first_time)
.bind(stat.last_time)
.bind(stat.frame_count)
.bind(&metadata)
.fetch_optional(db.pool())
.await;
if let Ok(Some(row)) = result {
persons_result.push(PersonSummary {
person_id: row.0,
name: row.1,
speaker_id: row.2,
appearance_count: row.3,
total_appearance_duration: row.4,
first_appearance_time: row.5,
last_appearance_time: row.6,
is_confirmed: row.7,
speaker_confidence: confidence,
});
}
}
Ok(Json(AutoIdentifyResponse {
success: true,
message: format!(
"Identified {} persons, {} matched to speakers",
persons_result.len(),
matched_count
),
total_persons: persons_result.len() as i32,
matched_speakers: matched_count,
persons: persons_result,
}))
}
/// List all persons with optional filters
async fn list_persons(
State(_state): State<crate::api::server::AppState>,
Query(query): Query<PersonListQuery>,
) -> Result<Json<PersonListResponse>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let limit = query.limit.unwrap_or(50) as i64;
let offset = query.offset.unwrap_or(0) as i64;
let min_appearances = query.min_appearances.unwrap_or(0);
let has_speaker = query.has_speaker.unwrap_or(false);
let (sql, count_sql) = if has_speaker {
if min_appearances > 0 {
(
"SELECT person_id, name, speaker_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time, is_confirmed, metadata::text FROM person_identities WHERE speaker_id IS NOT NULL AND appearance_count >= $1 ORDER BY appearance_count DESC LIMIT $2 OFFSET $3".to_string(),
"SELECT COUNT(*) FROM person_identities WHERE speaker_id IS NOT NULL AND appearance_count >= $1".to_string(),
)
} else {
(
"SELECT person_id, name, speaker_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time, is_confirmed, metadata::text FROM person_identities WHERE speaker_id IS NOT NULL ORDER BY appearance_count DESC LIMIT $1 OFFSET $2".to_string(),
"SELECT COUNT(*) FROM person_identities WHERE speaker_id IS NOT NULL".to_string(),
)
}
} else {
if min_appearances > 0 {
(
"SELECT person_id, name, speaker_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time, is_confirmed, metadata::text FROM person_identities WHERE appearance_count >= $1 ORDER BY appearance_count DESC LIMIT $2 OFFSET $3".to_string(),
"SELECT COUNT(*) FROM person_identities WHERE appearance_count >= $1".to_string(),
)
} else {
(
"SELECT person_id, name, speaker_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time, is_confirmed, metadata::text FROM person_identities ORDER BY appearance_count DESC LIMIT $1 OFFSET $2".to_string(),
"SELECT COUNT(*) FROM person_identities".to_string(),
)
}
};
let total: i64 = if min_appearances > 0 {
sqlx::query_scalar(&count_sql)
.bind(min_appearances)
.fetch_one(db.pool())
.await
.unwrap_or(0)
} else {
sqlx::query_scalar(&count_sql)
.fetch_one(db.pool())
.await
.unwrap_or(0)
};
let rows: Vec<(
String,
Option<String>,
Option<String>,
i32,
f64,
Option<f64>,
Option<f64>,
bool,
Option<String>,
)> = if has_speaker && min_appearances > 0 {
sqlx::query_as(&sql)
.bind(min_appearances)
.bind(limit)
.bind(offset)
.fetch_all(db.pool())
.await
.unwrap_or_default()
} else if has_speaker {
sqlx::query_as(&sql)
.bind(limit)
.bind(offset)
.fetch_all(db.pool())
.await
.unwrap_or_default()
} else if min_appearances > 0 {
sqlx::query_as(&sql)
.bind(min_appearances)
.bind(limit)
.bind(offset)
.fetch_all(db.pool())
.await
.unwrap_or_default()
} else {
sqlx::query_as(&sql)
.bind(limit)
.bind(offset)
.fetch_all(db.pool())
.await
.unwrap_or_default()
};
let persons: Vec<PersonSummary> = rows
.into_iter()
.map(|r| {
let speaker_confidence = r.8.as_ref().and_then(|m| {
serde_json::from_str::<serde_json::Value>(m)
.ok()
.and_then(|v| v.get("speaker_confidence").and_then(|v| v.as_f64()))
});
PersonSummary {
person_id: r.0,
name: r.1,
speaker_id: r.2,
appearance_count: r.3,
total_appearance_duration: r.4,
first_appearance_time: r.5,
last_appearance_time: r.6,
is_confirmed: r.7,
speaker_confidence,
}
})
.collect();
Ok(Json(PersonListResponse {
success: true,
persons,
total,
}))
}
/// Merge duplicate persons into one
async fn merge_persons(
State(_state): State<crate::api::server::AppState>,
Json(request): Json<MergePersonsRequest>,
) -> Result<Json<MergePersonsResponse>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
if request.source_person_ids.is_empty() {
return Err((
StatusCode::BAD_REQUEST,
"source_person_ids cannot be empty".into(),
));
}
let mut tx = match db.pool().begin().await {
Ok(tx) => tx,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Tx error: {}", e),
))
}
};
// 0. Save original stats for undo capability
let orig_target_query = "SELECT appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time FROM person_identities WHERE person_id = $1";
let orig_target: Option<(i32, f64, Option<f64>, Option<f64>)> =
match sqlx::query_as(orig_target_query)
.bind(&request.target_person_id)
.fetch_optional(&mut *tx)
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Target query error: {}", e),
))
}
};
let orig_target = match orig_target {
Some(t) => t,
None => {
return Err((
StatusCode::NOT_FOUND,
format!("Target person not found: {}", request.target_person_id),
))
}
};
let orig_target_stats = serde_json::json!({
"appearance_count": orig_target.0,
"total_appearance_duration": orig_target.1,
"first_appearance_time": orig_target.2,
"last_appearance_time": orig_target.3,
});
let orig_sources_query = "SELECT person_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time FROM person_identities WHERE person_id = ANY($1)";
let orig_sources: Vec<(String, i32, f64, Option<f64>, Option<f64>)> =
match sqlx::query_as(orig_sources_query)
.bind(&request.source_person_ids)
.fetch_all(&mut *tx)
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Source query error: {}", e),
))
}
};
let orig_source_stats: Vec<serde_json::Value> = orig_sources
.into_iter()
.map(|(pid, count, dur, first, last)| {
serde_json::json!({
"person_id": pid,
"appearance_count": count,
"total_appearance_duration": dur,
"first_appearance_time": first,
"last_appearance_time": last,
})
})
.collect();
// Generate merge_id
let merge_id = Uuid::new_v4().to_string();
// A. Calculate sum of stats from sources
let stats_query = r#"
SELECT
COALESCE(SUM(appearance_count), 0)::integer as count,
COALESCE(SUM(total_appearance_duration), 0.0)::double precision as duration
FROM person_identities
WHERE person_id = ANY($1)
"#;
let (add_count, add_duration): (i32, f64) = match sqlx::query_as(stats_query)
.bind(&request.source_person_ids)
.fetch_one(&mut *tx)
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Stats error: {}", e),
))
}
};
// B. Transfer person_appearances
let move_query = "UPDATE person_appearances SET person_id = $1 WHERE person_id = ANY($2)";
match sqlx::query(move_query)
.bind(&request.target_person_id)
.bind(&request.source_person_ids)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Move error: {}", e),
))
}
};
// C. Delete source person_identities
let delete_query = "DELETE FROM person_identities WHERE person_id = ANY($1)";
match sqlx::query(delete_query)
.bind(&request.source_person_ids)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Delete error: {}", e),
))
}
};
// D. Update target stats
let update_query = r#"
UPDATE person_identities
SET
appearance_count = appearance_count + $1,
total_appearance_duration = total_appearance_duration + $2,
updated_at = CURRENT_TIMESTAMP
WHERE person_id = $3
"#;
match sqlx::query(update_query)
.bind(add_count)
.bind(add_duration)
.bind(&request.target_person_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Update error: {}", e),
))
}
};
// E. Record merge history for undo capability
let history_query = r#"
INSERT INTO merge_history (merge_id, target_person_id, source_person_ids, original_target_stats, original_source_stats)
VALUES ($1::uuid, $2, $3, $4::jsonb, $5::jsonb)
"#;
let source_ids_json: Vec<String> = request.source_person_ids.clone();
let target_stats_json =
serde_json::to_string(&orig_target_stats).unwrap_or_else(|_| "{}".to_string());
let source_stats_json =
serde_json::to_string(&orig_source_stats).unwrap_or_else(|_| "[]".to_string());
match sqlx::query(history_query)
.bind(&merge_id)
.bind(&request.target_person_id)
.bind(&source_ids_json)
.bind(&target_stats_json)
.bind(&source_stats_json)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
tracing::warn!("[MERGE] Failed to record merge history: {}", e);
// Don't fail the merge if history recording fails
}
};
// F. Commit
match tx.commit().await {
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Commit error: {}", e),
))
}
};
Ok(Json(MergePersonsResponse {
success: true,
message: format!(
"Merged {} persons into {}",
request.source_person_ids.len(),
request.target_person_id
),
target_person_id: request.target_person_id,
merge_id,
}))
}
/// Undo a previous merge
async fn undo_merge(
State(_state): State<crate::api::server::AppState>,
Json(request): Json<UndoMergeRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
// 1. Get merge history
let history_query = "SELECT id, merge_id::text, target_person_id, source_person_ids, original_target_stats::text, original_source_stats::text, is_undone FROM merge_history WHERE merge_id = $1::uuid";
let history: Option<(i32, String, String, Vec<String>, String, String, bool)> =
match sqlx::query_as(history_query)
.bind(&request.merge_id)
.fetch_optional(db.pool())
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("History query error: {}", e),
))
}
};
let (history_id, _merge_id, target_id, source_ids, tgt_stats_str, src_stats_str, is_undone) =
match history {
Some(h) => h,
None => {
return Err((
StatusCode::NOT_FOUND,
format!("Merge history not found: {}", request.merge_id),
))
}
};
let orig_target_stats: serde_json::Value =
serde_json::from_str(&tgt_stats_str).unwrap_or(serde_json::json!({}));
let orig_source_stats: serde_json::Value =
serde_json::from_str(&src_stats_str).unwrap_or(serde_json::json!({}));
if is_undone {
return Err((
StatusCode::BAD_REQUEST,
"This merge has already been undone".into(),
));
}
let mut tx = match db.pool().begin().await {
Ok(tx) => tx,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Tx error: {}", e),
))
}
};
// 2. Restore target stats
let target_count = orig_target_stats
.get("appearance_count")
.and_then(|v| v.as_i64())
.unwrap_or(0) as i32;
let target_duration = orig_target_stats
.get("total_appearance_duration")
.and_then(|v| v.as_f64())
.unwrap_or(0.0);
let target_first = orig_target_stats
.get("first_appearance_time")
.and_then(|v| v.as_f64());
let target_last = orig_target_stats
.get("last_appearance_time")
.and_then(|v| v.as_f64());
let restore_target_query = "UPDATE person_identities SET appearance_count = $1, total_appearance_duration = $2, first_appearance_time = $3, last_appearance_time = $4, updated_at = CURRENT_TIMESTAMP WHERE person_id = $5";
match sqlx::query(restore_target_query)
.bind(target_count)
.bind(target_duration)
.bind(target_first)
.bind(target_last)
.bind(&target_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Restore target error: {}", e),
))
}
};
// 3. Recreate source person_identities
let empty_arr = vec![];
let source_stats_arr = orig_source_stats.as_array().unwrap_or(&empty_arr);
for source_stat in source_stats_arr {
let source_id = source_stat
.get("person_id")
.and_then(|v| v.as_str())
.unwrap_or("");
let source_count = source_stat
.get("appearance_count")
.and_then(|v| v.as_i64())
.unwrap_or(0) as i32;
let source_duration = source_stat
.get("total_appearance_duration")
.and_then(|v| v.as_f64())
.unwrap_or(0.0);
let source_first = source_stat
.get("first_appearance_time")
.and_then(|v| v.as_f64());
let source_last = source_stat
.get("last_appearance_time")
.and_then(|v| v.as_f64());
let restore_source_query = r#"
INSERT INTO person_identities (person_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time, metadata, is_confirmed)
VALUES ($1, $2, $3, $4, $5, $6, FALSE)
ON CONFLICT (person_id) DO UPDATE SET
appearance_count = EXCLUDED.appearance_count,
total_appearance_duration = EXCLUDED.total_appearance_duration,
first_appearance_time = EXCLUDED.first_appearance_time,
last_appearance_time = EXCLUDED.last_appearance_time,
updated_at = CURRENT_TIMESTAMP
"#;
match sqlx::query(restore_source_query)
.bind(source_id)
.bind(source_count)
.bind(source_duration)
.bind(source_first)
.bind(source_last)
.bind(&serde_json::json!({"restored_from_merge": _merge_id}))
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => tracing::warn!("[UNDO] Failed to restore {}: {}", source_id, e),
};
}
// 4. Mark merge history as undone
let mark_undone_query =
"UPDATE merge_history SET is_undone = TRUE, undone_at = CURRENT_TIMESTAMP WHERE id = $1";
match sqlx::query(mark_undone_query)
.bind(history_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Mark undone error: {}", e),
))
}
};
match tx.commit().await {
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Commit error: {}", e),
))
}
};
Ok(Json(serde_json::json!({
"success": true,
"message": format!("Undo merge completed. Restored {} source persons", source_ids.len()),
"merge_id": _merge_id,
"target_person_id": target_id,
"restored_persons": source_ids
})))
}
/// Get merge history
async fn get_merge_history(
State(_state): State<crate::api::server::AppState>,
) -> Result<Json<MergeHistoryResponse>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let query = "SELECT merge_id::text, target_person_id, source_person_ids, original_target_stats::text, original_source_stats::text, merged_at, is_undone, undone_at FROM merge_history ORDER BY merged_at DESC LIMIT 50";
let rows: Vec<(
String,
String,
Vec<String>,
String,
String,
chrono::DateTime<chrono::Utc>,
bool,
Option<chrono::DateTime<chrono::Utc>>,
)> = match sqlx::query_as(query).fetch_all(db.pool()).await {
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("History query error: {}", e),
))
}
};
let history: Vec<MergeHistoryEntry> = rows
.into_iter()
.map(
|(merge_id, target, sources, tgt_stats, src_stats, merged_at, is_undone, undone_at)| {
MergeHistoryEntry {
merge_id,
target_person_id: target,
source_person_ids: sources,
original_target_stats: serde_json::from_str(&tgt_stats)
.unwrap_or(serde_json::json!({})),
original_source_stats: serde_json::from_str(&src_stats)
.unwrap_or(serde_json::json!({})),
merged_at: merged_at.to_rfc3339(),
is_undone,
undone_at: undone_at.map(|t| t.to_rfc3339()),
}
},
)
.collect();
Ok(Json(MergeHistoryResponse {
success: true,
history,
}))
}
/// Get AI suggestions for naming and merging persons
async fn get_person_suggestions(
State(_state): State<crate::api::server::AppState>,
Json(request): Json<AutoIdentifyRequest>,
) -> Result<Json<SuggestionsResponse>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
// Get all persons for this video (or all if no video_uuid)
let persons_query = if request.video_uuid.is_empty() {
"SELECT person_id, name, speaker_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time, metadata FROM person_identities ORDER BY appearance_count DESC LIMIT 100"
} else {
// Filter by video_uuid via person_appearances
"SELECT DISTINCT pi.person_id, pi.name, pi.speaker_id, pi.appearance_count, pi.total_appearance_duration, pi.first_appearance_time, pi.last_appearance_time, pi.metadata FROM person_identities pi JOIN person_appearances pa ON pi.person_id = pa.person_id WHERE pa.video_uuid = $1 ORDER BY pi.appearance_count DESC LIMIT 100"
};
let persons: Vec<(
String,
Option<String>,
Option<String>,
i32,
f64,
Option<f64>,
Option<f64>,
Option<serde_json::Value>,
)> = if request.video_uuid.is_empty() {
sqlx::query_as(persons_query)
.fetch_all(db.pool())
.await
.unwrap_or_default()
} else {
sqlx::query_as(persons_query)
.bind(&request.video_uuid)
.fetch_all(db.pool())
.await
.unwrap_or_default()
};
let mut naming_suggestions = Vec::new();
let mut merge_suggestions = Vec::new();
// Group by speaker_id to find merge candidates
let mut speaker_groups: std::collections::HashMap<String, Vec<(String, i32)>> =
std::collections::HashMap::new();
for (
person_id,
name,
speaker_id,
appearance_count,
_duration,
_first_time,
_last_time,
metadata,
) in &persons
{
// Naming suggestions
if name.is_none() {
let mut sources = Vec::new();
let mut suggested_name = person_id.clone();
let mut confidence = 0.0;
// Check speaker_id
if let Some(sid) = speaker_id {
sources.push(SuggestionSource {
r#type: "speaker_match".to_string(),
detail: format!("Linked to speaker {}", sid),
weight: 0.4,
});
suggested_name = sid.clone();
confidence += 0.4;
}
// Check metadata for speaker_confidence
if let Some(meta) = metadata {
if let Some(sc) = meta.get("speaker_confidence").and_then(|v| v.as_f64()) {
confidence += sc * 0.3;
sources.push(SuggestionSource {
r#type: "speaker_confidence".to_string(),
detail: format!("Speaker match confidence: {:.0}%", sc * 100.0),
weight: sc * 0.3,
});
}
}
// High appearance count suggests main character
if *appearance_count > 1000 {
confidence += 0.2;
sources.push(SuggestionSource {
r#type: "high_appearance".to_string(),
detail: format!(
"Appears in {} frames (likely main character)",
appearance_count
),
weight: 0.2,
});
}
if confidence > 0.0 {
let action = if confidence >= 0.7 {
"auto_apply".to_string()
} else {
"needs_review".to_string()
};
naming_suggestions.push(NamingSuggestion {
person_id: person_id.clone(),
current_name: name.clone(),
suggested_name,
confidence,
sources,
action,
});
}
}
// Group by speaker_id for merge detection
if let Some(sid) = speaker_id {
speaker_groups
.entry(sid.clone())
.or_default()
.push((person_id.clone(), *appearance_count));
}
}
// Find merge candidates: multiple persons with same speaker_id
for (speaker_id, group) in &speaker_groups {
if group.len() > 1 {
let primary = group.iter().max_by_key(|(_, count)| *count).unwrap();
let others: Vec<String> = group
.iter()
.filter(|(pid, _)| pid != &primary.0)
.map(|(pid, _)| pid.clone())
.collect();
// Calculate confidence based on appearance ratio
let primary_count = primary.1 as f64;
let total_count: f64 = group.iter().map(|(_, c)| *c as f64).sum();
let confidence = if total_count > 0.0 {
primary_count / total_count
} else {
0.0
};
let reasons = vec![
format!("All share speaker_id: {}", speaker_id),
format!(
"Primary {} has {} appearances ({}% of group)",
primary.0,
primary.1,
(primary_count / total_count * 100.0) as i32
),
format!("{} persons to merge into primary", others.len()),
];
let action = if confidence >= 0.7 {
"auto_apply".to_string()
} else {
"needs_review".to_string()
};
merge_suggestions.push(MergeSuggestion {
person_id: primary.0.clone(),
merge_with: others,
confidence,
reasons,
action,
});
}
}
let total_naming = naming_suggestions.len();
let total_merge = merge_suggestions.len();
Ok(Json(SuggestionsResponse {
success: true,
naming_suggestions,
merge_suggestions,
total_naming,
total_merge,
}))
}
/// Find similar persons that could be merged
async fn get_similar_persons(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Query(query): Query<SimilarPersonsQuery>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let threshold = query.threshold.unwrap_or(0.5);
let limit = query.limit.unwrap_or(10);
// Get the target person's speaker_id and time range
let person_query = "SELECT speaker_id, first_appearance_time, last_appearance_time FROM person_identities WHERE person_id = $1";
let person_info: Option<(Option<String>, Option<f64>, Option<f64>)> =
match sqlx::query_as(person_query)
.bind(&person_id)
.fetch_optional(db.pool())
.await
{
Ok(info) => info,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Query error: {}", e),
))
}
};
let person_info = match person_info {
Some(info) => info,
None => {
return Err((
StatusCode::NOT_FOUND,
format!("Person not found: {}", person_id),
))
}
};
// Find similar persons by speaker_id overlap or time overlap
let similar_query = r#"
SELECT
pi.person_id,
pi.name,
pi.speaker_id,
pi.appearance_count,
pi.first_appearance_time,
pi.last_appearance_time,
CASE
WHEN pi.speaker_id IS NOT NULL AND $2 IS NOT NULL AND pi.speaker_id = $2 THEN 0.7::double precision
WHEN pi.speaker_id IS NULL THEN 0.3::double precision
ELSE 0.5::double precision
END as similarity
FROM person_identities pi
WHERE pi.person_id != $1
AND pi.appearance_count > 0
ORDER BY similarity DESC, pi.appearance_count DESC
LIMIT $3
"#;
let similar: Vec<(
String,
Option<String>,
Option<String>,
i32,
Option<f64>,
Option<f64>,
f64,
)> = match sqlx::query_as(similar_query)
.bind(&person_id)
.bind(&person_info.0)
.bind(limit)
.fetch_all(db.pool())
.await
{
Ok(rows) => rows,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Query error: {}", e),
))
}
};
let results: Vec<serde_json::Value> = similar
.into_iter()
.filter(|(_, _, _, _, _, _, similarity)| *similarity >= threshold)
.map(|(pid, name, speaker_id, count, first, last, similarity)| {
serde_json::json!({
"person_id": pid,
"name": name,
"speaker_id": speaker_id,
"appearance_count": count,
"first_appearance_time": first,
"last_appearance_time": last,
"similarity": similarity
})
})
.collect();
Ok(Json(serde_json::json!({
"success": true,
"person_id": person_id,
"similar_persons": results,
"threshold": threshold
})))
}
/// Confirm an AI suggestion (auto-apply naming)
async fn confirm_person_suggestion(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Json(request): Json<UpdatePersonIdentityRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let query = r#"
UPDATE person_identities
SET
name = COALESCE($2, name),
metadata = COALESCE($3, metadata),
is_confirmed = true,
updated_at = CURRENT_TIMESTAMP
WHERE person_id = $1
RETURNING person_id, name
"#;
let updated: Option<(String, Option<String>)> = match sqlx::query_as(query)
.bind(&person_id)
.bind(&request.name)
.bind(&request.metadata)
.fetch_optional(db.pool())
.await
{
Ok(result) => result,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Update error: {}", e),
))
}
};
match updated {
Some((id, name)) => Ok(Json(serde_json::json!({
"success": true,
"message": format!("Person '{}' confirmed", name.unwrap_or_else(|| id.clone())),
"person_id": id
}))),
None => Err((
StatusCode::NOT_FOUND,
format!("Person not found: {}", person_id),
)),
}
}
// ============================================================
// Correction APIs - For fixing incorrect person bindings
// ============================================================
/// Request to unbind speaker from person
#[derive(Debug, Deserialize)]
pub struct UnbindSpeakerRequest {
pub video_uuid: String,
pub reason: Option<String>,
}
/// Request to reassign speaker to person
#[derive(Debug, Deserialize)]
pub struct ReassignSpeakerRequest {
pub video_uuid: String,
pub speaker_id: String,
pub reason: Option<String>,
}
/// Request to remove a specific appearance
#[derive(Debug, Deserialize)]
pub struct RemoveAppearanceRequest {
pub video_uuid: String,
pub appearance_id: i32,
pub reason: Option<String>,
}
/// Request to reassign appearance to another person
#[derive(Debug, Deserialize)]
pub struct ReassignAppearanceRequest {
pub video_uuid: String,
pub appearance_id: i32,
pub target_person_id: String,
pub reason: Option<String>,
}
/// Request to split a person into two
#[derive(Debug, Deserialize)]
pub struct SplitPersonRequest {
pub video_uuid: String,
pub new_person_id: String,
pub appearance_ids_to_move: Vec<i32>,
pub new_person_name: Option<String>,
pub reason: Option<String>,
}
/// Unbind speaker from person
async fn unbind_speaker(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Json(request): Json<UnbindSpeakerRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let update_query = r#"
UPDATE person_identities
SET speaker_id = NULL, updated_at = CURRENT_TIMESTAMP,
metadata = jsonb_set(
COALESCE(metadata, '{}'::jsonb),
'{speaker_unbound}',
'true'::jsonb
)
WHERE person_id = $1
RETURNING person_id
"#;
let updated: Option<String> = match sqlx::query_scalar(update_query)
.bind(&person_id)
.fetch_optional(db.pool())
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Unbind error: {}", e),
))
}
};
match updated {
Some(id) => Ok(Json(serde_json::json!({
"success": true,
"message": format!("Speaker unbound from person '{}'", id),
"person_id": id,
"reason": request.reason.unwrap_or_default()
}))),
None => Err((
StatusCode::NOT_FOUND,
format!("Person not found: {}", person_id),
)),
}
}
/// Reassign speaker to person
async fn reassign_speaker(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Json(request): Json<ReassignSpeakerRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let update_query = r#"
UPDATE person_identities
SET speaker_id = $2, updated_at = CURRENT_TIMESTAMP,
metadata = jsonb_set(
COALESCE(metadata, '{}'::jsonb),
'{speaker_reassigned}',
'true'::jsonb
)
WHERE person_id = $1
RETURNING person_id
"#;
let updated: Option<String> = match sqlx::query_scalar(update_query)
.bind(&person_id)
.bind(&request.speaker_id)
.fetch_optional(db.pool())
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Reassign error: {}", e),
))
}
};
match updated {
Some(id) => Ok(Json(serde_json::json!({
"success": true,
"message": format!("Speaker '{}' assigned to person '{}'", request.speaker_id, id),
"person_id": id,
"new_speaker_id": request.speaker_id,
"reason": request.reason.unwrap_or_default()
}))),
None => Err((
StatusCode::NOT_FOUND,
format!("Person not found: {}", person_id),
)),
}
}
/// Remove a specific appearance
async fn remove_appearance(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Json(request): Json<RemoveAppearanceRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let mut tx = match db.pool().begin().await {
Ok(tx) => tx,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Tx error: {}", e),
))
}
};
// Get appearance info before deleting
let app_query =
"SELECT duration, person_id FROM person_appearances WHERE id = $1 AND person_id = $2";
let app_info: Option<(f64, String)> = match sqlx::query_as(app_query)
.bind(request.appearance_id)
.bind(&person_id)
.fetch_optional(&mut *tx)
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Appearance query error: {}", e),
))
}
};
let (duration, actual_person_id) = match app_info {
Some(info) => info,
None => {
return Err((
StatusCode::NOT_FOUND,
format!("Appearance not found: {}", request.appearance_id),
))
}
};
// Delete appearance
let delete_query = "DELETE FROM person_appearances WHERE id = $1 AND person_id = $2";
match sqlx::query(delete_query)
.bind(request.appearance_id)
.bind(&person_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Delete error: {}", e),
))
}
};
// Update person stats
let update_stats_query = r#"
UPDATE person_identities
SET appearance_count = appearance_count - 1,
total_appearance_duration = GREATEST(0, total_appearance_duration - $1),
updated_at = CURRENT_TIMESTAMP
WHERE person_id = $2
"#;
match sqlx::query(update_stats_query)
.bind(duration)
.bind(&actual_person_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Stats update error: {}", e),
))
}
};
match tx.commit().await {
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Commit error: {}", e),
))
}
};
Ok(Json(serde_json::json!({
"success": true,
"message": format!("Appearance {} removed from person '{}'", request.appearance_id, person_id),
"appearance_id": request.appearance_id,
"person_id": person_id,
"removed_duration": duration,
"reason": request.reason.unwrap_or_default()
})))
}
/// Reassign appearance to another person
async fn reassign_appearance(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Json(request): Json<ReassignAppearanceRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let mut tx = match db.pool().begin().await {
Ok(tx) => tx,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Tx error: {}", e),
))
}
};
// Get appearance info
let app_query =
"SELECT id, duration, person_id FROM person_appearances WHERE id = $1 AND person_id = $2";
let app_info: Option<(i32, f64, String)> = match sqlx::query_as(app_query)
.bind(request.appearance_id)
.bind(&person_id)
.fetch_optional(&mut *tx)
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Appearance query error: {}", e),
))
}
};
let (app_id, duration, _old_person_id) = match app_info {
Some(info) => info,
None => {
return Err((
StatusCode::NOT_FOUND,
format!("Appearance not found: {}", request.appearance_id),
))
}
};
// Reassign to new person
let update_query = "UPDATE person_appearances SET person_id = $1 WHERE id = $2";
match sqlx::query(update_query)
.bind(&request.target_person_id)
.bind(app_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Reassign error: {}", e),
))
}
};
// Update old person stats (decrement)
let update_old_query = r#"
UPDATE person_identities
SET appearance_count = GREATEST(0, appearance_count - 1),
total_appearance_duration = GREATEST(0, total_appearance_duration - $1),
updated_at = CURRENT_TIMESTAMP
WHERE person_id = $2
"#;
match sqlx::query(update_old_query)
.bind(duration)
.bind(&person_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Old person stats error: {}", e),
))
}
};
// Update new person stats (increment)
let update_new_query = r#"
UPDATE person_identities
SET appearance_count = appearance_count + 1,
total_appearance_duration = total_appearance_duration + $1,
updated_at = CURRENT_TIMESTAMP
WHERE person_id = $2
"#;
match sqlx::query(update_new_query)
.bind(duration)
.bind(&request.target_person_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("New person stats error: {}", e),
))
}
};
match tx.commit().await {
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Commit error: {}", e),
))
}
};
Ok(Json(serde_json::json!({
"success": true,
"message": format!("Appearance {} reassigned from '{}' to '{}'", request.appearance_id, person_id, request.target_person_id),
"appearance_id": request.appearance_id,
"from_person_id": person_id,
"to_person_id": request.target_person_id,
"reason": request.reason.unwrap_or_default()
})))
}
/// Split a person into two
async fn split_person(
State(_state): State<crate::api::server::AppState>,
Path(person_id): Path<String>,
Json(request): Json<SplitPersonRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
let db = match PostgresDb::init().await {
Ok(db) => db,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("DB error: {}", e),
))
}
};
let mut tx = match db.pool().begin().await {
Ok(tx) => tx,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Tx error: {}", e),
))
}
};
// Get original person info
let orig_query = "SELECT speaker_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time, metadata FROM person_identities WHERE person_id = $1";
let orig_info: Option<(
Option<String>,
i32,
f64,
Option<f64>,
Option<f64>,
Option<serde_json::Value>,
)> = match sqlx::query_as(orig_query)
.bind(&person_id)
.fetch_optional(&mut *tx)
.await
{
Ok(r) => r,
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Person query error: {}", e),
))
}
};
let (speaker_id, orig_count, orig_duration, orig_first, orig_last, orig_metadata) =
match orig_info {
Some(info) => info,
None => {
return Err((
StatusCode::NOT_FOUND,
format!("Person not found: {}", person_id),
))
}
};
// Create new person
let new_count = request.appearance_ids_to_move.len();
let create_query = r#"
INSERT INTO person_identities (person_id, name, speaker_id, appearance_count, total_appearance_duration, first_appearance_time, last_appearance_time, metadata, is_confirmed)
VALUES ($1, $2, $3, $4, 0, NULL, NULL, $5, FALSE)
ON CONFLICT (person_id) DO UPDATE SET
name = EXCLUDED.name,
speaker_id = EXCLUDED.speaker_id,
metadata = EXCLUDED.metadata
RETURNING person_id
"#;
let new_name = request
.new_person_name
.unwrap_or_else(|| format!("{}-split", request.new_person_id));
let mut new_metadata = orig_metadata.unwrap_or(serde_json::json!({}));
new_metadata["split_from"] = serde_json::json!(person_id);
match sqlx::query(create_query)
.bind(&request.new_person_id)
.bind(new_name)
.bind(&speaker_id)
.bind(new_count as i32)
.bind(&new_metadata)
.fetch_optional(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Create person error: {}", e),
))
}
};
// Move appearances to new person and calculate new stats
let mut new_duration: f64 = 0.0;
let mut new_first: Option<f64> = None;
let mut new_last: Option<f64> = None;
for app_id in &request.appearance_ids_to_move {
let app_query = "SELECT duration, start_time, end_time FROM person_appearances WHERE id = $1 AND person_id = $2";
let app_info: Option<(f64, f64, f64)> = match sqlx::query_as(app_query)
.bind(app_id)
.bind(&person_id)
.fetch_optional(&mut *tx)
.await
{
Ok(r) => r,
Err(e) => {
tracing::warn!("[SPLIT] Failed to get appearance {}: {}", app_id, e);
continue;
}
};
if let Some((dur, start, end)) = app_info {
// Update appearance to new person
let update_app_query = "UPDATE person_appearances SET person_id = $1 WHERE id = $2";
match sqlx::query(update_app_query)
.bind(&request.new_person_id)
.bind(app_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
tracing::warn!("[SPLIT] Failed to update appearance {}: {}", app_id, e);
continue;
}
};
new_duration += dur;
if new_first.is_none() || Some(start) < new_first {
new_first = Some(start);
}
if new_last.is_none() || Some(end) > new_last {
new_last = Some(end);
}
}
}
// Update new person stats
let update_new_query = r#"
UPDATE person_identities
SET total_appearance_duration = $1,
first_appearance_time = $2,
last_appearance_time = $3,
appearance_count = $4,
updated_at = CURRENT_TIMESTAMP
WHERE person_id = $5
"#;
match sqlx::query(update_new_query)
.bind(new_duration)
.bind(new_first)
.bind(new_last)
.bind(new_count as i32)
.bind(&request.new_person_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Update new person error: {}", e),
))
}
};
// Update original person stats (decrement)
let update_orig_query = r#"
UPDATE person_identities
SET appearance_count = GREATEST(0, appearance_count - $1),
total_appearance_duration = GREATEST(0, total_appearance_duration - $2),
updated_at = CURRENT_TIMESTAMP
WHERE person_id = $3
"#;
match sqlx::query(update_orig_query)
.bind(new_count as i32)
.bind(new_duration)
.bind(&person_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Update original person error: {}", e),
))
}
};
// Update original person's first/last appearance times
let recalc_query = r#"
UPDATE person_identities
SET first_appearance_time = (SELECT MIN(start_time) FROM person_appearances WHERE person_id = $1),
last_appearance_time = (SELECT MAX(end_time) FROM person_appearances WHERE person_id = $1)
WHERE person_id = $1
"#;
match sqlx::query(recalc_query)
.bind(&person_id)
.execute(&mut *tx)
.await
{
Ok(_) => {}
Err(e) => tracing::warn!("[SPLIT] Failed to recalc original person times: {}", e),
};
match tx.commit().await {
Ok(_) => {}
Err(e) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Commit error: {}", e),
))
}
};
Ok(Json(serde_json::json!({
"success": true,
"message": format!("Person '{}' split into '{}' with {} appearances moved", person_id, request.new_person_id, new_count),
"original_person_id": person_id,
"new_person_id": request.new_person_id,
"appearances_moved": new_count,
"new_person_duration": new_duration,
"new_person_first": new_first,
"new_person_last": new_last,
"reason": request.reason.unwrap_or_default()
})))
}
Reference in New Issue View Git Blame Copy Permalink