474 lines
29 KiB
Python
474 lines
29 KiB
Python
from fastapi import APIRouter, UploadFile, File, Form, Depends, BackgroundTasks
|
|
from app.models.models import Meeting, TranscriptSegment, TranscriptionTaskStatus, CreateMeetingRequest, UpdateMeetingRequest, SpeakerTagUpdateRequest, BatchSpeakerTagUpdateRequest, BatchTranscriptUpdateRequest, Tag
|
|
from app.core.database import get_db_connection
|
|
from app.core.config import BASE_DIR, AUDIO_DIR, MARKDOWN_DIR, ALLOWED_EXTENSIONS, ALLOWED_IMAGE_EXTENSIONS
|
|
import app.core.config as config_module
|
|
from app.services.llm_service import LLMService
|
|
from app.services.async_transcription_service import AsyncTranscriptionService
|
|
from app.services.async_meeting_service import async_meeting_service
|
|
from app.core.auth import get_current_user
|
|
from app.core.response import create_api_response
|
|
from typing import List, Optional
|
|
from datetime import datetime
|
|
from pydantic import BaseModel
|
|
import os
|
|
import uuid
|
|
import shutil
|
|
|
|
router = APIRouter()
|
|
|
|
llm_service = LLMService()
|
|
transcription_service = AsyncTranscriptionService()
|
|
|
|
class GenerateSummaryRequest(BaseModel):
|
|
user_prompt: Optional[str] = ""
|
|
|
|
def _process_tags(cursor, tag_string: Optional[str]) -> List[Tag]:
|
|
if not tag_string:
|
|
return []
|
|
tag_names = [name.strip() for name in tag_string.split(',') if name.strip()]
|
|
if not tag_names:
|
|
return []
|
|
insert_ignore_query = "INSERT IGNORE INTO tags (name) VALUES (%s)"
|
|
cursor.executemany(insert_ignore_query, [(name,) for name in tag_names])
|
|
format_strings = ', '.join(['%s'] * len(tag_names))
|
|
cursor.execute(f"SELECT id, name, color FROM tags WHERE name IN ({format_strings})", tuple(tag_names))
|
|
tags_data = cursor.fetchall()
|
|
return [Tag(**tag) for tag in tags_data]
|
|
|
|
@router.get("/meetings")
|
|
def get_meetings(current_user: dict = Depends(get_current_user), user_id: Optional[int] = None):
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
base_query = '''
|
|
SELECT m.meeting_id, m.title, m.meeting_time, m.summary, m.created_at, m.tags,
|
|
m.user_id as creator_id, u.caption as creator_username, af.file_path as audio_file_path
|
|
FROM meetings m JOIN users u ON m.user_id = u.user_id LEFT JOIN audio_files af ON m.meeting_id = af.meeting_id
|
|
'''
|
|
if user_id:
|
|
query = f'{base_query} LEFT JOIN attendees a ON m.meeting_id = a.meeting_id WHERE m.user_id = %s OR a.user_id = %s GROUP BY m.meeting_id ORDER BY m.meeting_time DESC, m.created_at DESC'
|
|
cursor.execute(query, (user_id, user_id))
|
|
else:
|
|
query = f" {base_query} ORDER BY m.meeting_time DESC, m.created_at DESC"
|
|
cursor.execute(query)
|
|
meetings = cursor.fetchall()
|
|
meeting_list = []
|
|
for meeting in meetings:
|
|
attendees_query = 'SELECT u.user_id, u.caption FROM attendees a JOIN users u ON a.user_id = u.user_id WHERE a.meeting_id = %s'
|
|
cursor.execute(attendees_query, (meeting['meeting_id'],))
|
|
attendees_data = cursor.fetchall()
|
|
attendees = [{'user_id': row['user_id'], 'caption': row['caption']} for row in attendees_data]
|
|
tags = _process_tags(cursor, meeting.get('tags'))
|
|
meeting_list.append(Meeting(
|
|
meeting_id=meeting['meeting_id'], title=meeting['title'], meeting_time=meeting['meeting_time'],
|
|
summary=meeting['summary'], created_at=meeting['created_at'], audio_file_path=meeting['audio_file_path'],
|
|
attendees=attendees, creator_id=meeting['creator_id'], creator_username=meeting['creator_username'], tags=tags
|
|
))
|
|
return create_api_response(code="200", message="获取会议列表成功", data=meeting_list)
|
|
|
|
@router.get("/meetings/{meeting_id}")
|
|
def get_meeting_details(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
query = '''
|
|
SELECT m.meeting_id, m.title, m.meeting_time, m.summary, m.created_at, m.tags,
|
|
m.user_id as creator_id, u.caption as creator_username, af.file_path as audio_file_path
|
|
FROM meetings m JOIN users u ON m.user_id = u.user_id LEFT JOIN audio_files af ON m.meeting_id = af.meeting_id
|
|
WHERE m.meeting_id = %s
|
|
'''
|
|
cursor.execute(query, (meeting_id,))
|
|
meeting = cursor.fetchone()
|
|
if not meeting:
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
attendees_query = 'SELECT u.user_id, u.caption FROM attendees a JOIN users u ON a.user_id = u.user_id WHERE a.meeting_id = %s'
|
|
cursor.execute(attendees_query, (meeting['meeting_id'],))
|
|
attendees_data = cursor.fetchall()
|
|
attendees = [{'user_id': row['user_id'], 'caption': row['caption']} for row in attendees_data]
|
|
tags = _process_tags(cursor, meeting.get('tags'))
|
|
cursor.close()
|
|
meeting_data = Meeting(
|
|
meeting_id=meeting['meeting_id'], title=meeting['title'], meeting_time=meeting['meeting_time'],
|
|
summary=meeting['summary'], created_at=meeting['created_at'], attendees=attendees,
|
|
creator_id=meeting['creator_id'], creator_username=meeting['creator_username'], tags=tags
|
|
)
|
|
if meeting['audio_file_path']:
|
|
meeting_data.audio_file_path = meeting['audio_file_path']
|
|
try:
|
|
transcription_status_data = transcription_service.get_meeting_transcription_status(meeting_id)
|
|
if transcription_status_data:
|
|
meeting_data.transcription_status = TranscriptionTaskStatus(**transcription_status_data)
|
|
except Exception as e:
|
|
print(f"Warning: Failed to get transcription status for meeting {meeting_id}: {e}")
|
|
return create_api_response(code="200", message="获取会议详情成功", data=meeting_data)
|
|
|
|
@router.get("/meetings/{meeting_id}/transcript")
|
|
def get_meeting_transcript(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT meeting_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
if not cursor.fetchone():
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
transcript_query = '''
|
|
SELECT segment_id, meeting_id, speaker_id, speaker_tag, start_time_ms, end_time_ms, text_content
|
|
FROM transcript_segments WHERE meeting_id = %s ORDER BY start_time_ms ASC
|
|
'''
|
|
cursor.execute(transcript_query, (meeting_id,))
|
|
segments = cursor.fetchall()
|
|
transcript_segments = [TranscriptSegment(
|
|
segment_id=s['segment_id'], meeting_id=s['meeting_id'], speaker_id=s['speaker_id'],
|
|
speaker_tag=s['speaker_tag'] if s['speaker_tag'] else f"发言人 {s['speaker_id']}",
|
|
start_time_ms=s['start_time_ms'], end_time_ms=s['end_time_ms'], text_content=s['text_content']
|
|
) for s in segments]
|
|
return create_api_response(code="200", message="获取转录内容成功", data=transcript_segments)
|
|
|
|
@router.post("/meetings")
|
|
def create_meeting(meeting_request: CreateMeetingRequest, current_user: dict = Depends(get_current_user)):
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
if meeting_request.tags:
|
|
tag_names = [name.strip() for name in meeting_request.tags.split(',') if name.strip()]
|
|
if tag_names:
|
|
cursor.executemany("INSERT IGNORE INTO tags (name) VALUES (%s)", [(name,) for name in tag_names])
|
|
meeting_query = 'INSERT INTO meetings (user_id, title, meeting_time, summary, tags, created_at) VALUES (%s, %s, %s, %s, %s, %s)'
|
|
cursor.execute(meeting_query, (meeting_request.user_id, meeting_request.title, meeting_request.meeting_time, None, meeting_request.tags, datetime.now().isoformat()))
|
|
meeting_id = cursor.lastrowid
|
|
for attendee_id in meeting_request.attendee_ids:
|
|
cursor.execute('INSERT IGNORE INTO attendees (meeting_id, user_id) VALUES (%s, %s)', (meeting_id, attendee_id))
|
|
connection.commit()
|
|
return create_api_response(code="200", message="Meeting created successfully", data={"meeting_id": meeting_id})
|
|
|
|
@router.put("/meetings/{meeting_id}")
|
|
def update_meeting(meeting_id: int, meeting_request: UpdateMeetingRequest, current_user: dict = Depends(get_current_user)):
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT user_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
meeting = cursor.fetchone()
|
|
if not meeting:
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
if meeting['user_id'] != current_user['user_id']:
|
|
return create_api_response(code="403", message="Permission denied")
|
|
if meeting_request.tags:
|
|
tag_names = [name.strip() for name in meeting_request.tags.split(',') if name.strip()]
|
|
if tag_names:
|
|
cursor.executemany("INSERT IGNORE INTO tags (name) VALUES (%s)", [(name,) for name in tag_names])
|
|
update_query = 'UPDATE meetings SET title = %s, meeting_time = %s, summary = %s, tags = %s WHERE meeting_id = %s'
|
|
cursor.execute(update_query, (meeting_request.title, meeting_request.meeting_time, meeting_request.summary, meeting_request.tags, meeting_id))
|
|
cursor.execute("DELETE FROM attendees WHERE meeting_id = %s", (meeting_id,))
|
|
for attendee_id in meeting_request.attendee_ids:
|
|
cursor.execute('INSERT INTO attendees (meeting_id, user_id) VALUES (%s, %s)', (meeting_id, attendee_id))
|
|
connection.commit()
|
|
return create_api_response(code="200", message="Meeting updated successfully")
|
|
|
|
@router.delete("/meetings/{meeting_id}")
|
|
def delete_meeting(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT user_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
meeting = cursor.fetchone()
|
|
if not meeting:
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
if meeting['user_id'] != current_user['user_id']:
|
|
return create_api_response(code="403", message="Permission denied")
|
|
cursor.execute("DELETE FROM transcript_segments WHERE meeting_id = %s", (meeting_id,))
|
|
cursor.execute("DELETE FROM audio_files WHERE meeting_id = %s", (meeting_id,))
|
|
cursor.execute("DELETE FROM attachments WHERE meeting_id = %s", (meeting_id,))
|
|
cursor.execute("DELETE FROM attendees WHERE meeting_id = %s", (meeting_id,))
|
|
cursor.execute("DELETE FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
connection.commit()
|
|
return create_api_response(code="200", message="Meeting deleted successfully")
|
|
|
|
@router.get("/meetings/{meeting_id}/edit")
|
|
def get_meeting_for_edit(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
query = '''
|
|
SELECT m.meeting_id, m.title, m.meeting_time, m.summary, m.created_at, m.tags,
|
|
m.user_id as creator_id, u.caption as creator_username, af.file_path as audio_file_path
|
|
FROM meetings m JOIN users u ON m.user_id = u.user_id LEFT JOIN audio_files af ON m.meeting_id = af.meeting_id
|
|
WHERE m.meeting_id = %s
|
|
'''
|
|
cursor.execute(query, (meeting_id,))
|
|
meeting = cursor.fetchone()
|
|
if not meeting:
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
attendees_query = 'SELECT u.user_id, u.caption FROM attendees a JOIN users u ON a.user_id = u.user_id WHERE a.meeting_id = %s'
|
|
cursor.execute(attendees_query, (meeting['meeting_id'],))
|
|
attendees_data = cursor.fetchall()
|
|
attendees = [{'user_id': row['user_id'], 'caption': row['caption']} for row in attendees_data]
|
|
tags = _process_tags(cursor, meeting.get('tags'))
|
|
cursor.close()
|
|
meeting_data = Meeting(
|
|
meeting_id=meeting['meeting_id'], title=meeting['title'], meeting_time=meeting['meeting_time'],
|
|
summary=meeting['summary'], created_at=meeting['created_at'], attendees=attendees,
|
|
creator_id=meeting['creator_id'], creator_username=meeting['creator_username'], tags=tags
|
|
)
|
|
if meeting.get('audio_file_path'):
|
|
meeting_data.audio_file_path = meeting['audio_file_path']
|
|
try:
|
|
transcription_status_data = transcription_service.get_meeting_transcription_status(meeting_id)
|
|
if transcription_status_data:
|
|
meeting_data.transcription_status = TranscriptionTaskStatus(**transcription_status_data)
|
|
except Exception as e:
|
|
print(f"Warning: Failed to get transcription status for meeting {meeting_id}: {e}")
|
|
return create_api_response(code="200", message="获取会议编辑信息成功", data=meeting_data)
|
|
|
|
@router.post("/meetings/upload-audio")
|
|
async def upload_audio(audio_file: UploadFile = File(...), meeting_id: int = Form(...), force_replace: str = Form("false"), current_user: dict = Depends(get_current_user)):
|
|
force_replace_bool = force_replace.lower() in ("true", "1", "yes")
|
|
file_extension = os.path.splitext(audio_file.filename)[1].lower()
|
|
if file_extension not in ALLOWED_EXTENSIONS:
|
|
return create_api_response(code="400", message=f"Unsupported file type. Allowed types: {', '.join(ALLOWED_EXTENSIONS)}")
|
|
max_file_size = getattr(config_module, 'MAX_FILE_SIZE', 100 * 1024 * 1024)
|
|
if audio_file.size > max_file_size:
|
|
return create_api_response(code="400", message=f"File size exceeds {max_file_size // (1024 * 1024)}MB limit")
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT user_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
meeting = cursor.fetchone()
|
|
if not meeting:
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
if meeting['user_id'] != current_user['user_id']:
|
|
return create_api_response(code="403", message="Permission denied")
|
|
cursor.execute("SELECT file_name, file_path, upload_time FROM audio_files WHERE meeting_id = %s", (meeting_id,))
|
|
existing_info = cursor.fetchone()
|
|
has_transcription = False
|
|
if existing_info:
|
|
cursor.execute("SELECT COUNT(*) as segment_count FROM transcript_segments WHERE meeting_id = %s", (meeting_id,))
|
|
has_transcription = cursor.fetchone()['segment_count'] > 0
|
|
cursor.close()
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to check existing files: {str(e)}")
|
|
if existing_info and has_transcription and not force_replace_bool:
|
|
return create_api_response(code="300", message="该会议已有音频文件和转录记录，重新上传将删除现有的转录内容", data={
|
|
"requires_confirmation": True,
|
|
"existing_file": {
|
|
"file_name": existing_info['file_name'],
|
|
"upload_time": existing_info['upload_time'].isoformat() if existing_info['upload_time'] else None
|
|
}
|
|
})
|
|
meeting_dir = AUDIO_DIR / str(meeting_id)
|
|
meeting_dir.mkdir(exist_ok=True)
|
|
unique_filename = f"{uuid.uuid4()}{file_extension}"
|
|
absolute_path = meeting_dir / unique_filename
|
|
relative_path = absolute_path.relative_to(BASE_DIR)
|
|
try:
|
|
with open(absolute_path, "wb") as buffer:
|
|
shutil.copyfileobj(audio_file.file, buffer)
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to save file: {str(e)}")
|
|
task_id = None
|
|
replaced_existing = existing_info is not None
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
if replaced_existing and force_replace_bool:
|
|
cursor.execute("DELETE FROM transcript_segments WHERE meeting_id = %s", (meeting_id,))
|
|
cursor.execute("DELETE FROM transcript_tasks WHERE meeting_id = %s", (meeting_id,))
|
|
if existing_info and existing_info['file_path']:
|
|
old_file_path = BASE_DIR / existing_info['file_path'].lstrip('/')
|
|
if old_file_path.exists():
|
|
try:
|
|
os.remove(old_file_path)
|
|
except Exception as e:
|
|
print(f"Warning: Failed to delete old file {old_file_path}: {e}")
|
|
if replaced_existing:
|
|
cursor.execute('UPDATE audio_files SET file_name = %s, file_path = %s, file_size = %s, upload_time = NOW(), task_id = NULL WHERE meeting_id = %s', (audio_file.filename, '/'+str(relative_path), audio_file.size, meeting_id))
|
|
else:
|
|
cursor.execute('INSERT INTO audio_files (meeting_id, file_name, file_path, file_size, upload_time) VALUES (%s, %s, %s, %s, NOW())', (meeting_id, audio_file.filename, '/'+str(relative_path), audio_file.size))
|
|
connection.commit()
|
|
cursor.close()
|
|
try:
|
|
task_id = transcription_service.start_transcription(meeting_id, '/'+str(relative_path))
|
|
print(f"Transcription task started with ID: {task_id}")
|
|
except Exception as e:
|
|
print(f"Failed to start transcription task: {e}")
|
|
except Exception as e:
|
|
if os.path.exists(absolute_path):
|
|
os.remove(absolute_path)
|
|
return create_api_response(code="500", message=f"Failed to save file info: {str(e)}")
|
|
return create_api_response(code="200", message="Audio file uploaded successfully" + (" and replaced existing file" if replaced_existing else ""), data={
|
|
"file_name": audio_file.filename, "file_path": '/'+str(relative_path), "task_id": task_id,
|
|
"transcription_started": task_id is not None, "replaced_existing": replaced_existing,
|
|
"previous_transcription_cleared": replaced_existing and has_transcription
|
|
})
|
|
|
|
@router.get("/meetings/{meeting_id}/audio")
|
|
def get_audio_file(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT file_name, file_path, file_size, upload_time FROM audio_files WHERE meeting_id = %s", (meeting_id,))
|
|
audio_file = cursor.fetchone()
|
|
if not audio_file:
|
|
return create_api_response(code="404", message="Audio file not found for this meeting")
|
|
return create_api_response(code="200", message="Audio file found", data=audio_file)
|
|
|
|
@router.get("/meetings/{meeting_id}/transcription/status")
|
|
def get_meeting_transcription_status(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
status_info = transcription_service.get_meeting_transcription_status(meeting_id)
|
|
if not status_info:
|
|
return create_api_response(code="404", message="No transcription task found for this meeting")
|
|
return create_api_response(code="200", message="Transcription status retrieved", data=status_info)
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to get meeting transcription status: {str(e)}")
|
|
|
|
@router.post("/meetings/{meeting_id}/transcription/start")
|
|
def start_meeting_transcription(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT meeting_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
if not cursor.fetchone():
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
cursor.execute("SELECT file_path FROM audio_files WHERE meeting_id = %s LIMIT 1", (meeting_id,))
|
|
audio_file = cursor.fetchone()
|
|
if not audio_file:
|
|
return create_api_response(code="400", message="No audio file found for this meeting")
|
|
existing_status = transcription_service.get_meeting_transcription_status(meeting_id)
|
|
if existing_status and existing_status['status'] in ['pending', 'processing']:
|
|
return create_api_response(code="409", message="Transcription task already exists", data={
|
|
"task_id": existing_status['task_id'], "status": existing_status['status']
|
|
})
|
|
task_id = transcription_service.start_transcription(meeting_id, audio_file['file_path'])
|
|
return create_api_response(code="200", message="Transcription task started successfully", data={
|
|
"task_id": task_id, "meeting_id": meeting_id
|
|
})
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to start transcription: {str(e)}")
|
|
|
|
@router.post("/meetings/{meeting_id}/upload-image")
|
|
async def upload_image(meeting_id: int, image_file: UploadFile = File(...), current_user: dict = Depends(get_current_user)):
|
|
file_extension = os.path.splitext(image_file.filename)[1].lower()
|
|
if file_extension not in ALLOWED_IMAGE_EXTENSIONS:
|
|
return create_api_response(code="400", message=f"Unsupported image type. Allowed types: {', '.join(ALLOWED_IMAGE_EXTENSIONS)}")
|
|
max_image_size = getattr(config_module, 'MAX_IMAGE_SIZE', 10 * 1024 * 1024)
|
|
if image_file.size > max_image_size:
|
|
return create_api_response(code="400", message=f"Image size exceeds {max_image_size // (1024 * 1024)}MB limit")
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT user_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
meeting = cursor.fetchone()
|
|
if not meeting:
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
if meeting['user_id'] != current_user['user_id']:
|
|
return create_api_response(code="403", message="Permission denied")
|
|
meeting_dir = MARKDOWN_DIR / str(meeting_id)
|
|
meeting_dir.mkdir(exist_ok=True)
|
|
unique_filename = f"{uuid.uuid4()}{file_extension}"
|
|
absolute_path = meeting_dir / unique_filename
|
|
relative_path = absolute_path.relative_to(BASE_DIR)
|
|
try:
|
|
with open(absolute_path, "wb") as buffer:
|
|
shutil.copyfileobj(image_file.file, buffer)
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to save image: {str(e)}")
|
|
return create_api_response(code="200", message="Image uploaded successfully", data={
|
|
"file_name": image_file.filename, "file_path": '/'+ str(relative_path)
|
|
})
|
|
|
|
@router.put("/meetings/{meeting_id}/speaker-tags")
|
|
def update_speaker_tag(meeting_id: int, request: SpeakerTagUpdateRequest, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor()
|
|
update_query = 'UPDATE transcript_segments SET speaker_tag = %s WHERE meeting_id = %s AND speaker_id = %s'
|
|
cursor.execute(update_query, (request.new_tag, meeting_id, request.speaker_id))
|
|
if cursor.rowcount == 0:
|
|
return create_api_response(code="404", message="No segments found for this speaker")
|
|
connection.commit()
|
|
return create_api_response(code="200", message="Speaker tag updated successfully", data={'updated_count': cursor.rowcount})
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to update speaker tag: {str(e)}")
|
|
|
|
@router.put("/meetings/{meeting_id}/speaker-tags/batch")
|
|
def batch_update_speaker_tags(meeting_id: int, request: BatchSpeakerTagUpdateRequest, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor()
|
|
total_updated = 0
|
|
for update_item in request.updates:
|
|
update_query = 'UPDATE transcript_segments SET speaker_tag = %s WHERE meeting_id = %s AND speaker_id = %s'
|
|
cursor.execute(update_query, (update_item.new_tag, meeting_id, update_item.speaker_id))
|
|
total_updated += cursor.rowcount
|
|
connection.commit()
|
|
return create_api_response(code="200", message="Speaker tags updated successfully", data={'total_updated': total_updated})
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to batch update speaker tags: {str(e)}")
|
|
|
|
@router.put("/meetings/{meeting_id}/transcript/batch")
|
|
def batch_update_transcript(meeting_id: int, request: BatchTranscriptUpdateRequest, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor()
|
|
total_updated = 0
|
|
for update_item in request.updates:
|
|
cursor.execute("SELECT segment_id FROM transcript_segments WHERE segment_id = %s AND meeting_id = %s", (update_item.segment_id, meeting_id))
|
|
if not cursor.fetchone():
|
|
continue
|
|
update_query = 'UPDATE transcript_segments SET text_content = %s WHERE segment_id = %s AND meeting_id = %s'
|
|
cursor.execute(update_query, (update_item.text_content, update_item.segment_id, meeting_id))
|
|
total_updated += cursor.rowcount
|
|
connection.commit()
|
|
return create_api_response(code="200", message="Transcript updated successfully", data={'total_updated': total_updated})
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to update transcript: {str(e)}")
|
|
|
|
@router.get("/meetings/{meeting_id}/summaries")
|
|
def get_meeting_summaries(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT meeting_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
if not cursor.fetchone():
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
summaries = llm_service.get_meeting_summaries(meeting_id)
|
|
return create_api_response(code="200", message="Summaries retrieved successfully", data={"summaries": summaries})
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to get summaries: {str(e)}")
|
|
|
|
@router.get("/meetings/{meeting_id}/summaries/{summary_id}")
|
|
def get_summary_detail(meeting_id: int, summary_id: int, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
query = "SELECT id, summary_content, user_prompt, created_at FROM meeting_summaries WHERE id = %s AND meeting_id = %s"
|
|
cursor.execute(query, (summary_id, meeting_id))
|
|
summary = cursor.fetchone()
|
|
if not summary:
|
|
return create_api_response(code="404", message="Summary not found")
|
|
return create_api_response(code="200", message="Summary detail retrieved", data=summary)
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to get summary detail: {str(e)}")
|
|
|
|
@router.post("/meetings/{meeting_id}/generate-summary-async")
|
|
def generate_meeting_summary_async(meeting_id: int, request: GenerateSummaryRequest, background_tasks: BackgroundTasks, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT meeting_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
if not cursor.fetchone():
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
task_id = async_meeting_service.start_summary_generation(meeting_id, request.user_prompt)
|
|
background_tasks.add_task(async_meeting_service._process_task, task_id)
|
|
return create_api_response(code="200", message="Summary generation task has been accepted.", data={
|
|
"task_id": task_id, "status": "pending", "meeting_id": meeting_id
|
|
})
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to start summary generation: {str(e)}")
|
|
|
|
@router.get("/meetings/{meeting_id}/llm-tasks")
|
|
def get_meeting_llm_tasks(meeting_id: int, current_user: dict = Depends(get_current_user)):
|
|
try:
|
|
with get_db_connection() as connection:
|
|
cursor = connection.cursor(dictionary=True)
|
|
cursor.execute("SELECT meeting_id FROM meetings WHERE meeting_id = %s", (meeting_id,))
|
|
if not cursor.fetchone():
|
|
return create_api_response(code="404", message="Meeting not found")
|
|
tasks = async_meeting_service.get_meeting_llm_tasks(meeting_id)
|
|
return create_api_response(code="200", message="LLM tasks retrieved successfully", data={
|
|
"tasks": tasks, "total": len(tasks)
|
|
})
|
|
except Exception as e:
|
|
return create_api_response(code="500", message=f"Failed to get LLM tasks: {str(e)}")
|