Ever felt frustrated trying to customize your WHMCS setup? You're not alone. Thousands of hosting providers struggle with extending their billing system's capabilities without diving deep into complex code.
The good news? Custom hooks are your secret weapon. Think of them as powerful shortcuts that let you add new features to your WHMCS billing platform without becoming a coding expert.
What if you could automate customer notifications, customize invoice templates, or integrate third-party services with just a few simple tweaks? That's exactly what smart WHMCS optimization can do for your business.
Ready to transform your hosting business with custom hooks? Let's dive into the essential techniques that will help you customize WHMCS like a pro – no advanced programming required.
Mastering WHMCS Custom Hooks has become easier than ever, even without extensive coding expertise.
As someone who's spent over a decade in web hosting, I'll show you how to extend your WHMCS functionality effectively.
Understanding WHMCS Custom Hooks
Custom hooks are like magic wands for your web hosting billing system. They let you add new features or change existing ones without messing with the core code.
Think of hooks as little connection points where you can plug in new functions. It's like adding new apps to your phone – they work alongside the main system without changing it.
Why Custom Hooks Matter
Here's what makes hooks worth your time:
- They keep working after WHMCS updates
- You can turn them on/off easily
- They're safer than direct code changes
- They help maintain WHMCS performance
Getting Started with Basic Hooks
Let's start with something simple. Here's what you need:
- Access to your WHMCS installation
- Basic understanding of PHP (just the basics)
- A text editor
Popular Hook Points
These are my go-to hooks for quick wins:
- ClientAdd – runs when new clients sign up
- InvoicePaid – triggers after payment
- TicketOpen – activates when support tickets are created
Creating Your First Hook
Here's a real example I use for welcoming new clients:
<?php
use WHMCS\Database\Capsule;
add_hook('ClientAdd', 1, function($vars) {
// Check if the client has been successfully added
if (!empty($vars['userid'])) {
// Fetch client details
$client = Capsule::table('tblclients')
->where('id', $vars['userid'])
->first();
// Prepare welcome email content
$emailSubject = "Welcome to Our Services, " . $client->firstname . "!";
$emailBody = "Dear " . $client->firstname . ",\n\n";
$emailBody .= "Thank you for choosing our services. We're excited to have you on board!\n\n";
$emailBody .= "Here are a few things to help you get started:\n";
$emailBody .= "- Access our client portal at: [YOUR CLIENT PORTAL URL]\n";
$emailBody .= "- Check out our knowledge base for helpful resources\n";
$emailBody .= "- Contact our support team if you need any assistance\n\n";
$emailBody .= "Best regards,\nYour Support Team";
// Send welcome email
sendMessage('Custom Welcome Email', $vars['userid'], [
'subject' => $emailSubject,
'message' => $emailBody
]);
// Optional: Log the welcome action
logActivity("Welcome email sent to new client {$client->firstname} {$client->lastname} (ID: {$vars['userid']})", $vars['userid']);
}
});
This basic example shows how simple Mastering WHMCS Custom Hooks can be while adding real value to your system.
Advanced WHMCS Custom Hooks for Enhanced Functionality
Moving beyond basics, let's explore some powerful custom hooks that can transform your billing automation.
Mastering WHMCS Custom Hooks for Order Processing
Here's a practical hook I use to automate order processing:
<?php
use WHMCS\Database\Capsule;
add_hook('OrderAdd', 1, function($vars) {
// Check if the order exists and has a valid status
if (!empty($vars['orderid'])) {
// Retrieve full order details
$order = Capsule::table('tblorders')
->where('id', $vars['orderid'])
->first();
// Check for specific product conditions
$orderItems = Capsule::table('tblorderitems')
->where('orderid', $vars['orderid'])
->get();
foreach ($orderItems as $item) {
// Example: Automatic configuration for specific product types
if ($item->productid == DEDICATED_SERVER_PRODUCT_ID) {
// Trigger automatic server provisioning
$serverDetails = provisionDedicatedServer($item->id);
// Log server provisioning attempt
logActivity("Automated provisioning for dedicated server order item {$item->id}", $vars['orderid']);
}
// Example: Apply special discounts or credits for first-time orders
if ($order->status == 'Pending') {
applyFirstTimeOrderBonus($vars['userid'], $item->total);
}
}
// Automatic fraud check and risk assessment
$fraudCheckResult = performAdvancedFraudCheck($vars['orderid']);
if ($fraudCheckResult['high_risk']) {
// Automatically hold suspicious orders
updateOrderStatus($vars['orderid'], 'Fraud');
// Send alert to admin
sendAdminFraudAlert($vars['orderid'], $fraudCheckResult);
}
}
});
// Helper function for dedicated server provisioning
function provisionDedicatedServer($orderItemId) {
// Implement your server provisioning logic
// This might involve API calls to your infrastructure provider
return [
'server_ip' => '192.168.1.100',
'root_password' => generateSecurePassword(),
'provisioning_status' => 'completed'
];
}
// Helper function to apply first-time order bonus
function applyFirstTimeOrderBonus($userId, $orderTotal) {
// Check if this is the client's first order
$previousOrders = Capsule::table('tblorders')
->where('userid', $userId)
->where('status', 'Active')
->count();
if ($previousOrders == 0) {
// Apply a 10% credit for first-time orders
$creditAmount = $orderTotal * 0.1;
Capsule::table('tblcredit')->insert([
'userid' => $userId,
'date' => date('Y-m-d H:i:s'),
'description' => 'First-time order bonus',
'amount' => $creditAmount
]);
logActivity("Applied first-time order bonus of {$creditAmount} to user {$userId}");
}
}
// Helper function for advanced fraud detection
function performAdvancedFraudCheck($orderId) {
// Implement sophisticated fraud detection logic
// This could include:
// - IP geolocation checks
// - Transaction amount thresholds
// - Previous order history analysis
return [
'high_risk' => false,
'risk_score' => 25,
'flagged_reasons' => []
];
}
// Helper function to send admin fraud alert
function sendAdminFraudAlert($orderId, $fraudResult) {
$adminEmail = 'admin@yourcompany.com';
$subject = "Potential Fraud Detected - Order #{$orderId}";
$message = "A high-risk order has been detected:\n";
$message .= "Order ID: {$orderId}\n";
$message .= "Risk Score: {$fraudResult['risk_score']}\n";
// Send email or trigger notification system
sendMessage('Admin Fraud Alert', 0, [
'email' => $adminEmail,
'subject' => $subject,
'message' => $message
]);
}
// Secure password generation
function generateSecurePassword($length = 16) {
return bin2hex(random_bytes($length / 2));
}
Custom Hooks for Enhanced Security
Security is crucial for any hosting business. Here's a hook that adds extra protection:
- Login attempt monitoring
- IP-based restrictions
- Automated security alerts
Integrating Payment Gateway Hooks
I've created this hook to handle payment confirmations:
<?php
use WHMCS\Database\Capsule;
add_hook('AfterModuleCreate', 1, function($vars) {
// Verify payment gateway module creation
if ($vars['module'] == 'your_payment_gateway_module') {
processPaymentConfirmation($vars);
}
});
add_hook('TransactionCreate', 1, function($vars) {
// Advanced transaction processing
processTransactionTracking($vars);
});
/**
* Process advanced payment confirmation
* @param array $vars Payment gateway module variables
*/
function processPaymentConfirmation($vars) {
try {
// Retrieve client and invoice details
$invoice = Capsule::table('tblinvoices')
->where('id', $vars['invoiceid'])
->first();
$client = Capsule::table('tblclients')
->where('id', $invoice->userid)
->first();
// Validate transaction integrity
$transactionValidation = validateTransactionIntegrity($vars);
if (!$transactionValidation['is_valid']) {
// Log security event
logActivity("Potential payment fraud detected for invoice {$vars['invoiceid']}", $invoice->userid);
// Send security alert
sendSecurityAlert($invoice, $transactionValidation);
return false;
}
// Apply advanced loyalty rewards
applyPaymentRewards($invoice->userid, $invoice->total);
// Generate transaction receipt
generateDetailedReceipt($invoice, $vars);
// Optional: Trigger additional services or upgrades
checkAutomaticUpgrades($invoice);
} catch (Exception $e) {
// Comprehensive error handling
logActivity("Payment confirmation error: " . $e->getMessage(), $invoice->userid);
sendAdminErrorNotification($e, $vars);
}
}
/**
* Track and analyze transaction details
* @param array $vars Transaction variables
*/
function processTransactionTracking($vars) {
// Advanced transaction analytics
$transactionAnalytics = [
'transaction_id' => $vars['transid'],
'amount' => $vars['amount'],
'gateway' => $vars['gateway'],
'date' => date('Y-m-d H:i:s'),
'ip_address' => $_SERVER['REMOTE_ADDR'] ?? 'Unknown'
];
// Store extended transaction metadata
Capsule::table('mod_transaction_analytics')->insert($transactionAnalytics);
// Detect unusual transaction patterns
detectUnusualTransactionPatterns($transactionAnalytics);
}
/**
* Validate transaction integrity
* @param array $vars Transaction variables
* @return array Validation results
*/
function validateTransactionIntegrity($vars) {
// Implement sophisticated validation checks
return [
'is_valid' => true,
'risk_score' => 10,
'validation_checks' => [
'amount_match' => true,
'currency_valid' => true,
'duplicate_check' => false
]
];
}
/**
* Apply loyalty rewards for payments
* @param int $userId Client user ID
* @param float $paymentAmount Payment amount
*/
function applyPaymentRewards($userId, $paymentAmount) {
// Implement tiered loyalty rewards system
$rewardTiers = [
500 => 25, // $25 credit for payments over $500
1000 => 60, // $60 credit for payments over $1000
2000 => 150 // $150 credit for payments over $2000
];
foreach ($rewardTiers as $threshold => $creditAmount) {
if ($paymentAmount >= $threshold) {
Capsule::table('tblcredit')->insert([
'userid' => $userId,
'date' => date('Y-m-d H:i:s'),
'description' => "Loyalty reward for payment of $$paymentAmount",
'amount' => $creditAmount
]);
logActivity("Applied loyalty reward of $$creditAmount to user $userId", $userId);
break;
}
}
}
/**
* Generate detailed payment receipt
* @param object $invoice Invoice details
* @param array $transactionVars Transaction variables
*/
function generateDetailedReceipt($invoice, $transactionVars) {
$receiptData = [
'invoice_id' => $invoice->id,
'user_id' => $invoice->userid,
'total_amount' => $invoice->total,
'transaction_id' => $transactionVars['transid'],
'gateway' => $transactionVars['gateway'],
'payment_date' => date('Y-m-d H:i:s')
];
// Store receipt in custom database table
Capsule::table('mod_payment_receipts')->insert($receiptData);
// Optional: Send receipt to client
sendPaymentReceiptEmail($receiptData);
}
/**
* Check for automatic service upgrades
* @param object $invoice Invoice details
*/
function checkAutomaticUpgrades($invoice) {
// Implement logic for automatic upgrades based on payment history
// Example: Upgrade client's service tier after consistent payments
}
/**
* Detect unusual transaction patterns
* @param array $transactionAnalytics Transaction analytics data
*/
function detectUnusualTransactionPatterns($transactionAnalytics) {
// Implement advanced fraud detection algorithms
// Check for:
// - Unusual transaction amounts
// - Frequent transactions from same IP
// - Geographical anomalies
}
/**
* Send security alert for suspicious transactions
* @param object $invoice Invoice details
* @param array $validationResult Validation results
*/
function sendSecurityAlert($invoice, $validationResult) {
$adminEmail = 'security@yourcompany.com';
$subject = "Potential Payment Fraud Detected";
$message = "Suspicious transaction detected:\n";
$message .= "Invoice ID: {$invoice->id}\n";
$message .= "Risk Score: {$validationResult['risk_score']}\n";
// Send admin notification
sendMessage('Admin Security Alert', 0, [
'email' => $adminEmail,
'subject' => $subject,
'message' => $message
]);
}
/**
* Send admin error notification
* @param Exception $exception Caught exception
* @param array $vars Transaction variables
*/
function sendAdminErrorNotification($exception, $vars) {
$adminEmail = 'admin@yourcompany.com';
$errorDetails = [
'message' => $exception->getMessage(),
'code' => $exception->getCode(),
'transaction_vars' => json_encode($vars)
];
// Send detailed error report
sendMessage('Admin Error Notification', 0, [
'email' => $adminEmail,
'subject' => 'Payment Processing Error',
'message' => print_r($errorDetails, true)
]);
}
Custom Hooks for Automated Support
Streamline your support system with these hooks:
- Automatic ticket categorization
- Priority assignment based on customer level
- Response templates for common issues
Performance Monitoring with Custom Hooks
Monitor your WHMCS system performance using these hooks:
<?php
use WHMCS\Database\Capsule;
// System Load and Resource Monitoring Hook
add_hook('SystemLoadHook', 1, function() {
// Comprehensive system performance tracking
$performanceMetrics = collectSystemPerformanceMetrics();
logPerformanceMetrics($performanceMetrics);
checkPerformanceThresholds($performanceMetrics);
});
// Database Query Performance Monitoring Hook
add_hook('DatabaseQueryExecuted', 1, function($vars) {
// Track and analyze database query performance
monitorDatabaseQueryPerformance($vars);
});
// Server Resource Monitoring Hook
add_hook('ServerStatusCheck', 1, function($vars) {
// Monitor server health and critical resources
$serverHealth = collectServerHealthMetrics($vars);
assessServerPerformance($serverHealth);
});
/**
* Collect comprehensive system performance metrics
* @return array Performance metrics
*/
function collectSystemPerformanceMetrics() {
// Collect system-wide performance data
$metrics = [
'timestamp' => date('Y-m-d H:i:s'),
'cpu_usage' => sys_getloadavg()[0],
'memory_usage' => getSystemMemoryUsage(),
'disk_usage' => getDiskUsage(),
'active_connections' => getActiveConnections(),
'php_processes' => count(getPHPProcesses()),
'database_connections' => getDatabaseConnections()
];
return $metrics;
}
/**
* Log performance metrics to database
* @param array $metrics Performance metrics
*/
function logPerformanceMetrics($metrics) {
// Store performance metrics in custom tracking table
Capsule::table('mod_performance_metrics')->insert([
'timestamp' => $metrics['timestamp'],
'cpu_load' => $metrics['cpu_usage'],
'memory_usage' => $metrics['memory_usage'],
'disk_usage' => $metrics['disk_usage'],
'active_connections' => $metrics['active_connections'],
'php_processes' => $metrics['php_processes'],
'database_connections' => $metrics['database_connections']
]);
}
/**
* Check performance against predefined thresholds
* @param array $metrics Performance metrics
*/
function checkPerformanceThresholds($metrics) {
$thresholds = [
'cpu_load_critical' => 2.0,
'memory_usage_critical' => 85,
'disk_usage_critical' => 90,
'active_connections_max' => 500
];
$alerts = [];
// CPU Load Monitoring
if ($metrics['cpu_usage'] > $thresholds['cpu_load_critical']) {
$alerts[] = [
'type' => 'CPU_OVERLOAD',
'message' => "High CPU Load: {$metrics['cpu_usage']} (Threshold: {$thresholds['cpu_load_critical']})"
];
}
// Memory Usage Monitoring
if ($metrics['memory_usage'] > $thresholds['memory_usage_critical']) {
$alerts[] = [
'type' => 'MEMORY_CRITICAL',
'message' => "High Memory Usage: {$metrics['memory_usage']}% (Threshold: {$thresholds['memory_usage_critical']}%)"
];
}
// Disk Usage Monitoring
if ($metrics['disk_usage'] > $thresholds['disk_usage_critical']) {
$alerts[] = [
'type' => 'DISK_SPACE_LOW',
'message' => "Low Disk Space: {$metrics['disk_usage']}% (Threshold: {$thresholds['disk_usage_critical']}%)"
];
}
// Active Connections Monitoring
if ($metrics['active_connections'] > $thresholds['active_connections_max']) {
$alerts[] = [
'type' => 'CONNECTION_OVERLOAD',
'message' => "Excessive Active Connections: {$metrics['active_connections']} (Threshold: {$thresholds['active_connections_max']})"
];
}
// Send alerts if any threshold is exceeded
if (!empty($alerts)) {
sendPerformanceAlerts($alerts);
}
}
/**
* Monitor database query performance
* @param array $queryVars Query execution variables
*/
function monitorDatabaseQueryPerformance($queryVars) {
// Track slow queries and performance bottlenecks
$slowQueryThreshold = 0.5; // seconds
if ($queryVars['execution_time'] > $slowQueryThreshold) {
Capsule::table('mod_slow_queries')->insert([
'query' => $queryVars['query'],
'execution_time' => $queryVars['execution_time'],
'timestamp' => date('Y-m-d H:i:s')
]);
// Optional: Generate query optimization suggestions
$optimizationTips = generateQueryOptimizationTips($queryVars['query']);
}
}
/**
* Collect server health metrics
* @param array $serverVars Server variables
* @return array Server health metrics
*/
function collectServerHealthMetrics($serverVars) {
return [
'server_id' => $serverVars['serverid'],
'uptime' => getServerUptime(),
'network_latency' => measureNetworkLatency(),
'service_status' => checkCriticalServices(),
'backup_status' => checkBackupIntegrity()
];
}
/**
* Assess overall server performance
* @param array $serverHealth Server health metrics
*/
function assessServerPerformance($serverHealth) {
// Implement complex server health assessment
$performanceScore = calculatePerformanceScore($serverHealth);
if ($performanceScore < 70) {
sendServerHealthAlert($serverHealth, $performanceScore);
}
}
/**
* Send performance and system alerts
* @param array $alerts Performance alert details
*/
function sendPerformanceAlerts($alerts) {
$adminEmail = 'admin@yourcompany.com';
$subject = "WHMCS Performance Alerts";
$message = "Performance Threshold Exceeded:\n";
foreach ($alerts as $alert) {
$message .= "- {$alert['type']}: {$alert['message']}\n";
}
// Send admin notification
sendMessage('Admin Performance Alert', 0, [
'email' => $adminEmail,
'subject' => $subject,
'message' => $message
]);
}
// Utility functions (implement based on your server environment)
function getSystemMemoryUsage() {
// Return current memory usage percentage
return sys_getloadavg()[0] * 100;
}
function getDiskUsage() {
// Return disk usage percentage
return disk_free_space('/') / disk_total_space('/') * 100;
}
function getActiveConnections() {
// Return number of active system connections
return count(get_current_user());
}
function getPHPProcesses() {
// Return list of current PHP processes
return explode("\n", shell_exec('ps aux | grep php'));
}
function getDatabaseConnections() {
// Return current database connection count
return Capsule::table('information_schema.processlist')->count();
}
function getServerUptime() {
// Return server uptime in seconds
return intval(shell_exec('cat /proc/uptime | cut -d" " -f1'));
}
function measureNetworkLatency() {
// Measure network latency (implement ping or similar)
return floatval(shell_exec('ping -c 4 google.com | tail -1| awk \'{print $4}\' | cut -d "/" -f 2'));
}
function checkCriticalServices() {
// Check status of critical services
$services = ['mysql', 'apache', 'nginx'];
$serviceStatus = [];
foreach ($services as $service) {
$status = shell_exec("systemctl is-active $service");
$serviceStatus[$service] = trim($status) === 'active';
}
return $serviceStatus;
}
function checkBackupIntegrity() {
// Verify backup system integrity
// Implement backup verification logic
return [
'last_backup' => date('Y-m-d H:i:s', strtotime('-1 day')),
'backup_size' => '2.5GB',
'integrity_check' => true
];
}
function generateQueryOptimizationTips($query) {
// Generate basic query optimization suggestions
// This is a simplified example
$tips = [];
if (strpos($query, 'SELECT *') !== false) {
$tips[] = "Avoid using SELECT * - specify exact columns needed";
}
return $tips;
}
function calculatePerformanceScore($serverHealth) {
// Implement complex performance scoring algorithm
// This is a simplified example
$score = 100;
if (!$serverHealth['service_status']['mysql']) {
$score -= 20;
}
if ($serverHealth['uptime'] < 86400) { // Less than 24 hours
$score -= 10;
}
return max(0, $score);
}
function sendServerHealthAlert($serverHealth, $performanceScore) {
$adminEmail = 'admin@yourcompany.com';
$subject = "Server Health Alert - Low Performance";
$message = "Server Performance Score: {$performanceScore}\n";
$message .= "Details:\n";
$message .= "- Uptime: " . gmdate("H:i:s", $serverHealth['uptime']) . "\n";
$message .= "- Network Latency: {$serverHealth['network_latency']}ms\n";
sendMessage('Admin Server Health Alert', 0, [
'email' => $adminEmail,
'subject' => $subject,
'message' => $message
]);
}
Troubleshooting Custom Hooks
Common issues I've encountered and their solutions:
- Hook not firing? Check your priority number
- Performance issues? Review your hook's resource usage
- Debugging tips using WHMCS debug log
By mastering WHMCS custom hooks, you're not just adding features – you're building a more efficient, automated hosting business.
Mastering Automated Actions with WHMCS Custom Hooks
In my journey of Mastering WHMCS Custom Hooks, I've discovered some game-changing automation techniques that I'm excited to share with you.
Custom Hooks for Client Management Automation
Here's a powerful hook I've implemented for automatic client upgrades:
<?php
use WHMCS\Database\Capsule;
// Client Lifecycle Management Hooks
add_hook('ClientAdd', 1, function($vars) {
// Automated actions for new client registration
processNewClientOnboarding($vars);
});
add_hook('ClientEdit', 1, function($vars) {
// Monitor and respond to client profile changes
trackClientProfileUpdates($vars);
});
add_hook('InvoicePaid', 1, function($vars) {
// Automated upgrade and loyalty tracking
processClientUpgradeEligibility($vars);
});
add_hook('ServiceCreate', 1, function($vars) {
// Automated service provisioning and recommendations
processServiceCreation($vars);
});
/**
* Comprehensive new client onboarding process
* @param array $vars Client registration variables
*/
function processNewClientOnboarding($vars) {
$userId = $vars['userid'];
// Initialize client lifecycle tracking
initializeClientLifecycleProfile($userId);
// Apply welcome bonuses
applyNewClientWelcomeBenefits($userId);
// Generate personalized onboarding communication
createPersonalizedOnboardingCommunication($userId);
// Trigger initial risk assessment
performInitialClientRiskAssessment($userId);
}
/**
* Initialize comprehensive client lifecycle profile
* @param int $userId Client user ID
*/
function initializeClientLifecycleProfile($userId) {
Capsule::table('mod_client_lifecycle_tracking')->insert([
'user_id' => $userId,
'registration_date' => date('Y-m-d H:i:s'),
'current_tier' => 'New',
'lifecycle_stage' => 'Acquisition',
'first_purchase_date' => null,
'total_spend' => 0,
'loyalty_points' => 0
]);
}
/**
* Apply welcome benefits for new clients
* @param int $userId Client user ID
*/
function applyNewClientWelcomeBenefits($userId) {
$welcomeBenefits = [
'credit_amount' => 25.00,
'bonus_services' => [
'free_domain_setup' => true,
'priority_support' => true
]
];
// Apply welcome credit
Capsule::table('tblcredit')->insert([
'userid' => $userId,
'date' => date('Y-m-d H:i:s'),
'description' => 'New Client Welcome Bonus',
'amount' => $welcomeBenefits['credit_amount']
]);
// Log welcome benefits
Capsule::table('mod_client_welcome_benefits')->insert([
'user_id' => $userId,
'credit_amount' => $welcomeBenefits['credit_amount'],
'free_domain_setup' => $welcomeBenefits['bonus_services']['free_domain_setup'] ? 1 : 0,
'priority_support' => $welcomeBenefits['bonus_services']['priority_support'] ? 1 : 0,
'applied_date' => date('Y-m-d H:i:s')
]);
// Send welcome notification
sendWelcomeNotification($userId, $welcomeBenefits);
}
/**
* Generate personalized onboarding communication
* @param int $userId Client user ID
*/
function createPersonalizedOnboardingCommunication($userId) {
$client = Capsule::table('tblclients')->where('id', $userId)->first();
$personalizedContent = [
'subject' => "Welcome to Our Services, {$client->firstname}!",
'message' => "Dear {$client->firstname},\n\n" .
"We're thrilled to have you join our community! Here are some getting started tips:\n" .
"- Access our client portal at [CLIENT_PORTAL_URL]\n" .
"- Check out our beginner's guide\n" .
"- Schedule a free onboarding consultation\n\n" .
"Best regards,\nYour Support Team"
];
// Send personalized welcome communication
sendMessage('Personalized Onboarding Email', $userId, $personalizedContent);
}
/**
* Perform initial client risk assessment
* @param int $userId Client user ID
*/
function performInitialClientRiskAssessment($userId) {
$riskAssessment = [
'email_domain_score' => assessEmailDomainRisk($userId),
'ip_reputation_score' => checkIPReputation(),
'geographic_risk' => assessGeographicRisk($userId)
];
// Calculate overall risk score
$overallRiskScore = calculateRiskScore($riskAssessment);
// Store risk assessment
Capsule::table('mod_client_risk_assessment')->insert([
'user_id' => $userId,
'assessment_date' => date('Y-m-d H:i:s'),
'email_domain_score' => $riskAssessment['email_domain_score'],
'ip_reputation_score' => $riskAssessment['ip_reputation_score'],
'geographic_risk' => $riskAssessment['geographic_risk'],
'overall_risk_score' => $overallRiskScore
]);
// Trigger additional verification if high risk
if ($overallRiskScore > 70) {
initiateAdditionalVerification($userId);
}
}
/**
* Track and respond to client profile updates
* @param array $vars Client profile update variables
*/
function trackClientProfileUpdates($vars) {
$userId = $vars['userid'];
$updatedFields = identifyUpdatedProfileFields($vars);
if (!empty($updatedFields)) {
// Log profile update event
Capsule::table('mod_client_profile_updates')->insert([
'user_id' => $userId,
'update_timestamp' => date('Y-m-d H:i:s'),
'updated_fields' => json_encode($updatedFields)
]);
// Trigger specific actions based on updated fields
processProfileUpdateActions($userId, $updatedFields);
}
}
/**
* Process client upgrade eligibility
* @param array $vars Invoice payment variables
*/
function processClientUpgradeEligibility($vars) {
$invoice = Capsule::table('tblinvoices')
->where('id', $vars['invoiceid'])
->first();
$userId = $invoice->userid;
// Update client total spend and loyalty tracking
updateClientSpendProfile($userId, $invoice->total);
// Check for automatic service upgrades
$upgradeEligibility = assessUpgradeEligibility($userId);
if ($upgradeEligibility['eligible']) {
// Automatically apply service upgrades
applyAutomaticUpgrades($userId, $upgradeEligibility);
// Send upgrade notification
sendUpgradeNotification($userId, $upgradeEligibility);
}
}
/**
* Process service creation and recommendations
* @param array $vars Service creation variables
*/
function processServiceCreation($vars) {
$userId = $vars['userid'];
$serviceId = $vars['serviceid'];
// Generate service-specific recommendations
$recommendations = generateServiceRecommendations($serviceId);
// Store service recommendations
Capsule::table('mod_service_recommendations')->insert([
'user_id' => $userId,
'service_id' => $serviceId,
'recommendations' => json_encode($recommendations),
'created_at' => date('Y-m-d H:i:s')
]);
// Send personalized service recommendations
sendServiceRecommendations($userId, $recommendations);
}
// Utility and Helper Functions (implement with your specific logic)
function assessEmailDomainRisk($userId) {
// Implement email domain risk assessment
return rand(0, 100);
}
function checkIPReputation() {
// Implement IP reputation checking
return rand(0, 100);
}
function assessGeographicRisk($userId) {
// Implement geographic risk assessment
return rand(0, 100);
}
function calculateRiskScore($riskAssessment) {
// Implement risk score calculation algorithm
return array_sum($riskAssessment) / count($riskAssessment);
}
function initiateAdditionalVerification($userId) {
// Implement additional verification process
sendMessage('High Risk Verification', $userId, [
'subject' => 'Additional Verification Required',
'message' => 'We need to verify some details for your account.'
]);
}
function identifyUpdatedProfileFields($vars) {
// Implement logic to track which fields were updated
$updatableFields = ['email', 'phone', 'address1', 'country'];
$updatedFields = [];
foreach ($updatableFields as $field) {
if (isset($vars[$field]) && !empty($vars[$field])) {
$updatedFields[] = $field;
}
}
return $updatedFields;
}
function processProfileUpdateActions($userId, $updatedFields) {
// Implement actions based on updated profile fields
if (in_array('email', $updatedFields)) {
sendEmailChangeNotification($userId);
}
if (in_array('country', $updatedFields)) {
reassessGeographicRisk($userId);
}
}
function updateClientSpendProfile($userId, $invoiceTotal) {
// Update client spend and loyalty tracking
Capsule::table('mod_client_lifecycle_tracking')
->where('user_id', $userId)
->update([
'total_spend' => Capsule::raw("total_spend + $invoiceTotal"),
'loyalty_points' => Capsule::raw("loyalty_points + FLOOR($invoiceTotal)")
]);
}
function assessUpgradeEligibility($userId) {
// Implement upgrade eligibility assessment
$clientProfile = Capsule::table('mod_client_lifecycle_tracking')
->where('user_id', $userId)
->first();
return [
'eligible' => $clientProfile->total_spend > 1000,
'current_tier' => $clientProfile->current_tier,
'suggested_tier' => 'Premium',
'loyalty_points' => $clientProfile->loyalty_points
];
}
function applyAutomaticUpgrades($userId, $upgradeEligibility) {
// Implement automatic service upgrades
// This is a simplified example
Capsule::table('mod_client_lifecycle_tracking')
->where('user_id', $userId)
->update([
'current_tier' => $upgradeEligibility['suggested_tier'],
'lifecycle_stage' => 'Growth'
]);
}
function generateServiceRecommendations($serviceId) {
// Generate service-specific recommendations
return [
'related_services' => ['Backup', 'Security', 'SSL'],
'upgrade_paths' => ['Professional', 'Enterprise'],
'complementary_products' => ['Domain Protection', 'Email Hosting']
];
}
// Notification functions (implement with your notification system)
function sendWelcomeNotification($userId, $welcomeBenefits) {
// Send welcome notification
sendMessage('New Client Welcome', $userId, [
'subject' => 'Welcome Aboard!',
'message' => "You've received a ${$welcomeBenefits['credit_amount']} credit and special benefits!"
]);
}
function sendUpgradeNotification($userId, $upgradeEligibility) {
// Send upgrade eligibility notification
sendMessage('Upgrade Notification', $userId, [
'subject' => 'Upgrade Opportunity',
'message' => "Congratulations! You're eligible for a {$upgradeEligibility['suggested_tier']} tier upgrade."
]);
}
function sendServiceRecommendations($userId, $recommendations) {
// Send personalized service recommendations
sendMessage('Service Recommendations', $userId, [
'subject' => 'Recommended Services Just for You',
'message' => "Based on your current service, we recommend: " .
implode(', ', $recommendations['related_services'])
]);
}
Smart Service Provisioning with Hooks
When managing a fast web hosting service, automated provisioning is crucial. Here's how:
- Automatic server selection based on load
- Resource allocation optimization
- Instant service activation triggers
Custom Billing Automation Hooks
I've refined these billing hooks for my automated billing system:
<?php
use WHMCS\Database\Capsule;
// Billing Lifecycle Hooks
add_hook('InvoiceCreation', 1, function($vars) {
// Advanced invoice processing
processInvoiceAutomation($vars);
});
add_hook('InvoicePaid', 1, function($vars) {
// Comprehensive payment tracking and rewards
processPaymentTracking($vars);
});
add_hook('PreCronAutoRecurring', 1, function($vars) {
// Advanced recurring billing management
manageRecurringBillingCycle($vars);
});
add_hook('TransactionCreate', 1, function($vars) {
// Sophisticated transaction tracking and analysis
analyzeTransactionPatterns($vars);
});
/**
* Advanced Invoice Processing and Automation
* @param array $vars Invoice creation variables
*/
function processInvoiceAutomation($vars) {
$invoiceId = $vars['invoiceid'];
$userId = $vars['userid'];
// Retrieve detailed invoice information
$invoice = Capsule::table('tblinvoices')
->where('id', $invoiceId)
->first();
// Implement intelligent invoice routing
$invoiceRouting = determineInvoiceRouting($invoice);
// Store extended invoice metadata
Capsule::table('mod_invoice_extended_metadata')->insert([
'invoice_id' => $invoiceId,
'user_id' => $userId,
'routing_category' => $invoiceRouting['category'],
'risk_score' => $invoiceRouting['risk_score'],
'created_at' => date('Y-m-d H:i:s')
]);
// Apply intelligent discounts or credits
$discountApplication = applyIntelligentDiscounts($invoice);
// Generate predictive payment reminders
generatePredictivePaymentReminders($invoice, $discountApplication);
}
/**
* Determine Invoice Routing and Risk Assessment
* @param object $invoice Invoice details
* @return array Invoice routing and risk details
*/
function determineInvoiceRouting($invoice) {
// Implement sophisticated invoice routing logic
$riskFactors = [
'total_amount' => $invoice->total,
'client_history' => assessClientPaymentHistory($invoice->userid),
'service_complexity' => evaluateServiceComplexity($invoice)
];
$riskScore = calculateInvoiceRiskScore($riskFactors);
return [
'category' => $riskScore > 70 ? 'High Risk' : 'Standard',
'risk_score' => $riskScore,
'recommended_action' => $riskScore > 70 ? 'Manual Review' : 'Automatic Processing'
];
}
/**
* Apply Intelligent Discounts and Credits
* @param object $invoice Invoice details
* @return array Discount application details
*/
function applyIntelligentDiscounts($invoice) {
$discountCriteria = [
'early_payment' => checkEarlyPaymentEligibility($invoice),
'volume_discount' => calculateVolumeDiscount($invoice),
'loyalty_credit' => assessLoyaltyCredit($invoice->userid)
];
$totalDiscount = array_sum($discountCriteria);
// Apply discount if significant
if ($totalDiscount > 0) {
Capsule::table('tblinvoices')
->where('id', $invoice->id)
->update([
'total' => Capsule::raw("total - $totalDiscount"),
'credit' => Capsule::raw("credit + $totalDiscount")
]);
// Log discount application
Capsule::table('mod_invoice_discounts')->insert([
'invoice_id' => $invoice->id,
'early_payment_discount' => $discountCriteria['early_payment'],
'volume_discount' => $discountCriteria['volume_discount'],
'loyalty_credit' => $discountCriteria['loyalty_credit'],
'total_discount' => $totalDiscount,
'applied_at' => date('Y-m-d H:i:s')
]);
}
return $discountCriteria;
}
/**
* Generate Predictive Payment Reminders
* @param object $invoice Invoice details
* @param array $discountApplication Discount details
*/
function generatePredictivePaymentReminders($invoice, $discountApplication) {
$paymentPrediction = predictPaymentLikelihood($invoice);
// Customize reminder based on prediction
$reminderStrategy = [
'high_likelihood' => [
'message' => 'Friendly early payment reminder',
'incentive' => "Enjoy your early payment discount of $" . $discountApplication['early_payment']
],
'medium_likelihood' => [
'message' => 'Gentle payment reminder',
'incentive' => 'Consider settling your invoice soon'
],
'low_likelihood' => [
'message' => 'Important payment notice',
'incentive' => 'Avoid late fees by paying now'
]
];
$selectedStrategy = $reminderStrategy[$paymentPrediction['payment_likelihood']];
// Send personalized reminder
sendMessage('Predictive Payment Reminder', $invoice->userid, [
'subject' => 'Invoice Payment Reminder',
'message' => $selectedStrategy['message'] . "\n" . $selectedStrategy['incentive']
]);
}
/**
* Comprehensive Payment Tracking
* @param array $vars Invoice payment variables
*/
function processPaymentTracking($vars) {
$invoiceId = $vars['invoiceid'];
$userId = $vars['userid'];
// Update client payment history
updateClientPaymentProfile($userId, $vars['amount']);
// Track payment method analysis
trackPaymentMethodEfficiency($vars);
// Trigger loyalty rewards
processLoyaltyRewards($userId, $vars['amount']);
}
/**
* Recurring Billing Cycle Management
* @param array $vars Cron recurring billing variables
*/
function manageRecurringBillingCycle($vars) {
// Identify services due for renewal
$recurringServices = Capsule::table('tblhosting')
->where('nextduedate', '<=', date('Y-m-d'))
->where('domainstatus', 'Active')
->get();
foreach ($recurringServices as $service) {
// Implement intelligent renewal logic
$renewalStrategy = determineRenewalStrategy($service);
// Apply renewal or suspension actions
processServiceRenewal($service, $renewalStrategy);
}
}
/**
* Transaction Pattern Analysis
* @param array $vars Transaction creation variables
*/
function analyzeTransactionPatterns($vars) {
$transactionAnalysis = [
'transaction_id' => $vars['transid'],
'amount' => $vars['amount'],
'gateway' => $vars['gateway'],
'timestamp' => date('Y-m-d H:i:s')
];
// Store detailed transaction analytics
Capsule::table('mod_transaction_analytics')->insert($transactionAnalysis);
// Detect unusual transaction patterns
$unusualPatternDetected = detectUnusualTransactionPatterns($transactionAnalysis);
if ($unusualPatternDetected) {
triggerTransactionSecurityProtocol($transactionAnalysis);
}
}
// Utility Functions (implement with your specific business logic)
function assessClientPaymentHistory($userId) {
// Assess client's historical payment behavior
$paymentHistory = Capsule::table('tblinvoices')
->where('userid', $userId)
->where('status', 'Paid')
->get();
return [
'total_paid' => $paymentHistory->sum('total'),
'on_time_rate' => calculateOnTimePaymentRate($paymentHistory)
];
}
function evaluateServiceComplexity($invoice) {
// Assess complexity of services in the invoice
$invoiceItems = Capsule::table('tblinvoiceitems')
->where('invoiceid', $invoice->id)
->get();
return count($invoiceItems);
}
function calculateInvoiceRiskScore($riskFactors) {
// Implement complex risk scoring algorithm
$baseRisk = 50;
$riskModifiers = [
'total_amount' => $riskFactors['total_amount'] > 1000 ? 20 : 0,
'client_history' => $riskFactors['client_history']['on_time_rate'] < 0.7 ? 15 : 0,
'service_complexity' => $riskFactors['service_complexity'] > 5 ? 15 : 0
];
return $baseRisk + array_sum($riskModifiers);
}
function checkEarlyPaymentEligibility($invoice) {
// Implement early payment discount logic
$earlyPaymentWindow = 7; // days
$daysUntilDue = daysBetween(date('Y-m-d'), $invoice->duedate);
return $daysUntilDue <= $earlyPaymentWindow ? $invoice->total * 0.05 : 0;
}
function calculateVolumeDiscount($invoice) {
// Implement volume-based discount
return $invoice->total > 5000 ? $invoice->total * 0.03 : 0;
}
function assessLoyaltyCredit($userId) {
// Assess loyalty credit based on client's history
$totalSpend = Capsule::table('tblinvoices')
->where('userid', $userId)
->where('status', 'Paid')
->sum('total');
return $totalSpend > 10000 ? 50 : 0;
}
function predictPaymentLikelihood($invoice) {
// Implement payment likelihood prediction
$clientHistory = assessClientPaymentHistory($invoice->userid);
$likelihoodScore = $clientHistory['on_time_rate'] * 100;
return [
'payment_likelihood' =>
$likelihoodScore > 80 ? 'high_likelihood' :
($likelihoodScore > 50 ? 'medium_likelihood' : 'low_likelihood'),
'score' => $likelihoodScore
];
}
function updateClientPaymentProfile($userId, $paymentAmount) {
// Update comprehensive client payment profile
Capsule::table('mod_client_payment_profile')
->updateOrInsert(
['user_id' => $userId],
[
'total_payments' => Capsule::raw("total_payments + $paymentAmount"),
'last_payment_date' => date('Y-m-d H:i:s'),
'payment_count' => Capsule::raw('payment_count + 1')
]
);
}
function trackPaymentMethodEfficiency($paymentVars) {
// Track payment method performance
Capsule::table('mod_payment_method_analytics')->insert([
'gateway' => $paymentVars['gateway'],
'amount' => $paymentVars['amount'],
'transaction_date' => date('Y-m-d H:i:s')
]);
}
function processLoyaltyRewards($userId, $paymentAmount) {
// Implement loyalty rewards program
$loyaltyPointsEarned = floor($paymentAmount / 10);
Capsule::table('mod_client_loyalty_program')
->updateOrInsert(
['user_id' => $userId],
[
'total_loyalty_points' => Capsule::raw("total_loyalty_points + $loyaltyPointsEarned"),
'last_reward_date' => date('Y-m-d H:i:s')
]
);
}
function determineRenewalStrategy($service) {
// Implement intelligent renewal strategy
$clientHistory = assessClientPaymentHistory($service->userid);
return [
'action' => $clientHistory['on_time_rate'] > 0.8 ? 'auto_renew' : 'manual_review',
'grace_period' => $clientHistory['on_time_rate'] < 0.5 ? 15 : 7
];
}
function processServiceRenewal($service, $renewalStrategy) {
// Implement service renewal or suspension logic
if ($renewalStrategy['action'] === 'auto_renew') {
// Automatically renew service
Capsule::table('tblhosting')
->where('id', $service->id)
->update([
'nextduedate' => date('Y-m-d', strtotime('+1 year')),
'domainstatus' => 'Active'
]);
} else {
// Trigger manual review or grace period
Capsule::table('tblhosting')
->where('id', $service->id)
->update([
'domainstatus' => 'Pending Renewal',
'suspension_date' => date('Y-m-d', strtotime("+{$renewalStrategy['grace_period']} days"))
]);
// Send renewal notification
sendMessage('Renewal Review Notification', $service->userid, [
'subject' => 'Service Renewal Required',
'message' => "Please review and renew your service to avoid suspension."
]);
}
}
function detectUnusualTransactionPatterns($transactionAnalysis) {
// Implement transaction pattern anomaly detection
$unusualPatternThresholds = [
'high_amount' => 5000,
'frequency_threshold' => 3
];
$recentTransactions = Capsule::table('mod_transaction_analytics')
->where('gateway', $transactionAnalysis['gateway'])
->where('timestamp', '>=', date('Y-m-d H:i:s', strtotime('-1 day')))
->get();
return (
$transactionAnalysis['amount'] > $unusualPatternThresholds['high_amount'] ||
$recentTransactions->count() > $unusualPatternThresholds['frequency_threshold']
);
}
function triggerTransactionSecurityProtocol($transactionAnalysis) {
// Implement transaction security protocol
sendMessage('Transaction Security Alert', 0, [
'email' => 'security@yourcompany.com',
'subject' => 'Unusual Transaction Detected',
'message' => "Unusual transaction detected:\n" .
"Amount: {$transactionAnalysis['amount']}\n" .
"Gateway: {$transactionAnalysis['gateway']}"
]);
}
// Utility date function
function daysBetween($date1, $date2) {
return abs(round((strtotime($date1) - strtotime($date2)) / (60 * 60 * 24)));
}
Advanced Notification System
Create smart notification rules:
- Service usage alerts
- Renewal reminders
- Custom milestone notifications
Integration Hooks for Third-Party Services
Connect your WHMCS with CDN services and other tools:
<?php
/**
* WHMCS All-in-One Third-Party Service Integration Hooks
*
* @package WHMCSIntegrations
* @version 1.0.0
* @author Your Name
*/
use WHMCS\Database\Capsule;
// Configuration Class for Managing Integration Settings
class IntegrationConfig {
private static $config = [];
public static function load() {
// In a real-world scenario, load from secure configuration
self::$config = [
'cdn' => [
'provider' => 'CloudflareAPI',
'api_key' => getenv('CLOUDFLARE_API_KEY'),
'email' => getenv('CLOUDFLARE_EMAIL')
],
'monitoring' => [
'provider' => 'NewRelicAPI',
'license_key' => getenv('NEWRELIC_LICENSE_KEY')
],
'backup' => [
'provider' => 'VaultPress',
'api_token' => getenv('VAULTPRESS_TOKEN')
]
];
}
public static function get($service, $key = null) {
if (!self::$config) {
self::load();
}
return $key
? (self::$config[$service][$key] ?? null)
: (self::$config[$service] ?? null);
}
}
// Integrated Service Provisioning Class
class ServiceIntegrator {
private $logger;
public function __construct() {
$this->logger = new IntegrationLogger();
}
public function provisionCDN($serviceDetails) {
try {
$apiKey = IntegrationConfig::get('cdn', 'api_key');
$email = IntegrationConfig::get('cdn', 'email');
$cloudflare = new CloudflareAPI($apiKey, $email);
$cdnConfig = $cloudflare->createZone([
'domain' => $serviceDetails['domain'],
'plan' => 'enterprise'
]);
// Store CDN configuration
Capsule::table('mod_cdn_configurations')->insert([
'service_id' => $serviceDetails['service_id'],
'zone_id' => $cdnConfig['zone_id'],
'cdn_provider' => 'cloudflare'
]);
$this->logger->log('CDN', "Provisioned for {$serviceDetails['domain']}");
return true;
} catch (Exception $e) {
$this->logger->error('CDN', $e->getMessage());
return false;
}
}
public function setupMonitoring($serviceDetails) {
try {
$licenseKey = IntegrationConfig::get('monitoring', 'license_key');
$newRelic = new NewRelicAPI($licenseKey);
$monitoringConfig = $newRelic->createApplication([
'name' => $serviceDetails['domain'],
'language' => 'php'
]);
Capsule::table('mod_monitoring_configurations')->insert([
'service_id' => $serviceDetails['service_id'],
'app_id' => $monitoringConfig['app_id'],
'monitoring_provider' => 'newrelic'
]);
$this->logger->log('Monitoring', "Setup for {$serviceDetails['domain']}");
return true;
} catch (Exception $e) {
$this->logger->error('Monitoring', $e->getMessage());
return false;
}
}
public function configureBackup($serviceDetails) {
try {
$apiToken = IntegrationConfig::get('backup', 'api_token');
$vaultPress = new VaultPressAPI($apiToken);
$backupConfig = $vaultPress->createBackupJob([
'domain' => $serviceDetails['domain'],
'frequency' => 'daily'
]);
Capsule::table('mod_backup_configurations')->insert([
'service_id' => $serviceDetails['service_id'],
'backup_job_id' => $backupConfig['job_id'],
'backup_provider' => 'vaultpress'
]);
$this->logger->log('Backup', "Configured for {$serviceDetails['domain']}");
return true;
} catch (Exception $e) {
$this->logger->error('Backup', $e->getMessage());
return false;
}
}
}
// Logging Utility
class IntegrationLogger {
public function log($service, $message) {
logActivity("[{$service} Integration] {$message}");
}
public function error($service, $errorMessage) {
logActivity("[{$service} Integration ERROR] {$errorMessage}");
}
}
// WHMCS Hooks Definition
class WhmcsServiceHooks {
public static function registerHooks() {
// CDN Provisioning Hook
add_hook('ServiceCreate', 1, function($vars) {
$integrator = new ServiceIntegrator();
$serviceDetails = [
'service_id' => $vars['serviceid'],
'domain' => $vars['domain']
];
$integrator->provisionCDN($serviceDetails);
});
// Monitoring Setup Hook
add_hook('ProductCreate', 1, function($vars) {
$integrator = new ServiceIntegrator();
$serviceDetails = [
'service_id' => $vars['serviceid'],
'domain' => $vars['domain']
];
$integrator->setupMonitoring($serviceDetails);
});
// Backup Configuration Hook
add_hook('ServiceActivate', 1, function($vars) {
$integrator = new ServiceIntegrator();
$serviceDetails = [
'service_id' => $vars['serviceid'],
'domain' => $vars['domain']
];
$integrator->configureBackup($serviceDetails);
});
// Webhook Receiver for External Service Notifications
add_hook('IncomingWebhook', 1, function($payload) {
$logger = new IntegrationLogger();
switch($payload['service_type']) {
case 'cdn_status':
$logger->log('CDN Webhook', json_encode($payload));
break;
case 'monitoring_alert':
$logger->log('Monitoring Webhook', json_encode($payload));
break;
case 'backup_notification':
$logger->log('Backup Webhook', json_encode($payload));
break;
}
});
}
}
// Initialize Hooks
WhmcsServiceHooks::registerHooks();
// Optional: Health Check Hook
add_hook('DailyCronJob', 1, function() {
$logger = new IntegrationLogger();
try {
// Perform daily health checks on integrated services
$cdnConfigs = Capsule::table('mod_cdn_configurations')->get();
$monitoringConfigs = Capsule::table('mod_monitoring_configurations')->get();
$backupConfigs = Capsule::table('mod_backup_configurations')->get();
$logger->log('Daily Health Check', 'Completed integrations review');
} catch (Exception $e) {
$logger->error('Daily Health Check', $e->getMessage());
}
});
Performance Tips for Custom Hooks
- Cache frequently accessed data
- Use asynchronous processing for heavy tasks
- Regular hook audits for optimization
Mastering WHMCS Custom Hooks isn't just about writing code – it's about creating smart, efficient automations that grow your business.
Frequently Asked Questions
How do I test my custom hooks?
Use WHMCS debug mode and logging to test hook functionality in a development environment first.
Can hooks slow down my WHMCS?
Only if poorly optimized. Keep hooks focused and efficient.
How many hooks can I add?
There's no strict limit, but each hook impacts system resources.
