@ozdao/martyrs 0.2.519 → 0.2.520

package/src/modules/auth/views/store/auth.js

@@ -7,6 +7,7 @@ import { Preferences } from '@capacitor/preferences';
 import { reactive, watch } from 'vue';
 // Globals
 import { setError } from '@martyrs/src/modules/globals/views/store/globals.js';
+import globalWebSocket from '@martyrs/src/modules/globals/views/classes/globals.websocket.js';
 // State
 import * as twofa from './twofa.js';
 
@@ -101,6 +102,11 @@ const actions = {
       });
 
       await this.initialize();
+      
+      // Переподключаем WebSocket с новым userId после входа
+      console.log('[AUTH] Reconnecting WebSocket after login for user:', response.data._id);
+      globalWebSocket.disconnect();
+      await globalWebSocket.connect(response.data._id);
 
       return response.data;
     } catch (error) {
@@ -159,6 +165,11 @@ const actions = {
       });
 
       await this.initialize();
+      
+      // Переподключаем WebSocket с новым userId после регистрации
+      console.log('[AUTH] Reconnecting WebSocket after signup for user:', response.data._id);
+      globalWebSocket.disconnect();
+      await globalWebSocket.connect(response.data._id);
 
       return response.data;
     } catch (error) {
@@ -174,6 +185,10 @@ const actions = {
     await removeCookie('user');
     setAuthToken(null);
     this.resetState();
+    
+    // Отключаем WebSocket при выходе
+    console.log('[AUTH] Disconnecting WebSocket on logout');
+    globalWebSocket.disconnect();
   },
 
   async resetPassword(user, type) {

package/src/modules/chats/CLAUDE.md

@@ -0,0 +1,137 @@
+# Модуль чатов
+
+## Обзор архитектуры
+
+Модуль реализует real-time чат с использованием WebSocket и MongoDB для хранения истории сообщений.
+
+### Структура файлов
+
+```
+chats/
+├── chats.client.js          # Точка входа клиентской части
+├── chats.server.js          # Точка входа серверной части
+├── components/
+│   ├── pages/
+│   │   └── ChatPage.vue     # Главная страница чата
+│   ├── sections/
+│   │   └── ChatWindow.vue   # Окно чата с сообщениями
+│   └── blocks/
+│       └── ChatMessage.vue  # Компонент отдельного сообщения
+├── controllers/
+│   └── chats.controller.js  # Бизнес-логика (сохранение/получение сообщений)
+├── models/
+│   └── chat.model.js        # MongoDB модель сообщения
+├── routes/
+│   └── chats.routes.js      # HTTP маршруты и WebSocket обработчики
+└── store/
+    └── chat.store.js        # Управление состоянием на клиенте
+```
+
+## Ключевые компоненты
+
+### WebSocket интеграция
+
+Модуль использует глобальный WebSocket класс из `@martyrs/src/modules/globals/views/classes/globals.websocket.js`:
+
+- Подключение: `globalWebSocket.connect(userId)`
+- Подписка на модуль: `globalWebSocket.subscribeModule('chat')`
+- Отправка сообщений: `globalWebSocket.send({ type: 'message', module: 'chat', ... })`
+
+### Store (chat.store.js)
+
+Управляет состоянием чата на клиенте:
+- `state.messages` - массив сообщений текущего чата
+- `state.currentChatId` - ID активного чата
+- `state.username` - имя текущего пользователя
+
+Основные методы:
+- `connectWebSocket(userId)` - подключение к WebSocket
+- `setCurrentChat(chatId)` - переключение чата и загрузка истории
+- `addMessage(message)` - отправка нового сообщения
+
+### Серверные обработчики
+
+WebSocket обработчики регистрируются через `wss.registerModule('chat', handler)`:
+
+1. `joinChat` - присоединение к чату (добавление chatId в ws.activeChats)
+2. `message` - обработка входящего сообщения:
+   - Сохранение в БД
+   - Рассылка всем участникам чата через `broadcastToModuleWithFilter`
+
+REST API:
+- `GET /messages/:chatId` - получение истории сообщений
+
+## Модель данных
+
+```javascript
+ChatMessageSchema = {
+  username: String,     // Имя отправителя
+  chatId: String,      // ID чата
+  text: String,        // Текст сообщения
+  createdAt: Date      // Время создания (автоматически)
+}
+```
+
+## Проблемы и TODO
+
+### Критические проблемы
+
+1. **Нет авторизации** в WebSocket обработчиках
+   - Любой может отправлять сообщения от имени любого пользователя
+   - Нет проверки прав доступа к чату
+
+3. **Отсутствует валидация данных**
+   - Нет проверки обязательных полей
+   - Нет санитизации входящих данных
+
+### Улучшения
+
+1. **Обработка ошибок**
+   - Добавить try/catch в компоненты
+   - Показывать уведомления об ошибках пользователю
+
+2. **Оптимизация**
+   - Пагинация для истории сообщений
+   - Виртуальный скроллинг для больших чатов
+
+3. **Функциональность**
+   - Индикатор набора текста
+   - Статусы доставки сообщений
+   - Поддержка файлов/изображений
+   - Уведомления о новых сообщениях
+
+## Использование
+
+### Инициализация на клиенте
+
+```javascript
+import ModuleChats from '@martyrs/src/modules/chats/chats.client.js';
+
+// В главном приложении
+ModuleChats.initialize(app, store, router);
+```
+
+### Использование в компоненте
+
+```vue
+<ChatPage 
+  :username="currentUser.name"
+  :user="currentUser.id"
+  :chatID="selectedChatId"
+/>
+```
+
+### Инициализация на сервере
+
+```javascript
+import { initialize } from '@martyrs/src/modules/chats/chats.server.js';
+
+// При старте сервера
+initialize(app, db, wss, origins, publicPath);
+```
+
+## Зависимости
+
+- `globals.websocket.js` - глобальный WebSocket класс
+- `auth/controllers/middlewares` - middleware для авторизации (не используется)
+- `globals/controllers/utils/mailing.js` - отправка уведомлений (импортирован, но не используется)

package/src/modules/chats/components/blocks/ChatMessage.vue

@@ -2,22 +2,34 @@
   <div 
     class="pd-small"
     :class="{'bg-main-nano': message.username === 'Support'}"
+    :data-message-id="message._id"
   >
     <p class="flex-v-center gap-thin flex-nowrap flex w-100 p-small">
       <!-- <img loading="lazy" v-if="message.username === 'Weeder Support'" src="/logo/logo.png" class="i-medium"> -->
       <strong class="mn-r-auto"><span class="t-semi">{{ message.username }}</span> <span class="t-transp">{{formatDate(message.createdAt)}}</span></strong>
+      <IconCheckmark v-if="isMessageRead" class="i-small t-main" />
     </p>
     <p>{{ message.text }}</p>
   </div>
 </template>
 
 <script>
+import IconCheckmark from '@martyrs/src/modules/icons/navigation/IconCheckmark.vue';
+
 export default {
+  components: {
+    IconCheckmark
+  },
   props: {
     message: {
       type: Object,
       required: true
     }
+  },
+  computed: {
+    isMessageRead() {
+      return this.message.readBy && this.message.readBy.length > 0;
+    }
   }
 };
 </script>

package/src/modules/chats/components/sections/ChatWindow.vue

@@ -28,7 +28,7 @@
 </template>
 
 <script setup>
-import { ref, computed, watch, onMounted, nextTick } from 'vue';
+import { ref, computed, watch, onMounted, onUnmounted, nextTick } from 'vue';
 
 import IconAdd from '@martyrs/src/modules/icons/navigation/IconAdd.vue'
 import PlaceholderChat from '@martyrs/src/modules/icons/placeholders/PlaceholderChat.vue'
@@ -38,6 +38,8 @@ import chatStore from '../../store/chat.store.js';
 
 const newMessage = ref('');
 const allMessages = ref(null);
+const visibleMessageIds = ref(new Set());
+let messageObserver = null;
 
 // Вычисляемые свойства
 const messages = computed(() => chatStore.state.messages);
@@ -69,12 +71,86 @@ const sendMessage = async () => {
   }
 };
 
+// Отслеживание видимых сообщений
+const observeMessages = () => {
+  console.log('[CHAT] Setting up message observer');
+  
+  // Очищаем предыдущий observer если есть
+  if (messageObserver) {
+    messageObserver.disconnect();
+  }
+  
+  messageObserver = new IntersectionObserver((entries) => {
+    console.log('[CHAT] Observer triggered for', entries.length, 'entries');
+    entries.forEach(entry => {
+      const messageId = entry.target.dataset.messageId;
+      if (entry.isIntersecting) {
+        visibleMessageIds.value.add(messageId);
+      } else {
+        visibleMessageIds.value.delete(messageId);
+      }
+    });
+    
+    // Отправляем прочтение видимых сообщений
+    if (visibleMessageIds.value.size > 0) {
+      const unreadVisibleMessages = messages.value
+        .filter(msg => {
+          // Проверяем, что сообщение видимо
+          if (!visibleMessageIds.value.has(msg._id)) return false;
+          
+          // Проверяем, что сообщение не от текущего пользователя
+          console.log('[CHAT] Checking if own message:', {
+            msgUserId: msg.userId,
+            currentUserId: chatStore.state.userId,
+            isEqual: msg.userId === chatStore.state.userId,
+            msgUserIdType: typeof msg.userId,
+            currentUserIdType: typeof chatStore.state.userId
+          });
+          if (msg.userId && msg.userId === chatStore.state.userId) return false;
+          
+          // Проверяем, что сообщение еще не прочитано текущим пользователем
+          if (msg.readBy?.some(r => r.userId === chatStore.state.userId)) return false;
+          
+          console.log('[CHAT] Message can be marked as read:', {
+            msgId: msg._id,
+            msgUserId: msg.userId,
+            currentUserId: chatStore.state.userId,
+            readBy: msg.readBy
+          });
+          
+          return true;
+        })
+        .map(msg => msg._id);
+      
+      console.log('[CHAT] Unread visible messages to mark:', unreadVisibleMessages);
+      
+      if (unreadVisibleMessages.length > 0) {
+        console.log('[CHAT] Sending markAsRead for messages:', unreadVisibleMessages);
+        chatStore.methods.markMessagesAsRead(unreadVisibleMessages);
+      } else {
+        console.log('[CHAT] No unread messages to mark');
+      }
+    }
+  }, {
+    root: allMessages.value,
+    threshold: 0.5
+  });
+  
+  // Наблюдаем за всеми сообщениями
+  nextTick(() => {
+    const messageElements = allMessages.value?.querySelectorAll('[data-message-id]');
+    console.log('[CHAT] Found message elements to observe:', messageElements?.length);
+    messageElements?.forEach(el => messageObserver.observe(el));
+  });
+};
+
 // Прокрутка вниз при монтировании
 onMounted(() => {
   nextTick(() => {
     if (allMessages.value) {
       allMessages.value.scrollTop = allMessages.value.scrollHeight;
     }
+    observeMessages();
   });
 });
 
@@ -84,10 +160,16 @@ watch(messages, () => {
     if (allMessages.value) {
       allMessages.value.scrollTop = allMessages.value.scrollHeight;
     }
+    observeMessages();
   });
 }, { deep: true });
 
-// Обработчик после завершения анимации входа нового элемента
+// Очистка observer при размонтировании
+onUnmounted(() => {
+  if (messageObserver) {
+    messageObserver.disconnect();
+  }
+});
 </script>
 
 <style>

package/src/modules/chats/controllers/chats.controller.js

@@ -1,16 +1,26 @@
 import mailing from '@martyrs/src/modules/globals/controllers/utils/mailing.js';
 const { sendChatMessageTelegram } = mailing;
+
 const controllerFactory = db => {
   const ChatMessage = db.chat;
+  const Department = db.department;
+  const Order = db.order;
+  
+  // Хранилище таймеров для отложенных нотификаций
+  const notificationTimers = new Map();
+  const NOTIFICATION_DELAY = 3000; // 30 секунд
+  
   const saveMessage = async msg => {
     try {
       const message = new ChatMessage(msg);
       await message.save();
+      console.log('[CHAT CONTROLLER] Saved message with userId:', msg.userId);
       return message;
     } catch (error) {
       console.error('Error saving message to database:', error);
     }
   };
+  
   const getMessages = async chatId => {
     try {
       const messages = await ChatMessage.find({ chatId }).sort({ createdAt: 1 });
@@ -19,9 +29,186 @@ const controllerFactory = db => {
       console.error('Error retrieving messages from database:', error);
     }
   };
+  
+  const markMessagesAsRead = async (messageIds, userId) => {
+    try {
+      console.log('[CHAT CONTROLLER] markMessagesAsRead called:', { messageIds, userId });
+      
+      // Сначала проверим сообщения
+      const messages = await ChatMessage.find({ _id: { $in: messageIds } });
+      console.log('[CHAT CONTROLLER] Found messages to mark:', messages.map(m => ({
+        id: m._id,
+        userId: m.userId,
+        isOwnMessage: m.userId?.toString() === userId.toString(),
+        alreadyRead: m.readBy?.some(r => r.userId.toString() === userId.toString())
+      })));
+      
+      // Обновляем только чужие непрочитанные сообщения
+      const result = await ChatMessage.updateMany(
+        {
+          _id: { $in: messageIds },
+          userId: { $ne: userId }, // НЕ свои сообщения
+          'readBy.userId': { $ne: userId } // еще не прочитанные
+        },
+        {
+          $push: {
+            readBy: {
+              userId: userId,
+              readAt: new Date()
+            }
+          }
+        }
+      );
+      
+      console.log('[CHAT CONTROLLER] Mark as read result:', result);
+      return result;
+    } catch (error) {
+      console.error('Error marking messages as read:', error);
+    }
+  };
+  
+  // Получить пользователей с доступом orders.confirm для организации
+  const getUsersWithOrdersConfirmAccess = async (organizationId) => {
+    const pipeline = [
+      { $match: { 
+        organization: new db.mongoose.Types.ObjectId(organizationId),
+        'accesses.orders.confirm': true 
+      }},
+      { $unwind: '$members' },
+      { $group: {
+        _id: '$members.user'
+      }},
+      { $project: { userId: '$_id' }}
+    ];
+    
+    const result = await Department.aggregate(pipeline);
+    return result.map(item => item.userId);
+  };
+  
+  // Отправка нотификаций (как в orders.controller)
+  const sendChatNotifications = async (message, recipientIds) => {
+    if (!recipientIds || recipientIds.length === 0) return;
+    
+    const notifications = recipientIds.map(userId => ({
+      title: 'New Message',
+      body: `${message.username}: ${message.text.substring(0, 100)}`,
+      type: 'chat_message',
+      metadata: {
+        type: 'chat_message',
+        chatId: message.chatId,
+        messageId: message._id,
+        context: 'chat'
+      },
+      userId: userId
+    }));
+    
+    try {
+      const response = await fetch(`${process.env.API_URL || ''}/api/notifications/batch`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Service-Key': process.env.SERVICE_KEY,
+        },
+        body: JSON.stringify({ notifications }),
+      });
+      
+      if (!response.ok) {
+        const errorData = await response.text();
+        throw new Error(`Notification API failed: ${response.status} - ${errorData}`);
+      }
+      
+      const result = await response.json();
+      console.log('Chat notifications sent:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to send chat notifications:', error);
+    }
+  };
+  
+  // Запланировать отправку нотификаций
+  const scheduleNotifications = async (message, wss, senderUserId) => {
+    console.log('[CHAT CONTROLLER] scheduleNotifications called for message:', message);
+    console.log('[CHAT CONTROLLER] Sender userId:', senderUserId);
+    console.log('[CHAT CONTROLLER] Chat type:', message.chatType);
+    console.log('[CHAT CONTROLLER] Chat ID:', message.chatId);
+    
+    // Определяем получателей в зависимости от типа чата
+    let recipientIds = [];
+    
+    if (message.chatType === 'order') {
+      // Для чатов типа order - chatId это ID заказа
+      try {
+        const order = await Order.findById(message.chatId);
+        console.log('[CHAT CONTROLLER] Found order:', order?._id, 'Owner:', order?.owner);
+        
+        const organizationId = order?.owner?.target?._id || order?.owner?.target;
+        
+        if (order && organizationId) {
+          console.log('[CHAT CONTROLLER] Looking for users with orders.confirm access in org:', organizationId);
+          recipientIds = await getUsersWithOrdersConfirmAccess(organizationId);
+          console.log('[CHAT CONTROLLER] Found recipient IDs:', recipientIds);
+        } else {
+          console.log('[CHAT CONTROLLER] Order not found or has no organization');
+        }
+      } catch (error) {
+        console.error('[CHAT CONTROLLER] Error fetching order:', error);
+      }
+    } else if (message.chatType === 'group') {
+      // Групповые нотификации замокированы
+      console.log('[CHAT CONTROLLER] Group notifications are mocked for now');
+      return;
+    } else {
+      console.log('[CHAT CONTROLLER] Unknown chat type:', message.chatType);
+      return;
+    }
+    
+    // Исключаем отправителя из списка получателей
+    const filteredRecipientIds = recipientIds.filter(userId => 
+      userId.toString() !== senderUserId?.toString()
+    );
+    
+    console.log('[CHAT CONTROLLER] Recipients after filtering out sender:', filteredRecipientIds);
+    
+    if (filteredRecipientIds.length === 0) {
+      console.log('[CHAT CONTROLLER] No recipients after filtering, skipping notifications');
+      return;
+    }
+    
+    // Планируем отправку через 30 секунд для каждого получателя
+    filteredRecipientIds.forEach(userId => {
+      const timerKey = `${message._id}_${userId}`;
+      console.log(`[CHAT CONTROLLER] Setting timer for user ${userId}, key: ${timerKey}`);
+      
+      const timer = setTimeout(async () => {
+        console.log(`[CHAT CONTROLLER] Timer fired for user ${userId}, checking if message is read`);
+        
+        // Проверяем, не прочитано ли сообщение
+        const currentMessage = await ChatMessage.findById(message._id);
+        const isRead = currentMessage.readBy.some(r => r.userId.toString() === userId.toString());
+        
+        console.log(`[CHAT CONTROLLER] Message read status for user ${userId}:`, isRead);
+        
+        if (!isRead) {
+          console.log(`[CHAT CONTROLLER] Sending notification to user ${userId}`);
+          await sendChatNotifications(message, [userId]);
+        } else {
+          console.log(`[CHAT CONTROLLER] Message already read by user ${userId}, skipping notification`);
+        }
+        
+        notificationTimers.delete(timerKey);
+      }, NOTIFICATION_DELAY);
+      
+      notificationTimers.set(timerKey, timer);
+    });
+  };
+  
   return {
     saveMessage,
     getMessages,
+    markMessagesAsRead,
+    scheduleNotifications,
+    notificationTimers
   };
 };
+
 export default controllerFactory;

package/src/modules/chats/models/chat.model.js

@@ -4,14 +4,35 @@ export default db => {
       type: String,
       required: true,
     },
+    userId: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+      required: true
+    },
     chatId: {
       type: String,
       required: true,
     },
+    chatType: {
+      type: String,
+      required: true,
+      enum: ['order', 'group', 'support', 'private'],
+      default: 'private'
+    },
     text: {
       type: String,
       required: true,
     },
+    readBy: [{
+      userId: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: 'User'
+      },
+      readAt: {
+        type: Date,
+        default: Date.now
+      }
+    }],
     createdAt: {
       type: Date,
       default: Date.now,

package/src/modules/chats/routes/chats.routes.js

@@ -3,6 +3,8 @@ import controllerFactory from '../controllers/chats.controller.js';
 export default (function (app, db, wss) {
   const controller = controllerFactory(db);
   const { verifySignUp, verifyUser } = middlewareFactory(db);
+  
+  
   // WebSocket-обработчик для модуля "chat"
   wss.registerModule('chat', async (ws, msg) => {
     if (msg.type === 'joinChat') {
@@ -11,8 +13,13 @@ export default (function (app, db, wss) {
       if (!ws.activeChats) ws.activeChats = new Set();
       ws.activeChats.add(msg.chatId);
     }
+    
     if (msg.type === 'message') {
+      console.log('[CHAT] Received message:', msg);
+      
       const savedMessage = await controller.saveMessage(msg);
+      console.log('[CHAT] Saved message:', savedMessage);
+      
       // Отправить сообщение всем в этом чате
       wss.broadcastToModuleWithFilter(
         'chat',
@@ -21,6 +28,45 @@ export default (function (app, db, wss) {
         },
         savedMessage
       );
+      
+      // Запланировать отправку нотификаций через 30 секунд
+      console.log('[CHAT] Scheduling notifications for message:', savedMessage._id, 'from user:', ws.userId);
+      controller.scheduleNotifications(savedMessage, wss, ws.userId);
+    }
+    
+    if (msg.type === 'markAsRead') {
+      console.log('[CHAT] markAsRead request:', { messageIds: msg.messageIds, userId: ws.userId });
+      
+      if (!msg.messageIds || !msg.chatId || !ws.userId) {
+        console.log('[CHAT] markAsRead missing params:', { hasMessageIds: !!msg.messageIds, hasChatId: !!msg.chatId, hasUserId: !!ws.userId });
+        return;
+      }
+      
+      // Отметить сообщения как прочитанные
+      const updatedMessages = await controller.markMessagesAsRead(msg.messageIds, ws.userId);
+      
+      // Отменить запланированные нотификации для этого пользователя
+      msg.messageIds.forEach(messageId => {
+        const timerKey = `${messageId}_${ws.userId}`;
+        if (controller.notificationTimers.has(timerKey)) {
+          clearTimeout(controller.notificationTimers.get(timerKey));
+          controller.notificationTimers.delete(timerKey);
+        }
+      });
+      
+      // Уведомить других участников чата о прочтении
+      wss.broadcastToModuleWithFilter(
+        'chat',
+        client => {
+          return client.activeChats?.has(msg.chatId) && client.userId !== ws.userId;
+        },
+        {
+          type: 'readReceipt',
+          messageIds: msg.messageIds,
+          userId: ws.userId,
+          readAt: new Date()
+        }
+      );
     }
   });
   // REST API: получить историю сообщений