collabdocchat 1.0.0

package/server/routes/groups.js

@@ -0,0 +1,317 @@
+import express from 'express';
+import Group from '../models/Group.js';
+import User from '../models/User.js';
+import Message from '../models/Message.js';
+import { authenticate, isAdmin } from '../middleware/auth.js';
+
+const router = express.Router();
+
+// 创建群组（仅管理员）
+router.post('/', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { name, description, members } = req.body;
+    
+    const group = new Group({
+      name,
+      description,
+      admin: req.user.userId,
+      members: [req.user.userId, ...(members || [])]  // 管理员 + 选中的成员
+    });
+    
+    await group.save();
+    
+    // 更新用户的群组列表
+    await User.updateMany(
+      { _id: { $in: group.members } },
+      { $push: { groups: group._id } }
+    );
+
+    res.status(201).json({ message: '群组创建成功', group });
+  } catch (error) {
+    res.status(500).json({ message: '创建群组失败', error: error.message });
+  }
+});
+
+// 获取所有群组（包括未加入的）
+router.get('/all', authenticate, async (req, res) => {
+  try {
+    const groups = await Group.find({})
+      .populate('admin', 'username avatar')
+      .populate('members', 'username avatar isOnline');
+    
+    res.json({ groups });
+  } catch (error) {
+    res.status(500).json({ message: '获取群组失败', error: error.message });
+  }
+});
+
+// 获取用户的所有群组
+router.get('/', authenticate, async (req, res) => {
+  try {
+    const groups = await Group.find({ members: req.user.userId })
+      .populate('admin', 'username avatar')
+      .populate('members', 'username avatar isOnline');
+    
+    res.json({ groups });
+  } catch (error) {
+    res.status(500).json({ message: '获取群组失败', error: error.message });
+  }
+});
+
+// 获取群组详情
+router.get('/:id', authenticate, async (req, res) => {
+  try {
+    const group = await Group.findById(req.params.id)
+      .populate('admin', 'username avatar')
+      .populate('members', 'username avatar isOnline')
+      .populate('documents')
+      .populate('tasks');
+    
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    res.json({ group });
+  } catch (error) {
+    res.status(500).json({ message: '获取群组详情失败', error: error.message });
+  }
+});
+
+// 用户加入群组
+router.post('/:id/join', authenticate, async (req, res) => {
+  try {
+    const group = await Group.findById(req.params.id);
+    
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    if (group.members.includes(req.user.userId)) {
+      return res.status(400).json({ message: '您已在该群组中' });
+    }
+
+    group.members.push(req.user.userId);
+    await group.save();
+
+    await User.findByIdAndUpdate(req.user.userId, { $push: { groups: group._id } });
+
+    res.json({ message: '加入群组成功', group });
+  } catch (error) {
+    res.status(500).json({ message: '加入群组失败', error: error.message });
+  }
+});
+
+// 用户退出群组
+router.post('/:id/leave', authenticate, async (req, res) => {
+  try {
+    const group = await Group.findById(req.params.id);
+    
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    if (group.admin.toString() === req.user.userId) {
+      return res.status(400).json({ message: '管理员不能退出群组' });
+    }
+
+    if (!group.members.includes(req.user.userId)) {
+      return res.status(400).json({ message: '您不在该群组中' });
+    }
+
+    group.members = group.members.filter(m => m.toString() !== req.user.userId);
+    await group.save();
+
+    await User.findByIdAndUpdate(req.user.userId, { $pull: { groups: group._id } });
+
+    res.json({ message: '退出群组成功' });
+  } catch (error) {
+    res.status(500).json({ message: '退出群组失败', error: error.message });
+  }
+});
+
+// 添加成员（仅管理员）
+router.post('/:id/members', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { userId } = req.body;
+    const group = await Group.findById(req.params.id);
+    
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    if (group.members.includes(userId)) {
+      return res.status(400).json({ message: '用户已在群组中' });
+    }
+
+    group.members.push(userId);
+    await group.save();
+
+    await User.findByIdAndUpdate(userId, { $push: { groups: group._id } });
+
+    res.json({ message: '成员添加成功', group });
+  } catch (error) {
+    res.status(500).json({ message: '添加成员失败', error: error.message });
+  }
+});
+
+// 移除成员（仅管理员）
+router.delete('/:id/members/:userId', authenticate, isAdmin, async (req, res) => {
+  try {
+    const group = await Group.findById(req.params.id);
+    
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    if (group.admin.toString() === req.params.userId) {
+      return res.status(400).json({ message: '不能移除管理员' });
+    }
+
+    group.members = group.members.filter(m => m.toString() !== req.params.userId);
+    await group.save();
+
+    await User.findByIdAndUpdate(req.params.userId, { $pull: { groups: group._id } });
+
+    res.json({ message: '成员移除成功' });
+  } catch (error) {
+    res.status(500).json({ message: '移除成员失败', error: error.message });
+  }
+});
+
+// 全体禁言（仅管理员） enabled=true -> 除管理员外都不能发言
+router.post('/:id/mute/all', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { enabled } = req.body || {};
+    const group = await Group.findById(req.params.id);
+
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    group.mutedAll = Boolean(enabled);
+    await group.save();
+
+    res.json({
+      message: group.mutedAll ? '已开启全体禁言' : '已取消全体禁言',
+      mutedAll: group.mutedAll
+    });
+  } catch (error) {
+    res.status(500).json({ message: '设置全体禁言失败', error: error.message });
+  }
+});
+
+// 个人禁言（仅管理员） muted=true/false
+router.post('/:id/mute/users/:userId', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { muted } = req.body || {};
+    const group = await Group.findById(req.params.id);
+
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    if (group.admin.toString() === req.params.userId) {
+      return res.status(400).json({ message: '不能禁言管理员' });
+    }
+
+    const targetUser = await User.findById(req.params.userId).select('_id');
+    if (!targetUser) {
+      return res.status(404).json({ message: '用户不存在' });
+    }
+
+    const isInGroup = group.members.some(m => m.toString() === req.params.userId);
+    if (!isInGroup) {
+      return res.status(400).json({ message: '该用户不在群组中' });
+    }
+
+    const alreadyMuted = group.mutedUsers.some(m => m.toString() === req.params.userId);
+
+    if (Boolean(muted)) {
+      if (!alreadyMuted) group.mutedUsers.push(targetUser._id);
+    } else {
+      group.mutedUsers = group.mutedUsers.filter(m => m.toString() !== req.params.userId);
+    }
+
+    await group.save();
+
+    res.json({
+      message: Boolean(muted) ? '已禁言该成员' : '已取消禁言',
+      mutedUsers: group.mutedUsers.map(m => m.toString())
+    });
+  } catch (error) {
+    res.status(500).json({ message: '设置个人禁言失败', error: error.message });
+  }
+});
+
+// 随机点名（仅管理员）
+router.post('/:id/call', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { count = 1 } = req.body;
+    const group = await Group.findById(req.params.id).populate('members', 'username avatar');
+    
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    // 排除管理员，随机选择成员
+    const eligibleMembers = group.members.filter(
+      member => member._id.toString() !== group.admin.toString()
+    );
+
+    if (eligibleMembers.length === 0) {
+      return res.status(400).json({ message: '没有可点名的成员' });
+    }
+
+    const calledCount = Math.min(count, eligibleMembers.length);
+    const shuffled = eligibleMembers.sort(() => 0.5 - Math.random());
+    const calledMembers = shuffled.slice(0, calledCount);
+
+    // 记录点名历史
+    calledMembers.forEach(member => {
+      group.callHistory.push({
+        calledUser: member._id,
+        timestamp: new Date(),
+        responded: false
+      });
+    });
+
+    await group.save();
+
+    res.json({ 
+      message: '点名成功', 
+      calledMembers: calledMembers.map(m => ({
+        id: m._id,
+        username: m.username,
+        avatar: m.avatar
+      }))
+    });
+  } catch (error) {
+    res.status(500).json({ message: '点名失败', error: error.message });
+  }
+});
+
+// 获取群组历史消息
+router.get('/:id/messages', authenticate, async (req, res) => {
+  try {
+    const group = await Group.findById(req.params.id);
+    if (!group) {
+      return res.status(404).json({ message: '群组不存在' });
+    }
+
+    // 检查用户是否在群组中
+    if (!group.members.includes(req.user.userId)) {
+      return res.status(403).json({ message: '您不在该群组中' });
+    }
+
+    const messages = await Message.find({ group: req.params.id })
+      .sort({ createdAt: 1 }) // 按时间正序排列
+      .limit(100); // 限制最近 100 条
+
+    res.json({ messages });
+  } catch (error) {
+    res.status(500).json({ message: '获取消息失败', error: error.message });
+  }
+});
+
+export default router;
+

package/server/routes/tasks.js

@@ -0,0 +1,110 @@
+import express from 'express';
+import Task from '../models/Task.js';
+import Group from '../models/Group.js';
+import { authenticate, isAdmin } from '../middleware/auth.js';
+
+const router = express.Router();
+
+// 创建任务（仅管理员）
+router.post('/', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { title, description, groupId, assignedTo, relatedDocument, deadline } = req.body;
+    
+    const task = new Task({
+      title,
+      description,
+      group: groupId,
+      creator: req.user.userId,
+      assignedTo,
+      relatedDocument,
+      deadline
+    });
+    
+    await task.save();
+    
+    // 更新群组的任务列表
+    await Group.findByIdAndUpdate(groupId, { $push: { tasks: task._id } });
+
+    res.status(201).json({ message: '任务创建成功', task });
+  } catch (error) {
+    res.status(500).json({ message: '创建任务失败', error: error.message });
+  }
+});
+
+// 获取群组的所有任务
+router.get('/group/:groupId', authenticate, async (req, res) => {
+  try {
+    const tasks = await Task.find({ group: req.params.groupId })
+      .populate('creator', 'username avatar')
+      .populate('assignedTo', 'username avatar')
+      .populate('relatedDocument', 'title')
+      .sort({ createdAt: -1 });
+    
+    res.json({ tasks });
+  } catch (error) {
+    res.status(500).json({ message: '获取任务失败', error: error.message });
+  }
+});
+
+// 获取用户的任务
+router.get('/my', authenticate, async (req, res) => {
+  try {
+    const tasks = await Task.find({ assignedTo: req.user.userId })
+      .populate('creator', 'username avatar')
+      .populate('group', 'name')
+      .populate('relatedDocument', 'title')
+      .sort({ createdAt: -1 });
+    
+    res.json({ tasks });
+  } catch (error) {
+    res.status(500).json({ message: '获取任务失败', error: error.message });
+  }
+});
+
+// 更新任务状态
+router.patch('/:id/status', authenticate, async (req, res) => {
+  try {
+    const { status } = req.body;
+    const task = await Task.findById(req.params.id);
+    
+    if (!task) {
+      return res.status(404).json({ message: '任务不存在' });
+    }
+
+    task.status = status;
+    
+    if (status === 'completed') {
+      task.completedBy.push({
+        user: req.user.userId,
+        completedAt: new Date()
+      });
+    }
+    
+    await task.save();
+
+    res.json({ message: '任务状态更新成功', task });
+  } catch (error) {
+    res.status(500).json({ message: '更新任务状态失败', error: error.message });
+  }
+});
+
+// 删除任务（仅管理员）
+router.delete('/:id', authenticate, isAdmin, async (req, res) => {
+  try {
+    const task = await Task.findByIdAndDelete(req.params.id);
+    
+    if (!task) {
+      return res.status(404).json({ message: '任务不存在' });
+    }
+
+    await Group.findByIdAndUpdate(task.group, { $pull: { tasks: task._id } });
+
+    res.json({ message: '任务删除成功' });
+  } catch (error) {
+    res.status(500).json({ message: '删除任务失败', error: error.message });
+  }
+});
+
+export default router;
+
+

package/server/utils/auditLogger.js

@@ -0,0 +1,238 @@
+import AuditLog from '../models/AuditLog.js';
+
+/**
+ * 计算文本差异
+ * @param {string} oldText - 原始文本
+ * @param {string} newText - 新文本
+ * @returns {Object} 包含插入和删除操作的对象
+ */
+function calculateTextDiff(oldText = '', newText = '') {
+  const insertions = [];
+  const deletions = [];
+  
+  // 简单的差异计算算法
+  // 这里使用基础实现，生产环境可以使用更复杂的diff算法
+  if (oldText !== newText) {
+    // 如果完全不同，记录为完全替换
+    if (oldText.length > 0) {
+      deletions.push({
+        position: 0,
+        content: oldText,
+        length: oldText.length
+      });
+    }
+    
+    if (newText.length > 0) {
+      insertions.push({
+        position: 0,
+        content: newText,
+        length: newText.length
+      });
+    }
+  }
+  
+  return { insertions, deletions };
+}
+
+/**
+ * 记录审计日志
+ * @param {Object} logData - 日志数据
+ * @param {Object} req - Express请求对象（可选，用于获取IP等信息）
+ */
+export async function logAuditAction(logData, req = null) {
+  try {
+    const auditData = {
+      action: logData.action,
+      user: logData.userId,
+      resourceType: logData.resourceType,
+      resourceId: logData.resourceId,
+      resourceTitle: logData.resourceTitle || '',
+      details: {
+        oldValue: logData.oldValue,
+        newValue: logData.newValue,
+        field: logData.field,
+        description: logData.description
+      },
+      metadata: {
+        groupId: logData.groupId
+      }
+    };
+
+    // 如果是内容编辑，计算文本差异
+    if (logData.action === 'content_edit' && logData.oldValue && logData.newValue) {
+      auditData.changes = calculateTextDiff(logData.oldValue, logData.newValue);
+    }
+
+    // 从请求中提取元数据
+    if (req) {
+      auditData.metadata.ipAddress = req.ip || req.connection.remoteAddress;
+      auditData.metadata.userAgent = req.get('User-Agent');
+    }
+
+    const auditLog = new AuditLog(auditData);
+    await auditLog.save();
+    
+    return auditLog;
+  } catch (error) {
+    console.error('记录审计日志失败:', error);
+    // 审计日志记录失败不应该影响主业务逻辑
+    return null;
+  }
+}
+
+/**
+ * 批量记录审计日志
+ * @param {Array} logDataArray - 日志数据数组
+ * @param {Object} req - Express请求对象
+ */
+export async function logMultipleAuditActions(logDataArray, req = null) {
+  const promises = logDataArray.map(logData => logAuditAction(logData, req));
+  return Promise.allSettled(promises);
+}
+
+/**
+ * 查询审计日志
+ * @param {Object} filters - 查询过滤条件
+ * @param {Object} options - 查询选项（分页、排序等）
+ */
+export async function queryAuditLogs(filters = {}, options = {}) {
+  try {
+    const {
+      page = 1,
+      limit = 50,
+      sortBy = 'createdAt',
+      sortOrder = -1
+    } = options;
+
+    const query = {};
+    
+    // 构建查询条件
+    if (filters.userId) {
+      query.user = filters.userId;
+    }
+    
+    if (filters.resourceId) {
+      query.resourceId = filters.resourceId;
+    }
+    
+    if (filters.resourceType) {
+      query.resourceType = filters.resourceType;
+    }
+    
+    if (filters.action) {
+      query.action = filters.action;
+    }
+    
+    if (filters.groupId) {
+      query['metadata.groupId'] = filters.groupId;
+    }
+    
+    if (filters.startDate && filters.endDate) {
+      query.createdAt = {
+        $gte: new Date(filters.startDate),
+        $lte: new Date(filters.endDate)
+      };
+    } else if (filters.startDate) {
+      query.createdAt = { $gte: new Date(filters.startDate) };
+    } else if (filters.endDate) {
+      query.createdAt = { $lte: new Date(filters.endDate) };
+    }
+
+    const skip = (page - 1) * limit;
+    
+    const [logs, total] = await Promise.all([
+      AuditLog.find(query)
+        .populate('user', 'username email avatar')
+        .populate('metadata.groupId', 'name')
+        .sort({ [sortBy]: sortOrder })
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      AuditLog.countDocuments(query)
+    ]);
+
+    return {
+      logs,
+      pagination: {
+        page,
+        limit,
+        total,
+        pages: Math.ceil(total / limit)
+      }
+    };
+  } catch (error) {
+    console.error('查询审计日志失败:', error);
+    throw new Error('查询审计日志失败');
+  }
+}
+
+/**
+ * 获取用户活动统计
+ * @param {string} userId - 用户ID
+ * @param {Object} timeRange - 时间范围
+ */
+export async function getUserActivityStats(userId, timeRange = {}) {
+  try {
+    const { startDate, endDate } = timeRange;
+    const matchStage = { user: userId };
+    
+    if (startDate && endDate) {
+      matchStage.createdAt = {
+        $gte: new Date(startDate),
+        $lte: new Date(endDate)
+      };
+    }
+
+    const stats = await AuditLog.aggregate([
+      { $match: matchStage },
+      {
+        $group: {
+          _id: '$action',
+          count: { $sum: 1 },
+          lastActivity: { $max: '$createdAt' }
+        }
+      },
+      { $sort: { count: -1 } }
+    ]);
+
+    const totalActions = stats.reduce((sum, stat) => sum + stat.count, 0);
+    
+    return {
+      totalActions,
+      actionBreakdown: stats,
+      timeRange
+    };
+  } catch (error) {
+    console.error('获取用户活动统计失败:', error);
+    throw new Error('获取用户活动统计失败');
+  }
+}
+
+/**
+ * 获取文档编辑历史摘要
+ * @param {string} documentId - 文档ID
+ * @param {number} limit - 返回记录数限制
+ */
+export async function getDocumentEditHistory(documentId, limit = 20) {
+  try {
+    const history = await AuditLog.find({
+      resourceId: documentId,
+      resourceType: 'document',
+      action: { $in: ['content_edit', 'title_edit', 'document_update'] }
+    })
+    .populate('user', 'username avatar')
+    .sort({ createdAt: -1 })
+    .limit(limit)
+    .lean();
+
+    return history;
+  } catch (error) {
+    console.error('获取文档编辑历史失败:', error);
+    throw new Error('获取文档编辑历史失败');
+  }
+}
+
+
+
+
+

package/server/utils/initAdmin.js

@@ -0,0 +1,51 @@
+import User from '../models/User.js';
+
+/**
+ * 初始化默认管理员账户
+ */
+export async function initDefaultAdmin() {
+  try {
+    // 检查是否已存在管理员账户
+    const existingAdmin = await User.findOne({ role: 'admin' });
+    
+    if (existingAdmin) {
+      console.log('✅ 管理员账户已存在:', existingAdmin.username);
+      return;
+    }
+
+    // 创建默认管理员账户
+    const defaultAdmin = new User({
+      username: 'admin',
+      email: 'admin@local.system',
+      password: 'admin123',
+      role: 'admin'
+    });
+
+    await defaultAdmin.save();
+    console.log('🎉 默认管理员账户创建成功!');
+    console.log('👤 用户名: admin');
+    console.log('🔐 密码: admin123');
+    console.log('🛡️  角色: 管理员');
+    
+  } catch (error) {
+    console.error('❌ 创建默认管理员失败:', error.message);
+  }
+}
+
+/**
+ * 检查是否存在管理员账户
+ */
+export async function checkAdminExists() {
+  try {
+    const adminCount = await User.countDocuments({ role: 'admin' });
+    return adminCount > 0;
+  } catch (error) {
+    console.error('检查管理员账户失败:', error);
+    return false;
+  }
+}
+
+
+
+
+