collabdocchat 1.0.0

package/server/websocket/index.js

@@ -0,0 +1,228 @@
+import jwt from 'jsonwebtoken';
+import * as Y from 'yjs';
+import Group from '../models/Group.js';
+import Message from '../models/Message.js';
+
+const clients = new Map();
+const documents = new Map();
+
+export const setupWebSocket = (wss) => {
+  wss.on('connection', (ws, req) => {
+    console.log('🔌 新的 WebSocket 连接');
+
+    ws.on('message', async (message) => {
+      try {
+        const data = JSON.parse(message);
+        
+        switch (data.type) {
+          case 'auth':
+            handleAuth(ws, data);
+            break;
+          case 'join_group':
+            await handleJoinGroup(ws, data);
+            break;
+          case 'chat_message':
+            await handleChatMessage(ws, data, wss);
+            break;
+          case 'document_sync':
+            handleDocumentSync(ws, data, wss);
+            break;
+          case 'call_response':
+            handleCallResponse(ws, data, wss);
+            break;
+          case 'typing':
+            handleTyping(ws, data, wss);
+            break;
+          default:
+            console.log('未知消息类型:', data.type);
+        }
+      } catch (error) {
+        console.error('WebSocket 消息处理错误:', error);
+        ws.send(JSON.stringify({ type: 'error', message: error.message }));
+      }
+    });
+
+    ws.on('close', () => {
+      handleDisconnect(ws, wss);
+    });
+  });
+};
+
+const handleAuth = (ws, data) => {
+  try {
+    const decoded = jwt.verify(data.token, process.env.JWT_SECRET);
+    ws.userId = decoded.userId;
+    ws.role = decoded.role;
+    clients.set(ws.userId, ws);
+    
+    ws.send(JSON.stringify({ 
+      type: 'auth_success', 
+      userId: ws.userId,
+      role: ws.role
+    }));
+  } catch (error) {
+    ws.send(JSON.stringify({ type: 'auth_error', message: '认证失败' }));
+    ws.close();
+  }
+};
+
+const handleJoinGroup = async (ws, data) => {
+  if (!ws.userId) {
+    ws.send(JSON.stringify({ type: 'error', message: '未认证，无法加入群组' }));
+    return;
+  }
+
+  const group = await Group.findById(data.groupId).select('members mutedAll mutedUsers');
+  if (!group) {
+    ws.send(JSON.stringify({ type: 'error', message: '群组不存在' }));
+    return;
+  }
+
+  const isMember = group.members.some(m => m.toString() === ws.userId);
+  if (!isMember) {
+    ws.send(JSON.stringify({ type: 'error', message: '你不在该群组中，请先加入群组' }));
+    return;
+  }
+
+  ws.groupId = data.groupId;
+  ws.send(JSON.stringify({
+    type: 'joined_group',
+    groupId: data.groupId
+  }));
+
+  ws.send(JSON.stringify({
+    type: 'mute_state',
+    groupId: data.groupId,
+    mutedAll: Boolean(group.mutedAll),
+    mutedUsers: (group.mutedUsers || []).map(u => u.toString())
+  }));
+};
+
+const handleChatMessage = async (ws, data, wss) => {
+  if (!ws.userId) {
+    ws.send(JSON.stringify({ type: 'error', message: '未认证，无法发送消息' }));
+    return;
+  }
+
+  if (!ws.groupId || ws.groupId !== data.groupId) {
+    ws.send(JSON.stringify({ type: 'chat_blocked', groupId: data.groupId, reason: 'not_in_group', message: '请先加入该群组再聊天' }));
+    return;
+  }
+
+  const group = await Group.findById(data.groupId).select('members admin mutedAll mutedUsers');
+  if (!group) {
+    ws.send(JSON.stringify({ type: 'error', message: '群组不存在' }));
+    return;
+  }
+
+  const isMember = group.members.some(m => m.toString() === ws.userId);
+  if (!isMember) {
+    ws.send(JSON.stringify({ type: 'chat_blocked', groupId: data.groupId, reason: 'not_in_group', message: '你不在该群组中，无法发言' }));
+    return;
+  }
+
+  const isAdmin = group.admin.toString() === ws.userId || ws.role === 'admin';
+  const isMutedUser = (group.mutedUsers || []).some(m => m.toString() === ws.userId);
+
+  if (!isAdmin && group.mutedAll) {
+    ws.send(JSON.stringify({ type: 'chat_blocked', groupId: data.groupId, reason: 'muted_all', message: '当前群组已开启全体禁言' }));
+    return;
+  }
+
+  if (!isAdmin && isMutedUser) {
+    ws.send(JSON.stringify({ type: 'chat_blocked', groupId: data.groupId, reason: 'muted_user', message: '你已被管理员禁言' }));
+    return;
+  }
+
+  // 保存消息到数据库
+  try {
+    const newMessage = new Message({
+      group: data.groupId,
+      sender: ws.userId,
+      username: data.username,
+      content: data.content,
+      timestamp: new Date()
+    });
+    await newMessage.save();
+  } catch (err) {
+    console.error('保存消息失败:', err);
+  }
+
+  const message = {
+    type: 'chat_message',
+    groupId: data.groupId,
+    userId: ws.userId,
+    username: data.username,
+    content: data.content,
+    timestamp: new Date().toISOString()
+  };
+
+  broadcastToGroup(wss, data.groupId, message);
+};
+
+const handleDocumentSync = (ws, data, wss) => {
+  const { documentId, content, cursorPosition } = data;
+  
+  if (!documents.has(documentId)) {
+    documents.set(documentId, new Y.Doc());
+  }
+
+  const message = {
+    type: 'document_update',
+    documentId,
+    content,
+    userId: ws.userId,
+    cursorPosition,
+    timestamp: new Date().toISOString()
+  };
+
+  broadcastToGroup(wss, ws.groupId, message, ws);
+};
+
+const handleCallResponse = (ws, data, wss) => {
+  const message = {
+    type: 'call_response',
+    groupId: data.groupId,
+    userId: ws.userId,
+    username: data.username,
+    responded: true,
+    timestamp: new Date().toISOString()
+  };
+
+  broadcastToGroup(wss, data.groupId, message);
+};
+
+const handleTyping = (ws, data, wss) => {
+  const message = {
+    type: 'typing',
+    documentId: data.documentId,
+    userId: ws.userId,
+    username: data.username,
+    isTyping: data.isTyping
+  };
+
+  broadcastToGroup(wss, ws.groupId, message, ws);
+};
+
+const handleDisconnect = (ws, wss) => {
+  if (ws.userId) {
+    clients.delete(ws.userId);
+    
+    if (ws.groupId) {
+      broadcastToGroup(wss, ws.groupId, {
+        type: 'user_offline',
+        userId: ws.userId
+      });
+    }
+  }
+  console.log('🔌 WebSocket 连接关闭');
+};
+
+const broadcastToGroup = (wss, groupId, message, excludeWs = null) => {
+  wss.clients.forEach(client => {
+    if (client.groupId === groupId && client !== excludeWs && client.readyState === 1) {
+      client.send(JSON.stringify(message));
+    }
+  });
+};
+

package/src/main.js

@@ -0,0 +1,53 @@
+import './styles/main.css';
+import { AuthService } from './services/auth.js';
+import { WebSocketService } from './services/websocket.js';
+import { renderLoginPage } from './pages/login.js';
+import { renderAdminDashboard } from './pages/admin-dashboard.js';
+import { renderUserDashboard } from './pages/user-dashboard.js';
+
+class App {
+  constructor() {
+    this.authService = new AuthService();
+    this.wsService = new WebSocketService();
+    this.currentUser = null;
+    this.init();
+  }
+
+  async init() {
+    const token = localStorage.getItem('token');
+    
+    if (token) {
+      try {
+        this.currentUser = await this.authService.getCurrentUser();
+        this.wsService.connect(token);
+        this.renderDashboard();
+      } catch (error) {
+        console.error('认证失败:', error);
+        this.renderLogin();
+      }
+    } else {
+      this.renderLogin();
+    }
+  }
+
+  renderLogin() {
+    renderLoginPage(async (user, token) => {
+      this.currentUser = user;
+      localStorage.setItem('token', token);
+      this.wsService.connect(token);
+      this.renderDashboard();
+    });
+  }
+
+  renderDashboard() {
+    if (this.currentUser.role === 'admin') {
+      renderAdminDashboard(this.currentUser, this.wsService);
+    } else {
+      renderUserDashboard(this.currentUser, this.wsService);
+    }
+  }
+}
+
+new App();
+
+