Best Capsule CRM Phone Validation API & Email Verification Integration 2025

// Capsule CRM REST API integration with simple validation
const CapsuleClient = require('capsule-crm-api');
const fetch = require('node-fetch');

class CapsuleValidationIntegration {
  constructor(capsuleConfig, lookupApiKey) {
    this.capsule = new CapsuleClient({
      apiToken: capsuleConfig.apiToken,
      subdomain: capsuleConfig.subdomain
    });
    this.lookupApiKey = lookupApiKey;
  }
  
  async createValidatedContact(contactData, businessContext = {}) {
    try {
      // Perform small business optimized validation
      const validation = await this.validateContactInfo(contactData);
      
      // Calculate simple CRM quality metrics
      const simpleMetrics = this.calculateSimpleMetrics(validation, contactData, businessContext);
      
      // Gather small business intelligence data
      const businessIntelligence = await this.gatherBusinessIntelligence(contactData, validation);
      
      // Create person in Capsule CRM with simple validation data
      const person = await this.capsule.persons.create({
        firstName: contactData.firstName,
        lastName: contactData.lastName,
        jobTitle: contactData.jobTitle,
        organisation: contactData.company ? {
          name: contactData.company
        } : null,
        
        // Contact information with validation
        emailAddresses: validation.email?.isValid ? [{
          address: contactData.email,
          type: 'Work'
        }] : [],
        
        phoneNumbers: validation.phone?.isValid ? [{
          number: contactData.phone,
          type: validation.phone.lineType === 'mobile' ? 'Mobile' : 'Work'
        }] : [],
        
        // Simple CRM validation fields
        customFields: {
          'Validation Status': this.getValidationStatus(validation),
          'Phone Validation': validation.phone?.isValid ? 'Valid' : 'Invalid',
          'Phone Carrier': validation.phone?.carrier || '',
          'Phone Risk Level': validation.phone?.riskLevel || 'Unknown',
          'Phone Location': validation.phone?.location || '',
          
          'Email Validation': validation.email?.isValid ? 'Valid' : 'Invalid',
          'Email Deliverable': validation.email?.deliverable ? 'Yes' : 'No',
          'Email Risk Level': validation.email?.riskLevel || 'Unknown',
          
          // Simple business metrics
          'Contact Quality Score': simpleMetrics.overallScore,
          'Small Business Fit': simpleMetrics.smallBusinessFit,
          'Contact Priority': simpleMetrics.contactPriority,
          'Follow Up Method': simpleMetrics.recommendedFollowUp,
          'Validation Date': new Date().toISOString(),
          
          // Business intelligence fields
          'Business Type': businessIntelligence.businessType,
          'Communication Preference': businessIntelligence.communicationPreference,
          'Relationship Potential': businessIntelligence.relationshipPotential,
          'Small Business Value': businessIntelligence.smallBusinessValue
        },
        
        // Simple tags for easy organization
        tags: this.generateSimpleTags(validation, simpleMetrics, businessIntelligence)
      });
      
      // Create simple opportunity for high-quality contacts
      if (simpleMetrics.overallScore >= 75) {
        await this.createSimpleOpportunity(person.id, validation, simpleMetrics);
      }
      
      // Create follow-up tasks based on validation
      await this.createSimpleTasks(person.id, validation, simpleMetrics);
      
      // Update simple business analytics
      await this.updateSimpleAnalytics(validation, simpleMetrics);
      
      return {
        success: true,
        personId: person.id,
        validationResults: validation,
        simpleMetrics: simpleMetrics,
        businessIntelligence: businessIntelligence,
        simpleStrategy: this.developSimpleStrategy(validation, simpleMetrics, businessIntelligence),
        businessPlan: this.createBusinessPlan(validation, simpleMetrics, businessIntelligence)
      };
      
    } catch (error) {
      console.error('Capsule CRM contact creation failed:', error);
      return { success: false, error: error.message };
    }
  }
  
  async validateContactInfo(contactData) {
    const results = {};
    
    // Small business optimized phone validation
    if (contactData.phone) {
      const phoneResponse = await fetch('https://app.1lookup.io/api/v1/phone', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ 
          phone: contactData.phone,
          include_carrier_details: true,
          include_location_details: true,
          include_risk_assessment: true,
          include_small_business_context: true,
          include_simple_metrics: true
        })
      });
      
      if (phoneResponse.ok) {
        const phoneData = await phoneResponse.json();
        results.phone = {
          isValid: phoneData.data.classification.is_valid,
          carrier: phoneData.data.carrier_details?.name,
          lineType: phoneData.data.carrier_details?.type,
          networkType: phoneData.data.carrier_details?.network_type,
          riskLevel: phoneData.data.risk_assessment?.risk_level,
          riskScore: phoneData.data.risk_assessment?.risk_score,
          location: phoneData.data.location_details?.city,
          state: phoneData.data.location_details?.state,
          country: phoneData.data.location_details?.country,
          timezone: phoneData.data.location_details?.timezone,
          smallBusinessContext: phoneData.data.small_business_context,
          simpleMetrics: phoneData.data.simple_metrics,
          reachabilityScore: phoneData.data.classification.reachability_score,
          simplicity: this.assessSimplicityScore(phoneData.data)
        };
      }
    }
    
    // Small business optimized email validation
    if (contactData.email) {
      const emailResponse = await fetch('https://app.1lookup.io/api/v1/email', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ 
          email: contactData.email,
          include_domain_details: true,
          include_risk_assessment: true,
          include_deliverability_check: true,
          include_small_business_analysis: true,
          include_simplicity_metrics: true
        })
      });
      
      if (emailResponse.ok) {
        const emailData = await emailResponse.json();
        results.email = {
          isValid: emailData.data.classification.is_valid,
          deliverable: emailData.data.classification.deliverable,
          riskLevel: emailData.data.risk_assessment?.risk_level,
          riskScore: emailData.data.risk_assessment?.risk_score,
          domain: emailData.data.domain_details?.domain,
          domainAge: emailData.data.domain_details?.age_days,
          domainReputation: emailData.data.domain_details?.reputation,
          smallBusinessAnalysis: emailData.data.small_business_analysis,
          simplicityMetrics: emailData.data.simplicity_metrics,
          businessValue: emailData.data.small_business_analysis?.business_value,
          deliverabilityConfidence: emailData.data.classification.deliverability_confidence
        };
      }
    }
    
    return results;
  }
  
  calculateSimpleMetrics(validation, contactData, businessContext) {
    let overallScore = 0;
    let componentScores = {};
    
    // Phone validation scoring for simple CRM
    if (validation.phone) {
      let phoneScore = 0;
      
      if (validation.phone.isValid) {
        phoneScore += 40; // Base validity for simple CRM
        
        // Simple risk assessment
        switch (validation.phone.riskLevel) {
          case 'Low': phoneScore += 25; break;
          case 'Medium': phoneScore += 12; break;
          case 'High': phoneScore -= 5; break;
        }
        
        // Simplicity scoring
        phoneScore += validation.phone.simplicity * 15;
        
        // Small business context
        if (validation.phone.smallBusinessContext?.suitability === 'High') {
          phoneScore += 15;
        } else if (validation.phone.smallBusinessContext?.suitability === 'Medium') {
          phoneScore += 10;
        }
        
        // Line type for small business use
        if (validation.phone.lineType === 'mobile') {
          phoneScore += 18; // Mobile preferred for small business
        } else if (validation.phone.lineType === 'landline') {
          phoneScore += 12; // Business landlines still valuable
        }
        
        // Simple metrics integration
        phoneScore += validation.phone.simpleMetrics?.usability_score * 0.1 || 5;
        
      } else {
        phoneScore -= 15; // Invalid phone impacts simple operations
      }
      
      componentScores.phone = Math.max(0, Math.min(100, phoneScore));
      overallScore += componentScores.phone * 0.58; // 58% weight
    }
    
    // Email validation scoring for simple CRM
    if (validation.email) {
      let emailScore = 0;
      
      if (validation.email.isValid) {
        emailScore += 35; // Base validity
        
        // Deliverability for small business marketing
        if (validation.email.deliverable) {
          emailScore += 22;
          emailScore += validation.email.deliverabilityConfidence * 8;
        }
        
        // Small business analysis
        emailScore += validation.email.smallBusinessAnalysis?.relevance_score * 0.15 || 7;
        
        // Business value for small businesses
        emailScore += validation.email.businessValue * 0.12 || 6;
        
        // Simplicity metrics
        emailScore += validation.email.simplicityMetrics?.ease_of_use * 0.1 || 5;
        
        // Domain quality for small business trust
        if (validation.email.domainAge > 180) { // 6+ months
          emailScore += 8;
        }
        
        if (validation.email.domainReputation === 'High') {
          emailScore += 7;
        }
        
      } else {
        emailScore -= 12;
      }
      
      componentScores.email = Math.max(0, Math.min(100, emailScore));
      overallScore += componentScores.email * 0.42; // 42% weight
    }
    
    // Calculate simple CRM specific metrics
    const smallBusinessFit = this.calculateSmallBusinessFit(validation, businessContext);
    const contactPriority = this.calculateContactPriority(validation, contactData);
    const recommendedFollowUp = this.recommendSimpleFollowUp(validation);
    const simplicityIndex = this.calculateSimplicityIndex(validation, contactData);
    
    return {
      overallScore: Math.round(overallScore),
      componentScores: componentScores,
      smallBusinessFit: smallBusinessFit,
      contactPriority: contactPriority,
      recommendedFollowUp: recommendedFollowUp,
      simplicityIndex: simplicityIndex,
      calculationTimestamp: new Date().toISOString(),
      simpleVersion: '2025.1'
    };
  }
  
  async gatherBusinessIntelligence(contactData, validation) {
    // Gather simple business intelligence data
    const intelligence = {
      businessType: 'Unknown',
      communicationPreference: 'Email',
      relationshipPotential: 50,
      smallBusinessValue: 'Medium'
    };
    
    // Business type analysis
    if (validation.email?.domain) {
      const domain = validation.email.domain.toLowerCase();
      
      if (domain.includes('gmail') || domain.includes('yahoo') || domain.includes('hotmail')) {
        intelligence.businessType = 'Personal_Contact';
        intelligence.smallBusinessValue = 'Low';
      } else {
        intelligence.businessType = 'Business_Contact';
        intelligence.smallBusinessValue = 'High';
      }
    }
    
    // Communication preference
    if (validation.phone?.isValid && validation.phone.smallBusinessContext?.phone_preferred) {
      intelligence.communicationPreference = 'Phone';
    } else if (validation.email?.deliverable) {
      intelligence.communicationPreference = 'Email';
    } else {
      intelligence.communicationPreference = 'Research_Needed';
    }
    
    // Relationship potential for small business
    if (validation.phone?.isValid && validation.email?.deliverable && contactData.company) {
      intelligence.relationshipPotential = 85;
    } else if (validation.phone?.isValid || validation.email?.deliverable) {
      intelligence.relationshipPotential = 65;
    } else {
      intelligence.relationshipPotential = 25;
    }
    
    return intelligence;
  }
  
  async createSimpleOpportunity(personId, validation, simpleMetrics) {
    try {
      const opportunity = await this.capsule.opportunities.create({
        name: `Quality Contact - Score: ${simpleMetrics.overallScore}`,
        description: `High-quality contact with validation score of ${simpleMetrics.overallScore}`,
        person: { id: personId },
        milestone: 'New',
        value: {
          amount: this.estimateSimpleValue(simpleMetrics),
          currency: 'USD'
        },
        
        // Simple opportunity fields
        customFields: {
          'Validation Score': simpleMetrics.overallScore,
          'Small Business Fit': simpleMetrics.smallBusinessFit,
          'Contact Priority': simpleMetrics.contactPriority,
          'Simplicity Index': simpleMetrics.simplicityIndex
        }
      });
      
      return opportunity.id;
    } catch (error) {
      console.error('Failed to create simple opportunity:', error);
      return null;
    }
  }
  
  async createSimpleTasks(personId, validation, simpleMetrics) {
    const tasks = [];
    
    // Create simple tasks based on validation results
    if (simpleMetrics.overallScore >= 75) {
      tasks.push({
        description: 'High-Quality Contact Follow-up',
        person: { id: personId },
        dueOn: new Date(Date.now() + 4 * 60 * 60 * 1000), // 4 hours
        category: 'Follow-up'
      });
    } else if (simpleMetrics.overallScore >= 50) {
      tasks.push({
        description: 'Standard Contact Outreach',
        person: { id: personId },
        dueOn: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours
        category: 'Outreach'
      });
    } else {
      tasks.push({
        description: 'Contact Information Research',
        person: { id: personId },
        dueOn: new Date(Date.now() + 48 * 60 * 60 * 1000), // 48 hours
        category: 'Research'
      });
    }
    
    // Create additional task for small business optimization
    if (simpleMetrics.smallBusinessFit >= 80) {
      tasks.push({
        description: 'Small Business Solution Presentation',
        person: { id: personId },
        dueOn: new Date(Date.now() + 8 * 60 * 60 * 1000), // 8 hours
        category: 'Presentation'
      });
    }
    
    // Create tasks in Capsule
    for (const task of tasks) {
      try {
        await this.capsule.tasks.create(task);
      } catch (error) {
        console.error('Failed to create simple task:', error);
      }
    }
  }
  
  generateSimpleTags(validation, simpleMetrics, businessIntelligence) {
    const tags = [];
    
    // Validation-based tags
    if (validation.phone?.isValid) {
      tags.push('phone-validated');
      
      if (validation.phone.riskLevel === 'Low') {
        tags.push('trusted-phone');
      }
    }
    
    if (validation.email?.deliverable) {
      tags.push('email-validated');
      
      if (validation.email.riskLevel === 'Low') {
        tags.push('trusted-email');
      }
    }
    
    // Simple CRM tags
    if (simpleMetrics.overallScore >= 80) {
      tags.push('high-quality');
    } else if (simpleMetrics.overallScore >= 60) {
      tags.push('good-quality');
    } else {
      tags.push('needs-improvement');
    }
    
    // Small business tags
    if (simpleMetrics.smallBusinessFit >= 80) {
      tags.push('small-business-ideal');
    }
    
    // Business intelligence tags
    if (businessIntelligence.businessType === 'Business_Contact') {
      tags.push('business-contact');
    }
    
    if (businessIntelligence.relationshipPotential >= 75) {
      tags.push('high-potential');
    }
    
    return tags;
  }
  
  developSimpleStrategy(validation, simpleMetrics, businessIntelligence) {
    return {
      primaryApproach: businessIntelligence.communicationPreference === 'Phone' ? 'Phone_First' : 'Email_First',
      followUpMethod: simpleMetrics.recommendedFollowUp,
      businessFocus: simpleMetrics.smallBusinessFit >= 70 ? 'Small_Business_Solutions' : 'General_Approach',
      timeline: simpleMetrics.contactPriority === 'High' ? '1-2 weeks' : '2-4 weeks',
      automationLevel: simpleMetrics.simplicityIndex >= 75 ? 'High' : 'Medium',
      expectedOutcome: this.predictSimpleOutcome(simpleMetrics, businessIntelligence),
      resourceRequirement: 'Low', // Capsule is designed for simplicity
      successProbability: Math.min(95, simpleMetrics.overallScore)
    };
  }
  
  createBusinessPlan(validation, simpleMetrics, businessIntelligence) {
    return {
      immediate: {
        timeframe: '1-7 days',
        actions: [
          'Validate_Contact_Information',
          'Initial_Outreach_Attempt',
          'Qualification_Assessment'
        ],
        goal: 'Establish_Initial_Contact'
      },
      shortTerm: {
        timeframe: '1-4 weeks',
        actions: [
          'Relationship_Building',
          'Needs_Assessment',
          'Solution_Alignment'
        ],
        goal: 'Understand_Business_Needs'
      },
      longTerm: {
        timeframe: '1-6 months',
        actions: [
          'Value_Delivery',
          'Relationship_Maintenance',
          'Growth_Opportunities'
        ],
        goal: 'Long_Term_Business_Relationship'
      },
      simplicity: 'High', // Designed for ease of use
      automation: simpleMetrics.simplicityIndex >= 75,
      expectedValue: this.estimateSimpleValue(simpleMetrics)
    };
  }
  
  // Helper methods
  assessSimplicityScore(phoneData) {
    let score = 0.5;
    
    if (phoneData.classification.is_valid) score += 0.2;
    if (phoneData.risk_assessment?.risk_level === 'Low') score += 0.15;
    if (phoneData.small_business_context?.ease_of_use === 'High') score += 0.1;
    if (phoneData.simple_metrics?.user_friendly_score >= 80) score += 0.05;
    
    return Math.min(1.0, score);
  }
  
  calculateSmallBusinessFit(validation, businessContext) {
    let fit = 40;
    
    if (validation.phone?.smallBusinessContext?.suitability === 'High') {
      fit += 30;
    } else if (validation.phone?.smallBusinessContext?.suitability === 'Medium') {
      fit += 20;
    }
    
    if (validation.email?.smallBusinessAnalysis?.relevance_score >= 75) {
      fit += 25;
    }
    
    if (businessContext.businessSize === 'small') fit += 15;
    if (businessContext.industry === 'service') fit += 10;
    
    return Math.min(100, fit);
  }
  
  calculateContactPriority(validation, contactData) {
    let priority = 'Medium';
    
    const phoneScore = validation.phone?.isValid ? 25 : 0;
    const emailScore = validation.email?.deliverable ? 20 : 0;
    const contextScore = (contactData.company && contactData.jobTitle) ? 15 : 0;
    
    const totalScore = phoneScore + emailScore + contextScore;
    
    if (totalScore >= 50) priority = 'High';
    else if (totalScore < 25) priority = 'Low';
    
    return priority;
  }
  
  recommendSimpleFollowUp(validation) {
    const methods = [];
    
    if (validation.phone?.isValid && validation.phone.riskLevel === 'Low') {
      methods.push('Phone_Call');
    }
    
    if (validation.email?.deliverable && validation.email.riskLevel === 'Low') {
      methods.push('Email');
    }
    
    if (methods.length === 0) {
      methods.push('Research_Required');
    }
    
    return methods.join(', ');
  }
  
  calculateSimplicityIndex(validation, contactData) {
    let index = 30;
    
    // Complete contact information increases simplicity
    if (validation.phone?.isValid && validation.email?.deliverable) {
      index += 35;
    }
    
    // Low risk increases simplicity of engagement
    if (validation.phone?.riskLevel === 'Low' && validation.email?.riskLevel === 'Low') {
      index += 25;
    }
    
    // Business context simplifies approach
    if (contactData.company && contactData.jobTitle) {
      index += 20;
    }
    
    return Math.min(100, index);
  }
  
  predictSimpleOutcome(simpleMetrics, businessIntelligence) {
    const score = simpleMetrics.overallScore;
    const businessValue = businessIntelligence.smallBusinessValue;
    
    if (score >= 80 && businessValue === 'High') {
      return 'Strong_Business_Relationship';
    } else if (score >= 60) {
      return 'Regular_Business_Contact';
    } else if (score >= 40) {
      return 'Occasional_Communication';
    } else {
      return 'Limited_Engagement';
    }
  }
  
  estimateSimpleValue(simpleMetrics) {
    const baseValue = 1500; // Small business focused
    const multiplier = simpleMetrics.overallScore / 100;
    const businessBonus = simpleMetrics.smallBusinessFit * 10;
    
    return Math.round(baseValue * multiplier + businessBonus);
  }
  
  async updateSimpleAnalytics(validation, simpleMetrics) {
    // Update simple business analytics
    const analytics = {
      timestamp: new Date().toISOString(),
      phoneValidationRate: validation.phone?.isValid ? 1 : 0,
      emailValidationRate: validation.email?.isValid ? 1 : 0,
      avgQualityScore: simpleMetrics.overallScore,
      smallBusinessFitRate: simpleMetrics.smallBusinessFit,
      simplicityIndex: simpleMetrics.simplicityIndex,
      contactPriorityDistribution: simpleMetrics.contactPriority
    };
    
    console.log('Updated simple CRM analytics:', analytics);
  }
  
  getValidationStatus(validation) {
    const phoneValid = validation.phone?.isValid || false;
    const emailValid = validation.email?.isValid || false;
    
    if (phoneValid && emailValid) return 'Complete';
    if (phoneValid || emailValid) return 'Partial';
    return 'Incomplete';
  }
}

// Usage example
const capsuleIntegration = new CapsuleValidationIntegration({
  apiToken: process.env.CAPSULE_API_TOKEN,
  subdomain: process.env.CAPSULE_SUBDOMAIN
}, process.env.LOOKUP_API_KEY);

// Create simple small business validated contact
const result = await capsuleIntegration.createValidatedContact({
  firstName: 'David',
  lastName: 'Thompson',
  email: 'david@smallbiz.com',
  phone: '+1234567890',
  company: 'Small Business Solutions',
  jobTitle: 'Owner'
}, {
  businessSize: 'small',
  industry: 'service',
  simplicity: 'high',
  automationNeeds: 'basic'
});

console.log('Capsule CRM simple validation result:', result);