@ozdao/martyrs 0.2.518 → 0.2.520

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: получить историю сообщений

package/src/modules/chats/store/chat.store.js

@@ -5,6 +5,7 @@ const state = reactive({
   messages: [],
   currentChatId: null,
   username: null,
+  userId: null,
 });
 
 const methods = {
@@ -15,6 +16,7 @@ const methods = {
   async connectWebSocket(userId) {
     try {
       console.log('[Chat] Connecting to WebSocket with userId:', userId);
+      state.userId = userId; // Сохраняем userId
       await globalWebSocket.connect(userId);
       await globalWebSocket.subscribeModule('chat'); // 👈 Подписка на модуль чата
 
@@ -31,6 +33,35 @@ const methods = {
         },
         { module: 'chat' }
       );
+      
+      // Обработчик подтверждения прочтения
+      globalWebSocket.addEventListener(
+        'readReceipt',
+        data => {
+          console.log('[CHAT STORE] Received readReceipt:', data);
+          
+          // Обновляем статус прочтения для сообщений
+          if (data.messageIds && data.userId) {
+            data.messageIds.forEach(messageId => {
+              const message = state.messages.find(m => m._id === messageId);
+              if (message) {
+                if (!message.readBy) {
+                  message.readBy = [];
+                }
+                // Добавляем запись о прочтении если её еще нет
+                if (!message.readBy.some(r => r.userId === data.userId)) {
+                  message.readBy.push({
+                    userId: data.userId,
+                    readAt: data.readAt || new Date()
+                  });
+                  console.log('[CHAT STORE] Updated message read status:', messageId);
+                }
+              }
+            });
+          }
+        },
+        { module: 'chat' }
+      );
     } catch (error) {
       console.error('[Chat] WebSocket connection failed:', error);
       throw error;
@@ -76,6 +107,42 @@ const methods = {
       module: 'chat',
       type: 'message',
       chatId: state.currentChatId,
+      chatType: 'order', // TODO: динамически определять тип чата
+      userId: state.userId, // Добавляем userId отправителя
+    });
+  },
+
+  /**
+   * Отметить сообщения как прочитанные
+   * @param {Array<String>} messageIds
+   */
+  async markMessagesAsRead(messageIds) {
+    console.log('[CHAT STORE] markMessagesAsRead called with:', messageIds);
+    console.log('[CHAT STORE] Current userId:', state.userId);
+    
+    // Обновляем локальное состояние сразу для текущего пользователя
+    messageIds.forEach(messageId => {
+      const message = state.messages.find(m => m._id === messageId);
+      if (message) {
+        if (!message.readBy) {
+          message.readBy = [];
+        }
+        // Добавляем запись о прочтении если её еще нет
+        if (!message.readBy.some(r => r.userId === state.userId)) {
+          message.readBy.push({
+            userId: state.userId,
+            readAt: new Date()
+          });
+          console.log('[CHAT STORE] Locally updated message read status:', messageId);
+        }
+      }
+    });
+    
+    await globalWebSocket.send({
+      type: 'markAsRead',
+      module: 'chat',
+      messageIds: messageIds,
+      chatId: state.currentChatId,
     });
   },
 

package/src/modules/community/components/layouts/Community.vue

@@ -211,7 +211,7 @@ fetchComments();
 import * as blog from '@martyrs/src/modules/community/store/blogposts.js';
 import * as auth from '@martyrs/src/modules/auth/views/store/auth.js'
 import * as organizations from '@martyrs/src/modules/organizations/store/organizations.js'
-import * as memberships from '@martyrs/src/modules/organizations/store/memberships.js'
+import membershipsStore from '@martyrs/src/modules/organizations/store/memberships.store.js'
 
 // State
 const route = useRoute();
@@ -222,7 +222,7 @@ if (route.params.category === 'new') blog.state.sort.param = 'createdAt';
 
 
 const handleMembershipUpdate = ({ membership, status, target }, statusName, statusNumber) => {
-  memberships.mutations.handleMembershipUpdate(organizations.state.current, membership, status, target, statusName, statusNumber)
+  membershipsStore.handleMembershipUpdate(organizations.state.current, membership, status, target, statusName, statusNumber)
 };
 
 </script>