{title}（开发中...）
10 | )
11 |
12 | const App: React.FC = () => {
13 | return (
14 |
72 | 
73 |
74 |
73 |
76 |
79 |
37 |
110 |
111 | )
112 | }
113 |
114 | export default InterviewNew
--------------------------------------------------------------------------------
/backend/app/routers/sessions.py:
--------------------------------------------------------------------------------
1 | from fastapi import APIRouter, Depends, HTTPException, status
2 | from sqlalchemy.orm import Session
3 | from sqlalchemy import func
4 | from typing import List
5 | import uuid
6 |
7 | from ..database import get_db
8 | from ..models import User as UserModel, InterviewSession, SessionMessage
9 | from ..schemas import (
10 | InterviewSessionCreate,
11 | InterviewSession as InterviewSessionSchema,
12 | InterviewSessionList,
13 | SessionMessageCreate,
14 | SessionMessage as SessionMessageSchema
15 | )
16 | from ..auth import get_current_active_user
17 |
18 | router = APIRouter()
19 |
20 | @router.post("/", response_model=InterviewSessionSchema)
21 | async def create_session(
22 | session: InterviewSessionCreate,
23 | current_user: UserModel = Depends(get_current_active_user),
24 | db: Session = Depends(get_db)
25 | ):
26 | # Generate unique session ID
27 | session_id = str(uuid.uuid4())
28 |
29 | # Create new session
30 | db_session = InterviewSession(
31 | user_id=current_user.id,
32 | session_id=session_id,
33 | title=session.title or f"Interview Session - {session_id[:8]}"
34 | )
35 | db.add(db_session)
36 | db.commit()
37 | db.refresh(db_session)
38 |
39 | return db_session
40 |
41 | @router.get("/", response_model=List[InterviewSessionList])
42 | async def get_user_sessions(
43 | current_user: UserModel = Depends(get_current_active_user),
44 | db: Session = Depends(get_db)
45 | ):
46 | # Get sessions with message count
47 | sessions = db.query(
48 | InterviewSession,
49 | func.count(SessionMessage.id).label('message_count')
50 | ).outerjoin(SessionMessage).filter(
51 | InterviewSession.user_id == current_user.id
52 | ).group_by(InterviewSession.id).order_by(
53 | InterviewSession.updated_at.desc()
54 | ).all()
55 |
56 | result = []
57 | for session, message_count in sessions:
58 | result.append({
59 | "id": session.id,
60 | "session_id": session.session_id,
61 | "title": session.title,
62 | "created_at": session.created_at,
63 | "updated_at": session.updated_at,
64 | "message_count": message_count or 0
65 | })
66 |
67 | return result
68 |
69 | @router.get("/{session_id}", response_model=InterviewSessionSchema)
70 | async def get_session(
71 | session_id: str,
72 | current_user: UserModel = Depends(get_current_active_user),
73 | db: Session = Depends(get_db)
74 | ):
75 | session = db.query(InterviewSession).filter(
76 | InterviewSession.session_id == session_id,
77 | InterviewSession.user_id == current_user.id
78 | ).first()
79 |
80 | if not session:
81 | raise HTTPException(
82 | status_code=status.HTTP_404_NOT_FOUND,
83 | detail="Session not found"
84 | )
85 |
86 | return session
87 |
88 | @router.post("/{session_id}/messages", response_model=SessionMessageSchema)
89 | async def add_message_to_session(
90 | session_id: str,
91 | message: SessionMessageCreate,
92 | current_user: UserModel = Depends(get_current_active_user),
93 | db: Session = Depends(get_db)
94 | ):
95 | # Get session
96 | session = db.query(InterviewSession).filter(
97 | InterviewSession.session_id == session_id,
98 | InterviewSession.user_id == current_user.id
99 | ).first()
100 |
101 | if not session:
102 | raise HTTPException(
103 | status_code=status.HTTP_404_NOT_FOUND,
104 | detail="Session not found"
105 | )
106 |
107 | # Create message
108 | db_message = SessionMessage(
109 | session_id=session.id,
110 | message_type=message.message_type,
111 | content=message.content,
112 | message_metadata=message.message_metadata
113 | )
114 | db.add(db_message)
115 | db.commit()
116 | db.refresh(db_message)
117 |
118 | # Update session timestamp
119 | from datetime import datetime
120 | session.updated_at = datetime.utcnow()
121 | db.commit()
122 |
123 | return db_message
124 |
125 | @router.get("/{session_id}/messages", response_model=List[SessionMessageSchema])
126 | async def get_session_messages(
127 | session_id: str,
128 | current_user: UserModel = Depends(get_current_active_user),
129 | db: Session = Depends(get_db)
130 | ):
131 | # Get session
132 | session = db.query(InterviewSession).filter(
133 | InterviewSession.session_id == session_id,
134 | InterviewSession.user_id == current_user.id
135 | ).first()
136 |
137 | if not session:
138 | raise HTTPException(
139 | status_code=status.HTTP_404_NOT_FOUND,
140 | detail="Session not found"
141 | )
142 |
143 | messages = db.query(SessionMessage).filter(
144 | SessionMessage.session_id == session.id
145 | ).order_by(SessionMessage.timestamp.asc()).all()
146 |
147 | return messages
148 |
149 | @router.delete("/{session_id}")
150 | async def delete_session(
151 | session_id: str,
152 | current_user: UserModel = Depends(get_current_active_user),
153 | db: Session = Depends(get_db)
154 | ):
155 | session = db.query(InterviewSession).filter(
156 | InterviewSession.session_id == session_id,
157 | InterviewSession.user_id == current_user.id
158 | ).first()
159 |
160 | if not session:
161 | raise HTTPException(
162 | status_code=status.HTTP_404_NOT_FOUND,
163 | detail="Session not found"
164 | )
165 |
166 | # Delete all messages first
167 | db.query(SessionMessage).filter(SessionMessage.session_id == session.id).delete()
168 |
169 | # Delete session
170 | db.delete(session)
171 | db.commit()
172 |
173 | return {"detail": "Session deleted successfully"}
--------------------------------------------------------------------------------
/frontend/src/api/deepseek.ts:
--------------------------------------------------------------------------------
1 | import { useApiConfigStore } from '../store/apiConfigStore'
2 | import { useInterviewStore } from '@/store/interviewStore'
3 | import { message as antdMessage } from 'antd'
4 |
5 | /**
6 | * DeepSeek API 响应接口
7 | */
8 | interface DeepSeekResponse {
9 | id: string
10 | object: string
11 | created: number
12 | model: string
13 | choices: Array<{
14 | index: number
15 | message: {
16 | role: string
17 | content: string
18 | }
19 | finish_reason: string
20 | }>
21 | usage: {
22 | prompt_tokens: number
23 | completion_tokens: number
24 | total_tokens: number
25 | }
26 | }
27 |
28 | /**
29 | * DeepSeek API 请求参数接口
30 | */
31 | interface DeepSeekRequest {
32 | model: string
33 | messages: Array<{
34 | role: 'user' | 'assistant' | 'system'
35 | content: string
36 | }>
37 | temperature?: number
38 | max_tokens?: number
39 | stream?: boolean
40 | }
41 |
42 | const DEEPSEEK_BASE_URL = 'https://api.deepseek.com'
43 |
44 | /**
45 | * 获取DeepSeek配置
46 | * @returns DeepSeek配置
47 | */
48 | const getDeepSeekConfig = () => {
49 | const { apiConfigs } = useApiConfigStore.getState()
50 | const config = apiConfigs.find(config => config.apiProvider === 'deepseek')
51 | if (!config) {
52 | throw new Error('DeepSeek configuration not found')
53 | }
54 | return config
55 | }
56 |
57 | /**
58 | * 调用 DeepSeek API 进行对话
59 | * @param messages 对话消息数组
60 | * @param options 可选参数
61 | * @returns Promise
45 | 应用设置
46 | 配置API密钥和相关参数
47 |
48 |
51 |
52 |
53 |
104 |
105 |
122 |
123 |
124 |
125 |
126 |
211 |
212 |
229 |
230 |
231 |
232 | )
233 | }
--------------------------------------------------------------------------------
/frontend/src/api/xfyunRtasr.ts:
--------------------------------------------------------------------------------
1 | // 科大讯飞实时语音转写API工具
2 | // 文档参考：https://www.xfyun.cn/doc/asr/rtasr/API.html
3 |
4 | import CryptoJS from 'crypto-js';
5 | import type { MeetingMessage } from '@/store/interviewStore'
6 | import { useInterviewStore } from '@/store/interviewStore'
7 | import { useXfyunConfigStore } from '@/store/xfyunConfigStore'
8 |
9 | // 获取当前时间戳（秒）
10 | function getTimestamp() {
11 | return Math.floor(Date.now() / 1000);
12 | }
13 |
14 | // 生成 signa（HMACSHA1 + base64 + urlencode）
15 | function getSigna(appid: string, apiKey: string, ts: number) {
16 | const signa = CryptoJS.MD5(appid + ts).toString();
17 | const signatureSha = CryptoJS.HmacSHA1(signa, apiKey);
18 | const signature = CryptoJS.enc.Base64.stringify(signatureSha);
19 | return encodeURIComponent(signature);
20 | }
21 |
22 | // 生成WebSocket URL
23 | export function getRtasrWebSocketUrl() {
24 | const { getAppId, getApiKey } = useXfyunConfigStore.getState();
25 | const appId = getAppId();
26 | const apiKey = getApiKey();
27 |
28 | if (!appId || !apiKey) {
29 | throw new Error('科大讯飞API配置未完成，请在设置中配置APPID和API_KEY');
30 | }
31 |
32 | const ts = getTimestamp();
33 | const signa = getSigna(appId, apiKey, ts);
34 | return `wss://rtasr.xfyun.cn/v1/ws?appid=${appId}&ts=${ts}&signa=${signa}&roleType=2`;
35 | }
36 |
37 | // 创建WebSocket并处理转写
38 | export function createRtasrWebSocket({
39 | onResult,
40 | onError,
41 | onOpen,
42 | onClose
43 | }: {
44 | onResult: (data: any) => void,
45 | onError?: (e: Event) => void,
46 | onOpen?: () => void,
47 | onClose?: () => void
48 | }) {
49 | const ws = new WebSocket(getRtasrWebSocketUrl());
50 | ws.onopen = () => {
51 | onOpen && onOpen();
52 | };
53 | ws.onmessage = (e) => {
54 | try {
55 | const json = JSON.parse(e.data);
56 | onResult(json);
57 | } catch (err) {
58 | // 忽略非JSON消息
59 | }
60 | };
61 | ws.onerror = (e) => {
62 | onError && onError(e);
63 | };
64 | ws.onclose = () => {
65 | onClose && onClose();
66 | };
67 | return ws;
68 | }
69 |
70 | // 全局状态：防抖器和数据追踪
71 | let questionDetectionDebouncer: any = null
72 | let lastDataReceiveTime = Date.now()
73 | let currentAudioActive = false
74 | let currentQuestionDetectionCallback: (() => void) | null = null
75 | let silenceCheckTimer: number | null = null
76 |
77 | /**
78 | * 清理问题检测相关资源
79 | */
80 | export function cleanupQuestionDetection() {
81 | if (silenceCheckTimer) {
82 | window.clearTimeout(silenceCheckTimer)
83 | silenceCheckTimer = null
84 | }
85 | currentQuestionDetectionCallback = null
86 |
87 | if (questionDetectionDebouncer) {
88 | questionDetectionDebouncer.destroy?.()
89 | questionDetectionDebouncer = null
90 | }
91 | }
92 |
93 | // 初始化防抖器（延迟加载以避免循环依赖）
94 | async function initDebouncer() {
95 | if (!questionDetectionDebouncer) {
96 | const { QuestionDetectionDebouncer } = await import('@/utils/questionDetection')
97 | questionDetectionDebouncer = new QuestionDetectionDebouncer(500)
98 | }
99 | return questionDetectionDebouncer
100 | }
101 |
102 | /**
103 | * 设置音频活跃状态并同步到问题检测系统
104 | * @param audioActive 音频是否活跃
105 | */
106 | export async function setAudioActiveState(audioActive: boolean) {
107 | currentAudioActive = audioActive
108 |
109 | // 同步到问题检测系统，追踪静音时间
110 | const { updateAudioActiveState } = await import('@/utils/questionDetection')
111 | updateAudioActiveState(audioActive)
112 |
113 | // 如果变为静音，启动延迟检查
114 | if (!audioActive && currentQuestionDetectionCallback) {
115 | // 清除之前的定时器
116 | if (silenceCheckTimer) {
117 | window.clearTimeout(silenceCheckTimer)
118 | }
119 |
120 | // 1.1秒后主动检查一次（绕过预检查）
121 | silenceCheckTimer = window.setTimeout(() => {
122 | console.log('🔍 静音1.1秒后主动检查触发条件')
123 | checkAndTriggerQuestionDetection(currentQuestionDetectionCallback, true) // bypassPreCheck = true
124 | silenceCheckTimer = null
125 | }, 1100)
126 | } else if (audioActive) {
127 | // 如果重新有声音，取消延迟检查
128 | if (silenceCheckTimer) {
129 | window.clearTimeout(silenceCheckTimer)
130 | silenceCheckTimer = null
131 | }
132 | }
133 | }
134 |
135 | /**
136 | * 轻量级预检查：避免过度触发完整检查
137 | * @param lastDataTime 最后收到数据的时间
138 | * @returns 是否需要进行完整检查
139 | */
140 | function shouldPreCheck(lastDataTime: number): boolean {
141 | const now = Date.now()
142 | const timeSinceLastData = now - lastDataTime
143 |
144 | // 只有在接近触发条件时才进行完整检查
145 | // 距离3秒数据中断还有500ms以内时才检查
146 | return timeSinceLastData > 2500
147 | }
148 |
149 | /**
150 | * 智能问题检测触发器
151 | * @param onQuestionDetection 问题检测回调
152 | * @param bypassPreCheck 是否绕过预检查（用于主动检查）
153 | */
154 | async function checkAndTriggerQuestionDetection(onQuestionDetection?: () => void, bypassPreCheck = false) {
155 | if (!onQuestionDetection) return
156 |
157 | // 轻量级预检查，避免过度触发（主动检查可以绕过）
158 | if (!bypassPreCheck && !shouldPreCheck(lastDataReceiveTime)) {
159 | return
160 | }
161 |
162 | // 动态导入避免循环依赖
163 | const { shouldTriggerQuestionDetection } = await import('@/utils/questionDetection')
164 |
165 | // 统一的触发检查入口（当前总是返回true，预留未来扩展）
166 | const shouldTrigger = shouldTriggerQuestionDetection(lastDataReceiveTime)
167 |
168 | if (shouldTrigger) {
169 | const debouncer = await initDebouncer()
170 | debouncer.debounce(() => {
171 | const triggerSource = bypassPreCheck ? '主动静音检查' : '被动数据检查'
172 | console.log(`🎯 触发AI问题检测 - ${triggerSource}`)
173 | onQuestionDetection()
174 | })
175 | }
176 | }
177 |
178 | /**
179 | * 解析科大讯飞实时转写API返回的data字段，转为 MeetingMessage[]，支持智能问题检测
180 | * @param contentData 科大讯飞ws返回的整体对象
181 | * @param onQuestionDetected 智能问题检测回调函数
182 | * @returns MeetingMessage[]
183 | */
184 | export function parseRtasrResult(contentData: any, onQuestionDetected?: () => void): MeetingMessage[] {
185 | const result: MeetingMessage[] = []
186 |
187 | // 更新数据接收时间
188 | lastDataReceiveTime = Date.now()
189 |
190 | // 设置当前回调，用于延迟主动检查
191 | if (onQuestionDetected) {
192 | currentQuestionDetectionCallback = onQuestionDetected
193 | }
194 |
195 | console.info('【parseRtasrResult】', contentData)
196 |
197 | try {
198 | if (!contentData || !contentData.cn || !contentData.cn.st || !contentData.cn.st.rt) {
199 | console.error('【parseRtasrResult】', 'dataObj is null')
200 | return result
201 | }
202 |
203 | if (contentData.cn.st.type !== '0') {
204 | return result
205 | }
206 |
207 | let lastRl: string | null = null
208 | let currentContent = ''
209 | let currentRole: 'user' | 'asker' = 'user'
210 |
211 | // 解析转写结果
212 | contentData.cn.st.rt.forEach((rtItem: any) => {
213 | rtItem.ws.forEach((wsItem: any) => {
214 | wsItem.cw.forEach((cwItem: any) => {
215 | const rl = cwItem.rl
216 | const role: 'user' | 'asker' = rl === '0' ? 'user' : 'asker'
217 |
218 | if (lastRl === null) {
219 | // 第一个
220 | lastRl = rl
221 | currentRole = role
222 | currentContent = cwItem.w
223 | } else if (rl === lastRl) {
224 | // 角色未变，继续累积内容
225 | currentContent += cwItem.w
226 | } else {
227 | // 角色切换，先推送上一个消息
228 | if (currentContent.trim()) {
229 | const message = {
230 | id: Date.now().toString() + Math.random(),
231 | timestamp: Date.now(),
232 | content: currentContent.trim(),
233 | role: currentRole,
234 | status: 'sent' as const,
235 | }
236 | result.push(message)
237 |
238 | // 每个消息只检查一次触发条件
239 | checkAndTriggerQuestionDetection(onQuestionDetected)
240 | }
241 |
242 | // 开始新角色的内容
243 | lastRl = rl
244 | currentRole = role
245 | currentContent = cwItem.w
246 | }
247 | })
248 | })
249 | })
250 |
251 | // 推送最后一段内容
252 | if (currentContent.trim()) {
253 | const message = {
254 | id: Date.now().toString() + Math.random(),
255 | timestamp: Date.now(),
256 | content: currentContent.trim(),
257 | role: currentRole,
258 | status: 'sent' as const,
259 | }
260 | result.push(message)
261 |
262 | // 对最后一个消息也检查触发条件
263 | checkAndTriggerQuestionDetection(onQuestionDetected)
264 | }
265 |
266 | return result
267 |
268 | } catch (e) {
269 | console.error('parseRtasrResult error', e)
270 | return result
271 | }
272 | }
--------------------------------------------------------------------------------
/frontend/src/store/interviewStore.ts:
--------------------------------------------------------------------------------
1 | import { create } from 'zustand'
2 | import { devtools } from 'zustand/middleware'
3 | import { immer } from 'zustand/middleware/immer'
4 | import * as sessionsApi from '../api/sessions';
5 | /**
6 | * 语音转写结果接口
7 | * @property action - 动作类型
8 | * @property code - 状态码
9 | * @property data - 转写数据
10 | * @property desc - 描述信息
11 | * @property sid - 会话ID
12 | * @property timestamp - 时间戳
13 | * @property isFinal - 是否为最终结果
14 | */
15 | interface TransResult {
16 | action: string
17 | code: string
18 | data: {
19 | cn: {
20 | st: {
21 | bg: string
22 | ed: string
23 | rt: Array<{
24 | ws: Array<{
25 | cw: Array<{
26 | w: string
27 | wp: string
28 | }>
29 | wb: number
30 | we: number
31 | }>
32 | }>
33 | type: string
34 | }
35 | }
36 | seg_id: number
37 | biz?: string
38 | src?: string
39 | dst?: string
40 | isEnd?: boolean
41 | rl?: number
42 | }
43 | desc: string
44 | sid: string
45 | timestamp: number
46 | isFinal: boolean
47 | }
48 |
49 | /**
50 | * 会议消息接口
51 | * @property id - 消息ID
52 | * @property timestamp - 时间戳
53 | * @property content - 消息内容
54 | * @property role - 消息角色（用户/助手）
55 | * @property status - 消息状态（发送中/已发送/错误）
56 | * @property error - 错误信息（可选）
57 | * @property audioUrl - 音频URL（可选）
58 | * @property duration - 音频时长（可选）
59 | * @property isTranslated - 是否已翻译（可选）
60 | * @property translatedContent - 翻译内容（可选）
61 | * @property metadata - 元数据（可选）
62 | */
63 | export interface MeetingMessage {
64 | id: string
65 | timestamp: number
66 | content: string
67 | role: 'user' | 'asker'
68 | status: 'sending' | 'sent' | 'error'
69 | error?: string
70 | audioUrl?: string
71 | duration?: number
72 | isTranslated?: boolean
73 | translatedContent?: string
74 | isAsked?: boolean // 新增：是否已发送给AI
75 | metadata?: {
76 | modelUsed?: string
77 | tokensUsed?: number
78 | processingTime?: number
79 | }
80 | }
81 |
82 | /**
83 | * 新建面试页表单配置
84 | */
85 | export interface InterviewConfig {
86 | hasReadGuide: boolean
87 | region: string
88 | job: string
89 | lang: string
90 | customQA: string
91 | qaLibStatus: string // 问答库状态
92 | }
93 |
94 | export interface Answer {
95 | id: string
96 | message: string
97 | created: number
98 | question: string
99 | }
100 |
101 | interface InterviewState {
102 | messages: MeetingMessage[]
103 | transResults: TransResult[]
104 | answers: Answer[]
105 | isRecording: boolean
106 | isProcessing: boolean
107 | interviewConfig: InterviewConfig
108 | currentSessionId: string | null
109 | sessionLoading: boolean
110 | setCurrentSessionId: (sessionId: string | null) => void
111 | createNewSession: (title?: string) => Promise
108 | 配置状态：
109 |
110 | {xfyunConfig.isConfigured ? " ✅ 已配置" : " ⚠️ 未配置"}
111 |
112 |
113 |
114 | {xfyunConfig.updatedAt && (
115 |
116 |
117 | 最后更新：{new Date(xfyunConfig.updatedAt).toLocaleString()}
118 |
119 |
120 | )}
121 |
215 | 配置状态：
216 |
217 | {deepseekConfig?.apiKey ? " ✅ 已配置" : " ⚠️ 未配置"}
218 |
219 |
220 |
221 | {deepseekConfig?.updatedAt && (
222 |
223 |
224 | 最后更新：{new Date(deepseekConfig.updatedAt).toLocaleString()}
225 |
226 |
227 | )}
228 |
120 | {/* 主内容区 */}
121 |
327 | )
328 | }
329 |
330 | export default InterviewMeeting
--------------------------------------------------------------------------------
128 | {/* 聊天区：Q左A右分栏 */}
129 |
217 |
218 | {/* 底部操作栏 - 固定在屏幕底部 */}
219 |
141 | {answers.length > 0 ? answers.map((ans, idx) => (
142 |
183 |
184 | {/* 语音区 */}
185 |
149 | {/* Q 左侧 */}
150 |
172 | )) : (
173 |
159 | Q: {ans.question}
160 |
161 | {/* A 右侧 */}
162 |
169 | A: {ans.message}
170 |
171 |
179 | 暂无问答
180 |
181 | )}
182 |
197 |
216 | 实时转录
198 |
199 | {messages.map((msg, idx) => (
200 |
215 |
208 |
209 | {msg.role === 'user' ? '用户' : '助手'}：
210 |
211 | {msg.content}
212 |
213 | ))}
214 |
230 |
326 |
231 | 帮助中心
232 | 236 |
237 |
238 | 232 | 236 |
239 |
249 |
259 |
269 |
279 |
280 |
281 |
282 |
325 |
283 |
290 |
291 | {recording ? (audioActive ? '录音中' : '静音中') : '未录音'}
292 |
293 |
294 |
295 |
310 |
311 |
324 |