shuttlepro-shared 1.4.2 → 1.4.4

package/common/repositories/call.repository.js

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

package/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);