shuttlepro-shared 1.4.3 → 1.4.5

package/package.json

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

package/common/repositories/call.repository.js

@@ -1,529 +0,0 @@
-const Call = require("../../models/Call");
-
-class CallRepository {
-  constructor() {
-    this.pipelines = {
-      callStats: this._buildCallStatsPipeline(),
-      holdQueue: this._buildHoldQueuePipeline(),
-    };
-  }
-
-  // Create a new call
-  async createCall(callData) {
-    try {
-      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);
-      return null;
-    }
-  }
-
-  // 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);
-      return null;
-    }
-  }
-
-  // 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);
-      return {
-        calls: [],
-        pagination: { page: 1, limit: 50, total: 0, pages: 0 },
-      };
-    }
-  }
-
-  // Update call
-  async updateCall(callId, updateData) {
-    try {
-      const allowedFields = [
-        "status",
-        "agentId",
-        "callerName",
-        "callerNumber",
-        "priority",
-        "tags",
-        "metadata",
-        "isOnHold",
-        "platformId",
-        "workspaceId",
-        "profileId",
-      ];
-
-      const filteredUpdate = {};
-      Object.keys(updateData).forEach((key) => {
-        if (allowedFields.includes(key)) {
-          filteredUpdate[key] = updateData[key];
-        }
-      });
-
-      const updateOps = {
-        $set: {
-          ...filteredUpdate,
-          lastHeartbeat: new Date(),
-        },
-      };
-
-      if (updateData.status) {
-        updateOps.$push = {
-          callHistory: {
-            timestamp: new Date(),
-            action: updateData.status,
-            agentId: updateData.agentId || null,
-            details:
-              updateData.reason || `Status changed to ${updateData.status}`,
-          },
-        };
-      }
-
-      const call = await Call.findOneAndUpdate({ callId }, updateOps, {
-        new: true,
-      });
-      return call || null;
-    } catch (error) {
-      console.error(`Failed to update call ${callId}:`, error);
-      return null;
-    }
-  }
-
-  // Assign call to agent
-  async assignCallToAgent(callId, agentId) {
-    try {
-      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
-      );
-      return null;
-    }
-  }
-
-  // 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);
-      return [];
-    }
-  }
-
-  // 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);
-      return [];
-    }
-  }
-
-  // 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);
-      return [];
-    }
-  }
-
-  // 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);
-      return this._getEmptyStats();
-    }
-  }
-
-  // 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) {
-          const moved = await this.moveCallToHoldQueue(
-            call.callId,
-            "Connection timeout"
-          );
-          if (moved)
-            results.push({ callId: call.callId, action: "moved_to_hold" });
-        } 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;
-    } catch (error) {
-      console.error("Failed to cleanup stale connections:", error);
-      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;
-    }
-  }
-
-  _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);
-    }
-  }
-}
-
-module.exports = new CallRepository();