shuttlepro-shared 1.3.97 → 1.3.98

package/common/repositories/index.js

@@ -15,7 +15,6 @@ 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,
@@ -35,5 +34,4 @@ exports.module = {
   customerProfileRepository,
   customerTimelineRepository,
   shopRepository,
-  callRepository,
 };

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

package/models/Location.js

@@ -14,6 +14,11 @@ 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,6 +103,11 @@ 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 },
@@ -223,6 +228,7 @@ 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,6 +20,11 @@ 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,6 +31,11 @@ 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,6 +31,11 @@ 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,6 +22,11 @@ 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,6 +16,11 @@ 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,6 +11,11 @@ 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,6 +11,11 @@ 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,6 +17,11 @@ 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,6 +8,11 @@ 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,6 +13,11 @@ 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,7 +104,6 @@ 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,
@@ -213,5 +212,4 @@ module.exports = {
   Workflow,
   Workspace,
   Shop,
-  Call,
 };

package/package.json

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

package/common/repositories/call.repository.js

@@ -1,540 +0,0 @@
-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/models/Call.js

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