@ozdao/martyrs 0.2.518 → 0.2.520

package/dist/chats.server.js

@@ -2,10 +2,15 @@ import "./mailing-DzlhsxCC.js";
 import { m as middlewareIndexFactory } from "./index-_Edcmck_.js";
 const controllerFactory = (db) => {
   const ChatMessage = db.chat;
+  const Department = db.department;
+  const Order = db.order;
+  const notificationTimers = /* @__PURE__ */ new Map();
+  const NOTIFICATION_DELAY = 3e3;
   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);
@@ -19,9 +24,149 @@ 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,
+              readAt: /* @__PURE__ */ new Date()
+            }
+          }
+        }
+      );
+      console.log("[CHAT CONTROLLER] Mark as read result:", result);
+      return result;
+    } catch (error) {
+      console.error("Error marking messages as read:", error);
+    }
+  };
+  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);
+  };
+  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
+    }));
+    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") {
+      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;
+    }
+    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
+    getMessages,
+    markMessagesAsRead,
+    scheduleNotifications,
+    notificationTimers
   };
 };
 const ChatModel = (db) => {
@@ -30,14 +175,35 @@ const ChatModel = (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
@@ -56,7 +222,9 @@ const chatsRoutes = function(app, db, wss) {
       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",
         (client) => {
@@ -64,6 +232,35 @@ const chatsRoutes = function(app, db, wss) {
         },
         savedMessage
       );
+      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;
+      }
+      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: /* @__PURE__ */ new Date()
+        }
+      );
     }
   });
   app.get("/messages/:chatId", async (req, res) => {

package/dist/{crud-sE7GLPbj.js → crud-BIFl1W1i.js}

@@ -1,7 +1,7 @@
 import { m as middlewareFactory } from "./authJwt-J1csaMWA.js";
 import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
-import { O as Observer } from "./globals.observer-CDqUjVU5.js";
-import { L as Logger, C as Cache } from "./globals.logger-Bf6rRU7j.js";
+import { O as ObserverNamespaced } from "./globals.observer-MZsqaE6F.js";
+import { L as LoggerNamespaced, C as CacheNamespaced } from "./globals.logger-VRHh-WUW.js";
 class CRUDCore {
   constructor(crud) {
     this.crud = crud;
@@ -833,8 +833,8 @@ class CRUDEvents {
     this.enabled = options.enabled !== false;
     this.options = options;
     if (this.enabled) {
-      this.observer = options.observer || new Observer();
-      this.logger = options.logger || new Logger(this.crud.db);
+      this.observer = options.observer || new ObserverNamespaced();
+      this.logger = options.logger || new LoggerNamespaced(this.crud.db);
     }
   }
   // Отправка события
@@ -1004,8 +1004,8 @@ class CRUD {
     this.model = model;
     this.basePath = basePath;
     this.modelName = modelName;
-    this.cache = cache !== false ? cache instanceof Cache ? cache : new Cache() : null;
-    this.logger = logger || new Logger(db);
+    this.cache = cache !== false ? cache instanceof CacheNamespaced ? cache : new CacheNamespaced() : null;
+    this.logger = logger || new LoggerNamespaced(db);
     this.initModules(otherOptions);
     this.core.init(otherOptions);
     if (!otherOptions.disableDefaultRoutes) {

package/dist/{crud-JN_LFj01.cjs → crud-CC6k6yY5.cjs}

@@ -1,8 +1,8 @@
 "use strict";
 const authJwt = require("./authJwt-BIZ2GIfT.cjs");
 const queryProcessor = require("./queryProcessor-B_X680wC.cjs");
-const globals_observer = require("./globals.observer-CV2wCzzh.cjs");
-const globals_logger = require("./globals.logger-CZMgIMlM.cjs");
+const globals_observer = require("./globals.observer-C_FYclgV.cjs");
+const globals_logger = require("./globals.logger-BuW7JHMY.cjs");
 class CRUDCore {
   constructor(crud) {
     this.crud = crud;
@@ -834,8 +834,8 @@ class CRUDEvents {
     this.enabled = options.enabled !== false;
     this.options = options;
     if (this.enabled) {
-      this.observer = options.observer || new globals_observer.Observer();
-      this.logger = options.logger || new globals_logger.Logger(this.crud.db);
+      this.observer = options.observer || new globals_observer.ObserverNamespaced();
+      this.logger = options.logger || new globals_logger.LoggerNamespaced(this.crud.db);
     }
   }
   // Отправка события
@@ -1005,8 +1005,8 @@ class CRUD {
     this.model = model;
     this.basePath = basePath;
     this.modelName = modelName;
-    this.cache = cache !== false ? cache instanceof globals_logger.Cache ? cache : new globals_logger.Cache() : null;
-    this.logger = logger || new globals_logger.Logger(db);
+    this.cache = cache !== false ? cache instanceof globals_logger.CacheNamespaced ? cache : new globals_logger.CacheNamespaced() : null;
+    this.logger = logger || new globals_logger.LoggerNamespaced(db);
     this.initModules(otherOptions);
     this.core.init(otherOptions);
     if (!otherOptions.disableDefaultRoutes) {

package/dist/{globals.logger-CZMgIMlM.cjs → globals.logger-BuW7JHMY.cjs}

@@ -6,30 +6,12 @@ class Cache {
     this.cache = new NodeCache({ stdTTL: ttlSeconds });
     this.tagStore = /* @__PURE__ */ new Map();
   }
-  /**
-   * Получение значения по ключу
-   * @param {string} key - Ключ
-   * @returns {Promise<any>} Значение из кэша
-   */
   async get(key) {
     return this.cache.get(key);
   }
-  /**
-   * Установка значения по ключу
-   * @param {string} key - Ключ
-   * @param {any} value - Значение
-   * @returns {Promise<boolean>} Успешность операции
-   */
   async set(key, value) {
     return this.cache.set(key, value);
   }
-  /**
-   * Установка значения с тегами
-   * @param {string} key - Ключ
-   * @param {any} value - Значение
-   * @param {string[]} tags - Массив тегов
-   * @returns {Promise<boolean>} Успешность операции
-   */
   async setWithTags(key, value, tags = []) {
     const success = this.cache.set(key, value);
     if (success && tags.length > 0) {
@@ -42,11 +24,6 @@ class Cache {
     }
     return success;
   }
-  /**
-   * Удаление по ключу или ключам
-   * @param {string|string[]} keys - Ключ или массив ключей
-   * @returns {Promise<number>} Количество удаленных элементов
-   */
   async del(keys) {
     const keyArray = Array.isArray(keys) ? keys : [keys];
     const deletedCount = this.cache.del(keyArray);
@@ -62,11 +39,6 @@ class Cache {
     }
     return deletedCount;
   }
-  /**
-   * Удаление всех ключей, связанных с тегом
-   * @param {string} tag - Тег
-   * @returns {Promise<number>} Количество удаленных элементов
-   */
   async delByTag(tag) {
     if (!this.tagStore.has(tag)) return 0;
     const keys = Array.from(this.tagStore.get(tag));
@@ -74,11 +46,6 @@ class Cache {
     this.tagStore.delete(tag);
     return deletedCount;
   }
-  /**
-   * Удаление всех ключей, связанных с массивом тегов
-   * @param {string[]} tags - Массив тегов
-   * @returns {Promise<number>} Количество удаленных элементов
-   */
   async delByTags(tags) {
     let totalDeleted = 0;
     for (const tag of tags) {
@@ -86,26 +53,13 @@ class Cache {
     }
     return totalDeleted;
   }
-  /**
-   * Полная очистка кэша
-   * @returns {Promise<void>}
-   */
   async flush() {
     this.cache.flushAll();
     this.tagStore.clear();
   }
-  /**
-   * Получение всех ключей в кэше
-   * @returns {Promise<string[]>} Массив ключей
-   */
   async keys() {
     return this.cache.keys();
   }
-  /**
-   * Получение тегов для ключа
-   * @param {string} key - Ключ
-   * @returns {Promise<string[]>} Массив тегов
-   */
   async getTagsForKey(key) {
     const tags = [];
     for (const [tag, keySet] of this.tagStore.entries()) {
@@ -115,10 +69,6 @@ class Cache {
     }
     return tags;
   }
-  /**
-   * Получение статистики кэша
-   * @returns {Promise<object>} Статистика
-   */
   async stats() {
     return {
       keys: this.cache.keys().length,
@@ -127,6 +77,42 @@ class Cache {
     };
   }
 }
+const instances$1 = /* @__PURE__ */ new Map();
+class CacheNamespaced {
+  constructor(namespaceOrOptions, options) {
+    let namespace = "global";
+    let cacheOptions = {};
+    if (typeof namespaceOrOptions === "string") {
+      namespace = namespaceOrOptions;
+      cacheOptions = options || {};
+    } else if (typeof namespaceOrOptions === "object") {
+      cacheOptions = namespaceOrOptions || {};
+    }
+    if (instances$1.has(namespace)) {
+      return instances$1.get(namespace);
+    }
+    const instance = new Cache(cacheOptions);
+    instances$1.set(namespace, instance);
+    return instance;
+  }
+  // Статический метод для получения всех namespace'ов
+  static getNamespaces() {
+    return Array.from(instances$1.keys());
+  }
+  // Статический метод для очистки конкретного namespace
+  static async flushNamespace(namespace) {
+    if (instances$1.has(namespace)) {
+      await instances$1.get(namespace).flush();
+    }
+  }
+  // Статический метод для удаления namespace (полностью)
+  static removeNamespace(namespace) {
+    if (instances$1.has(namespace)) {
+      instances$1.get(namespace).flush();
+      instances$1.delete(namespace);
+    }
+  }
+}
 class Logger {
   constructor(db) {
     this.LogModel = db.log;
@@ -143,7 +129,6 @@ class Logger {
       console.error("Logging error:", err);
     }
   }
-  // Удобные методы для различных уровней логирования
   async info(message) {
     await this.log("info", message);
   }
@@ -151,5 +136,30 @@ class Logger {
     await this.log("error", message);
   }
 }
-exports.Cache = Cache;
-exports.Logger = Logger;
+const instances = /* @__PURE__ */ new Map();
+class LoggerNamespaced {
+  constructor(namespaceOrDb, db) {
+    if (!db && namespaceOrDb && typeof namespaceOrDb === "object") {
+      const namespace2 = "global";
+      if (instances.has(namespace2)) {
+        return instances.get(namespace2);
+      }
+      const instance2 = new Logger(namespaceOrDb);
+      instances.set(namespace2, instance2);
+      return instance2;
+    }
+    const namespace = namespaceOrDb;
+    if (instances.has(namespace)) {
+      return instances.get(namespace);
+    }
+    const instance = new Logger(db);
+    instances.set(namespace, instance);
+    return instance;
+  }
+  // Статический метод для получения всех namespace'ов
+  static getNamespaces() {
+    return Array.from(instances.keys());
+  }
+}
+exports.CacheNamespaced = CacheNamespaced;
+exports.LoggerNamespaced = LoggerNamespaced;

package/dist/{globals.logger-Bf6rRU7j.js → globals.logger-VRHh-WUW.js}

@@ -5,30 +5,12 @@ class Cache {
     this.cache = new NodeCache({ stdTTL: ttlSeconds });
     this.tagStore = /* @__PURE__ */ new Map();
   }
-  /**
-   * Получение значения по ключу
-   * @param {string} key - Ключ
-   * @returns {Promise<any>} Значение из кэша
-   */
   async get(key) {
     return this.cache.get(key);
   }
-  /**
-   * Установка значения по ключу
-   * @param {string} key - Ключ
-   * @param {any} value - Значение
-   * @returns {Promise<boolean>} Успешность операции
-   */
   async set(key, value) {
     return this.cache.set(key, value);
   }
-  /**
-   * Установка значения с тегами
-   * @param {string} key - Ключ
-   * @param {any} value - Значение
-   * @param {string[]} tags - Массив тегов
-   * @returns {Promise<boolean>} Успешность операции
-   */
   async setWithTags(key, value, tags = []) {
     const success = this.cache.set(key, value);
     if (success && tags.length > 0) {
@@ -41,11 +23,6 @@ class Cache {
     }
     return success;
   }
-  /**
-   * Удаление по ключу или ключам
-   * @param {string|string[]} keys - Ключ или массив ключей
-   * @returns {Promise<number>} Количество удаленных элементов
-   */
   async del(keys) {
     const keyArray = Array.isArray(keys) ? keys : [keys];
     const deletedCount = this.cache.del(keyArray);
@@ -61,11 +38,6 @@ class Cache {
     }
     return deletedCount;
   }
-  /**
-   * Удаление всех ключей, связанных с тегом
-   * @param {string} tag - Тег
-   * @returns {Promise<number>} Количество удаленных элементов
-   */
   async delByTag(tag) {
     if (!this.tagStore.has(tag)) return 0;
     const keys = Array.from(this.tagStore.get(tag));
@@ -73,11 +45,6 @@ class Cache {
     this.tagStore.delete(tag);
     return deletedCount;
   }
-  /**
-   * Удаление всех ключей, связанных с массивом тегов
-   * @param {string[]} tags - Массив тегов
-   * @returns {Promise<number>} Количество удаленных элементов
-   */
   async delByTags(tags) {
     let totalDeleted = 0;
     for (const tag of tags) {
@@ -85,26 +52,13 @@ class Cache {
     }
     return totalDeleted;
   }
-  /**
-   * Полная очистка кэша
-   * @returns {Promise<void>}
-   */
   async flush() {
     this.cache.flushAll();
     this.tagStore.clear();
   }
-  /**
-   * Получение всех ключей в кэше
-   * @returns {Promise<string[]>} Массив ключей
-   */
   async keys() {
     return this.cache.keys();
   }
-  /**
-   * Получение тегов для ключа
-   * @param {string} key - Ключ
-   * @returns {Promise<string[]>} Массив тегов
-   */
   async getTagsForKey(key) {
     const tags = [];
     for (const [tag, keySet] of this.tagStore.entries()) {
@@ -114,10 +68,6 @@ class Cache {
     }
     return tags;
   }
-  /**
-   * Получение статистики кэша
-   * @returns {Promise<object>} Статистика
-   */
   async stats() {
     return {
       keys: this.cache.keys().length,
@@ -126,6 +76,42 @@ class Cache {
     };
   }
 }
+const instances$1 = /* @__PURE__ */ new Map();
+class CacheNamespaced {
+  constructor(namespaceOrOptions, options) {
+    let namespace = "global";
+    let cacheOptions = {};
+    if (typeof namespaceOrOptions === "string") {
+      namespace = namespaceOrOptions;
+      cacheOptions = options || {};
+    } else if (typeof namespaceOrOptions === "object") {
+      cacheOptions = namespaceOrOptions || {};
+    }
+    if (instances$1.has(namespace)) {
+      return instances$1.get(namespace);
+    }
+    const instance = new Cache(cacheOptions);
+    instances$1.set(namespace, instance);
+    return instance;
+  }
+  // Статический метод для получения всех namespace'ов
+  static getNamespaces() {
+    return Array.from(instances$1.keys());
+  }
+  // Статический метод для очистки конкретного namespace
+  static async flushNamespace(namespace) {
+    if (instances$1.has(namespace)) {
+      await instances$1.get(namespace).flush();
+    }
+  }
+  // Статический метод для удаления namespace (полностью)
+  static removeNamespace(namespace) {
+    if (instances$1.has(namespace)) {
+      instances$1.get(namespace).flush();
+      instances$1.delete(namespace);
+    }
+  }
+}
 class Logger {
   constructor(db) {
     this.LogModel = db.log;
@@ -142,7 +128,6 @@ class Logger {
       console.error("Logging error:", err);
     }
   }
-  // Удобные методы для различных уровней логирования
   async info(message) {
     await this.log("info", message);
   }
@@ -150,7 +135,32 @@ class Logger {
     await this.log("error", message);
   }
 }
+const instances = /* @__PURE__ */ new Map();
+class LoggerNamespaced {
+  constructor(namespaceOrDb, db) {
+    if (!db && namespaceOrDb && typeof namespaceOrDb === "object") {
+      const namespace2 = "global";
+      if (instances.has(namespace2)) {
+        return instances.get(namespace2);
+      }
+      const instance2 = new Logger(namespaceOrDb);
+      instances.set(namespace2, instance2);
+      return instance2;
+    }
+    const namespace = namespaceOrDb;
+    if (instances.has(namespace)) {
+      return instances.get(namespace);
+    }
+    const instance = new Logger(db);
+    instances.set(namespace, instance);
+    return instance;
+  }
+  // Статический метод для получения всех namespace'ов
+  static getNamespaces() {
+    return Array.from(instances.keys());
+  }
+}
 export {
-  Cache as C,
-  Logger as L
+  CacheNamespaced as C,
+  LoggerNamespaced as L
 };