shuttlepro-shared 1.3.94 → 1.3.96

package/common/repositories/call.repository.js

@@ -0,0 +1,540 @@
+const Call = require("../../models/Call");
+const mongoose = require("mongoose");
+
+class CallRepository {
+  constructor() {
+    this.pipelines = {
+      callStats: this._buildCallStatsPipeline(),
+      holdQueue: this._buildHoldQueuePipeline(),
+    };
+  }
+
+  // Create a new call with transaction support
+  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;
+      });
+    } catch (error) {
+      console.error(`Failed to create call ${callData.callId}:`, error);
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  // Get call by ID
+  async getCall(callId, options = {}) {
+    try {
+      const query = Call.findOne({ callId });
+
+      if (options.lean) query.lean();
+
+      // Auto-populate unless explicitly disabled
+      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 with advanced filtering
+  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 && 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 with optimistic locking
+  async updateCall(callId, updateData, 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`);
+
+        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({ session });
+
+        return call;
+      });
+    } catch (error) {
+      console.error(`Failed to update call ${callId}:`, error);
+      throw error;
+    } finally {
+      if (shouldCommitSession) await session.endSession();
+    }
+  }
+
+  // Assign call to agent
+  async assignCallToAgent(callId, agentId, options = {}) {
+    const session = await mongoose.startSession();
+
+    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;
+      });
+    } catch (error) {
+      console.error(
+        `Failed to assign call ${callId} to agent ${agentId}:`,
+        error
+      );
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  // Bulk operations for call management
+  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",
+                },
+              },
+            },
+          },
+        }));
+
+        return await Call.bulkWrite(bulkOps, { session });
+      });
+    } catch (error) {
+      console.error("Failed to perform bulk update:", error);
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  // 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) {
+    const session = await mongoose.startSession();
+
+    try {
+      return await session.withTransaction(async () => {
+        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 results = [];
+
+        for (const call of staleCalls) {
+          if (call.agentId) {
+            await this.moveCallToHoldQueue(call.callId, "Connection timeout", {
+              session,
+            });
+            results.push({ callId: call.callId, action: "moved_to_hold" });
+          } else {
+            await this.endCall(call.callId, null, { session });
+            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;
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  // Helper methods
+  _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, session = null) {
+    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

@@ -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/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 },

package/models/Call.js

@@ -0,0 +1,187 @@
+const mongoose = require("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/Chatbot.js

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

package/models.js

@@ -43,7 +43,6 @@ 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");
@@ -105,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,
@@ -152,7 +152,6 @@ module.exports = {
   GoogleClientInfo,
   GoogleCredentials,
   Integration,
-  Interactive,
   InternalComments,
   InternalThreads,
   JobDesign,
@@ -214,4 +213,5 @@ module.exports = {
   Workflow,
   Workspace,
   Shop,
+  Call,
 };

package/package.json

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

package/common/repositories/interactive.repository.js

@@ -1,124 +0,0 @@
-// 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/Interactive.js

@@ -1,70 +0,0 @@
-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);