werewolf_nodejs/server/auth.js

const express = require('express');
const pool = require('./db');
const { generateToken, verifyToken } = require('./jwt');

const router = express.Router();

/**
 * 注册接口
 */
router.post('/register', async (req, res) => {
  const { email, password } = req.body;

  if (!email || !password) {
    return res.status(400).json({ message: 'Email 和密码不能为空' });
  }

  try {
    // 检查 email 是否已存在
    const [existingUser] = await pool.execute('SELECT id FROM users WHERE email = ?', [email]);
    if (existingUser.length > 0) {
      return res.status(400).json({ message: '该 Email 已被注册' });
    }

    // 插入新用户
    await pool.execute('INSERT INTO users (email, password_hash, created_at) VALUES (?, ?, NOW())', [email, password]);
    res.status(201).json({ message: '注册成功' });
  } catch (error) {
    console.error('注册时出错:', error.message);
    res.status(500).json({ message: '服务器错误' });
  }
});

/**
 * 登录接口
 */
router.post('/login', async (req, res) => {
  const { email, password } = req.body;

  if (!email || !password) {
    return res.status(400).json({ message: 'Email 和密码不能为空' });
  }

  try {
    // 检查 email 是否存在
    const [users] = await pool.execute('SELECT id, password_hash FROM users WHERE email = ?', [email]);
    if (users.length === 0) {
      return res.status(404).json({ message: '用户不存在' });
    }

    const user = users[0];
    if (user.password_hash !== password) {
      return res.status(401).json({ message: '密码错误' });
    }

    // 生成 JWT
    const token = generateToken({ userId: user.id });
    res.status(200).json({ message: '登录成功', jwt: token });
  } catch (error) {
    console.error('登录时出错:', error.message);
    res.status(500).json({ message: '服务器错误' });
  }
});

// 请你写一个router.get接口/verify_token，接收的请求必须有Authorization: token头，调用verifyToken(token)来获取用户的id，然后通过id在users表中查询用户的username，并返回。
/**
 * 验证 Token 接口
 */
router.get('/verify_token', async (req, res) => {
  const authHeader = req.headers.authorization;

  // 检查 Authorization Header
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ message: '未提供有效的 Authorization Header' });
  }

  const token = authHeader.split(' ')[1]; // 获取 token
  const result = verifyToken(token); // 调用 verifyToken 验证 token

  // 检查验证结果
  if (result.error) {
    return res.status(401).json({ message: result.error });
  }

  const userId = result.userId;

  try {
    // 查询用户的 username
    const [rows] = await pool.execute('SELECT username FROM users WHERE id = ?', [userId]);

    if (rows.length === 0) {
      return res.status(404).json({ message: '用户不存在' });
    }

    const { username } = rows[0];
    res.status(200).json({ userId, username });
  } catch (error) {
    console.error('查询用户时出错:', error.message);
    res.status(500).json({ message: '服务器错误' });
  }
});

/**
 * 获取用户历史游戏数据接口
 */
router.get('/get_history', async (req, res) => {
  const authHeader = req.headers.authorization;

  // 检查 Authorization Header 是否有效
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ message: '未提供有效的 Authorization Header' });
  }

  const token = authHeader.split(' ')[1];

  // 调用 verifyToken 验证 Token
  const result = verifyToken(token);

  // 验证失败，返回相应错误信息
  if (result.error) {
    return res.status(401).json({ message: result.error });
  }

  const userId = result.userId;

  try {
    // 查询用户的游戏记录
    const [gameRecords] = await pool.execute(
      `SELECT play_id, identity, is_sheriff, is_alive, is_winner 
       FROM play_user 
       WHERE user_id = ?`,
      [userId]
    );

    if (gameRecords.length === 0) {
      return res.status(404).json({ message: '未找到相关游戏记录' });
    }

    // 获取每场游戏的时间信息
    const playIds = gameRecords.map((record) => record.play_id);
    const [playTimes] = await pool.execute(
      `SELECT id, create_time, finish_time 
       FROM plays 
       WHERE id IN (${playIds.join(',')})`
    );

    // 合并游戏记录和时间信息
    const history = gameRecords.map((record) => {
      const playTime = playTimes.find((play) => play.id === record.play_id);
      return {
        identity: record.identity,
        is_sheriff: Boolean(record.is_sheriff),
        is_alive: Boolean(record.is_alive),
        is_winner: Boolean(record.is_winner),
        create_time: playTime ? playTime.create_time : null,
        finish_time: playTime ? playTime.finish_time : null,
      };
    });

    res.status(200).json(history);
  } catch (error) {
    console.error('获取历史数据时出错:', error.message);
    res.status(500).json({ message: '服务器错误' });
  }
});

router.post('/edit_name', async (req, res) => {
  // 从请求头中获取 Authorization Token
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ message: '未提供有效的 Authorization Header' });
  }

  const token = authHeader.split(' ')[1];
  const result = verifyToken(token);

  // 验证失败，返回相应错误信息
  if (result.error) {
    return res.status(401).json({ message: result.error });
  }

  const userId = result.userId; // 获取用户 ID

  // 获取新用户名
  const { username } = req.body;
  if (!username || username.trim() === '') {
    return res.status(400).json({ message: '用户名不能为空' });
  }

  try {
    // 更新 users 表中的 username
    const [updateResult] = await pool.execute(
      'UPDATE users SET username = ? WHERE id = ?',
      [username.trim(), userId]
    );

    // 检查是否有更新的记录
    if (updateResult.affectedRows === 0) {
      return res.status(404).json({ message: '用户不存在或未修改任何内容' });
    }

    res.status(200).json({ message: '用户名更新成功', username });
  } catch (error) {
    console.error('更新用户名时出错:', error.message);
    res.status(500).json({ message: '服务器错误' });
  }
});


module.exports = router;