Best OnePageCRM Phone Validation API & Email Verification Integration 2025

// OnePageCRM API integration with action-focused validation
const OnePageClient = require('onepage-crm-api');
const fetch = require('node-fetch');

class OnePageValidationIntegration {
  constructor(onePageConfig, lookupApiKey) {
    this.onePage = new OnePageClient({
      userId: onePageConfig.userId,
      apiKey: onePageConfig.apiKey,
      baseUrl: 'https://app.onepagecrm.com/api/v3'
    });
    this.lookupApiKey = lookupApiKey;
  }
  
  async createValidatedContact(contactData, actionContext = {}) {
    try {
      // Perform action-focused validation
      const validation = await this.validateContactInfo(contactData);
      
      // Calculate action-oriented quality metrics
      const actionMetrics = this.calculateActionMetrics(validation, contactData, actionContext);
      
      // Gather sales action intelligence
      const actionIntelligence = await this.gatherActionIntelligence(contactData, validation);
      
      // Create contact in OnePageCRM with action validation data
      const contact = await this.onePage.contacts.create({
        contact: {
          first_name: contactData.firstName,
          last_name: contactData.lastName,
          company_name: contactData.company,
          job_title: contactData.jobTitle,
          
          // Contact information with validation
          emails: validation.email?.isValid ? [{
            type: 'work',
            address: contactData.email
          }] : [],
          
          phones: validation.phone?.isValid ? [{
            type: validation.phone.lineType === 'mobile' ? 'mobile' : 'work',
            number: contactData.phone
          }] : [],
          
          // Action-focused validation fields
          custom_fields: {
            'validation_status': this.getValidationStatus(validation),
            'phone_validation_result': validation.phone?.isValid ? 'Valid' : 'Invalid',
            'phone_carrier': validation.phone?.carrier || '',
            'phone_line_type': validation.phone?.lineType || '',
            'phone_risk_level': validation.phone?.riskLevel || 'Unknown',
            'phone_location': validation.phone?.location || '',
            
            'email_validation_result': validation.email?.isValid ? 'Valid' : 'Invalid',
            'email_deliverable': validation.email?.deliverable ? 'Deliverable' : 'Not Deliverable',
            'email_risk_level': validation.email?.riskLevel || 'Unknown',
            
            // Action-oriented metrics
            'action_score': actionMetrics.overallScore,
            'sales_action_priority': actionMetrics.salesActionPriority,
            'productivity_score': actionMetrics.productivityScore,
            'action_efficiency': actionMetrics.actionEfficiency,
            'validation_timestamp': new Date().toISOString(),
            
            // Sales action fields
            'next_action_type': actionIntelligence.nextActionType,
            'action_urgency': actionIntelligence.actionUrgency,
            'contact_approach': actionIntelligence.contactApproach,
            'action_sequence': actionIntelligence.actionSequence
          },
          
          // Action-focused tags
          tags: this.generateActionTags(validation, actionMetrics, actionIntelligence).join(',')
        }
      });
      
      // Create next action based on validation
      await this.createNextAction(contact.data.contact.id, validation, actionMetrics, actionIntelligence);
      
      // Add to action-based workflows
      await this.addToActionWorkflows(contact.data.contact.id, validation, actionMetrics);
      
      // Update action-focused analytics
      await this.updateActionAnalytics(validation, actionMetrics);
      
      return {
        success: true,
        contactId: contact.data.contact.id,
        validationResults: validation,
        actionMetrics: actionMetrics,
        actionIntelligence: actionIntelligence,
        actionStrategy: this.developActionStrategy(validation, actionMetrics, actionIntelligence),
        productivityPlan: this.createProductivityPlan(validation, actionMetrics, actionIntelligence)
      };
      
    } catch (error) {
      console.error('OnePageCRM contact creation failed:', error);
      return { success: false, error: error.message };
    }
  }
  
  async validateContactInfo(contactData) {
    const results = {};
    
    // Action-focused 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_action_context: true,
          include_productivity_metrics: true,
          include_sales_action_intelligence: 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,
          actionContext: phoneData.data.action_context,
          productivityMetrics: phoneData.data.productivity_metrics,
          salesActionIntelligence: phoneData.data.sales_action_intelligence,
          reachabilityScore: phoneData.data.classification.reachability_score,
          actionCompatibility: this.assessActionCompatibility(phoneData.data)
        };
      }
    }
    
    // Action-focused 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_action_intelligence: true,
          include_productivity_analysis: true,
          include_sales_action_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,
          actionIntelligence: emailData.data.action_intelligence,
          productivityAnalysis: emailData.data.productivity_analysis,
          salesActionMetrics: emailData.data.sales_action_metrics,
          actionScore: emailData.data.action_intelligence?.action_score,
          deliverabilityConfidence: emailData.data.classification.deliverability_confidence
        };
      }
    }
    
    return results;
  }
  
  calculateActionMetrics(validation, contactData, actionContext) {
    let overallScore = 0;
    let componentScores = {};
    
    // Phone validation scoring for action-focused CRM
    if (validation.phone) {
      let phoneScore = 0;
      
      if (validation.phone.isValid) {
        phoneScore += 37; // Base validity for action CRM
        
        // Action-focused risk assessment
        switch (validation.phone.riskLevel) {
          case 'Low': phoneScore += 25; break;
          case 'Medium': phoneScore += 14; break;
          case 'High': phoneScore -= 7; break;
        }
        
        // Action compatibility scoring
        phoneScore += validation.phone.actionCompatibility * 15;
        
        // Productivity context integration
        if (validation.phone.actionContext?.productivity_enhancing) {
          phoneScore += 13;
        }
        
        // Sales action intelligence
        phoneScore += validation.phone.salesActionIntelligence?.score * 0.09 || 4;
        
        // Line type for action efficiency
        if (validation.phone.lineType === 'mobile') {
          phoneScore += 16; // Mobile preferred for action CRM
        } else if (validation.phone.lineType === 'landline') {
          phoneScore += 11; // Business landlines for B2B actions
        }
        
        // Productivity metrics
        phoneScore += validation.phone.productivityMetrics?.efficiency_score * 0.08 || 4;
        
      } else {
        phoneScore -= 16; // Invalid phone impacts action efficiency
      }
      
      componentScores.phone = Math.max(0, Math.min(100, phoneScore));
      overallScore += componentScores.phone * 0.57; // 57% weight
    }
    
    // Email validation scoring for action-focused CRM
    if (validation.email) {
      let emailScore = 0;
      
      if (validation.email.isValid) {
        emailScore += 33; // Base validity
        
        // Deliverability for action-based marketing
        if (validation.email.deliverable) {
          emailScore += 23;
          emailScore += validation.email.deliverabilityConfidence * 8;
        }
        
        // Action intelligence scoring
        emailScore += validation.email.actionScore * 0.14 || 7;
        
        // Productivity analysis
        emailScore += validation.email.productivityAnalysis?.efficiency_rating * 0.11 || 5;
        
        // Sales action metrics
        emailScore += validation.email.salesActionMetrics?.action_potential * 0.1 || 5;
        
        // Domain quality for action trust
        if (validation.email.domainAge > 365) {
          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.43; // 43% weight
    }
    
    // Calculate action-focused specific metrics
    const salesActionPriority = this.calculateSalesActionPriority(validation, actionContext);
    const productivityScore = this.calculateProductivityScore(validation, contactData);
    const actionEfficiency = this.calculateActionEfficiency(validation, actionContext);
    const actionSequenceOptimization = this.calculateActionSequenceOptimization(validation);
    
    return {
      overallScore: Math.round(overallScore),
      componentScores: componentScores,
      salesActionPriority: salesActionPriority,
      productivityScore: productivityScore,
      actionEfficiency: actionEfficiency,
      actionSequenceOptimization: actionSequenceOptimization,
      calculationTimestamp: new Date().toISOString(),
      actionVersion: '2025.1'
    };
  }
  
  async gatherActionIntelligence(contactData, validation) {
    // Gather action-focused intelligence
    const intelligence = {
      nextActionType: 'Call',
      actionUrgency: 'Medium',
      contactApproach: 'Professional',
      actionSequence: 'Standard'
    };
    
    // Determine next action type
    if (validation.phone?.actionContext?.preferred_action === 'call') {
      intelligence.nextActionType = 'Call';
    } else if (validation.email?.actionIntelligence?.preferred_action === 'email') {
      intelligence.nextActionType = 'Email';
    } else if (validation.phone?.lineType === 'mobile' && validation.phone.riskLevel === 'Low') {
      intelligence.nextActionType = 'Call';
    } else if (validation.email?.deliverable && validation.email.riskLevel === 'Low') {
      intelligence.nextActionType = 'Email';
    }
    
    // Action urgency determination
    const phoneScore = validation.phone?.salesActionIntelligence?.urgency_score || 50;
    const emailScore = validation.email?.salesActionMetrics?.urgency_score || 50;
    const avgUrgency = (phoneScore + emailScore) / 2;
    
    if (avgUrgency >= 80) {
      intelligence.actionUrgency = 'High';
    } else if (avgUrgency >= 60) {
      intelligence.actionUrgency = 'Medium';
    } else {
      intelligence.actionUrgency = 'Low';
    }
    
    // Contact approach
    if (contactData.jobTitle?.toLowerCase().includes('ceo') || 
        contactData.jobTitle?.toLowerCase().includes('president')) {
      intelligence.contactApproach = 'Executive';
    } else if (contactData.jobTitle?.toLowerCase().includes('manager') || 
               contactData.jobTitle?.toLowerCase().includes('director')) {
      intelligence.contactApproach = 'Management';
    } else {
      intelligence.contactApproach = 'Professional';
    }
    
    // Action sequence
    if (validation.phone?.isValid && validation.email?.deliverable) {
      intelligence.actionSequence = 'Multi_Channel';
    } else if (validation.phone?.actionCompatibility >= 0.8) {
      intelligence.actionSequence = 'Phone_Focused';
    } else if (validation.email?.actionScore >= 80) {
      intelligence.actionSequence = 'Email_Focused';
    } else {
      intelligence.actionSequence = 'Research_First';
    }
    
    return intelligence;
  }
  
  async createNextAction(contactId, validation, actionMetrics, actionIntelligence) {
    try {
      const nextAction = await this.onePage.actions.create({
        contact_id: contactId,
        text: this.generateActionText(actionIntelligence, actionMetrics),
        date: this.calculateActionDate(actionIntelligence.actionUrgency),
        assignee_id: await this.getOptimalAssignee(actionMetrics),
        
        // Action-specific data
        custom_fields: {
          'validation_score': actionMetrics.overallScore,
          'action_priority': actionIntelligence.actionUrgency,
          'contact_approach': actionIntelligence.contactApproach,
          'expected_outcome': this.predictActionOutcome(actionMetrics),
          'action_sequence_type': actionIntelligence.actionSequence
        }
      });
      
      return nextAction.data.action.id;
    } catch (error) {
      console.error('Failed to create next action:', error);
      return null;
    }
  }
  
  generateActionText(actionIntelligence, actionMetrics) {
    const actionType = actionIntelligence.nextActionType;
    const urgency = actionIntelligence.actionUrgency;
    const score = actionMetrics.overallScore;
    
    let text = '';
    
    switch (actionType) {
      case 'Call':
        text = `${urgency} priority call - Quality Score: ${score}`;
        break;
      case 'Email':
        text = `Send ${urgency.toLowerCase()} priority email - Quality Score: ${score}`;
        break;
      default:
        text = `Follow up with contact - Quality Score: ${score}`;
    }
    
    return text;
  }
  
  calculateActionDate(urgency) {
    const now = new Date();
    
    switch (urgency) {
      case 'High':
        return new Date(now.getTime() + 2 * 60 * 60 * 1000); // 2 hours
      case 'Medium':
        return new Date(now.getTime() + 8 * 60 * 60 * 1000); // 8 hours
      case 'Low':
        return new Date(now.getTime() + 24 * 60 * 60 * 1000); // 24 hours
      default:
        return new Date(now.getTime() + 8 * 60 * 60 * 1000); // Default 8 hours
    }
  }
  
  predictActionOutcome(actionMetrics) {
    const score = actionMetrics.overallScore;
    
    if (score >= 85) return 'High_Success_Probability';
    if (score >= 70) return 'Good_Success_Probability';
    if (score >= 55) return 'Medium_Success_Probability';
    if (score >= 40) return 'Low_Success_Probability';
    return 'Research_Required';
  }
  
  developActionStrategy(validation, actionMetrics, actionIntelligence) {
    return {
      primaryAction: actionIntelligence.nextActionType,
      actionSequence: actionIntelligence.actionSequence,
      urgencyLevel: actionIntelligence.actionUrgency,
      contactMethod: this.recommendActionMethod(validation),
      expectedEfficiency: `+${Math.round(actionMetrics.actionEfficiency * 0.6)}%`,
      productivityGain: `+${Math.round(actionMetrics.productivityScore * 0.5)}%`,
      timeline: this.determineActionTimeline(actionIntelligence.actionUrgency),
      successProbability: this.predictActionOutcome(actionMetrics)
    };
  }
  
  createProductivityPlan(validation, actionMetrics, actionIntelligence) {
    return {
      dailyActions: {
        highPriority: actionIntelligence.actionUrgency === 'High' ? 1 : 0,
        mediumPriority: actionIntelligence.actionUrgency === 'Medium' ? 1 : 0,
        lowPriority: actionIntelligence.actionUrgency === 'Low' ? 1 : 0
      },
      weeklyGoals: {
        contactsToReach: this.calculateWeeklyTargets(actionMetrics),
        conversionTarget: Math.round(actionMetrics.overallScore * 0.15),
        productivityImprovement: `+${Math.round(actionMetrics.productivityScore * 0.3)}%`
      },
      monthlyObjectives: {
        relationshipBuilding: actionMetrics.overallScore >= 75,
        pipelineGrowth: `+${Math.round(actionMetrics.actionEfficiency * 0.4)}%`,
        teamProductivity: `+${Math.round(actionMetrics.productivityScore * 0.8)}%`
      },
      actionOptimization: {
        enabled: actionMetrics.actionSequenceOptimization >= 70,
        focus: this.identifyOptimizationFocus(actionMetrics),
        expectedImprovement: `+${Math.round(actionMetrics.actionSequenceOptimization * 0.5)}%`
      }
    };
  }
  
  // Helper methods
  assessActionCompatibility(phoneData) {
    let compatibility = 0.4;
    
    if (phoneData.classification.is_valid) compatibility += 0.2;
    if (phoneData.risk_assessment?.risk_level === 'Low') compatibility += 0.15;
    if (phoneData.action_context?.action_ready) compatibility += 0.12;
    if (phoneData.productivity_metrics?.efficiency_score >= 75) compatibility += 0.08;
    if (phoneData.sales_action_intelligence?.optimization_potential >= 70) compatibility += 0.05;
    
    return Math.min(1.0, compatibility);
  }
  
  calculateSalesActionPriority(validation, actionContext) {
    let priority = 'Medium';
    
    const phoneActionScore = validation.phone?.salesActionIntelligence?.priority_score || 50;
    const emailActionScore = validation.email?.salesActionMetrics?.priority_score || 50;
    const avgScore = (phoneActionScore + emailActionScore) / 2;
    
    if (avgScore >= 80) {
      priority = 'High';
    } else if (avgScore < 40) {
      priority = 'Low';
    }
    
    // Context adjustments
    if (actionContext.urgentNeed) priority = 'High';
    if (actionContext.lowPriority) priority = 'Low';
    
    return priority;
  }
  
  calculateProductivityScore(validation, contactData) {
    let score = 25;
    
    if (validation.phone?.productivityMetrics?.efficiency_score >= 80) {
      score += 35;
    }
    
    if (validation.email?.productivityAnalysis?.efficiency_rating >= 75) {
      score += 30;
    }
    
    if (contactData.company && contactData.jobTitle) {
      score += 20; // Clear business context improves productivity
    }
    
    if (validation.phone?.actionCompatibility >= 0.8) {
      score += 15;
    }
    
    return Math.min(100, score);
  }
  
  calculateActionEfficiency(validation, actionContext) {
    let efficiency = 30;
    
    if (validation.phone?.isValid && validation.phone.actionContext?.efficiency_rating >= 80) {
      efficiency += 35;
    }
    
    if (validation.email?.deliverable && validation.email.actionIntelligence?.efficiency_score >= 75) {
      efficiency += 25;
    }
    
    if (actionContext.automationReady) efficiency += 20;
    if (actionContext.teamOptimized) efficiency += 15;
    
    return Math.min(100, efficiency);
  }
  
  calculateActionSequenceOptimization(validation) {
    let optimization = 20;
    
    if (validation.phone?.salesActionIntelligence?.sequence_optimization >= 80) {
      optimization += 40;
    }
    
    if (validation.email?.salesActionMetrics?.sequence_potential >= 75) {
      optimization += 30;
    }
    
    if (validation.phone?.actionCompatibility >= 0.8 && validation.email?.actionScore >= 70) {
      optimization += 20; // Multi-channel sequence potential
    }
    
    return Math.min(100, optimization);
  }
  
  recommendActionMethod(validation) {
    const methods = [];
    
    if (validation.phone?.isValid && validation.phone.actionContext?.call_effectiveness >= 75) {
      methods.push('Phone_Call');
    }
    
    if (validation.email?.deliverable && validation.email.actionIntelligence?.email_effectiveness >= 70) {
      methods.push('Email_Outreach');
    }
    
    if (validation.phone?.lineType === 'mobile' && validation.phone.riskLevel === 'Low') {
      methods.push('SMS_Contact');
    }
    
    return methods.length > 0 ? methods.join(', ') : 'Research_First';
  }
  
  determineActionTimeline(urgency) {
    switch (urgency) {
      case 'High': return 'Same_Day';
      case 'Medium': return 'Within_24_Hours';
      case 'Low': return 'Within_Week';
      default: return 'Within_24_Hours';
    }
  }
  
  calculateWeeklyTargets(actionMetrics) {
    const baseTarget = 10;
    const multiplier = actionMetrics.productivityScore / 100;
    
    return Math.round(baseTarget * multiplier);
  }
  
  identifyOptimizationFocus(actionMetrics) {
    const scores = {
      productivity: actionMetrics.productivityScore,
      efficiency: actionMetrics.actionEfficiency,
      priority: actionMetrics.salesActionPriority === 'High' ? 85 : 
                actionMetrics.salesActionPriority === 'Medium' ? 65 : 45
    };
    
    const lowest = Object.keys(scores).reduce((a, b) => scores[a] < scores[b] ? a : b);
    
    return `${lowest.charAt(0).toUpperCase() + lowest.slice(1)}_Optimization`;
  }
  
  async getOptimalAssignee(actionMetrics) {
    // Determine optimal team member based on action metrics
    // In real implementation, would query OnePageCRM users
    return 1; // Default assignee ID
  }
  
  async updateActionAnalytics(validation, actionMetrics) {
    // Update action-focused analytics
    const analytics = {
      timestamp: new Date().toISOString(),
      phoneValidationRate: validation.phone?.isValid ? 1 : 0,
      emailValidationRate: validation.email?.isValid ? 1 : 0,
      avgActionScore: actionMetrics.overallScore,
      salesActionPriority: actionMetrics.salesActionPriority,
      productivityIndex: actionMetrics.productivityScore,
      actionEfficiency: actionMetrics.actionEfficiency
    };
    
    console.log('Updated action-focused analytics:', analytics);
  }
  
  getValidationStatus(validation) {
    const phoneValid = validation.phone?.isValid || false;
    const emailValid = validation.email?.isValid || false;
    
    if (phoneValid && emailValid) return 'Action_Ready';
    if (phoneValid || emailValid) return 'Partial_Action_Ready';
    return 'Research_Required';
  }
}

// Usage example
const onePageIntegration = new OnePageValidationIntegration({
  userId: process.env.ONEPAGE_USER_ID,
  apiKey: process.env.ONEPAGE_API_KEY
}, process.env.LOOKUP_API_KEY);

// Create action-focused validated contact
const result = await onePageIntegration.createValidatedContact({
  firstName: 'Michael',
  lastName: 'Johnson',
  email: 'michael@actioncorp.com',
  phone: '+1234567890',
  company: 'Action Corp',
  jobTitle: 'Sales Director'
}, {
  urgentNeed: false,
  automationReady: true,
  teamOptimized: true,
  actionFocus: 'productivity'
});

console.log('OnePageCRM action validation result:', result);