livedash-node/pages/api/dashboard/sessions.ts

import { NextApiRequest, NextApiResponse } from "next";
import { getServerSession } from "next-auth/next";
import { authOptions } from "../auth/[...nextauth]";
import { prisma } from "../../../lib/prisma";
import { ChatSession, SessionApiResponse, SessionQuery } from "../../../lib/types";

export default async function handler(
  req: NextApiRequest,
    res: NextApiResponse<SessionApiResponse | { error: string; details?: string; }>
) {
  if (req.method !== "GET") {
    return res.status(405).json({ error: "Method not allowed" });
  }

  const authSession = await getServerSession(req, res, authOptions);

  if (!authSession || !authSession.user?.companyId) {
    return res.status(401).json({ error: "Unauthorized" });
  }

  const companyId = authSession.user.companyId;
    const {
        searchTerm,
        category,
        language,
        startDate,
        endDate,
        sortKey,
        sortOrder,
        page: queryPage,
        pageSize: queryPageSize,
    } = req.query as SessionQuery;

    const page = Number(queryPage) || 1;
    const pageSize = Number(queryPageSize) || 10;

  try {
    const whereClause: any = { companyId };

      // Search Term
    if (
      searchTerm &&
      typeof searchTerm === "string" &&
      searchTerm.trim() !== ""
    ) {
      const searchConditions = [
        { id: { contains: searchTerm, mode: "insensitive" } },
          { sessionId: { contains: searchTerm, mode: "insensitive" } },
        { category: { contains: searchTerm, mode: "insensitive" } },
        { initialMsg: { contains: searchTerm, mode: "insensitive" } },
        { transcriptContent: { contains: searchTerm, mode: "insensitive" } },
      ];
      whereClause.OR = searchConditions;
    }

      // Category Filter
      if (category && typeof category === "string" && category.trim() !== "") {
          whereClause.category = category;
      }

      // Language Filter
      if (language && typeof language === "string" && language.trim() !== "") {
          whereClause.language = language;
      }

      // Date Range Filter
      if (startDate && typeof startDate === "string") {
          if (!whereClause.startTime) whereClause.startTime = {};
          whereClause.startTime.gte = new Date(startDate);
      }
      if (endDate && typeof endDate === "string") {
          if (!whereClause.startTime) whereClause.startTime = {};
          const inclusiveEndDate = new Date(endDate);
          inclusiveEndDate.setDate(inclusiveEndDate.getDate() + 1);
          whereClause.startTime.lt = inclusiveEndDate;
      }

      // Sorting
      let orderByClause: any = { startTime: "desc" };
      if (sortKey && typeof sortKey === "string") {
          const order =
              sortOrder === "asc" || sortOrder === "desc" ? sortOrder : "desc";
          const validSortKeys: { [key: string]: string; } = {
              startTime: "startTime",
              category: "category",
              language: "language",
              sentiment: "sentiment",
              messagesSent: "messagesSent",
              avgResponseTime: "avgResponseTime",
          };
          if (validSortKeys[sortKey]) {
              orderByClause = { [validSortKeys[sortKey]]: order };
          }
      }

    const prismaSessions = await prisma.session.findMany({
      where: whereClause,
        orderBy: orderByClause,
        skip: (page - 1) * pageSize,
        take: pageSize,
    });

      const totalSessions = await prisma.session.count({ where: whereClause });

    const sessions: ChatSession[] = prismaSessions.map((ps) => ({
      id: ps.id,
      sessionId: ps.id,
      companyId: ps.companyId,
      startTime: new Date(ps.startTime),
      endTime: ps.endTime ? new Date(ps.endTime) : null,
      createdAt: new Date(ps.createdAt),
      updatedAt: new Date(ps.createdAt),
      userId: null,
      category: ps.category ?? null,
      language: ps.language ?? null,
      country: ps.country ?? null,
      ipAddress: ps.ipAddress ?? null,
      sentiment: ps.sentiment ?? null,
      messagesSent: ps.messagesSent ?? undefined,
      avgResponseTime: ps.avgResponseTime ?? null,
      escalated: ps.escalated ?? undefined,
      forwardedHr: ps.forwardedHr ?? undefined,
      tokens: ps.tokens ?? undefined,
      tokensEur: ps.tokensEur ?? undefined,
      initialMsg: ps.initialMsg ?? undefined,
      fullTranscriptUrl: ps.fullTranscriptUrl ?? null,
      transcriptContent: ps.transcriptContent ?? null,
    }));

      return res.status(200).json({ sessions, totalSessions });
  } catch (error) {
    const errorMessage =
      error instanceof Error ? error.message : "An unknown error occurred";
    return res
      .status(500)
      .json({ error: "Failed to fetch sessions", details: errorMessage });
  }
}