shuttlepro-shared 1.3.98 → 1.4.1

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,
 };