shuttlepro-shared 1.4.14 → 1.4.16

package/common/repositories/call.repository.js

@@ -35,13 +35,21 @@ class CallRepository {
     }
   }
 
+  async getCall(callId) {
+    try {
+      return await Call.findOne({ callId }).lean().exec();
+    } catch (error) {
+      console.error(`❌ Failed to end call ${callId}:`, error);
+      return null;
+    }
+  }
+
   async endCall(callId, agentId = null, updateObj = {}, callHistory = {}) {
     try {
       return await Call.findOneAndUpdate(
         { callId },
         {
           $set: {
-            ...(updateObj?.status === "ended" ? { endTime: new Date() } : {}),
             ...updateObj,
           },
           $push: {
@@ -193,18 +201,54 @@ class CallRepository {
 
   /* -----------------  Query Helpers ----------------- */
 
-  async getCallsByWorkspace(workspaceId, filters = {}) {
-    return Call.find({ workspaceId, ...filters })
-      .sort({ createdAt: -1 })
-      .lean()
-      .exec();
+  async getCallsByWorkspace(
+    workspaceId,
+    {
+      filters = {},
+      select = null,
+      sortBy = { createdAt: -1 },
+      limit = null,
+      skip = null,
+    } = {}
+  ) {
+    let query = Call.find({ workspaceId, ...filters })
+      .select(select || {}) // if null → select all fields
+      .sort(sortBy) // default newest first
+      .lean();
+
+    if (limit !== null) {
+      query = query.limit(limit);
+    }
+    if (skip !== null) {
+      query = query.skip(skip);
+    }
+
+    return query.exec();
   }
 
-  async getCallsByAgent(agentId, filters = {}) {
-    return Call.find({ agentId, ...filters })
-      .sort({ createdAt: -1 })
-      .lean()
-      .exec();
+  async getCallsByAgent(
+    agentId,
+    {
+      filters = {},
+      select = null,
+      sortBy = { createdAt: -1 },
+      limit = null,
+      skip = null,
+    } = {}
+  ) {
+    let query = Call.find({ agentId, ...filters })
+      .select(select || {}) // if null → select all fields
+      .sort(sortBy) // default newest first
+      .lean();
+
+    if (limit !== null) {
+      query = query.limit(limit);
+    }
+    if (skip !== null) {
+      query = query.skip(skip);
+    }
+
+    return query.exec();
   }
 
   async getCallsByReceiver(receiver, filters = {}) {
@@ -236,45 +280,109 @@ class CallRepository {
   /* -----------------  Reporting & Analytics ----------------- */
 
   // Stats grouped by agent
-  async getAgentStats(workspaceId, from, to) {
-    return Call.aggregate([
-      { $match: { workspaceId, createdAt: { $gte: from, $lte: to } } },
+  // Stats grouped by agent
+  async getAgentStats({ from, to }, filters = {}) {
+    const result = await Call.aggregate([
+      {
+        $match: {
+          createdAt: { $gte: from, $lte: to },
+          ...filters,
+        },
+      },
       {
         $group: {
           _id: "$agentId",
           totalCalls: { $sum: 1 },
-          answered: {
-            $sum: { $cond: [{ $eq: ["$status", "active"] }, 1, 0] },
+          pending: {
+            $sum: { $cond: [{ $eq: ["$status", "pending"] }, 1, 0] },
+          },
+          abandoned: {
+            $sum: { $cond: [{ $eq: ["$status", "abandoned"] }, 1, 0] },
           },
           ended: {
             $sum: { $cond: [{ $eq: ["$status", "ended"] }, 1, 0] },
           },
-          avgDuration: { $avg: "$duration" },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          agentId: "$_id",
+          totalCalls: 1,
+          pending: 1,
+          abandoned: 1,
+          ended: 1,
         },
       },
     ]);
+
+    if (filters.agentId) {
+      // single agent case
+      return (
+        result.find((r) => r.agentId === filters.agentId) || {
+          agentId: filters.agentId,
+          totalCalls: 0,
+          pending: 0,
+          abandoned: 0,
+          ended: 0,
+        }
+      );
+    }
+
+    // multi-agent case
+    if (result.length === 0) {
+      return [];
+    }
+
+    return result;
   }
 
   // Daily call summary
-  async getDailySummary(workspaceId, from, to) {
+  async getDailySummary(workspaceId, from, to, filters = {}, groupBy = null) {
+    const matchStage = {
+      workspaceId,
+      createdAt: { $gte: from, $lte: to },
+      ...filters,
+    };
+
+    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)) {
+      groupId[groupBy] = `$${groupBy}`;
+    }
+
     return Call.aggregate([
-      { $match: { workspaceId, createdAt: { $gte: from, $lte: to } } },
+      { $match: matchStage },
       {
         $group: {
-          _id: {
-            day: { $dateToString: { format: "%Y-%m-%d", date: "$createdAt" } },
-          },
+          _id: groupId,
           total: { $sum: 1 },
-          ended: {
-            $sum: { $cond: [{ $eq: ["$status", "ended"] }, 1, 0] },
-          },
+          ended: { $sum: { $cond: [{ $eq: ["$status", "ended"] }, 1, 0] } },
           abandoned: {
             $sum: { $cond: [{ $eq: ["$status", "abandoned"] }, 1, 0] },
           },
           avgDuration: { $avg: "$duration" },
+          minDuration: { $min: "$duration" },
+          maxDuration: { $max: "$duration" },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          day: "$_id.day",
+          groupBy: groupBy ? `$_id.${groupBy}` : null,
+          total: 1,
+          ended: 1,
+          abandoned: 1,
+          avgDuration: { $round: ["$avgDuration", 2] }, // round to 2 decimals
+          minDuration: 1,
+          maxDuration: 1,
         },
       },
-      { $sort: { "_id.day": 1 } },
+      { $sort: { day: 1 } },
     ]);
   }
 

package/package.json

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