shuttlepro-shared 1.4.1 → 1.4.3

package/common/repositories/call.repository.js

@@ -1,5 +1,4 @@
 const Call = require("../../models/Call");
-const mongoose = require("mongoose");
 
 class CallRepository {
   constructor() {
@@ -9,39 +8,39 @@ class CallRepository {
     };
   }
 
-  // Create a new call with transaction support
+  // Create a new call
   async createCall(callData) {
-    const session = await mongoose.startSession();
-
     try {
-      return await session.withTransaction(async () => {
-        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({ session });
-
-        await this._updateCallMetrics("created", session);
-
-        return call;
+      const historyEntry = {
+        timestamp: new Date(),
+        action: "created",
+        agentId: null,
+        details: "Call created in system",
+      };
+
+      const call = await Call.create({
+        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,
+        platformTimestamp: callData.platformTimestamp || "",
+        receiver: callData.receiver || "",
+        callHistory: [historyEntry],
       });
+
+      await this._updateCallMetrics("created");
+      return call;
     } catch (error) {
       console.error(`Failed to create call ${callData.callId}:`, error);
-      throw error;
-    } finally {
-      await session.endSession();
+      return null;
     }
   }
 
@@ -52,7 +51,6 @@ class CallRepository {
 
       if (options.lean) query.lean();
 
-      // Auto-populate unless explicitly disabled
       if (options.populate !== false) {
         query.populate([
           { path: "platformId", model: "Integration" },
@@ -68,11 +66,11 @@ class CallRepository {
       return await query.exec();
     } catch (error) {
       console.error(`Failed to get call ${callId}:`, error);
-      throw error;
+      return null;
     }
   }
 
-  // Bulk get calls with advanced filtering
+  // Bulk get calls
   async getCalls(filters = {}, options = {}) {
     try {
       const {
@@ -90,7 +88,6 @@ class CallRepository {
       } = filters;
 
       const query = {};
-
       if (status)
         query.status = Array.isArray(status) ? { $in: status } : status;
       if (agentId) query.agentId = agentId;
@@ -106,7 +103,7 @@ class CallRepository {
       }
 
       if (priority !== undefined) query.priority = { $gte: priority };
-      if (tags && tags.length > 0) query.tags = { $in: tags };
+      if (tags?.length > 0) query.tags = { $in: tags };
 
       const skip = (page - 1) * limit;
 
@@ -140,132 +137,127 @@ class CallRepository {
       };
     } catch (error) {
       console.error("Failed to get calls:", error);
-      throw error;
+      return {
+        calls: [],
+        pagination: { page: 1, limit: 50, total: 0, pages: 0 },
+      };
     }
   }
 
-  // Update call with optimistic locking
-  async updateCall(callId, updateData, options = {}) {
-    const session = options.session || (await mongoose.startSession());
-    const shouldCommitSession = !options.session;
-
+  // Update call
+  async updateCall(callId, updateData) {
     try {
-      return await session.withTransaction(async () => {
-        const call = await Call.findOne({ callId }).session(session);
-        if (!call) throw new Error(`Call ${callId} not found`);
+      const allowedFields = [
+        "status",
+        "agentId",
+        "callerName",
+        "callerNumber",
+        "priority",
+        "tags",
+        "metadata",
+        "isOnHold",
+        "platformId",
+        "workspaceId",
+        "profileId",
+      ];
 
-        if (updateData.__v !== undefined && call.__v !== updateData.__v) {
-          throw new Error(`Concurrent update detected for call ${callId}`);
+      const filteredUpdate = {};
+      Object.keys(updateData).forEach((key) => {
+        if (allowedFields.includes(key)) {
+          filteredUpdate[key] = updateData[key];
         }
+      });
 
-        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}`
-          );
-        }
+      const updateOps = {
+        $set: {
+          ...filteredUpdate,
+          lastHeartbeat: new Date(),
+        },
+      };
 
-        call.updateHeartbeat();
-        await call.save({ session });
+      if (updateData.status) {
+        updateOps.$push = {
+          callHistory: {
+            timestamp: new Date(),
+            action: updateData.status,
+            agentId: updateData.agentId || null,
+            details:
+              updateData.reason || `Status changed to ${updateData.status}`,
+          },
+        };
+      }
 
-        return call;
+      const call = await Call.findOneAndUpdate({ callId }, updateOps, {
+        new: true,
       });
+      return call || null;
     } catch (error) {
       console.error(`Failed to update call ${callId}:`, error);
-      throw error;
-    } finally {
-      if (shouldCommitSession) await session.endSession();
+      return null;
     }
   }
 
   // Assign call to agent
-  async assignCallToAgent(callId, agentId, options = {}) {
-    const session = await mongoose.startSession();
-
+  async assignCallToAgent(callId, agentId) {
     try {
-      return await session.withTransaction(async () => {
-        const call = await Call.findOne({ callId }).session(session);
-        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({ session });
-        return call;
-      });
+      const call = await Call.findOneAndUpdate(
+        { callId, status: { $in: ["pending", "hold"] } },
+        {
+          $set: {
+            agentId,
+            status: "active",
+            startTime: new Date(),
+            isOnHold: false,
+            lastHeartbeat: new Date(),
+          },
+          $push: {
+            callHistory: {
+              timestamp: new Date(),
+              action: "answered",
+              agentId,
+              details: "Call answered by agent",
+            },
+          },
+        },
+        { new: true }
+      );
+      return call || null;
     } catch (error) {
       console.error(
         `Failed to assign call ${callId} to agent ${agentId}:`,
         error
       );
-      throw error;
-    } finally {
-      await session.endSession();
+      return null;
     }
   }
 
-  // Bulk operations for call management
+  // Bulk update calls
   async bulkUpdateCalls(operations) {
-    const session = await mongoose.startSession();
-
     try {
-      return await session.withTransaction(async () => {
-        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",
-                },
+      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, { session });
-      });
+      return await Call.bulkWrite(bulkOps);
     } catch (error) {
       console.error("Failed to perform bulk update:", error);
-      throw error;
-    } finally {
-      await session.endSession();
+      return [];
     }
   }
 
@@ -292,7 +284,7 @@ class CallRepository {
       return await Call.aggregate(pipeline);
     } catch (error) {
       console.error("Failed to get hold queue:", error);
-      throw error;
+      return [];
     }
   }
 
@@ -308,7 +300,7 @@ class CallRepository {
         .lean(options.lean !== false);
     } catch (error) {
       console.error("Failed to get available calls:", error);
-      throw error;
+      return [];
     }
   }
 
@@ -368,49 +360,110 @@ class CallRepository {
       return result[0] || this._getEmptyStats();
     } catch (error) {
       console.error("Failed to get advanced statistics:", error);
-      throw error;
+      return this._getEmptyStats();
     }
   }
 
   // Cleanup stale connections
   async cleanupStaleConnections(timeoutMinutes = 5) {
-    const session = await mongoose.startSession();
-
     try {
-      return await session.withTransaction(async () => {
-        const cutoffTime = new Date(Date.now() - timeoutMinutes * 60 * 1000);
+      const cutoffTime = new Date(Date.now() - timeoutMinutes * 60 * 1000);
 
-        const staleCalls = await Call.find({
-          status: { $in: ["active", "hold", "pending"] },
-          lastHeartbeat: { $lt: cutoffTime },
-        }).session(session);
+      const staleCalls = await Call.find({
+        status: { $in: ["active", "hold", "pending"] },
+        lastHeartbeat: { $lt: cutoffTime },
+      });
 
-        const results = [];
+      const results = [];
 
-        for (const call of staleCalls) {
-          if (call.agentId) {
-            await this.moveCallToHoldQueue(call.callId, "Connection timeout", {
-              session,
-            });
+      for (const call of staleCalls) {
+        if (call.agentId) {
+          const moved = await this.moveCallToHoldQueue(
+            call.callId,
+            "Connection timeout"
+          );
+          if (moved)
             results.push({ callId: call.callId, action: "moved_to_hold" });
-          } else {
-            await this.endCall(call.callId, null, { session });
-            results.push({ callId: call.callId, action: "ended" });
-          }
+        } else {
+          const ended = await this.endCall(call.callId);
+          if (ended) results.push({ callId: call.callId, action: "ended" });
         }
+      }
 
-        console.log(`Cleaned up ${results.length} stale connections`);
-        return results;
-      });
+      console.log(`Cleaned up ${results.length} stale connections`);
+      return results;
     } catch (error) {
       console.error("Failed to cleanup stale connections:", error);
-      throw error;
-    } finally {
-      await session.endSession();
+      return [];
+    }
+  }
+
+  async moveCallToHoldQueue(callId, reason = "Agent disconnected") {
+    try {
+      const call = await Call.findOneAndUpdate(
+        { callId },
+        {
+          $set: {
+            agentId: null,
+            status: "hold",
+            isOnHold: true,
+            autoAccepted: true,
+            isHoldConnection: true,
+            lastHeartbeat: new Date(),
+          },
+          $inc: { priority: 1 },
+          $push: {
+            callHistory: {
+              timestamp: new Date(),
+              action: "disconnected",
+              agentId: null,
+              details: reason,
+            },
+          },
+        },
+        { new: true }
+      );
+
+      if (call) {
+        console.log(
+          `Call ${callId} moved back to hold queue due to: ${reason}`
+        );
+      }
+      return call || null;
+    } catch (error) {
+      console.error(`Failed to move call ${callId} to hold queue:`, error);
+      return null;
+    }
+  }
+
+  async endCall(callId, agentId = null) {
+    try {
+      const call = await Call.findOneAndUpdate(
+        { callId },
+        {
+          $set: {
+            status: "ended",
+            endTime: new Date(),
+            lastHeartbeat: new Date(),
+          },
+          $push: {
+            callHistory: {
+              timestamp: new Date(),
+              action: "ended",
+              agentId,
+              details: "Call ended",
+            },
+          },
+        },
+        { new: true }
+      );
+      return call || null;
+    } catch (error) {
+      console.error(`Failed to end call ${callId}:`, error);
+      return null;
     }
   }
 
-  // Helper methods
   _buildDateFilter(timeframe) {
     const now = new Date();
     switch (timeframe) {
@@ -464,77 +517,13 @@ class CallRepository {
     };
   }
 
-  async _updateCallMetrics(action, session = null) {
+  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",
-    options = {}
-  ) {
-    const session = options.session || (await mongoose.startSession());
-    const shouldCommitSession = !options.session;
-
-    try {
-      return await session.withTransaction(async () => {
-        const call = await Call.findOne({ callId }).session(session);
-        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({ session });
-
-        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;
-    } finally {
-      if (shouldCommitSession) await session.endSession();
-    }
-  }
-
-  async endCall(callId, agentId = null, options = {}) {
-    const session = options.session || (await mongoose.startSession());
-    const shouldCommitSession = !options.session;
-
-    try {
-      return await session.withTransaction(async () => {
-        const call = await Call.findOne({ callId }).session(session);
-        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({ session });
-        return call;
-      });
-    } catch (error) {
-      console.error(`Failed to end call ${callId}:`, error);
-      throw error;
-    } finally {
-      if (shouldCommitSession) await session.endSession();
-    }
-  }
 }
 
 module.exports = new CallRepository();

package/common/repositories/index.js

@@ -16,6 +16,7 @@ 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,
@@ -36,4 +37,5 @@ exports.module = {
   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/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/Call.js

@@ -55,7 +55,7 @@ const callSchema = new mongoose.Schema(
       default: null,
     },
     duration: {
-      type: Number, // in seconds
+      type: Number,
       default: 0,
     },
     whatsappSdp: {
@@ -104,6 +104,14 @@ const callSchema = new mongoose.Schema(
         details: String,
       },
     ],
+    platformTimestamp: {
+      type: String,
+      default: "",
+    },
+    receiver: {
+      type: String,
+      default: "",
+    },
     platformId: {
       type: Schema.Types.ObjectId,
       ref: "Integration",

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/Chatbot.js

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

package/models/Interactive.js

@@ -0,0 +1,70 @@
+const { Schema, Types, model } = require("mongoose");
+
+const ActionSchema = new Schema({
+  type: {
+    type: String,
+    default: "",
+  },
+  interactiveId: { type: Types.ObjectId, ref: "Interactive", default: null },
+  value: { type: Schema.Types.Mixed, default: "" },
+});
+const InteractiveSchema = new Schema({
+  name: { type: String, default: "" },
+  workspace: { type: Types.ObjectId, ref: "Workspace", default: null },
+  type: {
+    type: String,
+    enum: ["button", "list"],
+    default: "list",
+  },
+  header: {
+    type: {
+      type: String,
+      enum: ["text", "image", "video"],
+      default: "text",
+    },
+    value: { type: String, default: "" },
+  },
+  body: {
+    type: {
+      type: String,
+      default: "text",
+    },
+    value: { type: String, default: "" },
+  },
+  footer: {
+    type: {
+      type: String,
+      default: "text",
+    },
+    value: { type: String, default: "" },
+  },
+  buttonTitle: {
+    type: String,
+    default: "Menu",
+  },
+  sections: [
+    {
+      title: { type: String, default: "" },
+      rows: [
+        {
+          id: { type: String, default: "" },
+          title: { type: String, default: "" },
+          description: { type: String, default: "" },
+          action: ActionSchema,
+        },
+      ],
+    },
+  ],
+  buttons: [
+    {
+      type: { type: String, default: "reply" },
+      reply: {
+        id: { type: String, default: "" },
+        title: { type: String, default: "" },
+        action: ActionSchema,
+      },
+    },
+  ],
+});
+
+module.exports = model("Interactive", InteractiveSchema);

package/models.js

@@ -43,6 +43,7 @@ const FormTemplate = require("./models/FormTemplate");
 const GoogleClientInfo = require("./models/GoogleClientInfo");
 const GoogleCredentials = require("./models/GoogleCredentials");
 const Integration = require("./models/Integration");
+const Interactive = require("./models/Interactive");
 const InternalComments = require("./models/InternalComments");
 const InternalThreads = require("./models/InternalThreads");
 const JobDesign = require("./models/JobDesign");
@@ -152,6 +153,7 @@ module.exports = {
   GoogleClientInfo,
   GoogleCredentials,
   Integration,
+  Interactive,
   InternalComments,
   InternalThreads,
   JobDesign,

package/package.json

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