rentease-backend-new/controllers/roleController.js

const { Op } = require('sequelize');
const Role = require('../models/Role');
const { logOperation } = require('../utils/logger');
const response = require('../utils/response');

// 获取角色列表
exports.getRoles = async (req, res) => {
  try {
    const { page = 1, pageSize = 10, name, status } = req.query;
    const tenantId = req.user.tenantId;
    
    const where = { 
      isDeleted: 0,
      [Op.or]: [
        { tenantId: tenantId },
        { tenantId: null }
      ]
    };
    if (name) where.name = { [Op.like]: `%${name}%` };
    if (status) where.status = status;
    
    const { count, rows: roles } = await Role.findAndCountAll({
      where,
      limit: parseInt(pageSize),
      offset: (parseInt(page) - 1) * parseInt(pageSize),
      order: [['id', 'DESC']]
    });
    
    response.success(res, '获取角色列表成功', {
      list: roles,
      total: count,
      page: parseInt(page),
      pageSize: parseInt(pageSize)
    });
    
    // 记录操作日志
    await logOperation({
      userId: req.user.id,
      username: req.user.username,
      tenantId: tenantId,
      module: '角色管理',
      action: '查询',
      description: '获取角色列表',
      method: req.method,
      path: req.path,
      ip: req.ip,
      status: 'success'
    });
    
  } catch (error) {
    console.error('获取角色列表错误:', error);
    response.serverError(res, '获取角色列表失败', error);
  }
};

// 获取角色详情
exports.getRoleById = async (req, res) => {
  try {
    const { id } = req.params;
    const tenantId = req.user.tenantId;
    
    const role = await Role.findOne({
      where: { 
        id,
        isDeleted: 0,
        [Op.or]: [
          { tenantId: tenantId },
          { tenantId: null }
        ]
      }
    });
    
    if (!role) {
      return response.notFound(res, '角色不存在');
    }
    
    response.success(res, '获取角色详情成功', role);
    
    // 记录操作日志
    await logOperation({
      userId: req.user.id,
      username: req.user.username,
      tenantId: tenantId,
      module: '角色管理',
      action: '查询',
      description: `获取角色详情，ID: ${id}`,
      method: req.method,
      path: req.path,
      ip: req.ip,
      status: 'success'
    });
    
  } catch (error) {
    console.error('获取角色详情错误:', error);
    response.serverError(res, '获取角色详情失败', error);
  }
};

// 创建角色
exports.createRole = async (req, res) => {
  try {
    const { name, code, description, permissions, status } = req.body;
    const tenantId = req.user.tenantId;
    
    // 参数验证
    if (!name || !code) {
      return response.badRequest(res, '角色名称和编码不能为空');
    }
    
    // 检查角色编码是否已存在（限制在当前租户内）
    const existingRole = await Role.findOne({
      where: { 
        code, 
        isDeleted: 0,
        tenantId: tenantId
      }
    });
    
    if (existingRole) {
      return response.badRequest(res, '角色编码已存在');
    }
    
    const role = await Role.create({
      name,
      code,
      description,
      permissions,
      status: status || 'active',
      tenantId: tenantId,
      createBy: req.user.id,
      updateBy: req.user.id
    });
    
    response.success(res, '创建角色成功', role);
    
    // 记录操作日志
    await logOperation({
      userId: req.user.id,
      username: req.user.username,
      tenantId: tenantId,
      module: '角色管理',
      action: '创建',
      description: `创建角色: ${name}`,
      method: req.method,
      path: req.path,
      ip: req.ip,
      status: 'success'
    });
    
  } catch (error) {
    console.error('创建角色错误:', error);
    response.serverError(res, '创建角色失败', error);
  }
};

// 更新角色
exports.updateRole = async (req, res) => {
  try {
    const { id } = req.params;
    const { name, code, description, permissions, status } = req.body;
    const tenantId = req.user.tenantId;
    
    // 查找角色
    const role = await Role.findOne({
      where: { 
        id,
        isDeleted: 0,
        tenantId: tenantId
      }
    });
    
    if (!role) {
      return response.notFound(res, '角色不存在');
    }
    
    // 检查角色编码是否已存在（排除当前角色）
    if (code && code !== role.code) {
      const existingRole = await Role.findOne({
        where: { 
          code, 
          isDeleted: 0, 
          tenantId: tenantId,
          id: { [Op.ne]: id } 
        }
      });
      
      if (existingRole) {
        return response.badRequest(res, '角色编码已存在');
      }
    }
    
    await role.update({
      name: name || role.name,
      code: code || role.code,
      description: description !== undefined ? description : role.description,
      permissions: permissions !== undefined ? permissions : role.permissions,
      status: status || role.status,
      updateBy: req.user.id
    });
    
    response.success(res, '更新角色成功', role);
    
    // 记录操作日志
    await logOperation({
      userId: req.user.id,
      username: req.user.username,
      tenantId: tenantId,
      module: '角色管理',
      action: '更新',
      description: `更新角色: ${role.name}`,
      method: req.method,
      path: req.path,
      ip: req.ip,
      status: 'success'
    });
    
  } catch (error) {
    console.error('更新角色错误:', error);
    response.serverError(res, '更新角色失败', error);
  }
};

// 删除角色
exports.deleteRole = async (req, res) => {
  try {
    const { id } = req.params;
    const tenantId = req.user.tenantId;
    
    // 查找角色
    const role = await Role.findOne({
      where: { 
        id,
        isDeleted: 0,
        tenantId: tenantId
      }
    });
    
    if (!role) {
      return response.notFound(res, '角色不存在');
    }
    
    // 检查是否有用户使用此角色
    const userCount = await role.countUsers({
      where: { isDeleted: 0 }
    });
    
    if (userCount > 0) {
      return response.badRequest(res, '该角色下还有用户，无法删除');
    }
    
    // 软删除
    await role.update({
      isDeleted: 1,
      updateBy: req.user.id
    });
    
    response.success(res, '删除角色成功');
    
    // 记录操作日志
    await logOperation({
      userId: req.user.id,
      username: req.user.username,
      tenantId: tenantId,
      module: '角色管理',
      action: '删除',
      description: `删除角色: ${role.name}`,
      method: req.method,
      path: req.path,
      ip: req.ip,
      status: 'success'
    });
    
  } catch (error) {
    console.error('删除角色错误:', error);
    response.serverError(res, '删除角色失败', error);
  }
};

// 获取所有角色（用于下拉选择）
exports.getAllRoles = async (req, res) => {
  try {
    const tenantId = req.user.tenantId;
    
    const roles = await Role.findAll({
      where: { 
        isDeleted: 0, 
        status: 'active',
        [Op.or]: [
          { tenantId: tenantId },
          { tenantId: null }
        ]
      },
      attributes: ['id', 'name', 'code']
    });
    
    response.success(res, '获取角色列表成功', roles);
    
  } catch (error) {
    console.error('获取角色列表错误:', error);
    response.serverError(res, '获取角色列表失败', error);
  }
};