route.ts

Go to the documentation of this file.

import { NextRequest, NextResponse } from 'next/server';
import { fieldpineServerApi } from '@/lib/server/fieldpineApi';
import { getStoredAuth } from '@/lib/server/auth';
 
// Helper function to calculate string similarity (Levenshtein distance)
function similarity(s1: string, s2: string): number {
  if (!s1 || !s2) return 0;
  
  const longer = s1.length > s2.length ? s1 : s2;
  const shorter = s1.length > s2.length ? s2 : s1;
  
  if (longer.length === 0) return 100;
  
  const editDistance = levenshteinDistance(longer.toLowerCase(), shorter.toLowerCase());
  return Math.round(((longer.length - editDistance) / longer.length) * 100);
}
 
function levenshteinDistance(s1: string, s2: string): number {
  const costs: number[] = [];
  for (let i = 0; i <= s1.length; i++) {
    let lastValue = i;
    for (let j = 0; j <= s2.length; j++) {
      if (i === 0) {
        costs[j] = j;
      } else if (j > 0) {
        let newValue = costs[j - 1];
        if (s1.charAt(i - 1) !== s2.charAt(j - 1)) {
          newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1;
        }
        costs[j - 1] = lastValue;
        lastValue = newValue;
      }
    }
    if (i > 0) costs[s2.length] = lastValue;
  }
  return costs[s2.length];
}
 
interface Customer {
  f100: number;    // Customer ID
  f101?: string;   // Name
  f102?: string;   // Last Name
  f103?: string;   // First Name
  f112?: string;   // Phone
  f113?: string;   // Mobile
  f115?: string;   // Email
  f254?: string;   // Physkey
}
 
interface DuplicateMatch {
  id1: number;
  id2: number;
  physkey1: string;
  physkey2: string;
  name1: string;
  name2: string;
  phone1: string;
  phone2: string;
  email1: string;
  email2: string;
  similarity: number;
  matchReason: string;
}
 
export async function GET(request: NextRequest) {
  try {
    // Verify authentication
    const authData = await getStoredAuth();
    if (!authData || !authData.authenticated) {
      return NextResponse.json(
        { error: 'Authentication required' },
        { status: 401 }
      );
    }
    
    console.log('[Duplicate Customers] Fetching customer data...');
    
    // Fetch all customers using BUCK API
    const result = await fieldpineServerApi.buckApiCall({
      "3": "retailmax.elink.customers",
      "10": "1000",  // Limit to 1000 customers for performance
      "17": "5"      // Return fields: f100 (id), f101 (name), f102 (lastname), f103 (firstname), f112 (phone), f113 (mobile), f115 (email), f254 (physkey)
    }, authData.apiKey);
    
    console.log('[Duplicate Customers] BUCK result:', {
      hasRootType: !!result?.RootType,
      hasDats: !!result?.DATS,
      datsLength: result?.DATS?.length || 0
    });
    
    // Extract customer data
    const customers: Customer[] = result?.DATS || [];
    
    if (!customers || customers.length === 0) {
      console.log('[Duplicate Customers] No customers found');
      return NextResponse.json({
        success: true,
        duplicates: [],
        message: 'No customers found'
      });
    }
    
    console.log('[Duplicate Customers] Processing', customers.length, 'customers');
    
    // Find potential duplicates
    const duplicates: DuplicateMatch[] = [];
    const processedPairs = new Set<string>();
    
    for (let i = 0; i < customers.length; i++) {
      for (let j = i + 1; j < customers.length; j++) {
        const c1 = customers[i];
        const c2 = customers[j];
        
        // Create unique pair key to avoid duplicates
        const pairKey = `${Math.min(c1.f100, c2.f100)}-${Math.max(c1.f100, c2.f100)}`;
        if (processedPairs.has(pairKey)) continue;
        
        const name1 = c1.f101 || c1.f102 || c1.f103 || '';
        const name2 = c2.f101 || c2.f102 || c2.f103 || '';
        
        const phone1 = c1.f112 || c1.f113 || '';
        const phone2 = c2.f112 || c2.f113 || '';
        
        const email1 = c1.f115 || '';
        const email2 = c2.f115 || '';
        
        let matchScore = 0;
        let matchReason = '';
        
        // Check name similarity
        if (name1 && name2) {
          const nameSimilarity = similarity(name1, name2);
          if (nameSimilarity >= 80) {
            matchScore = nameSimilarity;
            matchReason = 'Similar names';
          }
        }
        
        // Check exact phone match
        if (phone1 && phone2 && phone1 === phone2) {
          matchScore = Math.max(matchScore, 95);
          matchReason = matchReason ? `${matchReason}, Same phone` : 'Same phone number';
        }
        
        // Check exact email match
        if (email1 && email2 && email1.toLowerCase() === email2.toLowerCase()) {
          matchScore = Math.max(matchScore, 98);
          matchReason = matchReason ? `${matchReason}, Same email` : 'Same email address';
        }
        
        // If match score is high enough, add to duplicates
        if (matchScore >= 75) {
          processedPairs.add(pairKey);
          duplicates.push({
            id1: c1.f100,
            id2: c2.f100,
            physkey1: c1.f254 || '',
            physkey2: c2.f254 || '',
            name1: name1,
            name2: name2,
            phone1: phone1,
            phone2: phone2,
            email1: email1,
            email2: email2,
            similarity: matchScore,
            matchReason: matchReason
          });
        }
      }
    }
    
    console.log('[Duplicate Customers] Found', duplicates.length, 'potential duplicates');
    
    // Sort by similarity (highest first)
    duplicates.sort((a, b) => b.similarity - a.similarity);
    
    return NextResponse.json({
      success: true,
      duplicates: duplicates,
      totalCustomers: customers.length,
      source: 'elink'
    });
  } catch (error: any) {
    console.error('Duplicate Customers API error:', error);
    return NextResponse.json(
      { success: false, error: error.message || 'Failed to fetch duplicate customers' },
      { status: 500 }
    );
  }
}