API Documentation

import hmac
import hashlib

signature = request.headers.get('X-Webhook-Signature')
payload = request.get_data()
secret = b'your-webhook-secret'

expected_signature = hmac.new(secret, payload, hashlib.sha256).hexdigest()

if hmac.compare_digest(expected_signature, signature):
    # Signature is valid
    data = request.get_json()
    # Process webhook...
else:
    # Invalid signature
    return 'Unauthorized', 401

const crypto = require('crypto');

const signature = req.headers['x-webhook-signature'];
const payload = JSON.stringify(req.body);
const secret = 'your-webhook-secret';

const expectedSignature = crypto
  .createHmac('sha256', secret)
  .update(payload)
  .digest('hex');

if (crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))) {
    // Signature is valid
    // Process webhook...
} else {
    // Invalid signature
    res.status(401).send('Unauthorized');
}

<?php

class SMSClient {
    private $apiUrl;
    private $clientId;
    private $apiKey;
    private $senderId;

    public function __construct() {
        $this->apiUrl = getenv('SMS_API_URL') ?: 'https://crm.pradytecai.com/api';
        $this->clientId = getenv('SMS_CLIENT_ID') ?: '1';
        $this->apiKey = getenv('SMS_API_KEY');
        $this->senderId = getenv('SMS_SENDER_ID');
    }

    /**
     * Send SMS message
     */
    public function sendSMS($recipient, $message) {
        $url = "{$this->apiUrl}/{$this->clientId}/messages/send";
        
        $data = [
            'channel' => 'sms',
            'recipient' => $recipient,
            'body' => $message,
            'sender' => $this->senderId
        ];

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json',
        ]);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            return json_decode($response, true);
        } else {
            throw new Exception("SMS Error: " . $response);
        }
    }

    /**
     * Check account balance
     */
    public function checkBalance() {
        $url = "{$this->apiUrl}/{$this->clientId}/client/balance";
        
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
        ]);

        $response = curl_exec($ch);
        curl_close($ch);

        return json_decode($response, true);
    }

    /**
     * Get SMS history
     */
    public function getHistory($page = 1, $status = 'all') {
        $url = "{$this->apiUrl}/{$this->clientId}/sms/history?page={$page}&status={$status}";
        
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
        ]);

        $response = curl_exec($ch);
        curl_close($ch);

        return json_decode($response, true);
    }
}

// Usage Example
try {
    $sms = new SMSClient();
    
    // Send SMS
    $result = $sms->sendSMS('254712345678', 'Hello from your app!');
    echo "Message sent! ID: " . $result['data']['id'] . "\n";
    
    // Check Balance
    $balance = $sms->checkBalance();
    echo "Balance: KSH " . $balance['data']['balance'] . "\n";
    
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}
?>

<?php

namespace App\Services;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;

class SmsService
{
    private $apiUrl;
    private $clientId;
    private $apiKey;
    private $senderId;

    public function __construct()
    {
        $this->apiUrl = config('services.sms.api_url');
        $this->clientId = config('services.sms.client_id');
        $this->apiKey = config('services.sms.api_key');
        $this->senderId = config('services.sms.sender_id');
    }

    public function send($recipient, $message)
    {
        try {
            $response = Http::withHeaders([
                'X-API-Key' => $this->apiKey,
                'Content-Type' => 'application/json',
            ])->post("{$this->apiUrl}/{$this->clientId}/messages/send", [
                'channel' => 'sms',
                'recipient' => $recipient,
                'body' => $message,
                'sender' => $this->senderId,
            ]);

            if ($response->successful()) {
                return $response->json();
            }

            throw new \Exception('SMS sending failed: ' . $response->body());

        } catch (\Exception $e) {
            Log::error('SMS Error: ' . $e->getMessage());
            throw $e;
        }
    }

    public function checkBalance()
    {
        $response = Http::withHeaders([
            'X-API-Key' => $this->apiKey,
        ])->get("{$this->apiUrl}/{$this->clientId}/client/balance");

        return $response->json();
    }
}
?>

'sms' => [
    'api_url' => env('SMS_API_URL', 'https://crm.pradytecai.com/api'),
    'client_id' => env('SMS_CLIENT_ID', '1'),
    'api_key' => env('SMS_API_KEY'),
    'sender_id' => env('SMS_SENDER_ID'),
],

use App\Services\SmsService;

class NotificationController extends Controller
{
    protected $sms;

    public function __construct(SmsService $sms)
    {
        $this->sms = $sms;
    }

    public function sendNotification()
    {
        try {
            $result = $this->sms->send('254712345678', 'Your verification code is 1234');
            return response()->json(['success' => true, 'data' => $result]);
        } catch (\Exception $e) {
            return response()->json(['success' => false, 'error' => $e->getMessage()], 500);
        }
    }
}

import requests
import os
from typing import Dict

class SMSClient:
    def __init__(self):
        self.api_url = os.getenv('SMS_API_URL', 'https://crm.pradytecai.com/api')
        self.client_id = os.getenv('SMS_CLIENT_ID', '1')
        self.api_key = os.getenv('SMS_API_KEY')
        self.sender_id = os.getenv('SMS_SENDER_ID')
        
        self.headers = {
            'X-API-Key': self.api_key,
            'Content-Type': 'application/json'
        }
    
    def send_sms(self, recipient: str, message: str) -> Dict:
        """Send SMS message"""
        url = f'{self.api_url}/{self.client_id}/messages/send'
        
        data = {
            'channel': 'sms',
            'recipient': recipient,
            'body': message,
            'sender': self.sender_id
        }
        
        response = requests.post(url, headers=self.headers, json=data)
        
        if response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"SMS Error: {response.text}")
    
    def check_balance(self) -> Dict:
        """Check account balance"""
        url = f'{self.api_url}/{self.client_id}/client/balance'
        response = requests.get(url, headers=self.headers)
        return response.json()
    
    def get_history(self, page: int = 1, status: str = 'all') -> Dict:
        """Get SMS history"""
        url = f'{self.api_url}/{self.client_id}/sms/history'
        params = {'page': page, 'status': status}
        response = requests.get(url, headers=self.headers, params=params)
        return response.json()

# Usage Example
if __name__ == '__main__':
    sms = SMSClient()
    
    try:
        # Send SMS
        result = sms.send_sms('254712345678', 'Hello from Python!')
        print(f"Message sent! ID: {result['data']['id']}")
        
        # Check Balance
        balance = sms.check_balance()
        print(f"Balance: KSH {balance['data']['balance']}")
        
    except Exception as e:
        print(f"Error: {e}")

const axios = require('axios');

class SMSClient {
    constructor() {
        this.apiUrl = process.env.SMS_API_URL || 'https://crm.pradytecai.com/api';
        this.clientId = process.env.SMS_CLIENT_ID || '1';
        this.apiKey = process.env.SMS_API_KEY;
        this.senderId = process.env.SMS_SENDER_ID;
        
        this.headers = {
            'X-API-Key': this.apiKey,
            'Content-Type': 'application/json'
        };
    }

    async sendSMS(recipient, message) {
        try {
            const response = await axios.post(
                `${this.apiUrl}/${this.clientId}/messages/send`,
                {
                    channel: 'sms',
                    recipient: recipient,
                    body: message,
                    sender: this.senderId
                },
                { headers: this.headers }
            );
            
            return response.data;
        } catch (error) {
            throw new Error(`SMS Error: ${error.response?.data || error.message}`);
        }
    }

    async checkBalance() {
        try {
            const response = await axios.get(
                `${this.apiUrl}/${this.clientId}/client/balance`,
                { headers: this.headers }
            );
            return response.data;
        } catch (error) {
            throw new Error(`Balance Check Error: ${error.message}`);
        }
    }

    async getHistory(page = 1, status = 'all') {
        try {
            const response = await axios.get(
                `${this.apiUrl}/${this.clientId}/sms/history`,
                {
                    headers: this.headers,
                    params: { page, status }
                }
            );
            return response.data;
        } catch (error) {
            throw new Error(`History Error: ${error.message}`);
        }
    }
}

// Usage Example
(async () => {
    const sms = new SMSClient();
    
    try {
        // Send SMS
        const result = await sms.sendSMS('254712345678', 'Hello from Node.js!');
        console.log(`Message sent! ID: ${result.data.id}`);
        
        // Check Balance
        const balance = await sms.checkBalance();
        console.log(`Balance: KSH ${balance.data.balance}`);
        
    } catch (error) {
        console.error('Error:', error.message);
    }
})();

module.exports = SMSClient;