import_failed_domains.js

Go to the documentation of this file.

#!/usr/bin/env node
 
/**
 * Import failed domains from WHMCS with today's date as expiration
 * Handles domains that had null/invalid expiration dates
 */
 
require('dotenv').config();
const fs = require('fs');
const path = require('path');
const pool = require('../services/db');
 
const EXPORT_DIR = path.join(__dirname, '../exports');
 
// Get tenant ID from Precise PCs tenant file
/**
 *
 */
function getTenantId() {
  const tenantFilePath = path.join(EXPORT_DIR, 'precise_pcs_tenant.json');
  
  if (fs.existsSync(tenantFilePath)) {
    try {
      const tenantData = JSON.parse(fs.readFileSync(tenantFilePath, 'utf8'));
      console.log(`📂 Using tenant: ${tenantData.name} (${tenantData.tenant_id})`);
      return tenantData.tenant_id;
    } catch (error) {
      console.warn('⚠️  Could not read tenant file, using default');
    }
  }
  
  return process.env.TENANT_ID || '00000000-0000-0000-0000-000000000001';
}
 
/**
 * Map WHMCS status to our domain status
 * @param whmcsStatus
 */
function mapDomainStatus(whmcsStatus) {
  const statusMap = {
    'Active': 'active',
    'Pending': 'pending',
    'Pending Transfer': 'pending_transfer',
    'Expired': 'expired',
    'Cancelled': 'cancelled',
    'Fraud': 'cancelled',
    'Transferred Away': 'transferred_out',
    'Redemption': 'redemption'
  };
  
  return statusMap[whmcsStatus] || 'unknown';
}
 
/**
 * Parse date from WHMCS format
 * @param dateString
 */
function parseDate(dateString) {
  if (!dateString || dateString === 'Invalid Date') {
    return null;
  }
  const date = new Date(dateString);
  return isNaN(date.getTime()) ? null : date.toISOString();
}
 
/**
 * Create customer lookup map from WHMCS user ID to our customer ID
 */
async function createCustomerLookup() {
  const importLogPath = path.join(EXPORT_DIR, 'customer_import_log.json');
  
  if (fs.existsSync(importLogPath)) {
    const log = JSON.parse(fs.readFileSync(importLogPath, 'utf8'));
    const lookup = {};
    
    const entries = Array.isArray(log) ? log : (log.imported || []);
    
    for (const entry of entries) {
      if (entry.whmcs_id && entry.postgres_id) {
        lookup[entry.whmcs_id] = entry.postgres_id;
      } else if (entry.whmcs_id && entry.customer_id) {
        lookup[entry.whmcs_id] = entry.customer_id;
      }
    }
    
    console.log(`📋 Customer lookup: ${Object.keys(lookup).length} mappings loaded`);
    return lookup;
  }
  
  return {};
}
 
/**
 * Import failed domains with today's date as expiration
 */
async function importFailedDomains() {
  const tenantId = getTenantId();
  
  try {
    console.log('========================================');
    console.log('Import Failed Domains (with today\'s date)');
    console.log('========================================\n');
    
    // Load the domain import log to get failed domains
    const logPath = path.join(EXPORT_DIR, 'domain_import_log.json');
    if (!fs.existsSync(logPath)) {
      throw new Error('Domain import log not found. Run import_whmcs_domains.js first.');
    }
    
    const importLog = JSON.parse(fs.readFileSync(logPath, 'utf8'));
    const failedDomains = importLog.errors || [];
    
    console.log(`Found ${failedDomains.length} failed domains to retry\n`);
    
    if (failedDomains.length === 0) {
      console.log('No failed domains to import!');
      return;
    }
    
    // Load full WHMCS export data
    const jsonPath = path.join(EXPORT_DIR, 'whmcs_export.json');
    const exportData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
    const allDomains = exportData.domains || [];
    
    // Create customer lookup
    const customerLookup = await createCustomerLookup();
    
    // Create a map of failed domain names for quick lookup
    const failedDomainNames = new Set(failedDomains.map(d => d.domain?.toLowerCase()));
    
    console.log('Retrying failed domains with today\'s date as expiration...\n');
    
    let imported = 0;
    let skipped = 0;
    let errors = 0;
    const retryLog = {
      tenant_id: tenantId,
      imported_at: new Date().toISOString(),
      imported: [],
      skipped: [],
      errors: []
    };
    
    // Today's date for expiration
    const todayDate = new Date().toISOString();
    
    for (const domain of allDomains) {
      try {
        // Only process domains that failed before
        if (!domain.domain || !failedDomainNames.has(domain.domain.toLowerCase())) {
          continue;
        }
        
        // Get customer ID
        const customerId = customerLookup[domain.userid];
        if (!customerId) {
          console.log(`⚠️  Skipping ${domain.domain}: Customer not found (WHMCS user ${domain.userid})`);
          skipped++;
          retryLog.skipped.push({
            whmcs_id: domain.id,
            domain: domain.domain,
            whmcs_user_id: domain.userid,
            reason: 'Customer not found'
          });
          continue;
        }
        
        // Check if domain was already imported successfully
        const existing = await pool.query(
          'SELECT domain_id FROM domains WHERE tenant_id = $1 AND domain_name = $2',
          [tenantId, domain.domain.toLowerCase()]
        );
        
        if (existing.rows.length > 0) {
          console.log(`⏭️  Skipping ${domain.domain}: Already exists`);
          skipped++;
          retryLog.skipped.push({
            whmcs_id: domain.id,
            domain: domain.domain,
            reason: 'Already exists'
          });
          continue;
        }
        
        // Prepare domain data - use today's date for expiration
        const registrationDate = parseDate(domain.registrationdate) || todayDate;
        
        const domainData = {
          tenant_id: tenantId,
          customer_id: customerId,
          domain_name: domain.domain.toLowerCase(),
          registrar: domain.registrar || 'unknown',
          registrar_domain_id: domain.id.toString(),
          status: mapDomainStatus(domain.status),
          registration_date: registrationDate,
          expiration_date: todayDate, // Use today's date since original was null
          auto_renew: domain.donotrenew ? false : true,
          whois_privacy: domain.idprotection ? true : false,
          renewal_price: parseFloat(domain.recurringamount) || 0,
          currency: 'AUD',
          notes: `Migrated from WHMCS (expiry date missing - set to import date)\nWHMCS Domain ID: ${domain.id}\nOriginal Status: ${domain.status}\nRegistration Type: ${domain.type || 'Unknown'}\nPayment Method: ${domain.paymentmethod || 'N/A'}`
        };
        
        // Insert domain
        const insertQuery = `
          INSERT INTO domains (
            tenant_id, customer_id, domain_name, registrar, registrar_domain_id,
            status, registration_date, expiration_date, auto_renew, whois_privacy,
            renewal_price, currency, notes, created_at, updated_at
          ) VALUES (
            $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, NOW(), NOW()
          )
          RETURNING domain_id, domain_name, status
        `;
        
        const result = await pool.query(insertQuery, [
          domainData.tenant_id,
          domainData.customer_id,
          domainData.domain_name,
          domainData.registrar,
          domainData.registrar_domain_id,
          domainData.status,
          domainData.registration_date,
          domainData.expiration_date,
          domainData.auto_renew,
          domainData.whois_privacy,
          domainData.renewal_price,
          domainData.currency,
          domainData.notes
        ]);
        
        const insertedDomain = result.rows[0];
        
        console.log(`✅ Imported: ${insertedDomain.domain_name} (${insertedDomain.status}) - Expiry set to: ${new Date(todayDate).toLocaleDateString()}`);
        
        imported++;
        retryLog.imported.push({
          domain_id: insertedDomain.domain_id,
          domain_name: insertedDomain.domain_name,
          whmcs_id: domain.id,
          whmcs_user_id: domain.userid,
          customer_id: customerId,
          status: insertedDomain.status,
          registrar: domainData.registrar,
          expiration_date: domainData.expiration_date,
          note: 'Expiration date set to import date (was null in WHMCS)'
        });
        
      } catch (error) {
        console.error(`❌ Error importing ${domain.domain}:`, error.message);
        errors++;
        retryLog.errors.push({
          whmcs_id: domain.id,
          domain: domain.domain,
          error: error.message
        });
      }
    }
    
    // Save retry log
    const retryLogPath = path.join(EXPORT_DIR, 'domain_retry_import_log.json');
    fs.writeFileSync(retryLogPath, JSON.stringify(retryLog, null, 2));
    
    console.log('\n========================================');
    console.log('Failed Domain Retry Summary');
    console.log('========================================');
    console.log(`✅ Imported: ${imported}`);
    console.log(`⏭️  Skipped:  ${skipped}`);
    console.log(`❌ Errors:   ${errors}`);
    console.log('\nRetry log saved:', retryLogPath);
    console.log('========================================\n');
    
    if (imported > 0) {
      console.log('⚠️  Note: All imported domains have expiration date set to TODAY.');
      console.log('   Please update expiration dates manually if you have the correct dates.\n');
    }
    
  } catch (error) {
    console.error('❌ Failed domain import failed:', error.message);
    throw error;
  } finally {
    await pool.end();
  }
}
 
// Run if executed directly
if (require.main === module) {
  importFailedDomains()
    .then(() => {
      console.log('✅ Failed domain retry complete');
      process.exit(0);
    })
    .catch((error) => {
      console.error('❌ Failed domain retry failed:', error);
      process.exit(1);
    });
}
 
module.exports = { importFailedDomains };