Server : Apache/2 System : Linux server-15-235-50-60 5.15.0-164-generic #174-Ubuntu SMP Fri Nov 14 20:25:16 UTC 2025 x86_64 User : gositeme ( 1004) PHP Version : 8.2.29 Disable Function : exec,system,passthru,shell_exec,proc_close,proc_open,dl,popen,show_source,posix_kill,posix_mkfifo,posix_getpwuid,posix_setpgid,posix_setsid,posix_setuid,posix_setgid,posix_seteuid,posix_setegid,posix_uname Directory :  /home/gositeme/backups/lavocat.quebec/backup-20250730-021618/src/pages/api/search/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

import { NextApiRequest, NextApiResponse } from 'next';
import { getServerSession } from 'next-auth/next';
import { authOptions } from '../../../lib/auth';
import { prisma } from '../../../lib/prisma';

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  if (req.method !== 'GET') {
    return res.status(405).json({ message: 'Method not allowed' });
  }

  try {
    const session = await getServerSession(req, res, authOptions);
    const { q: searchTerm, type = 'all', limit = '10' } = req.query;

    if (!searchTerm || typeof searchTerm !== 'string') {
      return res.status(400).json({ message: 'Search term is required' });
    }

    const limitNum = Math.min(parseInt(limit as string) || 10, 50);
    const searchType = type as string;

    const results: any = {
      users: [],
      cases: []
    };

    // Search Users
    if (searchType === 'all' || searchType === 'users') {
      const users = await prisma.user.findMany({
        where: {
          OR: [
            { name: { contains: searchTerm } },
            { username: { contains: searchTerm } },
            { specialization: { contains: searchTerm } },
            { bio: { contains: searchTerm } }
          ]
        },
        select: {
          id: true,
          name: true,
          username: true,
          role: true,
          specialization: true,
          profilePicture: true,
          isVerified: true,
          bio: true,
          createdAt: true
        },
        take: limitNum
      });

      results.users = users.map(user => ({
        ...user,
        type: 'user',
        displayName: user.name,
        displayDescription: user.specialization || user.bio || `${user.role} Professional`,
        url: `/profile/${user.id}`
      }));
    }

    // Search Cases
    if (searchType === 'all' || searchType === 'cases') {
      const cases = await prisma.legalCase.findMany({
        where: {
          OR: [
            { title: { contains: searchTerm } },
            { description: { contains: searchTerm } },
            { publicSummary: { contains: searchTerm } }
          ],
          isPublic: true
        },
        include: {
          leadLawyer: {
            select: {
              id: true,
              name: true,
              username: true,
              profilePicture: true,
              isVerified: true
            }
          }
        },
        take: limitNum
      });

      results.cases = cases.map(case_ => ({
        ...case_,
        type: 'case',
        displayName: case_.title,
        displayDescription: case_.publicSummary || case_.description,
        url: `/live-cases/${case_.id}`
      }));
    }

    // Combine and sort all results
    const allResults = [
      ...results.users,
      ...results.cases
    ];

    // Sort by creation date (newest first)
    allResults.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());

    return res.status(200).json({
      results: allResults,
      total: allResults.length,
      searchTerm,
      searchType
    });

  } catch (error) {
    console.error('Search error:', error);
    return res.status(500).json({ message: 'Internal server error' });
  }
}