shuttlepro-shared 1.4.21 → 1.4.23

package/common/repositories/call.repository.js

@@ -1,19 +1,84 @@
 const Call = require("../../models/Call");
+const { Types } = require("mongoose");
 
 class CallRepository {
-  constructor() {}
+  /* -----------------  Internal Helpers ----------------- */
+
+  _utcDayBounds(from, to) {
+    const f = new Date(from);
+    const t = new Date(to);
+
+    return {
+      from: new Date(
+        Date.UTC(
+          f.getUTCFullYear(),
+          f.getUTCMonth(),
+          f.getUTCDate(),
+          0,
+          0,
+          0,
+          0
+        )
+      ),
+      to: new Date(
+        Date.UTC(
+          t.getUTCFullYear(),
+          t.getUTCMonth(),
+          t.getUTCDate(),
+          23,
+          59,
+          59,
+          999
+        )
+      ),
+    };
+  }
+
+  _filterAllowedFields(data, allowed) {
+    return Object.keys(data).reduce((acc, key) => {
+      if (allowed.includes(key)) acc[key] = data[key];
+      return acc;
+    }, {});
+  }
+
+  _historyEntry({
+    action,
+    agentId = null,
+    details = "",
+    direction = "Agent Initiated",
+    platformTimestamp = "",
+  }) {
+    return {
+      timestamp: new Date(),
+      platformTimestamp,
+      action,
+      agentId,
+      details,
+      direction,
+    };
+  }
 
-  async createCall(callData) {
+  async _safeExec(promise, errorMsg, fallback = null) {
     try {
-      const historyEntry = {
-        timestamp: new Date(),
-        platformTimestamp: callData.platformTimestamp || "",
-        action: "created",
-        agentId: null,
-        direction: "User Initiated",
-        details: "Call created from webhook",
-      };
-      return await Call.create({
+      return await promise;
+    } catch (error) {
+      console.error(`❌ ${errorMsg}`, error);
+      return fallback;
+    }
+  }
+
+  /* -----------------  Core CRUD ----------------- */
+
+  createCall(callData) {
+    const entry = this._historyEntry({
+      action: "created",
+      direction: "User Initiated",
+      details: "Call created from webhook",
+      platformTimestamp: callData.platformTimestamp || "",
+    });
+
+    return this._safeExec(
+      Call.create({
         callId: callData.callId,
         callerName: callData.callerName,
         callerNumber: callData.callerNumber,
@@ -27,97 +92,76 @@ class CallRepository {
         whatsappSdp: callData.whatsappSdp || null,
         metadata: callData.metadata || {},
         tags: callData.tags || [],
-        callHistory: [historyEntry],
-      });
-    } catch (error) {
-      console.error(`❌ Failed to create call ${callData.callId}:`, error);
-      return null;
-    }
+        callHistory: [entry],
+      }),
+      `Failed to create call ${callData.callId}`
+    );
   }
 
-  async getCall(callId) {
-    try {
-      return await Call.findOne({ callId }).lean().exec();
-    } catch (error) {
-      console.error(`❌ Failed to end call ${callId}:`, error);
-      return null;
-    }
+  getCall(callId) {
+    return this._safeExec(
+      Call.findOne({ callId }).lean().exec(),
+      `Failed to get call ${callId}`
+    );
   }
 
-  async endCall(callId, agentId = null, updateObj = {}, callHistory = {}) {
-    try {
-      return await Call.findOneAndUpdate(
+  endCall(callId, agentId = null, updateObj = {}, history = {}) {
+    const entry = this._historyEntry({ ...history, agentId });
+    return this._safeExec(
+      Call.findOneAndUpdate(
         { callId },
-        {
-          $set: {
-            ...updateObj,
-          },
-          $push: {
-            callHistory: {
-              ...callHistory,
-              timestamp: new Date(),
-              agentId,
-            },
-          },
-        },
+        { $set: { ...updateObj }, $push: { callHistory: entry } },
         { new: true }
-      );
-    } catch (error) {
-      console.error(`❌ Failed to end call ${callId}:`, error);
-      return null;
-    }
+      ),
+      `Failed to end call ${callId}`
+    );
   }
 
-  async updateCall(callId, updateData) {
-    try {
-      const allowedFields = [
-        "status",
-        "agentId",
-        "callerName",
-        "callerNumber",
-        "tags",
-        "metadata",
-        "platformId",
-        "workspaceId",
-        "profileId",
-        "receiver",
-      ];
-
-      const filteredUpdate = {};
-      Object.keys(updateData).forEach((key) => {
-        if (allowedFields.includes(key)) filteredUpdate[key] = updateData[key];
-      });
-
-      const updateOps = {
-        $set: {
-          ...filteredUpdate,
-          "connectionMetadata.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}`,
-            direction: "Agent Initiated",
-          },
-        };
-      }
+  updateCall(callId, updateData) {
+    const allowed = [
+      "status",
+      "agentId",
+      "callerName",
+      "callerNumber",
+      "tags",
+      "metadata",
+      "platformId",
+      "workspaceId",
+      "profileId",
+      "receiver",
+    ];
+    const filtered = this._filterAllowedFields(updateData, allowed);
+
+    const updateOps = {
+      $set: { ...filtered, "connectionMetadata.lastHeartbeat": new Date() },
+    };
 
-      return await Call.findOneAndUpdate({ callId }, updateOps, { new: true });
-    } catch (error) {
-      console.error(`❌ Failed to update call ${callId}:`, error);
-      return null;
+    if (updateData.status) {
+      updateOps.$push = {
+        callHistory: this._historyEntry({
+          action: updateData.status,
+          agentId: updateData.agentId,
+          details:
+            updateData.reason || `Status changed to ${updateData.status}`,
+        }),
+      };
     }
+
+    return this._safeExec(
+      Call.findOneAndUpdate({ callId }, updateOps, { new: true }),
+      `Failed to update call ${callId}`
+    );
   }
 
-  async assignCallToAgent(callId, agentId) {
-    try {
-      return await Call.findOneAndUpdate(
+  assignCallToAgent(callId, agentId) {
+    const entry = this._historyEntry({
+      action: "answered",
+      agentId,
+      details: "Call answered by agent",
+    });
+
+    return this._safeExec(
+      Call.findOneAndUpdate(
         { callId, status: { $in: ["pending", "hold"] } },
         {
           $set: {
@@ -126,54 +170,45 @@ class CallRepository {
             startTime: new Date(),
             "connectionMetadata.lastHeartbeat": new Date(),
           },
-          $push: {
-            callHistory: {
-              timestamp: new Date(),
-              action: "answered",
-              agentId,
-              details: "Call answered by agent",
-            },
-          },
+          $push: { callHistory: entry },
         },
         { new: true }
-      );
-    } catch (error) {
-      console.error(`❌ Failed to assign call ${callId}:`, error);
-      return null;
-    }
+      ),
+      `Failed to assign call ${callId}`
+    );
   }
 
-  async bulkUpdateCalls(operations) {
-    try {
-      const bulkOps = operations.map((op) => ({
-        updateOne: {
-          filter: { callId: op.callId },
-          update: {
-            $set: {
-              ...op.updateData,
-              "connectionMetadata.lastHeartbeat": new Date(),
-            },
-            $push: {
-              callHistory: {
-                timestamp: new Date(),
-                action: op.action || "bulk_update",
-                agentId: op.agentId,
-                details: op.details || "Bulk operation",
-              },
-            },
+  bulkUpdateCalls(operations) {
+    const bulkOps = operations.map((op) => ({
+      updateOne: {
+        filter: { callId: op.callId },
+        update: {
+          $set: {
+            ...op.updateData,
+            "connectionMetadata.lastHeartbeat": new Date(),
+          },
+          $push: {
+            callHistory: this._historyEntry({
+              action: op.action || "bulk_update",
+              agentId: op.agentId,
+              details: op.details || "Bulk operation",
+            }),
           },
         },
-      }));
-      return await Call.bulkWrite(bulkOps);
-    } catch (error) {
-      console.error("❌ Bulk update failed:", error);
-      return [];
-    }
+      },
+    }));
+
+    return this._safeExec(Call.bulkWrite(bulkOps), "Bulk update failed", []);
   }
 
-  async moveCallToHoldQueue(callId, reason = "Agent disconnected") {
-    try {
-      return await Call.findOneAndUpdate(
+  moveCallToHoldQueue(callId, reason = "Agent disconnected") {
+    const entry = this._historyEntry({
+      action: "disconnected",
+      details: reason,
+    });
+
+    return this._safeExec(
+      Call.findOneAndUpdate(
         { callId },
         {
           $set: {
@@ -182,94 +217,78 @@ class CallRepository {
             autoAccepted: true,
             "connectionMetadata.lastHeartbeat": new Date(),
           },
-          $push: {
-            callHistory: {
-              timestamp: new Date(),
-              action: "disconnected",
-              agentId: null,
-              details: reason,
-            },
-          },
+          $push: { callHistory: entry },
         },
         { new: true }
-      );
-    } catch (error) {
-      console.error(`❌ Failed to move call ${callId} to hold queue:`, error);
-      return null;
-    }
+      ),
+      `Failed to move call ${callId} to hold queue`
+    );
   }
 
-  /* -----------------  Query Helpers ----------------- */
+  /* -----------------  Queries ----------------- */
 
   async getCallsByWorkspace(
-    workspaceId,
+    { workspaceId, from, to },
     {
       filters = {},
       select = null,
       sortBy = { createdAt: -1 },
-      limit = null,
-      skip = null,
+      limit,
+      skip,
     } = {}
   ) {
-    let query = Call.find({ workspaceId, ...filters })
-      .select(select || {}) // if null → select all fields
-      .sort(sortBy) // default newest first
+    const { from: fromDate, to: toDate } = this._utcDayBounds(from, to);
+
+    let query = Call.find({
+      workspaceId,
+      createdAt: { $gte: fromDate, $lte: toDate },
+      ...filters,
+    })
+      .select(select || {})
+      .sort(sortBy)
       .lean();
 
-    if (limit !== null) {
-      query = query.limit(limit);
-    }
-    if (skip !== null) {
-      query = query.skip(skip);
-    }
+    if (limit) query = query.limit(limit);
+    if (skip) query = query.skip(skip);
 
     return query.exec();
   }
 
-  async getCallsByAgent(
+  getCallsByAgent(
     agentId,
     {
       filters = {},
       select = null,
       sortBy = { createdAt: -1 },
-      limit = null,
-      skip = null,
+      limit,
+      skip,
     } = {}
   ) {
     let query = Call.find({ agentId, ...filters })
-      .select(select || {}) // if null → select all fields
-      .sort(sortBy) // default newest first
+      .select(select || {})
+      .sort(sortBy)
       .lean();
-
-    if (limit !== null) {
-      query = query.limit(limit);
-    }
-    if (skip !== null) {
-      query = query.skip(skip);
-    }
-
+    if (limit) query = query.limit(limit);
+    if (skip) query = query.skip(skip);
     return query.exec();
   }
 
-  async getCallsByReceiver(receiver, filters = {}) {
+  getCallsByReceiver(receiver, filters = {}) {
     return Call.find({ receiver, ...filters })
       .sort({ createdAt: -1 })
       .lean()
       .exec();
   }
 
-  async getActiveCalls(workspaceId) {
-    return Call.find({
-      workspaceId,
-      status: { $in: ["active", "hold"] },
-    });
+  getActiveCalls(workspaceId) {
+    return Call.find({ workspaceId, status: { $in: ["active", "hold"] } });
   }
 
-  async getPendingCalls(workspaceId) {
+  getPendingCalls(workspaceId) {
     return Call.find({ workspaceId, status: "pending" });
   }
 
-  async getStaleCalls(timeoutMinutes = 5) {
+  getStaleCalls(timeoutMinutes = 5) {
     const timeout = new Date(Date.now() - timeoutMinutes * 60 * 1000);
     return Call.find({
       status: { $in: ["active", "hold", "pending"] },
@@ -277,29 +296,19 @@ class CallRepository {
     });
   }
 
-  /* -----------------  Reporting & Analytics ----------------- */
+  /* -----------------  Reporting ----------------- */
 
-  // Stats grouped by agent
   async getAgentStats({ from, to }, filters = {}) {
-    // Pakistan offset (+5 hours)
-    const PAK_OFFSET = 5 * 60 * 60 * 1000;
-
-    // convert input to Date objects
-    const fromDate = new Date(new Date(from).getTime() - PAK_OFFSET);
-    const toDate = new Date(new Date(to).getTime() - PAK_OFFSET);
+    const { from: fromDate, to: toDate } = this._utcDayBounds(from, to);
 
-    // set end of day in Pakistan time
-    toDate.setHours(23, 59, 59, 999);
-
-    console.log({ fromDate, toDate }, filters);
-
-    const matchStage = {
-      createdAt: { $gte: fromDate, $lte: toDate },
-      ...filters,
-    };
+    const match = { createdAt: { $gte: fromDate, $lte: toDate }, ...filters };
+    if (match.workspaceId && typeof match.workspaceId === "string")
+      match.workspaceId = new Types.ObjectId(match.workspaceId);
+    if (match.agentId && typeof match.agentId === "string")
+      match.agentId = new Types.ObjectId(match.agentId);
 
-    const result = await Call.aggregate([
-      { $match: matchStage },
+    const [stats] = await Call.aggregate([
+      { $match: match },
       {
         $group: {
           _id: filters.agentId ? "$agentId" : null,
@@ -312,25 +321,14 @@ class CallRepository {
         },
       },
       {
-        $project: {
-          _id: 0,
-          totalCalls: 1,
-          pending: 1,
-          abandoned: 1,
-          ended: 1,
-        },
+        $project: { _id: 0, totalCalls: 1, pending: 1, abandoned: 1, ended: 1 },
       },
     ]);
 
-    if (result.length === 0) {
-      return { totalCalls: 0, pending: 0, abandoned: 0, ended: 0 };
-    }
-
-    return result[0];
+    return stats || { totalCalls: 0, pending: 0, abandoned: 0, ended: 0 };
   }
 
-  // Daily call summary
-  async getDailySummary(workspaceId, from, to, filters = {}, groupBy = null) {
+  getDailySummary(workspaceId, from, to, filters = {}, groupBy = null) {
     const matchStage = {
       workspaceId,
       createdAt: { $gte: from, $lte: to },
@@ -340,11 +338,8 @@ class CallRepository {
     const groupId = {
       day: { $dateToString: { format: "%Y-%m-%d", date: "$createdAt" } },
     };
-
-    // If admin wants to group by agentId / receiver / platformId
-    if (groupBy && ["agentId", "receiver", "platformId"].includes(groupBy)) {
+    if (groupBy && ["agentId", "receiver", "platformId"].includes(groupBy))
       groupId[groupBy] = `$${groupBy}`;
-    }
 
     return Call.aggregate([
       { $match: matchStage },
@@ -369,7 +364,7 @@ class CallRepository {
           total: 1,
           ended: 1,
           abandoned: 1,
-          avgDuration: { $round: ["$avgDuration", 2] }, // round to 2 decimals
+          avgDuration: { $round: ["$avgDuration", 2] },
           minDuration: 1,
           maxDuration: 1,
         },
@@ -378,8 +373,7 @@ class CallRepository {
     ]);
   }
 
-  // Queue stats
-  async getQueueStats(workspaceId) {
+  getQueueStats(workspaceId) {
     return Call.aggregate([
       { $match: { workspaceId, status: "hold" } },
       {

package/package.json

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