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';
 
interface Product {
  f100: number;  // Product ID
  f101: string;  // Description
  f105: string | null;  // SKU
  f150?: number;  // SellFlags
  f151?: number;  // NoSell (0=can sell, 1=cannot sell)
  f155?: number;  // Hidden (0=visible, 1=hidden)
}
 
interface DuplicateGroup {
  description: string;
  products: Array<{
    id: number;
    sku: string;
    noSell?: boolean;
    hidden?: boolean;
  }>;
  count: number;
}
 
// Levenshtein distance algorithm for string similarity
function levenshteinDistance(str1: string, str2: string): number {
  const len1 = str1.length;
  const len2 = str2.length;
  const matrix: number[][] = [];
 
  for (let i = 0; i <= len1; i++) {
    matrix[i] = [i];
  }
  for (let j = 0; j <= len2; j++) {
    matrix[0][j] = j;
  }
 
  for (let i = 1; i <= len1; i++) {
    for (let j = 1; j <= len2; j++) {
      const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
      matrix[i][j] = Math.min(
        matrix[i - 1][j] + 1,
        matrix[i][j - 1] + 1,
        matrix[i - 1][j - 1] + cost
      );
    }
  }
 
  return matrix[len1][len2];
}
 
// Calculate similarity ratio between two strings (0-1, where 1 is identical)
function similarityRatio(str1: string, str2: string): number {
  const maxLength = Math.max(str1.length, str2.length);
  if (maxLength === 0) return 1.0;
  const distance = levenshteinDistance(str1, str2);
  return 1 - distance / maxLength;
}
 
export async function GET(request: NextRequest) {
  try {
    console.log('[Duplicate Descriptions API] Starting request');
    
    // Verify authentication
    const authData = await getStoredAuth();
    if (!authData || !authData.authenticated) {
      console.log('[Duplicate Descriptions API] Authentication failed');
      return NextResponse.json(
        { error: 'Authentication required' },
        { status: 401 }
      );
    }
    
    console.log('[Duplicate Descriptions API] Making BUCK call');
    
    // Fetch all products with required fields including status fields
    const result = await fieldpineServerApi.buckApiCall({
      "3": "retailmax.elink.products",
      "10": "113,349,100,101,105,103,113s,1101,1102,150,151,155",  // Fields: ID, description, SKU, price, status fields
      "18": "1101,1102",  // Additional fields
      "9": "f503,0,a6",   // Filter settings (a6 = all products including inactive/hidden)
      "8": "150000"       // Limit
    }, authData.apiKey);
    
    console.log('[Duplicate Descriptions API] BUCK result:', {
      hasData: !!result,
      hasDats: !!(result as any)?.DATS,
      datsLength: (result as any)?.DATS?.length || 0,
      resultKeys: Object.keys(result || {})
    });
    
    if (!result || !(result as any).DATS || !Array.isArray((result as any).DATS)) {
      console.error('[Duplicate Descriptions API] Invalid result structure');
      return NextResponse.json(
        { success: false, error: 'Invalid API response structure' },
        { status: 500 }
      );
    }
    
    const products: Product[] = (result as any).DATS;
    console.log('[Duplicate Descriptions API] Processing', products.length, 'products');
    
    // Filter products with descriptions
    const validProducts = products.filter(p => p.f101 && p.f101.trim().length > 0);
    console.log('[Duplicate Descriptions API] Valid products with descriptions:', validProducts.length);
    
    // Group products by similarity (75%+ match threshold)
    const SIMILARITY_THRESHOLD = 0.75;
    const duplicateGroups: Product[][] = [];
    const processed = new Set<number>();
    
    for (let i = 0; i < validProducts.length; i++) {
      if (processed.has(i)) continue;
      
      const product1 = validProducts[i];
      const desc1 = product1.f101.trim().toLowerCase();
      const group: Product[] = [product1];
      processed.add(i);
      
      // Compare with all remaining products
      for (let j = i + 1; j < validProducts.length; j++) {
        if (processed.has(j)) continue;
        
        const product2 = validProducts[j];
        const desc2 = product2.f101.trim().toLowerCase();
        
        // Calculate similarity
        const similarity = similarityRatio(desc1, desc2);
        
        if (similarity >= SIMILARITY_THRESHOLD) {
          group.push(product2);
          processed.add(j);
        }
      }
      
      // Only keep groups with 2+ products
      if (group.length >= 2) {
        duplicateGroups.push(group);
      }
    }
    
    console.log('[Duplicate Descriptions API] Found', duplicateGroups.length, 'duplicate groups using similarity matching');
    
    // Convert to response format with status information
    const duplicates: DuplicateGroup[] = duplicateGroups.map(group => ({
      description: group[0].f101, // Use original description from first product
      products: group.map(p => ({
        id: p.f100,
        sku: p.f105 || `PROD-${p.f100}`,
        noSell: p.f151 === 1,  // true if product cannot be sold
        hidden: p.f155 === 1   // true if product is hidden
      })),
      count: group.length
    }));
    
    // Sort by count (most duplicates first)
    duplicates.sort((a, b) => b.count - a.count);
    
    console.log('[Duplicate Descriptions API] Found', duplicates.length, 'duplicate groups');
    
    return NextResponse.json({
      success: true,
      data: {
        duplicates,
        totalGroups: duplicates.length,
        totalProducts: duplicates.reduce((sum, d) => sum + d.count, 0)
      }
    });
  } catch (error: any) {
    console.error('[Duplicate Descriptions API] Error:', error);
    return NextResponse.json(
      { success: false, error: error.message || 'Failed to fetch duplicate descriptions' },
      { status: 500 }
    );
  }
}