shuttlepro-shared 1.4.2 → 1.4.4

package/common/repositories/customerProfile.repository.js

@@ -60,10 +60,41 @@ const deleteCustomerProfile = async (id) => {
 const deleteAllCustomerProfilesByWorkspace = async (workspaceId) => {
   await CustomerProfile.deleteMany({ workspaceId }).exec();
 };
+
 const findAllCustomerProfilesByFilterFromDb = async (filter = {}) => {
   const profiles = await CustomerProfile.find(filter).lean().exec();
   return profiles ?? [];
 };
+
+const searchCustomerProfilesByName = async (
+  { searchValue, workspaceId },
+  page = 1,
+  limit = 10
+) => {
+  const queryObj = {};
+
+  if (workspaceId) {
+    queryObj.workspaceId = workspaceId;
+  }
+
+  if (searchValue) {
+    queryObj.name = { $regex: searchValue, $options: "i" };
+  }
+
+  const skip = (page - 1) * limit;
+
+  const [profiles, total] = await Promise.all([
+    CustomerProfile.find(queryObj).skip(skip).limit(limit).lean().exec(),
+    CustomerProfile.countDocuments(queryObj),
+  ]);
+
+  return {
+    data: profiles,
+    page,
+    total,
+    totalPages: Math.ceil(total / limit),
+  };
+};
 module.exports = {
   createCustomerProfile,
   findCustomerProfilesByWorkspaceId,
@@ -75,4 +106,5 @@ module.exports = {
   deleteAllCustomerProfilesByWorkspace,
   findAllCustomerProfilesByFilter,
   findAllCustomerProfilesByFilterFromDb,
+  searchCustomerProfilesByName,
 };

package/common/repositories/index.js

@@ -15,8 +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");
-
+const interactiveRepository = require("./interactive.repository");
 exports.module = {
   workspaceRepository,
   integrationRepository,
@@ -35,5 +34,5 @@ exports.module = {
   customerProfileRepository,
   customerTimelineRepository,
   shopRepository,
-  callRepository,
+  interactiveRepository,
 };

package/common/repositories/interactive.repository.js

@@ -0,0 +1,124 @@
+// repositories/interactive.repository.js
+const Interactive = require("../../models/Interactive");
+const { getRedisData, setRedisData } = require("../../config/redis");
+
+const CACHE_KEY_ALL = "interactive_all";
+
+/**
+ * Get cached interactive for all workspaces.
+ */
+const getCachedAllInteractive = async () => {
+  let interactive = await getRedisData(CACHE_KEY_ALL);
+  if (!interactive) {
+    interactive = await Interactive.find({}).lean().exec();
+    await setRedisData(CACHE_KEY_ALL, interactive);
+  }
+  return interactive;
+};
+
+/**
+ * Update cached interactive for all workspaces.
+ */
+const updateCachedAllInteractive = async () => {
+  const interactive = await Interactive.find({}).lean().exec();
+  await setRedisData(CACHE_KEY_ALL, interactive);
+};
+
+/**
+ * Get interactive for a specific workspace from cache.
+ */
+const getWorkspaceInteractive = async (workspaceId) => {
+  if (!workspaceId) return [];
+  const allInteractive = await getCachedAllInteractive();
+  return allInteractive.filter(
+    (item) => item.workspaceId?.toString() === workspaceId.toString()
+  );
+};
+/**
+ * Get interactive by ID (cache first).
+ */
+const getInteractiveById = async (id) => {
+  if (!id) return null;
+
+  const allInteractive = await getCachedAllInteractive();
+  let interactive = allInteractive.find(
+    (item) => item._id?.toString() === id.toString()
+  );
+
+  // If not found in cache, fetch from DB and update cache
+  if (!interactive) {
+    interactive = await Interactive.findById(id).lean().exec();
+    if (interactive) {
+      await updateCachedAllInteractive();
+    }
+  }
+
+  return interactive || null;
+};
+
+/**
+ * Create new interactive and refresh cache.
+ */
+const createInteractive = async (data) => {
+  const newInteractive = await Interactive.create(data);
+  if (newInteractive) {
+    await updateCachedAllInteractive();
+  }
+  return newInteractive;
+};
+
+/**
+ * Update interactive by ID and refresh cache.
+ */
+const updateInteractiveById = async (id, data) => {
+  const updated = await Interactive.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+  if (updated) {
+    await updateCachedAllInteractive();
+  }
+  return updated;
+};
+
+/**
+ * Update interactive by filter and refresh cache.
+ */
+const updateSingleInteractiveByFilter = async (filter, data) => {
+  const updated = await Interactive.findOneAndUpdate(filter, data, {
+    new: true,
+  }).exec();
+  if (updated) {
+    await updateCachedAllInteractive();
+  }
+  return updated;
+};
+
+/**
+ * Delete interactive by ID and refresh cache.
+ */
+const deleteInteractiveById = async (id) => {
+  const deleted = await Interactive.findByIdAndDelete(id).exec();
+  if (deleted) {
+    await updateCachedAllInteractive();
+  }
+  return deleted;
+};
+
+/**
+ * Delete interactive by filter and refresh cache.
+ */
+const deleteInteractiveByFilter = async (filter) => {
+  await Interactive.deleteMany(filter).exec();
+  await updateCachedAllInteractive();
+};
+
+module.exports = {
+  updateCachedAllInteractive,
+  getWorkspaceInteractive,
+  createInteractive,
+  updateInteractiveById,
+  updateSingleInteractiveByFilter,
+  deleteInteractiveById,
+  deleteInteractiveByFilter,
+  getInteractiveById,
+};

package/config/socket.js

@@ -4,46 +4,27 @@ 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",
-  options = {}
+  redisChannel = "socket_events"
 ) => {
-  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 });
+    io = new Server(server, {
+      cors: {
+        origin: "*",
+        methods: ["GET", "POST"],
+      },
+    });
     console.log("✅ Socket.IO server initialized");
   }
 
@@ -68,36 +49,21 @@ const initializeSocket = async (
   await subscriber.subscribe(nsRedisChannel, (messageStr) => {
     try {
       const message = JSON.parse(messageStr);
-      const { workspaceId, event, data, target } = message;
+      const { workspaceId, event, data } = message;
 
       console.log(`📥 Redis message received on ${nsRedisChannel}:`, {
         workspaceId,
         event,
-        target,
       });
 
-      // 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
+      // Emit to specific workspace room in this namespace
+      if (workspaceId) {
         namespace.to(workspaceId).emit(event, data);
         console.log(
           `📢 Event ${event} emitted to workspace ${workspaceId} in /${namespaceParam}`
         );
       } else {
-        // Default: broadcast to all clients in this namespace
+        // Broadcast to all clients in this namespace if no workspaceId specified
         namespace.emit(event, data);
         console.log(
           `📢 Event ${event} broadcasted to all clients in /${namespaceParam}`
@@ -113,44 +79,20 @@ const initializeSocket = async (
 
   // Handle new socket connections to this namespace
   namespace.on("connection", (socket) => {
-    const { workspaceId, callId, agentId } = socket.handshake.query;
+    const { workspaceId } = socket.handshake.query;
 
-    // Workspace ID validation (can be disabled for certain namespaces)
-    if (requireWorkspaceId && !workspaceId) {
-      console.warn(
-        `⚠️ Connection rejected: No workspaceId provided for namespace /${namespaceParam}`
-      );
+    if (!workspaceId) {
+      console.warn(`⚠️ Connection rejected: No workspaceId provided`);
       socket.disconnect(true);
       return;
     }
 
     console.log(
-      `✅ Client connected: ${socket.id} (Workspace: ${
-        workspaceId || "N/A"
-      }, CallId: ${callId || "N/A"}) in /${namespaceParam}`
+      `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
     );
 
-    // 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(),
-    };
+    // Join workspace room
+    socket.join(workspaceId);
 
     // Send connection confirmation to client
     socket.emit("connected", {
@@ -158,70 +100,25 @@ const initializeSocket = async (
       socketId: socket.id,
       namespace: namespaceParam,
       workspaceId,
-      callId,
-      agentId,
     });
 
-    // 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 custom events from clients
+    socket.on("client_event", (data) => {
+      console.log(`📥 Client event from ${socket.id}:`, data);
+      // You can process client events here
+    });
 
     // Handle disconnect
     socket.on("disconnect", (reason) => {
       console.log(
-        `❌ Client disconnected: ${socket.id} (Workspace: ${
-          workspaceId || "N/A"
-        }, Reason: ${reason}) from /${namespaceParam}`
+        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId}, Reason: ${reason})`
       );
-
-      // 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,
-      });
+      socket.leave(workspaceId);
     });
 
     // Handle errors
     socket.on("error", (error) => {
-      console.error(
-        `❌ Socket error for ${socket.id} in /${namespaceParam}:`,
-        error
-      );
+      console.error(`❌ Socket error for ${socket.id}:`, error);
     });
   });
 
@@ -231,64 +128,15 @@ 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
- * @param {string} [params.target] - Specific target (broadcast, socket:socketId, etc.)
- * @returns {Promise<boolean>}
+ * @returns {Promise<void>}
  */
 const sendEventToServer = async ({
   workspaceId,
@@ -296,7 +144,6 @@ const sendEventToServer = async ({
   data,
   namespace = "conversation",
   redisChannel = "socket_events",
-  target,
 }) => {
   try {
     // Create namespace-specific Redis channel
@@ -306,21 +153,13 @@ const sendEventToServer = async ({
     await connectRedis();
 
     // Create message payload
-    const message = JSON.stringify({
-      workspaceId,
-      event,
-      data,
-      target,
-      timestamp: new Date().toISOString(),
-    });
+    const message = JSON.stringify({ workspaceId, event, data });
 
     // Publish to Redis
     await publisher.publish(nsRedisChannel, message);
 
     console.log(
-      `📢 Event published to Redis channel ${nsRedisChannel}: ${event} (Workspace: ${
-        workspaceId || "N/A"
-      }, Target: ${target || "default"})`
+      `📢 Event published to Redis channel ${nsRedisChannel}: ${event} (Workspace: ${workspaceId})`
     );
 
     return true;
@@ -330,62 +169,4 @@ const sendEventToServer = async ({
   }
 };
 
-/**
- * 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,
-};
+module.exports = { initializeSocket, sendEventToServer };

package/models/Attribute.js

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

package/models/Card.js

@@ -156,6 +156,11 @@ 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,6 +11,11 @@ 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/Chatbot.js

@@ -30,6 +30,7 @@ const ChatbotSchema = new Schema(
     },
     events: [
       {
+        type: { type: String, default: "" },
         value: { type: String, default: "" },
       },
     ],

package/models/Checkpoint.js

@@ -14,6 +14,11 @@ 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,6 +18,11 @@ 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,