Best Close CRM Phone Validation API & Email Verification Integration 2025

// Close CRM API integration with phone validation
const closeApi = require('closeio');
const client = closeApi('YOUR_CLOSE_API_KEY');

async function createValidatedLead(leadData) {
  // Validate phone before creating lead
  if (leadData.phone) {
    const phoneValidation = await fetch('https://app.1lookup.io/api/v1/phone', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ phone: leadData.phone })
    });
    
    const phoneResult = await phoneValidation.json();
    
    // Add validation results to lead data
    leadData.custom = {
      ...leadData.custom,
      phone_validation_status: phoneResult.data.classification.is_valid ? 'Valid' : 'Invalid',
      phone_carrier: phoneResult.data.carrier_details?.name || '',
      phone_risk_level: phoneResult.data.risk_assessment?.risk_level || ''
    };
  }
  
  // Create lead in Close CRM
  return await client.lead.create(leadData);
}

const express = require('express');
const fetch = require('node-fetch');
const app = express();

// Close CRM webhook handler with validation
app.post('/close-webhook', async (req, res) => {
  try {
    const { event, data } = req.body;
    console.log(`Received Close CRM event: ${event}`);
    
    if (event === 'lead.created' || event === 'lead.updated') {
      await processLeadValidation(data);
    } else if (event === 'contact.created' || event === 'contact.updated') {
      await processContactValidation(data);
    }
    
    res.status(200).json({ status: 'success' });
    
  } catch (error) {
    console.error('Webhook processing error:', error);
    res.status(500).json({ error: 'Processing failed' });
  }
});

async function processLeadValidation(lead) {
  const validationResults = {
    phone: null,
    email: null
  };
  
  // Validate phone numbers
  if (lead.phones && lead.phones.length > 0) {
    for (const phoneObj of lead.phones) {
      const result = await validatePhone(phoneObj.phone);
      validationResults.phone = result;
      
      // Update lead with phone validation results
      await updateCloseRecord('lead', lead.id, {
        'custom.phone_validation_status': result.isValid ? 'Valid' : 'Invalid',
        'custom.phone_carrier': result.carrier || '',
        'custom.phone_line_type': result.lineType || '',
        'custom.phone_risk_level': result.riskLevel || 'Low',
        'custom.phone_location': result.location || ''
      });
      
      break; // Process first phone number only
    }
  }
  
  // Validate email addresses  
  if (lead.emails && lead.emails.length > 0) {
    for (const emailObj of lead.emails) {
      const result = await validateEmail(emailObj.email);
      validationResults.email = result;
      
      // Update lead with email validation results
      await updateCloseRecord('lead', lead.id, {
        'custom.email_validation_status': result.isValid ? 'Valid' : 'Invalid',
        'custom.email_risk_level': result.riskLevel || 'Low',
        'custom.email_deliverable': result.deliverable ? 'Yes' : 'No'
      });
      
      break; // Process first email only
    }
  }
  
  // Update lead score based on validation results
  await updateLeadScore(lead.id, validationResults);
}

async function validatePhone(phoneNumber) {
  try {
    const response = await fetch('https://app.1lookup.io/api/v1/phone', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.LOOKUP_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ phone: phoneNumber })
    });
    
    const data = await response.json();
    
    return {
      isValid: data.data.classification.is_valid,
      carrier: data.data.carrier_details?.name,
      lineType: data.data.carrier_details?.type,
      riskLevel: data.data.risk_assessment?.risk_level,
      location: data.data.location_details?.city,
      country: data.data.location_details?.country
    };
    
  } catch (error) {
    console.error('Phone validation error:', error);
    return { isValid: false, error: error.message };
  }
}

async function validateEmail(emailAddress) {
  try {
    const response = await fetch('https://app.1lookup.io/api/v1/email', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.LOOKUP_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ email: emailAddress })
    });
    
    const data = await response.json();
    
    return {
      isValid: data.data.classification.is_valid,
      deliverable: data.data.classification.deliverable,
      riskLevel: data.data.risk_assessment?.risk_level,
      domain: data.data.domain_details?.domain
    };
    
  } catch (error) {
    console.error('Email validation error:', error);
    return { isValid: false, error: error.message };
  }
}

async function updateCloseRecord(recordType, recordId, fields) {
  try {
    const response = await fetch(`https://api.close.com/api/v1/${recordType}/${recordId}/`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${process.env.CLOSE_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(fields)
    });
    
    if (!response.ok) {
      throw new Error(`Close API error: ${response.statusText}`);
    }
    
    return await response.json();
    
  } catch (error) {
    console.error('Close record update error:', error);
    throw error;
  }
}

async function updateLeadScore(leadId, validationResults) {
  let scoreAdjustment = 0;
  
  // Phone validation scoring
  if (validationResults.phone) {
    if (validationResults.phone.isValid) {
      scoreAdjustment += 25;
      
      if (validationResults.phone.riskLevel === 'Low') {
        scoreAdjustment += 15;
      }
      
      if (validationResults.phone.lineType === 'mobile') {
        scoreAdjustment += 10;
      }
    } else {
      scoreAdjustment -= 20;
    }
  }
  
  // Email validation scoring
  if (validationResults.email) {
    if (validationResults.email.isValid && validationResults.email.deliverable) {
      scoreAdjustment += 20;
      
      if (validationResults.email.riskLevel === 'Low') {
        scoreAdjustment += 10;
      }
    } else {
      scoreAdjustment -= 15;
    }
  }
  
  // Update lead with new score
  await updateCloseRecord('lead', leadId, {
    'custom.validation_score': scoreAdjustment,
    'custom.last_validation_date': new Date().toISOString()
  });
}

// Start webhook server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Close CRM webhook server running on port ${PORT}`);
});

// Pre-call validation and logging integration
class CloseCallManager {
  constructor(closeApiKey, lookupApiKey) {
    this.closeClient = new CloseAPI(closeApiKey);
    this.lookupApiKey = lookupApiKey;
  }
  
  async prepareCall(leadId, phoneNumber) {
    try {
      // Validate phone before making call
      const validation = await this.validatePhone(phoneNumber);
      
      // Create call preparation activity
      const activity = await this.closeClient.activity.create({
        lead_id: leadId,
        type: 'call',
        status: 'planned',
        note: `Call prepared - Phone validation: ${validation.isValid ? 'Valid' : 'Invalid'}`,
        custom: {
          phone_carrier: validation.carrier,
          phone_risk_level: validation.riskLevel,
          expected_call_quality: this.calculateCallQuality(validation),
          validation_timestamp: new Date().toISOString()
        }
      });
      
      return {
        canCall: validation.isValid && validation.riskLevel !== 'High',
        callQuality: this.calculateCallQuality(validation),
        carrierInfo: validation.carrier,
        activityId: activity.id,
        recommendations: this.getCallRecommendations(validation)
      };
      
    } catch (error) {
      console.error('Call preparation failed:', error);
      return { canCall: false, error: error.message };
    }
  }
  
  async logCallOutcome(activityId, outcome, duration, notes) {
    try {
      // Update the call activity with outcome
      await this.closeClient.activity.update(activityId, {
        status: 'completed',
        duration: duration,
        note: notes,
        custom: {
          call_outcome: outcome,
          call_duration: duration,
          validation_accuracy: outcome === 'connected' ? 'Accurate' : 'Review',
          completion_timestamp: new Date().toISOString()
        }
      });
      
      // Update lead scoring based on call outcome
      const lead = await this.closeClient.activity.get(activityId).then(a => a.lead_id);
      await this.updateLeadCallScore(lead, outcome, duration);
      
      return { success: true };
      
    } catch (error) {
      console.error('Call logging failed:', error);
      return { success: false, error: error.message };
    }
  }
  
  calculateCallQuality(validation) {
    let score = 0;
    
    if (validation.isValid) score += 40;
    if (validation.riskLevel === 'Low') score += 30;
    if (validation.lineType === 'mobile') score += 20;
    if (validation.carrier && validation.carrier !== 'Unknown') score += 10;
    
    if (score >= 80) return 'Excellent';
    if (score >= 60) return 'Good';
    if (score >= 40) return 'Fair';
    return 'Poor';
  }
  
  getCallRecommendations(validation) {
    const recommendations = [];
    
    if (!validation.isValid) {
      recommendations.push('⚠️ Invalid phone number - do not call');
      return recommendations;
    }
    
    if (validation.riskLevel === 'High') {
      recommendations.push('🚨 High spam risk - proceed with caution');
    }
    
    if (validation.lineType === 'mobile') {
      recommendations.push('📱 Mobile number - text before calling');
    }
    
    if (validation.lineType === 'landline') {
      recommendations.push('🏢 Landline - best calling hours 9-5 local time');
    }
    
    if (validation.carrier) {
      recommendations.push(`📡 Carrier: ${validation.carrier}`);
    }
    
    return recommendations;
  }
  
  async updateLeadCallScore(leadId, outcome, duration) {
    const lead = await this.closeClient.lead.get(leadId);
    const currentScore = lead.custom?.call_score || 0;
    
    let scoreChange = 0;
    
    switch (outcome) {
      case 'connected':
        scoreChange = 25;
        break;
      case 'no_answer':
        scoreChange = -5;
        break;
      case 'busy':
        scoreChange = 5; // Still a valid number
        break;
      case 'invalid':
        scoreChange = -20;
        break;
      case 'voicemail':
        scoreChange = 10;
        break;
      default:
        scoreChange = 0;
    }
    
    // Bonus for longer conversations
    if (duration > 120) { // 2+ minutes
      scoreChange += 15;
    } else if (duration > 60) { // 1+ minute
      scoreChange += 10;
    }
    
    await this.closeClient.lead.update(leadId, {
      'custom.call_score': currentScore + scoreChange,
      'custom.last_call_outcome': outcome,
      'custom.last_call_duration': duration,
      'custom.total_call_attempts': (lead.custom?.total_call_attempts || 0) + 1
    });
  }
  
  async validatePhone(phoneNumber) {
    const response = await fetch('https://app.1lookup.io/api/v1/phone', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.lookupApiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ phone: phoneNumber })
    });
    
    const data = await response.json();
    
    return {
      isValid: data.data.classification.is_valid,
      carrier: data.data.carrier_details?.name,
      lineType: data.data.carrier_details?.type,
      riskLevel: data.data.risk_assessment?.risk_level,
      location: data.data.location_details?.city,
      timezone: data.data.location_details?.timezone
    };
  }
}

// Usage example
const callManager = new CloseCallManager(
  process.env.CLOSE_API_KEY,
  process.env.LOOKUP_API_KEY
);

// Before making a call
const callPrep = await callManager.prepareCall('lead_123', '+1234567890');
if (callPrep.canCall) {
  console.log('Call quality:', callPrep.callQuality);
  console.log('Recommendations:', callPrep.recommendations);
  
  // Make the call...
  
  // After the call
  await callManager.logCallOutcome(
    callPrep.activityId,
    'connected',
    180, // 3 minutes
    'Great conversation, scheduled follow-up'
  );
}

// Close CRM Pipeline and Territory Management Automation
class ClosePipelineManager {
  constructor(closeApiKey) {
    this.closeClient = new CloseAPI(closeApiKey);
    this.pipelineStages = {
      'new_lead': { order: 1, autoAdvance: false },
      'qualified': { order: 2, autoAdvance: true },
      'contacted': { order: 3, autoAdvance: false },
      'demo_scheduled': { order: 4, autoAdvance: false },
      'proposal': { order: 5, autoAdvance: false },
      'closed_won': { order: 6, autoAdvance: false },
      'closed_lost': { order: 7, autoAdvance: false }
    };
    
    this.territories = {
      'US_EAST': { timezone: 'America/New_York', states: ['NY', 'MA', 'FL'] },
      'US_WEST': { timezone: 'America/Los_Angeles', states: ['CA', 'OR', 'WA'] },
      'US_CENTRAL': { timezone: 'America/Chicago', states: ['TX', 'IL', 'CO'] }
    };
  }
  
  async processLeadValidation(leadId, validationResults) {
    try {
      const lead = await this.closeClient.lead.get(leadId);
      
      // Calculate lead quality score
      const qualityScore = this.calculateLeadQuality(validationResults);
      
      // Determine territory assignment
      const territory = this.assignTerritory(validationResults);
      
      // Auto-advance pipeline if qualified
      const newStage = this.determineStage(lead.status_id, qualityScore);
      
      // Find best sales rep for assignment
      const assignedRep = await this.findBestRep(territory, qualityScore);
      
      // Update lead with all new data
      await this.closeClient.lead.update(leadId, {
        status_id: newStage,
        user_id: assignedRep.id,
        custom: {
          validation_score: qualityScore,
          territory: territory,
          phone_carrier: validationResults.phone?.carrier,
          phone_risk_level: validationResults.phone?.riskLevel,
          email_risk_level: validationResults.email?.riskLevel,
          auto_assigned_date: new Date().toISOString(),
          optimal_call_time: this.calculateOptimalCallTime(validationResults.phone?.timezone)
        }
      });
      
      // Create follow-up task for assigned rep
      await this.createFollowUpTask(leadId, assignedRep.id, qualityScore);
      
      return {
        success: true,
        newStage: newStage,
        assignedRep: assignedRep.name,
        territory: territory,
        qualityScore: qualityScore
      };
      
    } catch (error) {
      console.error('Pipeline processing error:', error);
      return { success: false, error: error.message };
    }
  }
  
  calculateLeadQuality(validationResults) {
    let score = 0;
    
    // Phone validation scoring
    if (validationResults.phone) {
      if (validationResults.phone.isValid) {
        score += 40;
        
        switch (validationResults.phone.riskLevel) {
          case 'Low': score += 25; break;
          case 'Medium': score += 15; break;
          case 'High': score -= 10; break;
        }
        
        if (validationResults.phone.lineType === 'mobile') {
          score += 15; // Mobile numbers typically better for sales
        }
        
        if (validationResults.phone.carrier && validationResults.phone.carrier !== 'Unknown') {
          score += 10;
        }
      } else {
        score -= 30; // Invalid phone is a major red flag
      }
    }
    
    // Email validation scoring
    if (validationResults.email) {
      if (validationResults.email.isValid) {
        score += 30;
        
        if (validationResults.email.deliverable) {
          score += 15;
        }
        
        switch (validationResults.email.riskLevel) {
          case 'Low': score += 10; break;
          case 'Medium': score += 5; break;
          case 'High': score -= 5; break;
        }
      } else {
        score -= 20;
      }
    }
    
    // Normalize score to 0-100 range
    return Math.max(0, Math.min(100, score));
  }
  
  assignTerritory(validationResults) {
    // Default territory assignment logic
    if (validationResults.phone?.location) {
      const state = validationResults.phone.location.state;
      
      for (const [territory, config] of Object.entries(this.territories)) {
        if (config.states.includes(state)) {
          return territory;
        }
      }
    }
    
    // Default territory if no match
    return 'US_CENTRAL';
  }
  
  determineStage(currentStage, qualityScore) {
    // Auto-advance high-quality leads
    if (currentStage === 'new_lead' && qualityScore >= 75) {
      return 'qualified';
    }
    
    // Keep current stage for lower quality leads
    return currentStage;
  }
  
  async findBestRep(territory, qualityScore) {
    // Get all active sales reps for territory
    const reps = await this.closeClient.user.list({
      territory: territory,
      is_active: true
    });
    
    // For high-value leads, assign to senior reps
    if (qualityScore >= 80) {
      return reps.find(rep => rep.role === 'senior_sales') || reps[0];
    }
    
    // For medium leads, round-robin assignment
    return this.getRoundRobinRep(reps);
  }
  
  calculateOptimalCallTime(timezone) {
    // Calculate optimal calling time based on timezone
    const now = new Date();
    const timeZoneOffset = this.getTimezoneOffset(timezone);
    
    // Optimal calling hours: 9 AM - 5 PM local time
    const optimalStart = new Date(now);
    optimalStart.setHours(9 + timeZoneOffset, 0, 0, 0);
    
    const optimalEnd = new Date(now);
    optimalEnd.setHours(17 + timeZoneOffset, 0, 0, 0);
    
    return {
      start: optimalStart.toISOString(),
      end: optimalEnd.toISOString(),
      timezone: timezone
    };
  }
  
  async createFollowUpTask(leadId, repId, qualityScore) {
    const priority = qualityScore >= 80 ? 'high' : qualityScore >= 60 ? 'medium' : 'low';
    const dueDate = new Date();
    dueDate.setHours(dueDate.getHours() + (priority === 'high' ? 1 : priority === 'medium' ? 4 : 24));
    
    await this.closeClient.task.create({
      lead_id: leadId,
      assigned_to: repId,
      text: `Follow up on validated lead (Quality Score: ${qualityScore})`,
      due_date: dueDate.toISOString(),
      is_complete: false
    });
  }
  
  getRoundRobinRep(reps) {
    // Simple round-robin logic - in production, use more sophisticated assignment
    const randomIndex = Math.floor(Math.random() * reps.length);
    return reps[randomIndex];
  }
  
  getTimezoneOffset(timezone) {
    // Simplified timezone offset calculation
    const offsets = {
      'America/New_York': -5,
      'America/Chicago': -6,
      'America/Denver': -7,
      'America/Los_Angeles': -8
    };
    
    return offsets[timezone] || -6; // Default to Central Time
  }
}

// Usage example
const pipelineManager = new ClosePipelineManager(process.env.CLOSE_API_KEY);

// Process a lead after validation
const result = await pipelineManager.processLeadValidation('lead_123', {
  phone: {
    isValid: true,
    carrier: 'Verizon',
    lineType: 'mobile',
    riskLevel: 'Low',
    location: { state: 'CA', city: 'San Francisco' },
    timezone: 'America/Los_Angeles'
  },
  email: {
    isValid: true,
    deliverable: true,
    riskLevel: 'Low'
  }
});

console.log('Pipeline result:', result);

// Complete Close CRM integration with advanced sales features
class CloseCRMIntegration {
  constructor(config) {
    this.closeClient = new CloseAPI(config.closeApiKey);
    this.lookupApiKey = config.lookupApiKey;
    this.webhookSecret = config.webhookSecret;
  }
  
  // Bulk lead import with validation
  async importAndValidateLeads(csvData) {
    const results = {
      processed: 0,
      validated: 0,
      invalid: 0,
      errors: []
    };
    
    try {
      const leads = this.parseCSV(csvData);
      
      for (const leadData of leads) {
        try {
          // Validate contact information
          const validation = await this.validateContactInfo(leadData);
          
          // Create lead in Close with validation data
          const lead = await this.closeClient.lead.create({
            name: leadData.company || 'Unknown Company',
            description: leadData.description || '',
            status_id: this.determineInitialStatus(validation),
            custom: {
              phone_validation_status: validation.phone?.isValid ? 'Valid' : 'Invalid',
              email_validation_status: validation.email?.isValid ? 'Valid' : 'Invalid',
              lead_source: 'Bulk Import',
              validation_score: this.calculateValidationScore(validation),
              import_date: new Date().toISOString()
            }
          });
          
          // Add contacts with validated information
          if (leadData.phone && validation.phone?.isValid) {
            await this.closeClient.contact.create({
              lead_id: lead.id,
              name: leadData.contact_name || 'Unknown Contact',
              phones: [{
                phone: leadData.phone,
                type: validation.phone.lineType || 'other'
              }],
              emails: validation.email?.isValid ? [{ email: leadData.email }] : []
            });
          }
          
          results.processed++;
          if (validation.phone?.isValid || validation.email?.isValid) {
            results.validated++;
          } else {
            results.invalid++;
          }
          
        } catch (error) {
          results.errors.push(`Lead ${leadData.company}: ${error.message}`);
        }
      }
      
      return results;
      
    } catch (error) {
      throw new Error(`Bulk import failed: ${error.message}`);
    }
  }
  
  // Sales forecasting based on validation data
  async generateSalesForecast(dateRange = 30) {
    try {
      const leads = await this.closeClient.lead.list({
        date_created__gte: this.getDateDaysAgo(dateRange),
        _limit: 1000
      });
      
      const forecast = {
        totalLeads: leads.data.length,
        validatedLeads: 0,
        highQualityLeads: 0,
        expectedConversions: 0,
        forecastRevenue: 0,
        byCarrier: {},
        byTerritory: {},
        callConnectRate: 0,
        emailDeliverabilityRate: 0
      };
      
      let totalValidationScore = 0;
      let phoneValidCount = 0;
      let emailValidCount = 0;
      
      for (const lead of leads.data) {
        const validationScore = lead.custom?.validation_score || 0;
        
        if (validationScore > 0) {
          forecast.validatedLeads++;
          totalValidationScore += validationScore;
          
          if (validationScore >= 75) {
            forecast.highQualityLeads++;
          }
          
          // Carrier analysis
          const carrier = lead.custom?.phone_carrier;
          if (carrier) {
            forecast.byCarrier[carrier] = (forecast.byCarrier[carrier] || 0) + 1;
          }
          
          // Territory analysis
          const territory = lead.custom?.territory;
          if (territory) {
            forecast.byTerritory[territory] = (forecast.byTerritory[territory] || 0) + 1;
          }
        }
        
        if (lead.custom?.phone_validation_status === 'Valid') {
          phoneValidCount++;
        }
        
        if (lead.custom?.email_validation_status === 'Valid') {
          emailValidCount++;
        }
      }
      
      // Calculate forecasting metrics
      const avgValidationScore = totalValidationScore / Math.max(forecast.validatedLeads, 1);
      forecast.expectedConversions = Math.round(forecast.highQualityLeads * 0.15); // 15% conversion rate
      forecast.forecastRevenue = forecast.expectedConversions * 5000; // Avg deal size $5k
      
      forecast.callConnectRate = Math.round((phoneValidCount / forecast.totalLeads) * 100);
      forecast.emailDeliverabilityRate = Math.round((emailValidCount / forecast.totalLeads) * 100);
      
      return forecast;
      
    } catch (error) {
      throw new Error(`Forecast generation failed: ${error.message}`);
    }
  }
  
  // Lead scoring automation
  async updateLeadScoring() {
    try {
      const leads = await this.closeClient.lead.list({
        status_id__in: ['new_lead', 'qualified', 'contacted'],
        _limit: 500
      });
      
      const updates = [];
      
      for (const lead of leads.data) {
        const score = this.calculateAdvancedLeadScore(lead);
        const priority = this.determinePriority(score);
        
        updates.push({
          id: lead.id,
          custom: {
            ...lead.custom,
            lead_score: score,
            priority: priority,
            score_updated: new Date().toISOString()
          }
        });
      }
      
      // Batch update leads
      for (const update of updates) {
        await this.closeClient.lead.update(update.id, update);
      }
      
      return { updated: updates.length };
      
    } catch (error) {
      throw new Error(`Lead scoring update failed: ${error.message}`);
    }
  }
  
  // Territory performance analysis
  async analyzeTerritoryPerformance() {
    try {
      const leads = await this.closeClient.lead.list({
        date_created__gte: this.getDateDaysAgo(90), // Last 90 days
        _limit: 2000
      });
      
      const analysis = {};
      
      for (const lead of leads.data) {
        const territory = lead.custom?.territory || 'Unassigned';
        
        if (!analysis[territory]) {
          analysis[territory] = {
            totalLeads: 0,
            validatedLeads: 0,
            highQualityLeads: 0,
            conversions: 0,
            avgValidationScore: 0,
            carrierDistribution: {},
            conversionRate: 0
          };
        }
        
        const territoryData = analysis[territory];
        territoryData.totalLeads++;
        
        const validationScore = lead.custom?.validation_score || 0;
        if (validationScore > 0) {
          territoryData.validatedLeads++;
          territoryData.avgValidationScore += validationScore;
          
          if (validationScore >= 75) {
            territoryData.highQualityLeads++;
          }
        }
        
        if (lead.status_id === 'closed_won') {
          territoryData.conversions++;
        }
        
        const carrier = lead.custom?.phone_carrier;
        if (carrier) {
          territoryData.carrierDistribution[carrier] = (territoryData.carrierDistribution[carrier] || 0) + 1;
        }
      }
      
      // Calculate final metrics for each territory
      Object.keys(analysis).forEach(territory => {
        const data = analysis[territory];
        data.avgValidationScore = data.validatedLeads > 0 ? 
          Math.round(data.avgValidationScore / data.validatedLeads) : 0;
        data.conversionRate = data.totalLeads > 0 ? 
          Math.round((data.conversions / data.totalLeads) * 100) : 0;
      });
      
      return analysis;
      
    } catch (error) {
      throw new Error(`Territory analysis failed: ${error.message}`);
    }
  }
  
  // Helper methods
  async validateContactInfo(contactData) {
    const results = {};
    
    if (contactData.phone) {
      results.phone = await this.validatePhone(contactData.phone);
    }
    
    if (contactData.email) {
      results.email = await this.validateEmail(contactData.email);
    }
    
    return results;
  }
  
  async validatePhone(phoneNumber) {
    const response = await fetch('https://app.1lookup.io/api/v1/phone', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.lookupApiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ phone: phoneNumber })
    });
    
    const data = await response.json();
    
    return {
      isValid: data.data.classification.is_valid,
      carrier: data.data.carrier_details?.name,
      lineType: data.data.carrier_details?.type,
      riskLevel: data.data.risk_assessment?.risk_level,
      location: data.data.location_details?.city
    };
  }
  
  calculateAdvancedLeadScore(lead) {
    let score = lead.custom?.validation_score || 0;
    
    // Age of lead factor
    const leadAge = this.getDaysOld(lead.date_created);
    if (leadAge < 7) score += 10; // New leads get bonus
    else if (leadAge > 30) score -= 15; // Old leads get penalty
    
    // Activity factor
    const hasRecentActivity = lead.date_updated > this.getDateDaysAgo(7);
    if (hasRecentActivity) score += 15;
    
    // Source factor
    const source = lead.custom?.lead_source;
    if (source === 'Website Form') score += 20;
    else if (source === 'Referral') score += 25;
    else if (source === 'Cold Outreach') score -= 10;
    
    return Math.max(0, Math.min(100, score));
  }
  
  determinePriority(score) {
    if (score >= 80) return 'Hot';
    if (score >= 60) return 'Warm';
    if (score >= 40) return 'Cold';
    return 'Ice Cold';
  }
  
  getDateDaysAgo(days) {
    const date = new Date();
    date.setDate(date.getDate() - days);
    return date.toISOString();
  }
  
  getDaysOld(dateString) {
    const date = new Date(dateString);
    const now = new Date();
    return Math.floor((now - date) / (1000 * 60 * 60 * 24));
  }
}

// Usage examples
const closeIntegration = new CloseCRMIntegration({
  closeApiKey: process.env.CLOSE_API_KEY,
  lookupApiKey: process.env.LOOKUP_API_KEY,
  webhookSecret: process.env.WEBHOOK_SECRET
});

// Generate sales forecast
const forecast = await closeIntegration.generateSalesForecast(30);
console.log('30-day forecast:', forecast);

// Analyze territory performance
const territoryAnalysis = await closeIntegration.analyzeTerritoryPerformance();
console.log('Territory performance:', territoryAnalysis);