Guides & Tutorials

// JavaScript - Upload an image
const formData = new FormData();
formData.append('file', fileInput.files[0]);
formData.append('filename', 'product-showcase.jpg');

const uploadResponse = await fetch('https://api.amanahagent.cloud/v1/media', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY'
  },
  body: formData
});

const mediaData = await uploadResponse.json();
console.log('Media uploaded:', mediaData.media_id);

// Express.js webhook endpoint
const express = require('express');
const app = express();
app.use(express.json());

app.post('/webhook/amanahagent', (req, res) => {
  const { event, data } = req.body;
  
  if (event === 'message.received') {
    console.log('New message:', data);
    processIncomingMessage(data);
  }
  
  res.status(200).send('OK');
});

async function processIncomingMessage(messageData) {
  const { from, message, type } = messageData;
  
  // Process the message and generate response
  const response = await generateResponse(message, from);
  
  // Send reply
  await sendReply(from, response);
}

app.listen(3000, () => {
  console.log('Webhook server running on port 3000');
});

async function generateResponse(message, userPhone) {
  const intent = detectIntent(message.toLowerCase());
  
  switch (intent) {
    case 'greeting':
      return {
        type: 'text',
        message: 'Hello! How can I help you today? 😊\n\n' +
                '• Type "menu" to see our services\n' +
                '• Type "support" for customer support\n' +
                '• Type "hours" for business hours'
      };
      
    case 'menu':
      return {
        type: 'text',
        message: '📋 Our Services:\n\n' +
                '1️⃣ Product Information\n' +
                '2️⃣ Order Status\n' +
                '3️⃣ Technical Support\n' +
                '4️⃣ Billing Questions\n\n' +
                'Reply with a number to continue!'
      };
      
    case 'support':
      return {
        type: 'text',
        message: '🎧 Connecting you with support...\n\n' +
                'Please describe your issue and our team will respond shortly.'
      };
      
    case 'hours':
      return {
        type: 'text',
        message: '🕒 Business Hours:\n\n' +
                'Monday - Friday: 9AM - 6PM\n' +
                'Saturday: 10AM - 4PM\n' +
                'Sunday: Closed\n\n' +
                'We typically respond within 2 hours during business hours.'
      };
      
    default:
      return {
        type: 'text',
        message: 'I didn\'t quite understand that. Type "menu" to see available options or "support" to speak with a human.'
      };
  }
}

function detectIntent(message) {
  const greetings = ['hello', 'hi', 'hey', 'good morning', 'good afternoon'];
  const menuKeywords = ['menu', 'options', 'services', 'help'];
  const supportKeywords = ['support', 'help', 'problem', 'issue'];
  const hoursKeywords = ['hours', 'time', 'open', 'closed'];
  
  if (greetings.some(word => message.includes(word))) return 'greeting';
  if (menuKeywords.some(word => message.includes(word))) return 'menu';
  if (supportKeywords.some(word => message.includes(word))) return 'support';
  if (hoursKeywords.some(word => message.includes(word))) return 'hours';
  
  return 'unknown';
}

const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));

async function sendBulkMessages(recipients, messageData) {
  const results = [];
  const batchSize = 10; // Send 10 messages per batch
  const batchDelay = 1000; // 1 second delay between batches
  
  for (let i = 0; i < recipients.length; i += batchSize) {
    const batch = recipients.slice(i, i + batchSize);
    
    console.log(`Processing batch ${Math.floor(i/batchSize) + 1}...`);
    
    const batchPromises = batch.map(async (recipient) => {
      try {
        const response = await client.messages.send({
          to: recipient.phone,
          type: 'template',
          template_id: messageData.template_id,
          parameters: {
            name: recipient.name,
            // other template parameters
          }
        });
        
        return { 
          phone: recipient.phone, 
          success: true, 
          message_id: response.message_id 
        };
      } catch (error) {
        return { 
          phone: recipient.phone, 
          success: false, 
          error: error.message 
        };
      }
    });
    
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Wait before processing next batch
    if (i + batchSize < recipients.length) {
      await delay(batchDelay);
    }
  }
  
  return results;
}

class CustomerJourney {
  constructor() {
    this.workflows = new Map();
  }
  
  // Start welcome series when customer signs up
  async startWelcomeSeries(customerPhone, customerData) {
    const workflow = {
      customer_phone: customerPhone,
      current_step: 0,
      data: customerData,
      started_at: new Date()
    };
    
    this.workflows.set(customerPhone, workflow);
    
    // Send immediate welcome message
    await this.sendWelcomeMessage(customerPhone, customerData.name);
    
    // Schedule follow-up messages
    this.scheduleFollowUp(customerPhone, 'day_1', 24 * 60 * 60 * 1000); // 1 day
    this.scheduleFollowUp(customerPhone, 'day_3', 3 * 24 * 60 * 60 * 1000); // 3 days
    this.scheduleFollowUp(customerPhone, 'week_1', 7 * 24 * 60 * 60 * 1000); // 1 week
  }
  
  async sendWelcomeMessage(phone, customerName) {
    await client.messages.send({
      to: phone,
      type: 'template',
      template_id: 'welcome_series_1',
      parameters: {
        customer_name: customerName,
        company_name: 'AmanahAgent'
      }
    });
  }
  
  scheduleFollowUp(phone, step, delayMs) {
    setTimeout(async () => {
      await this.processWorkflowStep(phone, step);
    }, delayMs);
  }
  
  async processWorkflowStep(phone, step) {
    const workflow = this.workflows.get(phone);
    if (!workflow) return;
    
    switch (step) {
      case 'day_1':
        await this.sendDay1Message(phone, workflow.data);
        break;
      case 'day_3':
        await this.sendDay3Message(phone, workflow.data);
        break;
      case 'week_1':
        await this.sendWeek1Message(phone, workflow.data);
        break;
    }
  }
}

async function startPurchaseFollowUp(orderData) {
  const { customer_phone, customer_name, order_id, items } = orderData;
  
  // Immediate order confirmation
  await client.messages.send({
    to: customer_phone,
    type: 'template',
    template_id: 'order_confirmation',
    parameters: {
      customer_name: customer_name,
      order_id: order_id,
      order_total: orderData.total
    }
  });
  
  // Schedule delivery notification (example: 2 days)
  setTimeout(async () => {
    await client.messages.send({
      to: customer_phone,
      type: 'template',
      template_id: 'delivery_notification',
      parameters: {
        customer_name: customer_name,
        tracking_number: orderData.tracking_number
      }
    });
  }, 2 * 24 * 60 * 60 * 1000);
  
  // Schedule feedback request (example: 1 week)
  setTimeout(async () => {
    await client.messages.send({
      to: customer_phone,
      type: 'template',
      template_id: 'feedback_request',
      parameters: {
        customer_name: customer_name,
        product_name: items[0].name
      }
    });
  }, 7 * 24 * 60 * 60 * 1000);
}