jurong_circle_black/routes/riskManagement.js

const express = require('express');
const router = express.Router();
const { auth } = require('../middleware/auth');
const timeoutService = require('../services/timeoutService');
const { getDB } = require('../database');

/**
 * 检查管理员权限
 */
const requireAdmin = (req, res, next) => {
  if (req.user.role !== 'admin') {
    return res.status(403).json({ success: false, message: '需要管理员权限' });
  }
  next();
};

/**
 * 获取风险用户列表
 */
router.get('/users', auth, requireAdmin, async (req, res) => {
  try {
    const { page = 1, limit = 10, is_blacklisted, username } = req.query;
    
    const filters = {};
    if (is_blacklisted !== undefined) {
      filters.is_blacklisted = parseInt(is_blacklisted);
    }
    if (username) {
      filters.username = username;
    }
    
    const result = await timeoutService.getRiskUsers(filters, { page, limit });
    
    res.json({
      success: true,
      data: result
    });
  } catch (error) {
    console.error('获取风险用户列表失败:', error);
    res.status(500).json({ success: false, message: '获取风险用户列表失败' });
  }
});

/**
 * 拉黑用户
 */
router.post('/blacklist/:userId', auth, requireAdmin, async (req, res) => {
  try {
    const { userId } = req.params;
    const { reason } = req.body;
    const operatorId = req.user.id;
    
    if (!reason || reason.trim() === '') {
      return res.status(400).json({ success: false, message: '请提供拉黑原因' });
    }
    
    await timeoutService.blacklistUser(parseInt(userId), reason.trim(), operatorId);
    
    res.json({
      success: true,
      message: '用户已被拉黑'
    });
  } catch (error) {
    console.error('拉黑用户失败:', error);
    res.status(500).json({ success: false, message: error.message || '拉黑用户失败' });
  }
});

/**
 * 解除拉黑
 */
router.post('/unblacklist/:userId', auth, requireAdmin, async (req, res) => {
  try {
    const { userId } = req.params;
    const operatorId = req.user.id;
    
    await timeoutService.unblacklistUser(parseInt(userId), operatorId);
    
    res.json({
      success: true,
      message: '已解除拉黑'
    });
  } catch (error) {
    console.error('解除拉黑失败:', error);
    res.status(500).json({ success: false, message: error.message || '解除拉黑失败' });
  }
});

/**
 * 获取超时转账列表
 */
router.get('/overdue-transfers', auth, requireAdmin, async (req, res) => {
  try {
    const { page = 1, limit = 10 } = req.query;
    const pageNum = parseInt(page, 10) || 1;
    const limitNum = parseInt(limit, 10) || 10;
    const offset = (pageNum - 1) * limitNum;
    
    const db = getDB();
    
    // 获取总数
    const [countResult] = await db.execute(
      'SELECT COUNT(*) as total FROM transfers WHERE is_overdue = 1'
    );
    const total = countResult[0].total;
    
    // 获取数据
    const [transfers] = await db.execute(
      `SELECT t.*, 
              fu.username as from_username, fu.real_name as from_real_name,
              tu.username as to_username, tu.real_name as to_real_name
       FROM transfers t
       LEFT JOIN users fu ON t.from_user_id = fu.id
       LEFT JOIN users tu ON t.to_user_id = tu.id
       WHERE t.is_overdue = 1
       ORDER BY t.overdue_at DESC
       LIMIT ${limitNum} OFFSET ${offset}`
    );
    
    res.json({
      success: true,
      data: {
        transfers,
        pagination: {
          page: pageNum,
          limit: limitNum,
          total,
          pages: Math.ceil(total / limitNum)
        }
      }
    });
  } catch (error) {
    console.error('获取超时转账列表失败:', error);
    res.status(500).json({ success: false, message: '获取超时转账列表失败' });
  }
});

/**
 * 手动检查转账超时
 */
router.post('/check-timeouts', auth, requireAdmin, async (req, res) => {
  try {
    await timeoutService.checkTransferTimeouts();
    
    res.json({
      success: true,
      message: '转账超时检查已完成'
    });
  } catch (error) {
    console.error('手动检查转账超时失败:', error);
    res.status(500).json({ success: false, message: '检查转账超时失败' });
  }
});

/**
 * 获取风险管理统计信息
 */
router.get('/stats', auth, requireAdmin, async (req, res) => {
  try {
    const db = getDB();
    
    // 获取统计数据
    const [stats] = await db.execute(
      `SELECT 
        COUNT(CASE WHEN is_risk_user = 1 THEN 1 END) as risk_users_count,
        COUNT(CASE WHEN is_blacklisted = 1 THEN 1 END) as blacklisted_users_count,
        COUNT(CASE WHEN is_risk_user = 1 AND is_blacklisted = 0 THEN 1 END) as risk_not_blacklisted_count
       FROM users`
    );
    
    const [overdueStats] = await db.execute(
      `SELECT 
        COUNT(*) as overdue_transfers_count,
        SUM(amount) as overdue_amount_total
       FROM transfers 
       WHERE is_overdue = 1`
    );
    
    const [todayOverdue] = await db.execute(
      `SELECT COUNT(*) as today_overdue_count
       FROM transfers 
       WHERE is_overdue = 1 AND DATE(overdue_at) = CURDATE()`
    );
    
    res.json({
      success: true,
      data: {
        riskUsersCount: stats[0].risk_users_count,
        blacklistedUsersCount: stats[0].blacklisted_users_count,
        riskNotBlacklistedCount: stats[0].risk_not_blacklisted_count,
        overdueTransfersCount: overdueStats[0].overdue_transfers_count,
        overdueAmountTotal: overdueStats[0].overdue_amount_total || 0,
        todayOverdueCount: todayOverdue[0].today_overdue_count
      }
    });
  } catch (error) {
    console.error('获取风险管理统计失败:', error);
    res.status(500).json({ success: false, message: '获取统计信息失败' });
  }
});

module.exports = router;