collabdocchat 1.0.0

package/server/models/AuditLog.js

@@ -0,0 +1,90 @@
+import mongoose from 'mongoose';
+
+const auditLogSchema = new mongoose.Schema({
+  action: {
+    type: String,
+    required: true,
+    enum: [
+      'content_edit',
+      'title_edit',
+      'document_create',
+      'document_update',
+      'document_delete',
+      'document_share',
+      'user_login',
+      'user_logout',
+      'user_register',
+      'group_create',
+      'group_update',
+      'group_delete',
+      'member_add',
+      'member_remove',
+      'permission_change',
+      'task_create',
+      'task_update',
+      'task_delete',
+      'comment_create',
+      'comment_update',
+      'comment_delete'
+    ]
+  },
+  user: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  resourceType: {
+    type: String,
+    required: true,
+    enum: ['document', 'group', 'user', 'task', 'comment', 'message']
+  },
+  resourceId: {
+    type: mongoose.Schema.Types.ObjectId,
+    required: true
+  },
+  resourceTitle: {
+    type: String,
+    default: ''
+  },
+  details: {
+    oldValue: mongoose.Schema.Types.Mixed,
+    newValue: mongoose.Schema.Types.Mixed,
+    field: String,
+    description: String
+  },
+  changes: {
+    insertions: [{
+      position: Number,
+      content: String,
+      length: Number
+    }],
+    deletions: [{
+      position: Number,
+      content: String,
+      length: Number
+    }]
+  },
+  metadata: {
+    groupId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Group'
+    },
+    ipAddress: String,
+    userAgent: String
+  }
+}, {
+  timestamps: true
+});
+
+// 索引优化查询性能
+auditLogSchema.index({ user: 1, createdAt: -1 });
+auditLogSchema.index({ resourceId: 1, resourceType: 1, createdAt: -1 });
+auditLogSchema.index({ action: 1, createdAt: -1 });
+auditLogSchema.index({ 'metadata.groupId': 1, createdAt: -1 });
+
+export default mongoose.model('AuditLog', auditLogSchema);
+
+
+
+
+

package/server/models/Document.js

@@ -0,0 +1,59 @@
+import mongoose from 'mongoose';
+
+const documentSchema = new mongoose.Schema({
+  title: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  content: {
+    type: String,
+    default: ''
+  },
+  group: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Group',
+    required: true
+  },
+  creator: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  permission: {
+    type: String,
+    enum: ['readonly', 'editable'],
+    default: 'editable'
+  },
+  editors: [{
+    user: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User'
+    },
+    lastEdit: {
+      type: Date,
+      default: Date.now
+    }
+  }],
+  versions: [{
+    content: String,
+    editor: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User'
+    },
+    timestamp: {
+      type: Date,
+      default: Date.now
+    }
+  }],
+  yjsState: {
+    type: Buffer,
+    default: null
+  }
+}, {
+  timestamps: true
+});
+
+export default mongoose.model('Document', documentSchema);
+
+

package/server/models/File.js

@@ -0,0 +1,43 @@
+import mongoose from 'mongoose';
+
+const fileSchema = new mongoose.Schema({
+  filename: {
+    type: String,
+    required: true
+  },
+  originalName: {
+    type: String,
+    required: true
+  },
+  path: {
+    type: String,
+    required: true
+  },
+  mimetype: {
+    type: String,
+    required: true
+  },
+  size: {
+    type: Number,
+    required: true
+  },
+  group: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Group',
+    required: true
+  },
+  uploader: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  description: {
+    type: String,
+    default: ''
+  }
+}, {
+  timestamps: true
+});
+
+export default mongoose.model('File', fileSchema);
+

package/server/models/Group.js

@@ -0,0 +1,61 @@
+import mongoose from 'mongoose';
+
+const groupSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  description: {
+    type: String,
+    default: ''
+  },
+  admin: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  members: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  }],
+  documents: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Document'
+  }],
+  files: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'File'
+  }],
+  tasks: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Task'
+  }],
+  mutedAll: {
+    type: Boolean,
+    default: false
+  },
+  mutedUsers: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  }],
+  callHistory: [{
+    calledUser: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User'
+    },
+    timestamp: {
+      type: Date,
+      default: Date.now
+    },
+    responded: {
+      type: Boolean,
+      default: false
+    }
+  }]
+}, {
+  timestamps: true
+});
+
+export default mongoose.model('Group', groupSchema);
+

package/server/models/Message.js

@@ -0,0 +1,31 @@
+import mongoose from 'mongoose';
+
+const messageSchema = new mongoose.Schema({
+  group: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Group',
+    required: true
+  },
+  sender: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  username: {
+    type: String,
+    required: true
+  },
+  content: {
+    type: String,
+    required: true
+  },
+  timestamp: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: true
+});
+
+export default mongoose.model('Message', messageSchema);
+

package/server/models/Task.js

@@ -0,0 +1,55 @@
+import mongoose from 'mongoose';
+
+const taskSchema = new mongoose.Schema({
+  title: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  description: {
+    type: String,
+    default: ''
+  },
+  group: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Group',
+    required: true
+  },
+  creator: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  assignedTo: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  }],
+  relatedDocument: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Document'
+  },
+  status: {
+    type: String,
+    enum: ['pending', 'in_progress', 'completed', 'terminated'],
+    default: 'pending'
+  },
+  deadline: {
+    type: Date
+  },
+  completedBy: [{
+    user: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User'
+    },
+    completedAt: {
+      type: Date,
+      default: Date.now
+    }
+  }]
+}, {
+  timestamps: true
+});
+
+export default mongoose.model('Task', taskSchema);
+
+

package/server/models/User.js

@@ -0,0 +1,60 @@
+import mongoose from 'mongoose';
+import bcrypt from 'bcryptjs';
+
+const userSchema = new mongoose.Schema({
+  username: {
+    type: String,
+    required: true,
+    unique: true,
+    trim: true
+  },
+  email: {
+    type: String,
+    required: true,
+    unique: true,
+    lowercase: true
+  },
+  password: {
+    type: String,
+    required: true
+  },
+  role: {
+    type: String,
+    enum: ['admin', 'user'],
+    default: 'user'
+  },
+  avatar: {
+    type: String,
+    default: ''
+  },
+  groups: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Group'
+  }],
+  isOnline: {
+    type: Boolean,
+    default: false
+  },
+  lastSeen: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: true
+});
+
+// 密码加密
+userSchema.pre('save', async function(next) {
+  if (!this.isModified('password')) return next();
+  this.password = await bcrypt.hash(this.password, 10);
+  next();
+});
+
+// 密码验证
+userSchema.methods.comparePassword = async function(candidatePassword) {
+  return await bcrypt.compare(candidatePassword, this.password);
+};
+
+export default mongoose.model('User', userSchema);
+
+

package/server/routes/audit.js

@@ -0,0 +1,210 @@
+import express from 'express';
+import { authenticate, isAdmin } from '../middleware/auth.js';
+import { 
+  queryAuditLogs, 
+  getUserActivityStats, 
+  getDocumentEditHistory 
+} from '../utils/auditLogger.js';
+
+const router = express.Router();
+
+// 获取审计日志列表（仅管理员）
+router.get('/', authenticate, isAdmin, async (req, res) => {
+  try {
+    const {
+      page = 1,
+      limit = 50,
+      userId,
+      resourceId,
+      resourceType,
+      action,
+      groupId,
+      startDate,
+      endDate,
+      sortBy = 'createdAt',
+      sortOrder = -1
+    } = req.query;
+
+    const filters = {};
+    if (userId) filters.userId = userId;
+    if (resourceId) filters.resourceId = resourceId;
+    if (resourceType) filters.resourceType = resourceType;
+    if (action) filters.action = action;
+    if (groupId) filters.groupId = groupId;
+    if (startDate) filters.startDate = startDate;
+    if (endDate) filters.endDate = endDate;
+
+    const options = {
+      page: parseInt(page),
+      limit: parseInt(limit),
+      sortBy,
+      sortOrder: parseInt(sortOrder)
+    };
+
+    const result = await queryAuditLogs(filters, options);
+    
+    res.json({
+      message: '获取审计日志成功',
+      ...result
+    });
+  } catch (error) {
+    console.error('获取审计日志失败:', error);
+    res.status(500).json({ 
+      message: '获取审计日志失败', 
+      error: error.message 
+    });
+  }
+});
+
+// 获取特定用户的活动统计（仅管理员）
+router.get('/user-stats/:userId', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { userId } = req.params;
+    const { startDate, endDate } = req.query;
+    
+    const timeRange = {};
+    if (startDate) timeRange.startDate = startDate;
+    if (endDate) timeRange.endDate = endDate;
+    
+    const stats = await getUserActivityStats(userId, timeRange);
+    
+    res.json({
+      message: '获取用户活动统计成功',
+      stats
+    });
+  } catch (error) {
+    console.error('获取用户活动统计失败:', error);
+    res.status(500).json({ 
+      message: '获取用户活动统计失败', 
+      error: error.message 
+    });
+  }
+});
+
+// 获取文档编辑历史（仅管理员）
+router.get('/document-history/:documentId', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { documentId } = req.params;
+    const { limit = 20 } = req.query;
+    
+    const history = await getDocumentEditHistory(documentId, parseInt(limit));
+    
+    res.json({
+      message: '获取文档编辑历史成功',
+      history
+    });
+  } catch (error) {
+    console.error('获取文档编辑历史失败:', error);
+    res.status(500).json({ 
+      message: '获取文档编辑历史失败', 
+      error: error.message 
+    });
+  }
+});
+
+// 获取群组活动日志（仅管理员）
+router.get('/group/:groupId', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { groupId } = req.params;
+    const {
+      page = 1,
+      limit = 50,
+      action,
+      userId,
+      startDate,
+      endDate
+    } = req.query;
+
+    const filters = { groupId };
+    if (action) filters.action = action;
+    if (userId) filters.userId = userId;
+    if (startDate) filters.startDate = startDate;
+    if (endDate) filters.endDate = endDate;
+
+    const options = {
+      page: parseInt(page),
+      limit: parseInt(limit),
+      sortBy: 'createdAt',
+      sortOrder: -1
+    };
+
+    const result = await queryAuditLogs(filters, options);
+    
+    res.json({
+      message: '获取群组活动日志成功',
+      ...result
+    });
+  } catch (error) {
+    console.error('获取群组活动日志失败:', error);
+    res.status(500).json({ 
+      message: '获取群组活动日志失败', 
+      error: error.message 
+    });
+  }
+});
+
+// 获取审计日志统计信息（仅管理员）
+router.get('/stats/summary', authenticate, isAdmin, async (req, res) => {
+  try {
+    const { startDate, endDate, groupId } = req.query;
+    
+    const filters = {};
+    if (groupId) filters.groupId = groupId;
+    if (startDate || endDate) {
+      filters.startDate = startDate;
+      filters.endDate = endDate;
+    }
+
+    // 获取总体统计
+    const result = await queryAuditLogs(filters, { limit: 1 });
+    const totalLogs = result.pagination.total;
+
+    // 获取按操作类型统计
+    const actionStats = await queryAuditLogs(filters, { limit: totalLogs });
+    const actionBreakdown = {};
+    
+    actionStats.logs.forEach(log => {
+      actionBreakdown[log.action] = (actionBreakdown[log.action] || 0) + 1;
+    });
+
+    // 获取最活跃用户
+    const userActivity = {};
+    actionStats.logs.forEach(log => {
+      const userId = log.user._id.toString();
+      if (!userActivity[userId]) {
+        userActivity[userId] = {
+          user: log.user,
+          count: 0
+        };
+      }
+      userActivity[userId].count++;
+    });
+
+    const topUsers = Object.values(userActivity)
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 10);
+
+    res.json({
+      message: '获取统计信息成功',
+      summary: {
+        totalLogs,
+        actionBreakdown,
+        topUsers,
+        timeRange: { startDate, endDate }
+      }
+    });
+  } catch (error) {
+    console.error('获取统计信息失败:', error);
+    res.status(500).json({ 
+      message: '获取统计信息失败', 
+      error: error.message 
+    });
+  }
+});
+
+export default router;
+
+
+
+
+