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/domains/lavocat.quebec/public_html/scripts/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

import { prisma } from '../src/lib/prisma';

async function main() {
  console.log('🧪 Testing Business Profiles API Logic...\n');

  // Step 1: Get business profiles (same as API)
  const businessProfiles = await prisma.businessProfile.findMany({
    where: {
      isPublic: true
    },
    include: {
      owner: {
        select: {
          id: true,
          name: true,
          email: true,
          role: true,
          isProfilePublic: true
        }
      }
    },
    orderBy: {
      createdAt: 'desc'
    }
  });

  console.log(`📊 Found ${businessProfiles.length} public business profiles`);

  // Step 2: Test the lawyer query for each business
  let totalLawyersFound = 0;
  let businessesWithLawyers = 0;
  let businessesWithoutLawyers = 0;

  for (const business of businessProfiles.slice(0, 5)) { // Test first 5
    console.log(`\n🔍 Testing business: ${business.businessName}`);
    console.log(`   User ID: ${business.ownerId}`);
    console.log(`   User Role: ${business.owner.role}`);
    console.log(`   User isProfilePublic: ${business.owner.isProfilePublic}`);

    // Test the exact lawyer query from the API
    const lawyers = await prisma.user.findMany({
      where: {
        id: business.ownerId,
        role: 'LAWYER',
        isProfilePublic: true,
      },
      select: {
        id: true,
        name: true,
        role: true,
        profilePicture: true,
        specialization: true,
        yearsOfExperience: true,
        totalCases: true,
        wonCases: true,
        lostCases: true,
        averageRating: true,
        hourlyRate: true,
        totalBadges: true,
        level: true,
        isVerified: true
      }
    });

    console.log(`   Lawyers found: ${lawyers.length}`);
    
    if (lawyers.length > 0) {
      businessesWithLawyers++;
      totalLawyersFound += lawyers.length;
      console.log(`   ✅ Lawyer: ${lawyers[0].name} (${lawyers[0].role})`);
    } else {
      businessesWithoutLawyers++;
      console.log(`   ❌ No lawyers found for this business`);
      
      // Debug: Check what's wrong with the user
      const userCheck = await prisma.user.findUnique({
        where: { id: business.ownerId },
        select: {
          id: true,
          name: true,
          role: true,
          isProfilePublic: true
        }
      });
      
      if (userCheck) {
        console.log(`   🔍 User exists but doesn't match criteria:`);
        console.log(`      Role: ${userCheck.role} (expected: LAWYER)`);
        console.log(`      isProfilePublic: ${userCheck.isProfilePublic} (expected: true)`);
      } else {
        console.log(`   🔍 User not found!`);
      }
    }
  }

  console.log(`\n📈 Summary:`);
  console.log(`   Businesses with lawyers: ${businessesWithLawyers}`);
  console.log(`   Businesses without lawyers: ${businessesWithoutLawyers}`);
  console.log(`   Total lawyers found: ${totalLawyersFound}`);

  // Test the complete API logic
  console.log(`\n🔄 Testing complete API logic...`);
  
  const enhancedBusinesses = await Promise.all(
    businessProfiles.slice(0, 3).map(async (business) => {
      const lawyers = await prisma.user.findMany({
        where: {
          id: business.ownerId,
          role: 'LAWYER',
          isProfilePublic: true,
        },
        select: {
          id: true,
          name: true,
          role: true,
          profilePicture: true,
          specialization: true,
          yearsOfExperience: true,
          totalCases: true,
          wonCases: true,
          lostCases: true,
          averageRating: true,
          hourlyRate: true,
          totalBadges: true,
          level: true,
          isVerified: true
        }
      });

      const lawyersWithStats = lawyers.map(lawyer => ({
        ...lawyer,
        winRate: lawyer.totalCases > 0 ? (lawyer.wonCases / lawyer.totalCases) * 100 : 0
      }));

      const firmStats = {
        totalLawyers: lawyersWithStats.length,
        totalCases: lawyersWithStats.reduce((sum, lawyer) => sum + lawyer.totalCases, 0),
        totalWonCases: lawyersWithStats.reduce((sum, lawyer) => sum + lawyer.wonCases, 0),
        totalLostCases: lawyersWithStats.reduce((sum, lawyer) => sum + lawyer.lostCases, 0),
        averageWinRate: lawyersWithStats.length > 0 
          ? lawyersWithStats.reduce((sum, lawyer) => sum + lawyer.winRate, 0) / lawyersWithStats.length 
          : 0,
        averageRating: lawyersWithStats.length > 0 
          ? lawyersWithStats.reduce((sum, lawyer) => sum + (lawyer.averageRating || 0), 0) / lawyersWithStats.length 
          : 0,
        averageHourlyRate: lawyersWithStats.length > 0 
          ? lawyersWithStats.reduce((sum, lawyer) => sum + (lawyer.hourlyRate || 0), 0) / lawyersWithStats.length 
          : 0,
        totalBadges: lawyersWithStats.reduce((sum, lawyer) => sum + lawyer.totalBadges, 0),
        averageLevel: lawyersWithStats.length > 0 
          ? lawyersWithStats.reduce((sum, lawyer) => sum + lawyer.level, 0) / lawyersWithStats.length 
          : 0
      };

      return {
        ...business,
        lawyers: lawyersWithStats,
        firmStats
      };
    })
  );

  console.log(`\n📋 Enhanced businesses result:`);
  enhancedBusinesses.forEach((business, index) => {
    console.log(`\n${index + 1}. ${business.businessName}`);
    console.log(`   Lawyers: ${business.lawyers.length}`);
    console.log(`   Firm Stats - Total Lawyers: ${business.firmStats.totalLawyers}`);
    console.log(`   Firm Stats - Total Cases: ${business.firmStats.totalCases}`);
  });

  console.log(`\n🎯 Test Complete!`);
}

main()
  .catch((e) => {
    console.error('❌ Error during test:', e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });