niumalll/backend/routes/users.js

const express = require('express')
const bcrypt = require('bcryptjs')
const Joi = require('joi')
const router = express.Router()

// 模拟用户数据
let users = [
  {
    id: 1,
    username: 'admin',
    email: 'admin@example.com',
    phone: '13800138000',
    role: 'admin',
    status: 'active',
    createdAt: '2024-01-01T00:00:00Z',
    updatedAt: '2024-01-01T00:00:00Z'
  },
  {
    id: 2,
    username: 'buyer01',
    email: 'buyer01@example.com',
    phone: '13800138001',
    role: 'buyer',
    status: 'active',
    createdAt: '2024-01-02T00:00:00Z',
    updatedAt: '2024-01-02T00:00:00Z'
  },
  {
    id: 3,
    username: 'supplier01',
    email: 'supplier01@example.com',
    phone: '13800138002',
    role: 'supplier',
    status: 'inactive',
    createdAt: '2024-01-03T00:00:00Z',
    updatedAt: '2024-01-03T00:00:00Z'
  }
]

// 验证模式
const createUserSchema = Joi.object({
  username: Joi.string().min(2).max(50).required(),
  email: Joi.string().email().required(),
  phone: Joi.string().pattern(/^1[3-9]\d{9}$/).allow(''),
  password: Joi.string().min(6).max(100).required(),
  role: Joi.string().valid('admin', 'buyer', 'trader', 'supplier', 'driver').required(),
  status: Joi.string().valid('active', 'inactive').default('active')
})

const updateUserSchema = Joi.object({
  username: Joi.string().min(2).max(50),
  email: Joi.string().email(),
  phone: Joi.string().pattern(/^1[3-9]\d{9}$/).allow(''),
  role: Joi.string().valid('admin', 'buyer', 'trader', 'supplier', 'driver'),
  status: Joi.string().valid('active', 'inactive', 'banned')
})

// 获取用户列表
router.get('/', (req, res) => {
  try {
    const { page = 1, pageSize = 20, keyword, role, status } = req.query
    
    let filteredUsers = [...users]
    
    // 关键词搜索
    if (keyword) {
      filteredUsers = filteredUsers.filter(user => 
        user.username.includes(keyword) || 
        user.email.includes(keyword)
      )
    }
    
    // 角色筛选
    if (role) {
      filteredUsers = filteredUsers.filter(user => user.role === role)
    }
    
    // 状态筛选
    if (status) {
      filteredUsers = filteredUsers.filter(user => user.status === status)
    }
    
    // 分页
    const total = filteredUsers.length
    const startIndex = (page - 1) * pageSize
    const endIndex = startIndex + parseInt(pageSize)
    const paginatedUsers = filteredUsers.slice(startIndex, endIndex)
    
    res.json({
      success: true,
      data: {
        items: paginatedUsers,
        total: total,
        page: parseInt(page),
        pageSize: parseInt(pageSize),
        totalPages: Math.ceil(total / pageSize)
      }
    })
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '获取用户列表失败'
    })
  }
})

// 获取用户详情
router.get('/:id', (req, res) => {
  try {
    const { id } = req.params
    const user = users.find(u => u.id === parseInt(id))
    
    if (!user) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      })
    }
    
    res.json({
      success: true,
      data: user
    })
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '获取用户详情失败'
    })
  }
})

// 创建用户
router.post('/', async (req, res) => {
  try {
    // 参数验证
    const { error, value } = createUserSchema.validate(req.body)
    if (error) {
      return res.status(400).json({
        success: false,
        message: '参数验证失败',
        details: error.details[0].message
      })
    }
    
    const { username, email, phone, password, role, status } = value
    
    // 检查用户名是否已存在
    if (users.find(u => u.username === username)) {
      return res.status(400).json({
        success: false,
        message: '用户名已存在'
      })
    }
    
    // 检查邮箱是否已存在
    if (users.find(u => u.email === email)) {
      return res.status(400).json({
        success: false,
        message: '邮箱已存在'
      })
    }
    
    // 创建新用户
    const newUser = {
      id: Math.max(...users.map(u => u.id)) + 1,
      username,
      email,
      phone: phone || '',
      role,
      status,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    }
    
    users.push(newUser)
    
    res.status(201).json({
      success: true,
      message: '用户创建成功',
      data: newUser
    })
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '创建用户失败'
    })
  }
})

// 更新用户
router.put('/:id', (req, res) => {
  try {
    const { id } = req.params
    const userIndex = users.findIndex(u => u.id === parseInt(id))
    
    if (userIndex === -1) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      })
    }
    
    // 参数验证
    const { error, value } = updateUserSchema.validate(req.body)
    if (error) {
      return res.status(400).json({
        success: false,
        message: '参数验证失败',
        details: error.details[0].message
      })
    }
    
    // 更新用户信息
    users[userIndex] = {
      ...users[userIndex],
      ...value,
      updatedAt: new Date().toISOString()
    }
    
    res.json({
      success: true,
      message: '用户更新成功',
      data: users[userIndex]
    })
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '更新用户失败'
    })
  }
})

// 删除用户
router.delete('/:id', (req, res) => {
  try {
    const { id } = req.params
    const userIndex = users.findIndex(u => u.id === parseInt(id))
    
    if (userIndex === -1) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      })
    }
    
    users.splice(userIndex, 1)
    
    res.json({
      success: true,
      message: '用户删除成功'
    })
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '删除用户失败'
    })
  }
})

// 批量删除用户
router.delete('/batch', (req, res) => {
  try {
    const { ids } = req.body
    
    if (!Array.isArray(ids) || ids.length === 0) {
      return res.status(400).json({
        success: false,
        message: '请提供有效的用户ID列表'
      })
    }
    
    users = users.filter(user => !ids.includes(user.id))
    
    res.json({
      success: true,
      message: `成功删除 ${ids.length} 个用户`
    })
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '批量删除用户失败'
    })
  }
})

// 重置用户密码
router.put('/:id/password', async (req, res) => {
  try {
    const { id } = req.params
    const { password } = req.body
    
    const userIndex = users.findIndex(u => u.id === parseInt(id))
    if (userIndex === -1) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      })
    }
    
    if (!password || password.length < 6) {
      return res.status(400).json({
        success: false,
        message: '密码长度不能少于6位'
      })
    }
    
    // 在实际项目中，这里会对密码进行加密
    users[userIndex].updatedAt = new Date().toISOString()
    
    res.json({
      success: true,
      message: '密码重置成功'
    })
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '重置密码失败'
    })
  }
})

// 更新用户状态
router.put('/:id/status', (req, res) => {
  try {
    const { id } = req.params
    const { status } = req.body
    
    const userIndex = users.findIndex(u => u.id === parseInt(id))
    if (userIndex === -1) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      })
    }
    
    if (!['active', 'inactive', 'banned'].includes(status)) {
      return res.status(400).json({
        success: false,
        message: '无效的用户状态'
      })
    }
    
    users[userIndex].status = status
    users[userIndex].updatedAt = new Date().toISOString()
    
    res.json({
      success: true,
      message: '用户状态更新成功',
      data: users[userIndex]
    })
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '更新用户状态失败'
    })
  }
})

module.exports = router