@talkpilot/core-db 1.3.0 → 1.3.1

package/src/municipal/tickets/tickets.getters.ts

@@ -1,4 +1,5 @@
 import { CityName, getDb, ObjectId, Ticket } from "../index";
+import type { SubjectStatsItem } from "./tickets.types";
 import { Collection, Filter, ObjectId as MongoObjectId } from "mongodb";
 
 /**
@@ -67,6 +68,145 @@ export const deleteTicket = async (ticketId: string): Promise<boolean> => {
   return result.deletedCount > 0;
 };
 
+/**
+ * Count tickets by city and date range (createdAt converted to given timezone).
+ * Used as "open" tickets count when status is not available.
+ */
+export async function getTicketsCountByCityAndDateRange(
+  cityName: string,
+  startStr: string,
+  endStr: string,
+  timezone: string,
+): Promise<number> {
+  const doc = await getTicketsCollection()
+    .aggregate<{ n: number }>([
+      { $match: { cityName, callSid: { $exists: true, $nin: [null, ""] } } },
+      {
+        $addFields: {
+          dateLocal: {
+            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
+          },
+        },
+      },
+      { $match: { dateLocal: { $gte: startStr, $lte: endStr } } },
+      { $count: "n" },
+    ])
+    .next();
+  return doc?.n ?? 0;
+}
+
+/**
+ * Count of tickets by department (subject) from departmentsSubjects. Different departments (subject_id) are grouped, and sub-subjects are unified under their department.
+ * Date filter: createdAt in [startStr, endStr] (in the given timezone). Fallback to "Unclassified" when no match is found in the lookup.
+ */
+export async function getTicketsSubjectStats(
+  cityName: string,
+  startStr: string,
+  endStr: string,
+  timezone: string,
+): Promise<SubjectStatsItem[]> {
+  const coll = getTicketsCollection();
+  const rows = await coll
+    .aggregate<{ _id: string; subject: string; count: number }>([
+      { $match: { cityName } },
+      {
+        $addFields: {
+          dateLocal: {
+            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
+          },
+        },
+      },
+      { $match: { dateLocal: { $gte: startStr, $lte: endStr } } },
+      {
+        $addFields: {
+          effectiveSubjectId: {
+            $ifNull: [
+              "$externalCallFields.event_subject_id",
+              {
+                $ifNull: [
+                  "$externalCallFields.event_sub_subject_id",
+                  "$externalCallFields.event_sub_subject_id2",
+                ],
+              },
+            ],
+          },
+        },
+      },
+      {
+        $lookup: {
+          from: "departmentsSubjects",
+          let: { sid: "$effectiveSubjectId", c: cityName },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: ["$cityName", "$$c"] },
+                    {
+                      $or: [
+                        { $eq: ["$subject_id", { $ifNull: ["$$sid", ""] }] },
+                        {
+                          $eq: ["$sub_subject_id", { $ifNull: ["$$sid", ""] }],
+                        },
+                        {
+                          $eq: ["$sub_subject_id2", { $ifNull: ["$$sid", ""] }],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+            { $limit: 1 },
+          ],
+          as: "subj",
+        },
+      },
+      {
+        $addFields: {
+          subject_id: {
+            $cond: {
+              if: { $gt: [{ $size: "$subj" }, 0] },
+              then: {
+                $ifNull: [{ $arrayElemAt: ["$subj.subject_id", 0] }, ""],
+              },
+              else: "",
+            },
+          },
+          subject: {
+            $cond: {
+              if: { $gt: [{ $size: "$subj" }, 0] },
+              then: {
+                $ifNull: [
+                  { $arrayElemAt: ["$subj.subjectName", 0] },
+                  "Unclassified",
+                ],
+              },
+              else: "Unclassified",
+            },
+          },
+        },
+      },
+      {
+        $group: {
+          _id: "$subject_id",
+          subject: { $first: "$subject" },
+          count: { $sum: 1 },
+        },
+      },
+      { $sort: { count: -1 } },
+    ])
+    .toArray();
+
+  const total = rows.reduce((s: number, r: any) => s + r.count, 0);
+  return rows.map((r: any) => ({
+    subject_name: r.subject,
+    subject_id: r._id,
+    count: r.count,
+    percentage: total > 0 ? Math.round((r.count / total) * 100) : 0,
+  }));
+}
+
 export const findTicketByQuery = async (query: Partial<Ticket>) => {
   return await getTicketsCollection().findOne(query);
 };

package/src/municipal/tickets/tickets.types.ts

@@ -9,6 +9,7 @@ export type Ticket = {
   callSid?: string;
   cityName: CityName;
   externalCallFields: {
+    // Request fields
     first_name?: string;
     last_name?: string;
     event_description?: string;
@@ -17,9 +18,10 @@ export type Ticket = {
     event_subject_id?: string;
     event_sub_subject_id?: string;
     event_sub_subject_id2?: string | null;
+    // Response fields (only if external call was successful)
     call_number?: string;
-    status?: number;
-    error?: string;
+    status?: number; // Response status from Bina API (1 = success)
+    error?: string; // Error message from Bina API if any
     image1?: string;
     image2?: string;
     image3?: string;
@@ -32,17 +34,10 @@ export type Ticket = {
 
 export type TicketDoc = WithId<Ticket>;
 
-export type SubjectItem = {
-  subject: string;
+/** Call count by department (subject). */
+export type SubjectStatsItem = {
+  subject_name: string;
+  subject_id: string;
   count: number;
-};
-
-export type TicketStatsDateScope = {
-  from?: Date;
-  to?: Date;
-};
-
-export type TicketStatsDateRange = {
-  from: Date;
-  to: Date;
+  percentage: number;
 };

package/src/talkpilot/calls/__tests__/calls.dashboard.spec.ts

@@ -25,8 +25,8 @@ describe("getDashboardStats", () => {
 
     const params = {
       clientId,
-      startDate: "2026-05-01",
-      endDate: "2026-05-31",
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-31T23:59:59.999Z",
     };
 
     const result = await getDashboardStats(params);
@@ -35,12 +35,115 @@ describe("getDashboardStats", () => {
     expect(result.kpis.totalCalls).toBe(0);
     expect(result.kpis.completedCount).toBe(0);
     expect(result.kpis.avgDurationSeconds).toBe(0);
-    expect(result.charts.volumeData).toEqual([]);
-    expect(result.charts.heatmap).toEqual({});
-    expect(result.charts.callLengthBuckets).toEqual({
-      short: 0,
-      medium: 0,
-      long: 0,
+    expect(result.kpis.busyCount).toBe(0);
+    expect(result.kpis.timeSavedMinutes).toBe(0);
+    // ~30 day range -> daily buckets, gap-filled with zeros across the whole range
+    expect(result.charts.volumeGranularity).toBe("day");
+    expect(result.charts.volumeData.length).toBeGreaterThan(0);
+    expect(result.charts.volumeData.every((d) => d.completed === 0)).toBe(true);
+    expect(result.charts.volumeData[0].date).toBe("2026-05-01");
+    expect(
+      result.charts.volumeData[result.charts.volumeData.length - 1].date,
+    ).toBe("2026-05-31");
+  });
+
+  it("should pick a bucket size that keeps the volume chart readable across range lengths", async () => {
+    const clientId = "client-dash-456";
+
+    await getClientsConfigCollection().insertOne({
+      clientId,
+      timezone: "UTC",
+      products: {},
+    } as any);
+
+    const oneDay = await getDashboardStats({
+      clientId,
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-01T23:59:59.999Z",
+    });
+    expect(oneDay.charts.volumeGranularity).toBe("hour");
+
+    const threeWeeks = await getDashboardStats({
+      clientId,
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-21T23:59:59.999Z",
+    });
+    expect(threeWeeks.charts.volumeGranularity).toBe("day");
+
+    const fourMonths = await getDashboardStats({
+      clientId,
+      startDate: "2026-01-01T00:00:00.000Z",
+      endDate: "2026-04-30T23:59:59.999Z",
+    });
+    expect(fourMonths.charts.volumeGranularity).toBe("week");
+
+    const eighteenMonths = await getDashboardStats({
+      clientId,
+      startDate: "2025-01-01T00:00:00.000Z",
+      endDate: "2026-06-30T23:59:59.999Z",
+    });
+    expect(eighteenMonths.charts.volumeGranularity).toBe("month");
+
+    const threeYears = await getDashboardStats({
+      clientId,
+      startDate: "2023-01-01T00:00:00.000Z",
+      endDate: "2026-01-01T23:59:59.999Z",
+    });
+    expect(threeYears.charts.volumeGranularity).toBe("quarter");
+
+    const fiveYears = await getDashboardStats({
+      clientId,
+      startDate: "2021-01-01T00:00:00.000Z",
+      endDate: "2026-01-01T23:59:59.999Z",
+    });
+    expect(fiveYears.charts.volumeGranularity).toBe("year");
+  });
+
+  it("should fill gaps with zero-count buckets so the chart has no missing points", async () => {
+    const clientId = "client-dash-789";
+
+    await getClientsConfigCollection().insertOne({
+      clientId,
+      timezone: "UTC",
+      products: {},
+    } as any);
+
+    // Sparse data: only two of the day's hours have calls.
+    await getCallsCollection().insertMany([
+      {
+        clientId,
+        status: "completed",
+        callLength: 60,
+        createdAt: new Date("2026-05-01T09:15:00Z"),
+      },
+      {
+        clientId,
+        status: "completed",
+        callLength: 90,
+        createdAt: new Date("2026-05-01T18:45:00Z"),
+      },
+    ] as any);
+
+    const result = await getDashboardStats({
+      clientId,
+      startDate: "2026-05-01T00:00:00.000Z",
+      endDate: "2026-05-01T23:59:59.999Z",
     });
+
+    expect(result.charts.volumeGranularity).toBe("hour");
+    // A full day of hourly buckets, with no gaps, sorted chronologically.
+    expect(result.charts.volumeData).toHaveLength(24);
+    expect(result.charts.volumeData[0].date).toBe("2026-05-01T00:00");
+    expect(result.charts.volumeData[23].date).toBe("2026-05-01T23:00");
+
+    const populated = result.charts.volumeData.filter((d) => d.completed > 0);
+    expect(populated).toHaveLength(2);
+    expect(populated.map((d) => d.date)).toEqual([
+      "2026-05-01T09:00",
+      "2026-05-01T18:00",
+    ]);
+
+    const empty = result.charts.volumeData.filter((d) => d.completed === 0);
+    expect(empty).toHaveLength(22);
   });
 });

package/src/talkpilot/calls/calls.types.ts

@@ -2,10 +2,8 @@ import { ObjectId, Sort, WithId } from "mongodb";
 import { TranscriptionSegment } from "../results";
 import { LeadProperty } from "../leads";
 
-import {
-  CONFERENCE_ROLE_CUSTOMER,
-  CONFERENCE_ROLE_SUPERVISOR,
-} from "./calls.constants";
+export const CONFERENCE_ROLE_CUSTOMER = "customer" as const;
+export const CONFERENCE_ROLE_SUPERVISOR = "supervisor" as const;
 
 export type ConferenceRole =
   | typeof CONFERENCE_ROLE_CUSTOMER