Guide: Constructing WhatsApp Template Send Requests

// @ts-check
require('dotenv').config();
const axios = require('axios');
const fs = require('fs');
const path = require('path');

const API_BASE_URL = process.env.API_BASE_URL || 'https://chatapps.8x8.com';
const ACCOUNT_ID = process.env.ACCOUNT_ID || '';
const CHANNEL_ID = process.env.CHANNEL_ID || '';
const SUBACCOUNT_ID = process.env.SUBACCOUNT_ID || '';
const API_TOKEN = process.env.API_TOKEN || '';

const OUTPUT_DIR = 'generated_curl_scripts';

function getComponents(template) {
  if (
    (template.type && template.type.toUpperCase() === 'AUTHENTICATION') ||
    (template.category && template.category.toUpperCase() === 'AUTHENTICATION')
  ) {
    return [
      {
        "type": "body",
        "parameters": [
          {
            "type": "text",
            "text": "{{otpCode}}" // Using placeholder for OTP
          }
        ]
      },
      {
        "type": "Button",
        "subType": "url",
        "index": 0,
        "parameters": [
          {
            "type": "text",
            "text": "{{otpCode}}" // Using placeholder for OTP
          }
        ]
      }
    ];
  }

  // For other templates, generate descriptive placeholders based on structure
  const components = [];
  if (template.components) {
    template.components.forEach(component => {
      const componentType = component.type.toUpperCase();
      if (componentType === 'HEADER') {
        const format = component.format?.toUpperCase();
        if (format === 'TEXT' && component.text) {
          const placeholders = findPlaceholders(component.text);
          if (placeholders.length > 0) {
            components.push({
              type: "header",
              parameters: placeholders.map(num => ({ type: "text", text: `{{header_text_${num}}}` }))
            });
          }
        } else if (['IMAGE', 'VIDEO', 'DOCUMENT'].includes(format)) {
           components.push({
              type: "header",
              parameters: [{ type: format.toLowerCase(), url: `{{header_${format.toLowerCase()}_url}}` }]
            });
        } else if (format === 'LOCATION') {
             components.push({
                type: "header",
                location: { latitude: "{{header_loc_lat}}", longitude: "{{header_loc_lon}}", name: "{{header_loc_name}}", address: "{{header_loc_addr}}" }
             });
        }
      } else if (componentType === 'BODY' && component.text) {
        const placeholders = findPlaceholders(component.text);
        if (placeholders.length > 0) {
          components.push({
            type: "body",
            parameters: placeholders.map(num => ({ type: "text", text: `{{body_text_${num}}}` }))
          });
        }
      } else if (componentType === 'BUTTONS' && component.buttons) {
          component.buttons.forEach((button, buttonIndex) => {
              if (button.type.toUpperCase() === 'URL' && button.url) {
                  const placeholders = findPlaceholders(button.url);
                  if (placeholders.length > 0) {
                      components.push({
                          type: "button",
                          subType: "url",
                          index: buttonIndex,
                          parameters: placeholders.map(num => ({ type: "text", text: `{{button_${buttonIndex}_url_param_${num}}}` }))
                      });
                  }
              }
          });
      }
    });
  }

  return components;
}

// Extracts {{n}} placeholders from a string (copied from static/script.js)
function findPlaceholders(text) {
    if (!text) return [];
    const regex = /\{\{(\d+)\}\}/g;
    const placeholders = new Set();
    let match;
    while ((match = regex.exec(text)) !== null) {
        placeholders.add(parseInt(match[1], 10));
    }
    return Array.from(placeholders).sort((a, b) => a - b);
}


async function fetchTemplates() {
  const url = `${API_BASE_URL}/api/v1/accounts/${ACCOUNT_ID}/channels/${CHANNEL_ID}/templates`;
  const headers = { Authorization: `Bearer ${API_TOKEN}` };
  const { data } = await axios.get(url, { headers });
  return data.templates || [];
}

function generateCurlCommand(template) {
  const payload = {
    user: { msisdn: '{{recipientPhoneNumber}}' }, // Use placeholder here
    type: 'template',
    content: {
      template: {
        name: template.templateName || template.name,
        language: template.language || 'en',
        components: getComponents(template)
      }
    }
  };

  const jsonString = JSON.stringify(payload, null, 2);
  const escapedJsonString = jsonString.replace(/'/g, "'\\''");

  const curlCommand = `curl -X POST \\
  '${API_BASE_URL}/api/v1/subaccounts/${SUBACCOUNT_ID}/messages' \\
  -H 'Authorization: Bearer YOUR_API_TOKEN' \\
  -H 'Content-Type: application/json' \\
  -d '${escapedJsonString}'`;

  return curlCommand;
}

(async () => {
  try {
    if (!fs.existsSync(OUTPUT_DIR)) {
      fs.mkdirSync(OUTPUT_DIR);
    }

    const templates = await fetchTemplates();
    if (templates.length === 0) {
      console.log('No templates found.');
      return;
    }

    console.log(`Generating cURL scripts for ${templates.length} templates in ./${OUTPUT_DIR}/`);

    for (const template of templates) {
      const templateName = template.templateName || template.name;
      const language = template.language || 'en';
      const filename = `${templateName}_${language}.sh`;
      const filepath = path.join(OUTPUT_DIR, filename);
      const curlCommand = generateCurlCommand(template);

      const scriptContent = `#!/bin/bash
# cURL command for template: ${templateName} (${language})
# Category: ${template.category || 'N/A'}

# Replace YOUR_API_TOKEN with your actual 8x8 API token
# Replace placeholder values in the -d payload as needed, including {{recipientPhoneNumber}}

${curlCommand}
`;

      fs.writeFileSync(filepath, scriptContent);
      fs.chmodSync(filepath, '755'); // Make the script executable
    }

    console.log('cURL scripts generated successfully.');

  } catch (err) {
    console.error('Failed to generate cURL scripts:', err.message);
  }
})();