d8d-admin-mobile-starter-public/server/routes_io_exam.ts

import { Variables } from './router_io.ts';
import type { QuizContent, Answer } from '../client/mobile/components/Exam/types.ts';

interface ExamRoomData {
  roomId: string;
  userId?: string;
}

interface ExamQuestionData extends ExamRoomData {
  question: QuizContent;
}

interface ExamAnswerData extends ExamRoomData {
  questionId: string;
  answer: Answer;
}

interface ExamPriceData extends ExamRoomData {
  date: string;
  price: string;
}

export function setupExamEvents({ socket, apiClient }: Variables) {
  // 加入考试房间
  socket.on('exam:join', async (data: ExamRoomData) => {
    try {
      const { roomId } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 加入房间
      socket.join(roomId);
      
      // 通知用户加入成功
      socket.emit('exam:joined', {
        roomId,
        message: `成功加入考试房间: ${roomId}`
      });

      // 通知房间其他用户有新成员加入
      socket.to(roomId).emit('exam:memberJoined', {
        roomId,
        userId: user.id,
        username: user.username
      });

      console.log(`用户 ${user.username} 加入考试房间 ${roomId}`);
    } catch (error) {
      console.error('加入考试房间失败:', error);
      socket.emit('error', '加入考试房间失败');
    }
  });

  // 离开考试房间
  socket.on('exam:leave', async (data: ExamRoomData) => {
    try {
      const { roomId } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 离开房间
      socket.leave(roomId);
      
      // 通知用户离开成功
      socket.emit('exam:left', {
        roomId,
        message: `已离开考试房间: ${roomId}`
      });

      // 通知房间其他用户有成员离开
      socket.to(roomId).emit('exam:memberLeft', {
        roomId,
        userId: user.id,
        username: user.username
      });

      console.log(`用户 ${user.username} 离开考试房间 ${roomId}`);
    } catch (error) {
      console.error('离开考试房间失败:', error);
      socket.emit('error', '离开考试房间失败');
    }
  });

  // 发送考试房间消息
  socket.on('exam:message', async (data: {
    roomId: string;
    message: {
      type: string;
      content: any;
    }
  }) => {
    try {
      const { roomId, message } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 广播消息到房间
      socket.to(roomId).emit('exam:message', {
        roomId,
        message: {
          ...message,
          from: user.id,
          username: user.username,
          timestamp: new Date().toISOString()
        }
      });

      console.log(`用户 ${user.username} 在房间 ${roomId} 发送消息: ${message.type}`);
    } catch (error) {
      console.error('发送考试消息失败:', error);
      socket.emit('error', '发送考试消息失败');
    }
  });

  // 推送题目
  socket.on('exam:question', async (data: ExamQuestionData) => {
    try {
      const { roomId, question } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 存储当前问题状态
      await apiClient.database.table('exam_questions').insert({
        room_id: roomId,
        question_id: 'current_state',
        date: question.date,
        price: question.price,
        created_at: apiClient.database.fn.now(),
        updated_at: apiClient.database.fn.now()
      });

      // 广播题目到房间
      socket.to(roomId).emit('exam:question', {
        roomId,
        question: {
          ...question,
          timestamp: new Date().toISOString()
        }
      });

      console.log(`用户 ${user.username} 在房间 ${roomId} 推送题目`);
    } catch (error) {
      console.error('推送题目失败:', error);
      socket.emit('error', '推送题目失败');
    }
  });

  // 存储答案
  socket.on('exam:storeAnswer', async (data: ExamAnswerData) => {
    try {
      const { roomId, questionId, answer } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 存储答案
      await apiClient.database.table('exam_answers').insert({
        room_id: roomId,
        question_id: questionId,
        user_id: user.id,
        username: user.username,
        date: answer.date,
        price: answer.price,
        holding_stock: answer.holdingStock,
        holding_cash: answer.holdingCash,
        profit_amount: answer.profitAmount,
        profit_percent: answer.profitPercent,
        total_profit_amount: answer.totalProfitAmount,
        total_profit_percent: answer.totalProfitPercent,
        created_at: apiClient.database.fn.now(),
        updated_at: apiClient.database.fn.now()
      });

      // 广播答案更新到房间
      socket.to(roomId).emit('exam:answerUpdated', {
        roomId,
        questionId,
        userId: user.id,
        username: user.username
      });

      console.log(`用户 ${user.username} 在房间 ${roomId} 存储答案`);
    } catch (error) {
      console.error('存储答案失败:', error);
      socket.emit('error', '存储答案失败');
    }
  });

  // 获取答案
  socket.on('exam:getAnswers', async (data: {
    roomId: string;
    questionId: string;
  }, callback: (answers: Answer[]) => void) => {
    try {
      const { roomId, questionId } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 查询答案
      const answers = await apiClient.database.table('exam_answers')
        .where('room_id', roomId)
        .where('question_id', questionId)
        .select('*');

      // 转换为前端需要的格式
      const formattedAnswers: Answer[] = answers.map((a: any) => ({
        date: a.date,
        price: a.price,
        holdingStock: a.holding_stock,
        holdingCash: a.holding_cash,
        profitAmount: a.profit_amount,
        profitPercent: a.profit_percent,
        totalProfitAmount: a.total_profit_amount,
        totalProfitPercent: a.total_profit_percent,
        userId: a.user_id
      }));

      callback(formattedAnswers);
    } catch (error) {
      console.error('获取答案失败:', error);
      socket.emit('error', '获取答案失败');
      callback([]);
    }
  });

  // 清理房间数据
  socket.on('exam:cleanup', async (data: {
    roomId: string;
    questionId?: string;
  }) => {
    try {
      const { roomId, questionId } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      if (questionId) {
        // 清理特定问题的数据
        await apiClient.database.table('exam_answers')
          .where('room_id', roomId)
          .where('question_id', questionId)
          .delete();
      } else {
        // 清理整个房间的数据
        await apiClient.database.table('exam_answers')
          .where('room_id', roomId)
          .delete();
          
        await apiClient.database.table('exam_questions')
          .where('room_id', roomId)
          .delete();
          
        await apiClient.database.table('exam_prices')
          .where('room_id', roomId)
          .delete();
      }

      socket.emit('exam:cleaned', {
        roomId,
        message: questionId 
          ? `已清理房间 ${roomId} 的问题 ${questionId} 数据`
          : `已清理房间 ${roomId} 的所有数据`
      });

      console.log(`用户 ${user.username} 清理房间 ${roomId} 数据`);
    } catch (error) {
      console.error('清理房间数据失败:', error);
      socket.emit('error', '清理房间数据失败');
    }
  });

  // 存储价格历史
  socket.on('exam:storePrice', async (data: ExamPriceData) => {
    try {
      const { roomId, date, price } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 检查是否已存在该日期的价格
      const existing = await apiClient.database.table('exam_prices')
        .where('room_id', roomId)
        .where('date', date)
        .first();

      if (existing) {
        // 更新现有价格
        await apiClient.database.table('exam_prices')
          .where('room_id', roomId)
          .where('date', date)
          .update({
            price,
            updated_at: apiClient.database.fn.now()
          });
      } else {
        // 插入新价格
        await apiClient.database.table('exam_prices').insert({
          room_id: roomId,
          date,
          price,
          created_at: apiClient.database.fn.now(),
          updated_at: apiClient.database.fn.now()
        });
      }

      console.log(`用户 ${user.username} 存储房间 ${roomId} 的价格历史: ${date} - ${price}`);
    } catch (error) {
      console.error('存储价格历史失败:', error);
      socket.emit('error', '存储价格历史失败');
    }
  });

  // 获取历史价格
  socket.on('exam:getPrice', async (data: {
    roomId: string;
    date: string;
  }, callback: (price: string) => void) => {
    try {
      const { roomId, date } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 查询价格
      const priceData = await apiClient.database.table('exam_prices')
        .where('room_id', roomId)
        .where('date', date)
        .select('price')
        .first();

      callback(priceData?.price || '0');
    } catch (error) {
      console.error('获取历史价格失败:', error);
      socket.emit('error', '获取历史价格失败');
      callback('0');
    }
  });

  // 获取所有价格历史
  socket.on('exam:getPrices', async (data: {
    roomId: string;
  }, callback: (prices: Record<string, string>) => void) => {
    try {
      const { roomId } = data;
      const user = socket.user;
      
      if (!user) {
        socket.emit('error', '未授权访问');
        return;
      }

      // 查询所有价格
      const prices = await apiClient.database.table('exam_prices')
        .where('room_id', roomId)
        .select('date', 'price');

      // 转换为日期-价格的映射
      const priceMap: Record<string, string> = {};
      prices.forEach((p: any) => {
        priceMap[p.date] = p.price;
      });

      callback(priceMap);
    } catch (error) {
      console.error('获取所有价格历史失败:', error);
      socket.emit('error', '获取所有价格历史失败');
      callback({});
    }
  });
}