shuttlepro-shared 1.3.98 → 1.4.2

package/common/repositories/call.repository.js

@@ -0,0 +1,480 @@
+const Call = require("../../models/Call");
+
+class CallRepository {
+  constructor() {
+    this.pipelines = {
+      callStats: this._buildCallStatsPipeline(),
+      holdQueue: this._buildHoldQueuePipeline(),
+    };
+  }
+
+  // Create a new call without transaction
+  async createCall(callData) {
+    try {
+      const call = new Call({
+        callId: callData.callId,
+        callerName: callData.callerName,
+        callerNumber: callData.callerNumber,
+        whatsappSdp: callData.whatsappSdp,
+        status: callData.status || "pending",
+        autoAccepted: callData.autoAccepted || false,
+        metadata: callData.metadata || {},
+        tags: callData.tags || [],
+        priority: callData.priority || 0,
+        platformId: callData.platformId || null,
+        workspaceId: callData.workspaceId || null,
+        profileId: callData.profileId || null,
+      });
+
+      call.addToHistory("created", null, "Call created in system");
+      await call.save();
+
+      await this._updateCallMetrics("created");
+      return call;
+    } catch (error) {
+      console.error(`Failed to create call ${callData.callId}:`, error);
+      throw error;
+    }
+  }
+
+  // Get call by ID
+  async getCall(callId, options = {}) {
+    try {
+      const query = Call.findOne({ callId });
+
+      if (options.lean) query.lean();
+
+      if (options.populate !== false) {
+        query.populate([
+          { path: "platformId", model: "Integration" },
+          { path: "workspaceId", model: "Workspace" },
+          { path: "profileId", model: "Profile" },
+        ]);
+      } else if (options.populate) {
+        query.populate(options.populate);
+      }
+
+      if (options.select) query.select(options.select);
+
+      return await query.exec();
+    } catch (error) {
+      console.error(`Failed to get call ${callId}:`, error);
+      throw error;
+    }
+  }
+
+  // Bulk get calls
+  async getCalls(filters = {}, options = {}) {
+    try {
+      const {
+        status,
+        agentId,
+        dateRange,
+        priority,
+        tags,
+        platformId,
+        workspaceId,
+        profileId,
+        page = 1,
+        limit = 50,
+        sort = { createdAt: -1 },
+      } = filters;
+
+      const query = {};
+      if (status)
+        query.status = Array.isArray(status) ? { $in: status } : status;
+      if (agentId) query.agentId = agentId;
+      if (platformId) query.platformId = platformId;
+      if (workspaceId) query.workspaceId = workspaceId;
+      if (profileId) query.profileId = profileId;
+
+      if (dateRange) {
+        query.createdAt = {
+          $gte: new Date(dateRange.start),
+          $lte: new Date(dateRange.end),
+        };
+      }
+
+      if (priority !== undefined) query.priority = { $gte: priority };
+      if (tags?.length > 0) query.tags = { $in: tags };
+
+      const skip = (page - 1) * limit;
+
+      const [calls, total] = await Promise.all([
+        Call.find(query)
+          .sort(sort)
+          .skip(skip)
+          .limit(limit)
+          .lean(options.lean !== false)
+          .populate(
+            options.populate !== false
+              ? [
+                  { path: "platformId", model: "Integration" },
+                  { path: "workspaceId", model: "Workspace" },
+                  { path: "profileId", model: "Profile" },
+                ]
+              : []
+          )
+          .exec(),
+        Call.countDocuments(query),
+      ]);
+
+      return {
+        calls,
+        pagination: {
+          page,
+          limit,
+          total,
+          pages: Math.ceil(total / limit),
+        },
+      };
+    } catch (error) {
+      console.error("Failed to get calls:", error);
+      throw error;
+    }
+  }
+
+  // Update call
+  async updateCall(callId, updateData) {
+    try {
+      const call = await Call.findOne({ callId });
+      if (!call) throw new Error(`Call ${callId} not found`);
+
+      if (updateData.__v !== undefined && call.__v !== updateData.__v) {
+        throw new Error(`Concurrent update detected for call ${callId}`);
+      }
+
+      const allowedFields = [
+        "status",
+        "agentId",
+        "callerName",
+        "callerNumber",
+        "priority",
+        "tags",
+        "metadata",
+        "isOnHold",
+        "platformId",
+        "workspaceId",
+        "profileId",
+      ];
+
+      Object.keys(updateData).forEach((key) => {
+        if (allowedFields.includes(key)) {
+          call[key] = updateData[key];
+        }
+      });
+
+      if (updateData.status && updateData.status !== call.status) {
+        call.addToHistory(
+          updateData.status,
+          updateData.agentId || call.agentId,
+          updateData.reason || `Status changed to ${updateData.status}`
+        );
+      }
+
+      call.updateHeartbeat();
+      await call.save();
+      return call;
+    } catch (error) {
+      console.error(`Failed to update call ${callId}:`, error);
+      throw error;
+    }
+  }
+
+  // Assign call to agent
+  async assignCallToAgent(callId, agentId) {
+    try {
+      const call = await Call.findOne({ callId });
+      if (!call) throw new Error(`Call ${callId} not found`);
+
+      if (call.status !== "pending" && call.status !== "hold") {
+        throw new Error(`Call ${callId} is not available for assignment`);
+      }
+
+      call.agentId = agentId;
+      call.status = "active";
+      call.startTime = new Date();
+      call.isOnHold = false;
+      call.addToHistory("answered", agentId, "Call answered by agent");
+      call.updateHeartbeat();
+
+      await call.save();
+      return call;
+    } catch (error) {
+      console.error(
+        `Failed to assign call ${callId} to agent ${agentId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  // Bulk update calls
+  async bulkUpdateCalls(operations) {
+    try {
+      const bulkOps = operations.map((op) => ({
+        updateOne: {
+          filter: { callId: op.callId },
+          update: {
+            $set: {
+              ...op.updateData,
+              lastHeartbeat: new Date(),
+            },
+            $push: {
+              callHistory: {
+                timestamp: new Date(),
+                action: op.action || "bulk_update",
+                agentId: op.agentId,
+                details: op.details || "Bulk operation",
+              },
+            },
+          },
+        },
+      }));
+
+      return await Call.bulkWrite(bulkOps);
+    } catch (error) {
+      console.error("Failed to perform bulk update:", error);
+      throw error;
+    }
+  }
+
+  // Hold queue with priority
+  async getHoldQueue(options = {}) {
+    try {
+      const pipeline = [
+        { $match: { status: "hold", isOnHold: true } },
+        {
+          $addFields: {
+            waitingTime: {
+              $divide: [{ $subtract: [new Date(), "$createdAt"] }, 1000 * 60],
+            },
+            priorityScore: {
+              $add: ["$priority", { $multiply: ["$waitingTime", 0.1] }],
+            },
+          },
+        },
+        { $sort: { priorityScore: -1, createdAt: 1 } },
+      ];
+
+      if (options.limit) pipeline.push({ $limit: options.limit });
+
+      return await Call.aggregate(pipeline);
+    } catch (error) {
+      console.error("Failed to get hold queue:", error);
+      throw error;
+    }
+  }
+
+  // Get available calls
+  async getAvailableCalls(options = {}) {
+    try {
+      return await Call.find({
+        status: { $in: ["pending", "hold"] },
+        agentId: null,
+      })
+        .sort({ priority: -1, createdAt: 1 })
+        .limit(options.limit || 20)
+        .lean(options.lean !== false);
+    } catch (error) {
+      console.error("Failed to get available calls:", error);
+      throw error;
+    }
+  }
+
+  // Advanced stats
+  async getAdvancedStatistics(timeframe = "today", groupBy = null) {
+    try {
+      const dateFilter = this._buildDateFilter(timeframe);
+
+      const pipeline = [
+        { $match: dateFilter },
+        {
+          $group: {
+            _id: groupBy ? `$${groupBy}` : null,
+            totalCalls: { $sum: 1 },
+            activeCalls: {
+              $sum: { $cond: [{ $in: ["$status", ["active", "hold"]] }, 1, 0] },
+            },
+            completedCalls: {
+              $sum: { $cond: [{ $eq: ["$status", "ended"] }, 1, 0] },
+            },
+            abandonedCalls: {
+              $sum: { $cond: [{ $eq: ["$status", "abandoned"] }, 1, 0] },
+            },
+            averageDuration: { $avg: { $ifNull: ["$duration", 0] } },
+            totalDuration: { $sum: { $ifNull: ["$duration", 0] } },
+            averageWaitTime: {
+              $avg: {
+                $divide: [
+                  { $subtract: ["$startTime", "$createdAt"] },
+                  1000 * 60,
+                ],
+              },
+            },
+          },
+        },
+        {
+          $addFields: {
+            answerRate: {
+              $cond: [
+                { $gt: ["$totalCalls", 0] },
+                { $divide: ["$completedCalls", "$totalCalls"] },
+                0,
+              ],
+            },
+            abandonRate: {
+              $cond: [
+                { $gt: ["$totalCalls", 0] },
+                { $divide: ["$abandonedCalls", "$totalCalls"] },
+                0,
+              ],
+            },
+          },
+        },
+      ];
+
+      const result = await Call.aggregate(pipeline);
+      return result[0] || this._getEmptyStats();
+    } catch (error) {
+      console.error("Failed to get advanced statistics:", error);
+      throw error;
+    }
+  }
+
+  // Cleanup stale connections
+  async cleanupStaleConnections(timeoutMinutes = 5) {
+    try {
+      const cutoffTime = new Date(Date.now() - timeoutMinutes * 60 * 1000);
+
+      const staleCalls = await Call.find({
+        status: { $in: ["active", "hold", "pending"] },
+        lastHeartbeat: { $lt: cutoffTime },
+      });
+
+      const results = [];
+
+      for (const call of staleCalls) {
+        if (call.agentId) {
+          await this.moveCallToHoldQueue(call.callId, "Connection timeout");
+          results.push({ callId: call.callId, action: "moved_to_hold" });
+        } else {
+          await this.endCall(call.callId);
+          results.push({ callId: call.callId, action: "ended" });
+        }
+      }
+
+      console.log(`Cleaned up ${results.length} stale connections`);
+      return results;
+    } catch (error) {
+      console.error("Failed to cleanup stale connections:", error);
+      throw error;
+    }
+  }
+
+  _buildDateFilter(timeframe) {
+    const now = new Date();
+    switch (timeframe) {
+      case "today":
+        const today = new Date(now);
+        today.setHours(0, 0, 0, 0);
+        return { createdAt: { $gte: today } };
+      case "week":
+        const weekAgo = new Date(now);
+        weekAgo.setDate(weekAgo.getDate() - 7);
+        return { createdAt: { $gte: weekAgo } };
+      case "month":
+        const monthAgo = new Date(now);
+        monthAgo.setMonth(monthAgo.getMonth() - 1);
+        return { createdAt: { $gte: monthAgo } };
+      default:
+        return {};
+    }
+  }
+
+  _buildCallStatsPipeline() {
+    return [
+      {
+        $group: {
+          _id: "$status",
+          count: { $sum: 1 },
+          avgDuration: { $avg: "$duration" },
+        },
+      },
+    ];
+  }
+
+  _buildHoldQueuePipeline() {
+    return [
+      { $match: { status: "hold", isOnHold: true } },
+      { $sort: { priority: -1, createdAt: 1 } },
+    ];
+  }
+
+  _getEmptyStats() {
+    return {
+      totalCalls: 0,
+      activeCalls: 0,
+      completedCalls: 0,
+      abandonedCalls: 0,
+      averageDuration: 0,
+      totalDuration: 0,
+      averageWaitTime: 0,
+      answerRate: 0,
+      abandonRate: 0,
+    };
+  }
+
+  async _updateCallMetrics(action) {
+    try {
+      console.log(`Updating metrics for action: ${action}`);
+    } catch (error) {
+      console.error("Failed to update metrics:", error);
+    }
+  }
+
+  async moveCallToHoldQueue(callId, reason = "Agent disconnected") {
+    try {
+      const call = await Call.findOne({ callId });
+      if (!call) throw new Error(`Call ${callId} not found`);
+
+      const previousAgentId = call.agentId;
+
+      call.agentId = null;
+      call.status = "hold";
+      call.isOnHold = true;
+      call.autoAccepted = true;
+      call.isHoldConnection = true;
+      call.priority = Math.min(call.priority + 1, 10);
+      call.addToHistory("disconnected", previousAgentId, reason);
+      call.updateHeartbeat();
+
+      await call.save();
+      console.log(`Call ${callId} moved back to hold queue due to: ${reason}`);
+      return call;
+    } catch (error) {
+      console.error(`Failed to move call ${callId} to hold queue:`, error);
+      throw error;
+    }
+  }
+
+  async endCall(callId, agentId = null) {
+    try {
+      const call = await Call.findOne({ callId });
+      if (!call) throw new Error(`Call ${callId} not found`);
+
+      call.status = "ended";
+      call.endTime = new Date();
+      call.duration = call.currentDuration;
+      call.addToHistory("ended", agentId, "Call ended");
+
+      await call.save();
+      return call;
+    } catch (error) {
+      console.error(`Failed to end call ${callId}:`, error);
+      throw error;
+    }
+  }
+}
+
+module.exports = new CallRepository();

package/common/repositories/index.js

@@ -15,6 +15,7 @@ const notificationSettingsRepository = require("./notificationSettings.repositor
 const customerProfileRepository = require("./customerProfile.repository");
 const customerTimelineRepository = require("./customerTimeline.repository");
 const shopRepository = require("./shop.repository");
+const callRepository = require("./call.repository");
 
 exports.module = {
   workspaceRepository,
@@ -34,4 +35,5 @@ exports.module = {
   customerProfileRepository,
   customerTimelineRepository,
   shopRepository,
+  callRepository,
 };

package/config/socket.js

@@ -4,27 +4,46 @@ require("dotenv").config();
 
 let io;
 const namespaceSockets = {}; // Store different namespace sockets
+const namespaceHandlers = {}; // Store custom handlers for each namespace
+
+/**
+ * Register custom event handlers for a specific namespace
+ * @param {string} namespace - Namespace name
+ * @param {Function} handlerFunction - Function that sets up socket event handlers
+ */
+const registerNamespaceHandlers = (namespace, handlerFunction) => {
+  namespaceHandlers[namespace] = handlerFunction;
+  console.log(`📋 Registered custom handlers for namespace: /${namespace}`);
+};
 
 /**
  * Initialize Socket.IO server with namespaces
  * @param {http.Server} server - HTTP server instance
  * @param {string} namespaceParam - Socket namespace name (default: "conversation")
  * @param {string} redisChannel - Redis channel for this namespace (default: "socket_events")
+ * @param {Object} options - Additional options for namespace configuration
+ * @param {Function} options.customHandlers - Custom socket event handlers for this namespace
+ * @param {boolean} options.requireWorkspaceId - Whether workspace ID is required (default: true)
  * @returns {SocketIO.Namespace} - The initialized namespace
  */
 const initializeSocket = async (
   server,
   namespaceParam = "conversation",
-  redisChannel = "socket_events"
+  redisChannel = "socket_events",
+  options = {}
 ) => {
+  const {
+    customHandlers,
+    requireWorkspaceId = true,
+    cors = {
+      origin: "*",
+      methods: ["GET", "POST"],
+    },
+  } = options;
+
   // Initialize Socket.IO server if not already done
   if (!io) {
-    io = new Server(server, {
-      cors: {
-        origin: "*",
-        methods: ["GET", "POST"],
-      },
-    });
+    io = new Server(server, { cors });
     console.log("✅ Socket.IO server initialized");
   }
 
@@ -49,21 +68,36 @@ const initializeSocket = async (
   await subscriber.subscribe(nsRedisChannel, (messageStr) => {
     try {
       const message = JSON.parse(messageStr);
-      const { workspaceId, event, data } = message;
+      const { workspaceId, event, data, target } = message;
 
       console.log(`📥 Redis message received on ${nsRedisChannel}:`, {
         workspaceId,
         event,
+        target,
       });
 
-      // Emit to specific workspace room in this namespace
-      if (workspaceId) {
+      // Handle different targeting options
+      if (target === "broadcast") {
+        // Broadcast to all clients in this namespace
+        namespace.emit(event, data);
+        console.log(
+          `📢 Event ${event} broadcasted to all clients in /${namespaceParam}`
+        );
+      } else if (target && target.startsWith("socket:")) {
+        // Target specific socket ID
+        const socketId = target.replace("socket:", "");
+        namespace.to(socketId).emit(event, data);
+        console.log(
+          `📢 Event ${event} emitted to socket ${socketId} in /${namespaceParam}`
+        );
+      } else if (workspaceId) {
+        // Emit to specific workspace room in this namespace
         namespace.to(workspaceId).emit(event, data);
         console.log(
           `📢 Event ${event} emitted to workspace ${workspaceId} in /${namespaceParam}`
         );
       } else {
-        // Broadcast to all clients in this namespace if no workspaceId specified
+        // Default: broadcast to all clients in this namespace
         namespace.emit(event, data);
         console.log(
           `📢 Event ${event} broadcasted to all clients in /${namespaceParam}`
@@ -79,20 +113,44 @@ const initializeSocket = async (
 
   // Handle new socket connections to this namespace
   namespace.on("connection", (socket) => {
-    const { workspaceId } = socket.handshake.query;
+    const { workspaceId, callId, agentId } = socket.handshake.query;
 
-    if (!workspaceId) {
-      console.warn(`⚠️ Connection rejected: No workspaceId provided`);
+    // Workspace ID validation (can be disabled for certain namespaces)
+    if (requireWorkspaceId && !workspaceId) {
+      console.warn(
+        `⚠️ Connection rejected: No workspaceId provided for namespace /${namespaceParam}`
+      );
       socket.disconnect(true);
       return;
     }
 
     console.log(
-      `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
+      `✅ Client connected: ${socket.id} (Workspace: ${
+        workspaceId || "N/A"
+      }, CallId: ${callId || "N/A"}) in /${namespaceParam}`
     );
 
-    // Join workspace room
-    socket.join(workspaceId);
+    // Join workspace room if workspaceId is provided
+    if (workspaceId) {
+      socket.join(workspaceId);
+    }
+
+    // Join additional rooms based on query parameters
+    if (callId) {
+      socket.join(`call:${callId}`);
+    }
+    if (agentId) {
+      socket.join(`agent:${agentId}`);
+    }
+
+    // Store socket metadata
+    socket.metadata = {
+      workspaceId,
+      callId,
+      agentId,
+      namespace: namespaceParam,
+      connectedAt: new Date(),
+    };
 
     // Send connection confirmation to client
     socket.emit("connected", {
@@ -100,25 +158,70 @@ const initializeSocket = async (
       socketId: socket.id,
       namespace: namespaceParam,
       workspaceId,
+      callId,
+      agentId,
     });
 
-    // Handle custom events from clients
-    socket.on("client_event", (data) => {
-      console.log(`📥 Client event from ${socket.id}:`, data);
-      // You can process client events here
-    });
+    // Apply custom handlers if provided
+    if (customHandlers && typeof customHandlers === "function") {
+      try {
+        customHandlers(socket, namespace);
+        console.log(
+          `📋 Applied custom handlers for socket ${socket.id} in /${namespaceParam}`
+        );
+      } catch (error) {
+        console.error(
+          `❌ Error applying custom handlers for socket ${socket.id}:`,
+          error
+        );
+      }
+    }
+
+    // Apply registered namespace handlers
+    if (namespaceHandlers[namespaceParam]) {
+      try {
+        namespaceHandlers[namespaceParam](socket, namespace);
+        console.log(
+          `📋 Applied registered handlers for socket ${socket.id} in /${namespaceParam}`
+        );
+      } catch (error) {
+        console.error(
+          `❌ Error applying registered handlers for socket ${socket.id}:`,
+          error
+        );
+      }
+    }
+
+    // Default event handlers for backward compatibility
+    setupDefaultHandlers(socket, namespace, namespaceParam);
 
     // Handle disconnect
     socket.on("disconnect", (reason) => {
       console.log(
-        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId}, Reason: ${reason})`
+        `❌ Client disconnected: ${socket.id} (Workspace: ${
+          workspaceId || "N/A"
+        }, Reason: ${reason}) from /${namespaceParam}`
       );
-      socket.leave(workspaceId);
+
+      // Leave all rooms
+      if (workspaceId) socket.leave(workspaceId);
+      if (callId) socket.leave(`call:${callId}`);
+      if (agentId) socket.leave(`agent:${agentId}`);
+
+      // Emit disconnect event to namespace for cleanup
+      namespace.emit("client_disconnected", {
+        socketId: socket.id,
+        metadata: socket.metadata,
+        reason,
+      });
     });
 
     // Handle errors
     socket.on("error", (error) => {
-      console.error(`❌ Socket error for ${socket.id}:`, error);
+      console.error(
+        `❌ Socket error for ${socket.id} in /${namespaceParam}:`,
+        error
+      );
     });
   });
 
@@ -128,15 +231,64 @@ const initializeSocket = async (
   return namespace;
 };
 
+/**
+ * Setup default event handlers for backward compatibility
+ * @param {Socket} socket - Socket.IO socket instance
+ * @param {Namespace} namespace - Socket.IO namespace instance
+ * @param {string} namespaceParam - Namespace name
+ */
+const setupDefaultHandlers = (socket, namespace, namespaceParam) => {
+  // Handle custom events from clients (backward compatibility)
+  socket.on("client_event", (data) => {
+    console.log(
+      `📥 Client event from ${socket.id} in /${namespaceParam}:`,
+      data
+    );
+
+    // Emit to Redis for other instances to handle
+    sendEventToServer({
+      workspaceId: socket.metadata.workspaceId,
+      event: "client_event_received",
+      data: {
+        socketId: socket.id,
+        originalData: data,
+        metadata: socket.metadata,
+      },
+      namespace: namespaceParam,
+    }).catch((err) => {
+      console.error(`❌ Error publishing client_event to Redis:`, err);
+    });
+  });
+
+  // Handle room join requests
+  socket.on("join_room", (roomName) => {
+    if (roomName && typeof roomName === "string") {
+      socket.join(roomName);
+      socket.emit("room_joined", { room: roomName, success: true });
+      console.log(`📥 Socket ${socket.id} joined room: ${roomName}`);
+    }
+  });
+
+  // Handle room leave requests
+  socket.on("leave_room", (roomName) => {
+    if (roomName && typeof roomName === "string") {
+      socket.leave(roomName);
+      socket.emit("room_left", { room: roomName, success: true });
+      console.log(`📤 Socket ${socket.id} left room: ${roomName}`);
+    }
+  });
+};
+
 /**
  * Send event to clients via Redis pub/sub
  * @param {object} params - Event parameters
- * @param {string} params.workspaceId - Target workspace ID
+ * @param {string} [params.workspaceId] - Target workspace ID
  * @param {string} params.event - Event name
  * @param {any} params.data - Event data payload
  * @param {string} [params.namespace="conversation"] - Target namespace
  * @param {string} [params.redisChannel="socket_events"] - Base Redis channel
- * @returns {Promise<void>}
+ * @param {string} [params.target] - Specific target (broadcast, socket:socketId, etc.)
+ * @returns {Promise<boolean>}
  */
 const sendEventToServer = async ({
   workspaceId,
@@ -144,6 +296,7 @@ const sendEventToServer = async ({
   data,
   namespace = "conversation",
   redisChannel = "socket_events",
+  target,
 }) => {
   try {
     // Create namespace-specific Redis channel
@@ -153,13 +306,21 @@ const sendEventToServer = async ({
     await connectRedis();
 
     // Create message payload
-    const message = JSON.stringify({ workspaceId, event, data });
+    const message = JSON.stringify({
+      workspaceId,
+      event,
+      data,
+      target,
+      timestamp: new Date().toISOString(),
+    });
 
     // Publish to Redis
     await publisher.publish(nsRedisChannel, message);
 
     console.log(
-      `📢 Event published to Redis channel ${nsRedisChannel}: ${event} (Workspace: ${workspaceId})`
+      `📢 Event published to Redis channel ${nsRedisChannel}: ${event} (Workspace: ${
+        workspaceId || "N/A"
+      }, Target: ${target || "default"})`
     );
 
     return true;
@@ -169,4 +330,62 @@ const sendEventToServer = async ({
   }
 };
 
-module.exports = { initializeSocket, sendEventToServer };
+/**
+ * Get a specific namespace instance
+ * @param {string} namespace - Namespace name
+ * @returns {SocketIO.Namespace|null} - Namespace instance or null if not found
+ */
+const getNamespace = (namespace) => {
+  return namespaceSockets[namespace] || null;
+};
+
+/**
+ * Get all active namespaces
+ * @returns {Object} - Object containing all active namespaces
+ */
+const getAllNamespaces = () => {
+  return { ...namespaceSockets };
+};
+
+/**
+ * Get Socket.IO server instance
+ * @returns {SocketIO.Server|null} - Server instance or null if not initialized
+ */
+const getSocketServer = () => {
+  return io || null;
+};
+
+/**
+ * Emit event to specific room in a namespace
+ * @param {string} namespace - Namespace name
+ * @param {string} room - Room name
+ * @param {string} event - Event name
+ * @param {any} data - Event data
+ * @returns {boolean} - Success status
+ */
+const emitToRoom = (namespace, room, event, data) => {
+  try {
+    const ns = namespaceSockets[namespace];
+    if (!ns) {
+      console.warn(`❌ Namespace /${namespace} not found`);
+      return false;
+    }
+
+    ns.to(room).emit(event, data);
+    console.log(`📢 Event ${event} emitted to room ${room} in /${namespace}`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Error emitting to room ${room} in /${namespace}:`, error);
+    return false;
+  }
+};
+
+module.exports = {
+  initializeSocket,
+  sendEventToServer,
+  registerNamespaceHandlers,
+  getNamespace,
+  getAllNamespaces,
+  getSocketServer,
+  emitToRoom,
+};

package/models/Attribute.js

@@ -10,11 +10,6 @@ const AttributeSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     oldId: { type: String, default: "" },
     createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
     updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },

package/models/Automation.js

@@ -61,9 +61,6 @@ const AutomationAction = new Schema({
   deleteComment: {
     enabled: { type: Boolean, default: false },
   },
-  hideComment: {
-    enabled: { type: Boolean, default: false },
-  },
   closeChat: {
     enabled: { type: Boolean, default: false },
   },
@@ -99,11 +96,6 @@ const AutomationAction = new Schema({
       default: null,
     },
     members: [userJoin],
-    templateFormId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "FormTemplate",
-      default: null,
-    },
   },
   escalation: {
     enabled: { type: Boolean, default: false },
@@ -168,7 +160,6 @@ const AutomationCondition = new Schema({
         "post",
         "shift",
         "newCommentPost",
-        "profile",
       ],
     },
     keyValue: {
@@ -192,7 +183,6 @@ const AutomationCondition = new Schema({
         "orderConfirmation",
         "orderPublish",
         "newCommentPost",
-        "profile",
       ],
     },
     subKeyValue: {

package/models/Call.js

@@ -0,0 +1,188 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const callSchema = new mongoose.Schema(
+  {
+    callId: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+    },
+    callerName: {
+      type: String,
+      required: true,
+    },
+    callerNumber: {
+      type: String,
+      required: true,
+      index: true,
+    },
+    status: {
+      type: String,
+      enum: ["pending", "hold", "active", "ended", "disconnected"],
+      default: "pending",
+      index: true,
+    },
+    queuePosition: {
+      type: Number,
+      default: 0,
+    },
+    isOnHold: {
+      type: Boolean,
+      default: false,
+      index: true,
+    },
+    autoAccepted: {
+      type: Boolean,
+      default: false,
+    },
+    isHoldConnection: {
+      type: Boolean,
+      default: false,
+    },
+    agentId: {
+      type: String,
+      default: null,
+      index: true,
+    },
+    startTime: {
+      type: Date,
+      default: null,
+    },
+    endTime: {
+      type: Date,
+      default: null,
+    },
+    duration: {
+      type: Number, // in seconds
+      default: 0,
+    },
+    whatsappSdp: {
+      type: String,
+      default: null,
+    },
+    browserSdp: {
+      type: String,
+      default: null,
+    },
+    connectionMetadata: {
+      browserConnectionState: {
+        type: String,
+        default: "new",
+      },
+      whatsappConnectionState: {
+        type: String,
+        default: "new",
+      },
+      lastHeartbeat: {
+        type: Date,
+        default: Date.now,
+      },
+    },
+    type: { type: String, default: "inbound" },
+    callHistory: [
+      {
+        action: {
+          type: String,
+          enum: [
+            "created",
+            "answered",
+            "held",
+            "unheld",
+            "transferred",
+            "ended",
+            "disconnected",
+            "reconnected",
+          ],
+        },
+        timestamp: {
+          type: Date,
+          default: Date.now,
+        },
+        agentId: String,
+        details: String,
+      },
+    ],
+    platformId: {
+      type: Schema.Types.ObjectId,
+      ref: "Integration",
+      default: null,
+    },
+    workspaceId: { type: Schema.Types.ObjectId, ref: "Workspace" },
+    profileId: { type: Schema.Types.ObjectId, ref: "Profile" },
+  },
+  {
+    timestamps: true,
+    collection: "calls",
+  }
+);
+
+// Indexes for performance
+callSchema.index({ status: 1, createdAt: 1 });
+callSchema.index({ agentId: 1, status: 1 });
+callSchema.index({ callerNumber: 1, createdAt: -1 });
+callSchema.index({ isOnHold: 1, status: 1 });
+
+// Virtual for call duration calculation
+callSchema.virtual("currentDuration").get(function () {
+  if (this.startTime) {
+    const endTime = this.endTime || new Date();
+    return Math.floor((endTime - this.startTime) / 1000);
+  }
+  return 0;
+});
+
+// Methods
+callSchema.methods.addToHistory = function (
+  action,
+  agentId = null,
+  details = null
+) {
+  this.callHistory.push({
+    action,
+    agentId,
+    details,
+    timestamp: new Date(),
+  });
+};
+
+callSchema.methods.updateHeartbeat = function () {
+  this.connectionMetadata.lastHeartbeat = new Date();
+};
+
+callSchema.methods.isStale = function (timeoutMinutes = 5) {
+  const timeout = timeoutMinutes * 60 * 1000; // Convert to milliseconds
+  return new Date() - this.connectionMetadata.lastHeartbeat > timeout;
+};
+
+// Static methods
+callSchema.statics.getActiveCallsForAgent = function (agentId) {
+  return this.find({
+    agentId,
+    status: { $in: ["active", "hold"] },
+  }).sort({ createdAt: 1 });
+};
+
+callSchema.statics.getHoldQueue = function () {
+  return this.find({
+    status: "hold",
+    agentId: null,
+  }).sort({ createdAt: 1 });
+};
+
+callSchema.statics.getPendingCalls = function () {
+  return this.find({
+    status: "pending",
+  }).sort({ createdAt: 1 });
+};
+
+callSchema.statics.getStaleConnections = function (timeoutMinutes = 5) {
+  const timeout = new Date(Date.now() - timeoutMinutes * 60 * 1000);
+  return this.find({
+    status: { $in: ["active", "hold", "pending"] },
+    "connectionMetadata.lastHeartbeat": { $lt: timeout },
+  });
+};
+
+module.exports = mongoose.model("Call", callSchema);

package/models/Card.js

@@ -156,11 +156,6 @@ const cardSchema = new mongoose.Schema(
       type: mongoose.Schema.Types.Mixed,
       default: {},
     },
-    templateFormId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "FormTemplate",
-      default: null,
-    },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

package/models/Category.js

@@ -11,11 +11,6 @@ const CategorySchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     oldId: { type: String, default: "" },
     webCategoryId: { type: Number, default: null },
     parentId: { type: Schema.Types.ObjectId, ref: "Category", default: null },

package/models/Checkpoint.js

@@ -14,11 +14,6 @@ const CheckpointSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

package/models/Customer.js

@@ -18,11 +18,6 @@ const CustomerSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     isBlackListed: { type: Boolean, default: false },
     createdBy: {
       type: Schema.Types.ObjectId,

package/models/Location.js

@@ -14,11 +14,6 @@ const LocationSchema = new Schema(
     oldId: { type: String, default: "" },
     webLocationId: { type: Number, default: null },
     bcLocationId: { type: String, default: "" },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     workspaceId: {
       type: Schema.Types.ObjectId,
       ref: "Workspace",

package/models/Order.js

@@ -103,11 +103,6 @@ const OrderSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     orderType: { type: String, default: "" },
     barCode: { type: String, default: "" },
     quantity: { type: Number, default: 0 },
@@ -228,7 +223,6 @@ const markOrUnMarkOrderAsDuplicate = async (doc) => {
       const phoneRegex = getPhoneRegex(doc?.customerPhone);
       let orders = await Order.find({
         workspaceId: doc?.workspaceId,
-        websiteId: doc?.websiteId,
         isDeleted: false,
         statusType: "pending",
         customerPhone: phoneRegex,

package/models/OrderPdf.js

@@ -20,11 +20,6 @@ const OrderPdfScehma = new mongoose.Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
     updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
   },

package/models/OrderProduct.js

@@ -31,11 +31,6 @@ const OrderProductSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

package/models/Product.js

@@ -31,11 +31,6 @@ const ProductSchema = new Schema(
       type: Schema.Types.ObjectId,
       ref: "Workspace",
       default: null,
-    },
-     websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
     },
     storeType: { type: String, default: "LOCAL" },
     isDeleted: { type: Boolean, default: false },

package/models/ProductAttachment.js

@@ -22,11 +22,6 @@ const ProductAttachmentSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     height: { type: Number, default: 0 },
     variantIds: [
       { type: Schema.Types.ObjectId, ref: "ProductVariant", default: null },

package/models/ProductAttribute.js

@@ -16,11 +16,6 @@ const ProductAttributeSchema = new mongoose.Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     isDeleted: { type: Boolean, default: false },
     position: { type: String, default: "1" },
   },

package/models/ProductCategory.js

@@ -11,11 +11,6 @@ const ProductCategorySchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
     updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
     isDeleted: { type: Boolean, default: false },

package/models/ProductTag.js

@@ -11,11 +11,6 @@ const ProductTagSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
     updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
     isDeleted: { type: Boolean, default: false },

package/models/ProductVariant.js

@@ -17,11 +17,6 @@ const ProductVariantSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     webVariantId: { type: Number, default: null },
     inventoryPolicy: { type: String, default: "deny" }, //deny,continue
     taxable: { type: Boolean, default: false },

package/models/Tag.js

@@ -8,11 +8,6 @@ const TagSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     oldId: { type: String, default: "" },
     webTagId: { type: Number, default: "" },
     createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },

package/models/VariantLocation.js

@@ -13,11 +13,6 @@ const VariantLocationSchema = new Schema(
       ref: "Workspace",
       default: null,
     },
-    websiteId: {
-      type: Schema.Types.ObjectId,
-      ref: "Website",
-      default: null,
-    },
     productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
     locationId: { type: Schema.Types.ObjectId, ref: "Location", default: null },
     webVariantLocationId: { type: Number, default: null },

package/models.js

@@ -104,6 +104,7 @@ const WhatsappFlow = require("./models/WhatsappFlow");
 const Workflow = require("./models/Workflow");
 const Workspace = require("./models/Workspace");
 const Shop = require("./models/Shop");
+const Call = require("./models/Call");
 
 module.exports = {
   Activity,
@@ -212,4 +213,5 @@ module.exports = {
   Workflow,
   Workspace,
   Shop,
+  Call,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shuttlepro-shared",
-  "version": "1.3.98",
+  "version": "1.4.02",
   "description": "",
   "main": "index.js",
   "scripts": {