Remove Tailwind CSS configuration file

app/api/dashboard/config/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getServerSession } from "next-auth";
+import { prisma } from "../../../../lib/prisma";
+import { authOptions } from "../../auth/[...nextauth]/route";
+
+export async function GET(request: NextRequest) {
+  const session = await getServerSession(authOptions);
+  if (!session?.user) {
+    return NextResponse.json({ error: "Not logged in" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email as string },
+  });
+
+  if (!user) {
+    return NextResponse.json({ error: "No user" }, { status: 401 });
+  }
+
+  // Get company data
+  const company = await prisma.company.findUnique({
+    where: { id: user.companyId },
+  });
+
+  return NextResponse.json({ company });
+}
+
+export async function POST(request: NextRequest) {
+  const session = await getServerSession(authOptions);
+  if (!session?.user) {
+    return NextResponse.json({ error: "Not logged in" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email as string },
+  });
+
+  if (!user) {
+    return NextResponse.json({ error: "No user" }, { status: 401 });
+  }
+
+  const body = await request.json();
+  const { csvUrl } = body;
+
+  await prisma.company.update({
+    where: { id: user.companyId },
+    data: { csvUrl },
+  });
+
+  return NextResponse.json({ ok: true });
+}

app/api/dashboard/metrics/route.ts

@@ -0,0 +1,110 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getServerSession } from "next-auth";
+import { prisma } from "../../../../lib/prisma";
+import { sessionMetrics } from "../../../../lib/metrics";
+import { authOptions } from "../../auth/[...nextauth]/route";
+import { ChatSession } from "../../../../lib/types";
+
+interface SessionUser {
+  email: string;
+  name?: string;
+}
+
+interface SessionData {
+  user: SessionUser;
+}
+
+export async function GET(request: NextRequest) {
+  const session = (await getServerSession(authOptions)) as SessionData | null;
+  if (!session?.user) {
+    return NextResponse.json({ error: "Not logged in" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email },
+    include: { company: true },
+  });
+
+  if (!user) {
+    return NextResponse.json({ error: "No user" }, { status: 401 });
+  }
+
+  // Get date range from query parameters
+  const { searchParams } = new URL(request.url);
+  const startDate = searchParams.get("startDate");
+  const endDate = searchParams.get("endDate");
+
+  // Build where clause with optional date filtering
+  const whereClause: any = {
+    companyId: user.companyId,
+  };
+
+  if (startDate && endDate) {
+    whereClause.startTime = {
+      gte: new Date(startDate),
+      lte: new Date(endDate + 'T23:59:59.999Z'), // Include full end date
+    };
+  }
+
+  const prismaSessions = await prisma.session.findMany({
+    where: whereClause,
+    include: {
+      messages: true, // Include messages for question extraction
+    },
+  });
+
+  // Convert Prisma sessions to ChatSession[] type for sessionMetrics
+  const chatSessions: ChatSession[] = prismaSessions.map((ps) => ({
+    id: ps.id, // Map Prisma's id to ChatSession.id
+    sessionId: ps.id, // Map Prisma's id to ChatSession.sessionId
+    companyId: ps.companyId,
+    startTime: new Date(ps.startTime), // Ensure startTime is a Date object
+    endTime: ps.endTime ? new Date(ps.endTime) : null, // Ensure endTime is a Date object or null
+    transcriptContent: "", // Session model doesn't have transcriptContent field
+    createdAt: new Date(ps.createdAt), // Map Prisma's createdAt
+    updatedAt: new Date(ps.createdAt), // Use createdAt for updatedAt as Session model doesn't have updatedAt
+    category: ps.category || undefined,
+    language: ps.language || undefined,
+    country: ps.country || undefined,
+    ipAddress: ps.ipAddress || undefined,
+    sentiment: ps.sentiment === null ? undefined : ps.sentiment,
+    messagesSent: ps.messagesSent === null ? undefined : ps.messagesSent, // Handle null messagesSent
+    avgResponseTime:
+      ps.avgResponseTime === null ? undefined : ps.avgResponseTime,
+    escalated: ps.escalated || false,
+    forwardedHr: ps.forwardedHr || false,
+    initialMsg: ps.initialMsg || undefined,
+    fullTranscriptUrl: ps.fullTranscriptUrl || undefined,
+    summary: ps.summary || undefined, // Include summary field
+    messages: ps.messages || [], // Include messages for question extraction
+    // userId is missing in Prisma Session model, assuming it's not strictly needed for metrics or can be null
+    userId: undefined, // Or some other default/mapping if available
+  }));
+
+  // Pass company config to metrics
+  const companyConfigForMetrics = {
+    sentimentAlert:
+      user.company.sentimentAlert === null
+        ? undefined
+        : user.company.sentimentAlert,
+  };
+
+  const metrics = sessionMetrics(chatSessions, companyConfigForMetrics);
+
+  // Calculate date range from sessions
+  let dateRange: { minDate: string; maxDate: string } | null = null;
+  if (prismaSessions.length > 0) {
+    const dates = prismaSessions.map(s => new Date(s.startTime)).sort((a, b) => a.getTime() - b.getTime());
+    dateRange = {
+      minDate: dates[0].toISOString().split('T')[0], // First session date
+      maxDate: dates[dates.length - 1].toISOString().split('T')[0] // Last session date
+    };
+  }
+
+  return NextResponse.json({
+    metrics,
+    csvUrl: user.company.csvUrl,
+    company: user.company,
+    dateRange,
+  });
+}

app/api/dashboard/session-filter-options/route.ts

@@ -0,0 +1,71 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getServerSession } from "next-auth/next";
+import { authOptions } from "../../auth/[...nextauth]/route";
+import { prisma } from "../../../../lib/prisma";
+import { SessionFilterOptions } from "../../../../lib/types";
+
+export async function GET(request: NextRequest) {
+  const authSession = await getServerSession(authOptions);
+
+  if (!authSession || !authSession.user?.companyId) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const companyId = authSession.user.companyId;
+
+  try {
+    const categories = await prisma.session.findMany({
+      where: {
+        companyId,
+        category: {
+          not: null, // Ensure category is not null
+        },
+      },
+      distinct: ["category"],
+      select: {
+        category: true,
+      },
+      orderBy: {
+        category: "asc",
+      },
+    });
+
+    const languages = await prisma.session.findMany({
+      where: {
+        companyId,
+        language: {
+          not: null, // Ensure language is not null
+        },
+      },
+      distinct: ["language"],
+      select: {
+        language: true,
+      },
+      orderBy: {
+        language: "asc",
+      },
+    });
+
+    const distinctCategories = categories
+      .map((s) => s.category)
+      .filter(Boolean) as string[]; // Filter out any nulls and assert as string[]
+    const distinctLanguages = languages
+      .map((s) => s.language)
+      .filter(Boolean) as string[]; // Filter out any nulls and assert as string[]
+
+    return NextResponse.json({ 
+      categories: distinctCategories, 
+      languages: distinctLanguages 
+    });
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error ? error.message : "An unknown error occurred";
+    return NextResponse.json(
+      {
+        error: "Failed to fetch filter options",
+        details: errorMessage,
+      },
+      { status: 500 }
+    );
+  }
+}

app/api/dashboard/session/[id]/route.ts

@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "../../../../../lib/prisma";
+import { ChatSession } from "../../../../../lib/types";
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  const { id } = params;
+
+  if (!id) {
+    return NextResponse.json(
+      { error: "Session ID is required" },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const prismaSession = await prisma.session.findUnique({
+      where: { id },
+      include: {
+        messages: {
+          orderBy: { order: "asc" },
+        },
+      },
+    });
+
+    if (!prismaSession) {
+      return NextResponse.json(
+        { error: "Session not found" },
+        { status: 404 }
+      );
+    }
+
+    // Map Prisma session object to ChatSession type
+    const session: ChatSession = {
+      // Spread prismaSession to include all its properties
+      ...prismaSession,
+      // Override properties that need conversion or specific mapping
+      id: prismaSession.id, // ChatSession.id from Prisma.Session.id
+      sessionId: prismaSession.id, // ChatSession.sessionId from Prisma.Session.id
+      startTime: new Date(prismaSession.startTime),
+      endTime: prismaSession.endTime ? new Date(prismaSession.endTime) : null,
+      createdAt: new Date(prismaSession.createdAt),
+      // Prisma.Session does not have an `updatedAt` field. We'll use `createdAt` as a fallback.
+      // Or, if your business logic implies an update timestamp elsewhere, use that.
+      updatedAt: new Date(prismaSession.createdAt), // Fallback to createdAt
+      // Prisma.Session does not have a `userId` field.
+      userId: null, // Explicitly set to null or map if available from another source
+      // Ensure nullable fields from Prisma are correctly mapped to ChatSession's optional or nullable fields
+      category: prismaSession.category ?? null,
+      language: prismaSession.language ?? null,
+      country: prismaSession.country ?? null,
+      ipAddress: prismaSession.ipAddress ?? null,
+      sentiment: prismaSession.sentiment ?? null,
+      messagesSent: prismaSession.messagesSent ?? undefined, // Use undefined if ChatSession expects number | undefined
+      avgResponseTime: prismaSession.avgResponseTime ?? null,
+      escalated: prismaSession.escalated ?? undefined,
+      forwardedHr: prismaSession.forwardedHr ?? undefined,
+      initialMsg: prismaSession.initialMsg ?? undefined,
+      fullTranscriptUrl: prismaSession.fullTranscriptUrl ?? null,
+      summary: prismaSession.summary ?? null, // New field
+      transcriptContent: null, // Not available in Session model
+      messages:
+        prismaSession.messages?.map((msg) => ({
+          id: msg.id,
+          sessionId: msg.sessionId,
+          timestamp: msg.timestamp ? new Date(msg.timestamp) : new Date(),
+          role: msg.role,
+          content: msg.content,
+          order: msg.order,
+          createdAt: new Date(msg.createdAt),
+        })) ?? [], // New field - parsed messages
+    };
+
+    return NextResponse.json({ session });
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error ? error.message : "An unknown error occurred";
+    return NextResponse.json(
+      { error: "Failed to fetch session", details: errorMessage },
+      { status: 500 }
+    );
+  }
+}

app/api/dashboard/sessions/route.ts

@@ -0,0 +1,149 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getServerSession } from "next-auth/next";
+import { authOptions } from "../../auth/[...nextauth]/route";
+import { prisma } from "../../../../lib/prisma";
+import {
+  ChatSession,
+  SessionApiResponse,
+  SessionQuery,
+} from "../../../../lib/types";
+import { Prisma } from "@prisma/client";
+
+export async function GET(request: NextRequest) {
+  const authSession = await getServerSession(authOptions);
+
+  if (!authSession || !authSession.user?.companyId) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const companyId = authSession.user.companyId;
+  const { searchParams } = new URL(request.url);
+  
+  const searchTerm = searchParams.get("searchTerm");
+  const category = searchParams.get("category");
+  const language = searchParams.get("language");
+  const startDate = searchParams.get("startDate");
+  const endDate = searchParams.get("endDate");
+  const sortKey = searchParams.get("sortKey");
+  const sortOrder = searchParams.get("sortOrder");
+  const queryPage = searchParams.get("page");
+  const queryPageSize = searchParams.get("pageSize");
+
+  const page = Number(queryPage) || 1;
+  const pageSize = Number(queryPageSize) || 10;
+
+  try {
+    const whereClause: Prisma.SessionWhereInput = { companyId };
+
+    // Search Term
+    if (searchTerm && searchTerm.trim() !== "") {
+      const searchConditions = [
+        { id: { contains: searchTerm } },
+        { initialMsg: { contains: searchTerm } },
+        { summary: { contains: searchTerm } },
+      ];
+      whereClause.OR = searchConditions;
+    }
+
+    // Category Filter
+    if (category && category.trim() !== "") {
+      // Cast to SessionCategory enum if it's a valid value
+      whereClause.category = category as any;
+    }
+
+    // Language Filter
+    if (language && language.trim() !== "") {
+      whereClause.language = language;
+    }
+
+    // Date Range Filter
+    if (startDate) {
+      whereClause.startTime = {
+        ...((whereClause.startTime as object) || {}),
+        gte: new Date(startDate),
+      };
+    }
+    if (endDate) {
+      const inclusiveEndDate = new Date(endDate);
+      inclusiveEndDate.setDate(inclusiveEndDate.getDate() + 1);
+      whereClause.startTime = {
+        ...((whereClause.startTime as object) || {}),
+        lt: inclusiveEndDate,
+      };
+    }
+
+    // Sorting
+    const validSortKeys: { [key: string]: string } = {
+      startTime: "startTime",
+      category: "category",
+      language: "language",
+      sentiment: "sentiment",
+      messagesSent: "messagesSent",
+      avgResponseTime: "avgResponseTime",
+    };
+
+    let orderByCondition:
+      | Prisma.SessionOrderByWithRelationInput
+      | Prisma.SessionOrderByWithRelationInput[];
+
+    const primarySortField =
+      sortKey && validSortKeys[sortKey]
+        ? validSortKeys[sortKey]
+        : "startTime"; // Default to startTime field if sortKey is invalid/missing
+
+    const primarySortOrder =
+      sortOrder === "asc" || sortOrder === "desc" ? sortOrder : "desc"; // Default to desc order
+
+    if (primarySortField === "startTime") {
+      // If sorting by startTime, it's the only sort criteria
+      orderByCondition = { [primarySortField]: primarySortOrder };
+    } else {
+      // If sorting by another field, use startTime: "desc" as secondary sort
+      orderByCondition = [
+        { [primarySortField]: primarySortOrder },
+        { startTime: "desc" },
+      ];
+    }
+
+    const prismaSessions = await prisma.session.findMany({
+      where: whereClause,
+      orderBy: orderByCondition,
+      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,
+      initialMsg: ps.initialMsg ?? undefined,
+      fullTranscriptUrl: ps.fullTranscriptUrl ?? null,
+      transcriptContent: null, // Transcript content is now fetched from fullTranscriptUrl when needed
+    }));
+
+    return NextResponse.json({ sessions, totalSessions });
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error ? error.message : "An unknown error occurred";
+    return NextResponse.json(
+      { error: "Failed to fetch sessions", details: errorMessage },
+      { status: 500 }
+    );
+  }
+}

app/api/dashboard/settings/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getServerSession } from "next-auth";
+import { prisma } from "../../../../lib/prisma";
+import { authOptions } from "../../auth/[...nextauth]/route";
+
+export async function POST(request: NextRequest) {
+  const session = await getServerSession(authOptions);
+  if (!session?.user || session.user.role !== "ADMIN") {
+    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+  }
+
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email as string },
+  });
+
+  if (!user) {
+    return NextResponse.json({ error: "No user" }, { status: 401 });
+  }
+
+  const body = await request.json();
+  const { csvUrl, csvUsername, csvPassword, sentimentThreshold } = body;
+
+  await prisma.company.update({
+    where: { id: user.companyId },
+    data: {
+      csvUrl,
+      csvUsername,
+      ...(csvPassword ? { csvPassword } : {}),
+      sentimentAlert: sentimentThreshold
+        ? parseFloat(sentimentThreshold)
+        : null,
+    },
+  });
+
+  return NextResponse.json({ ok: true });
+}

app/api/dashboard/users/route.ts

@@ -0,0 +1,80 @@
+import { NextRequest, NextResponse } from "next/server";
+import crypto from "crypto";
+import { getServerSession } from "next-auth";
+import { prisma } from "../../../../lib/prisma";
+import bcrypt from "bcryptjs";
+import { authOptions } from "../../auth/[...nextauth]/route";
+
+interface UserBasicInfo {
+  id: string;
+  email: string;
+  role: string;
+}
+
+export async function GET(request: NextRequest) {
+  const session = await getServerSession(authOptions);
+  if (!session?.user || session.user.role !== "ADMIN") {
+    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+  }
+
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email as string },
+  });
+
+  if (!user) {
+    return NextResponse.json({ error: "No user" }, { status: 401 });
+  }
+
+  const users = await prisma.user.findMany({
+    where: { companyId: user.companyId },
+  });
+
+  const mappedUsers: UserBasicInfo[] = users.map((u) => ({
+    id: u.id,
+    email: u.email,
+    role: u.role,
+  }));
+
+  return NextResponse.json({ users: mappedUsers });
+}
+
+export async function POST(request: NextRequest) {
+  const session = await getServerSession(authOptions);
+  if (!session?.user || session.user.role !== "ADMIN") {
+    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+  }
+
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email as string },
+  });
+
+  if (!user) {
+    return NextResponse.json({ error: "No user" }, { status: 401 });
+  }
+
+  const body = await request.json();
+  const { email, role } = body;
+
+  if (!email || !role) {
+    return NextResponse.json({ error: "Missing fields" }, { status: 400 });
+  }
+
+  const exists = await prisma.user.findUnique({ where: { email } });
+  if (exists) {
+    return NextResponse.json({ error: "Email exists" }, { status: 409 });
+  }
+
+  const tempPassword = crypto.randomBytes(12).toString("base64").slice(0, 12); // secure random initial password
+  
+  await prisma.user.create({
+    data: {
+      email,
+      password: await bcrypt.hash(tempPassword, 10),
+      companyId: user.companyId,
+      role,
+    },
+  });
+
+  // TODO: Email user their temp password (stub, for demo) - Implement a robust and secure email sending mechanism. Consider using a transactional email service.
+  return NextResponse.json({ ok: true, tempPassword });
+}