Event Types

async function handleInboundMessage(data) {
  const { from, text, channel } = data;

  // Store the message
  await db.messages.create({
    from,
    text,
    channel,
    receivedAt: new Date()
  });

  // Send auto-reply if needed
  if (text.toLowerCase().includes("help")) {
    await zavu.messages.send({
      to: from,
      text: "Thanks for reaching out! A support agent will contact you shortly."
    });
  }
}

async def handle_inbound_message(data):
    from_number = data["from"]
    text = data["text"]
    channel = data["channel"]

    # Store the message
    await db.messages.create(
        from_number=from_number,
        text=text,
        channel=channel,
        received_at=datetime.now()
    )

    # Send auto-reply if needed
    if "help" in text.lower():
        await zavu.messages.send(
            to=from_number,
            text="Thanks for reaching out! A support agent will contact you shortly."
        )

def handle_inbound_message(data)
  from_number = data["from"]
  text = data["text"]
  channel = data["channel"]

  # Store the message
  Message.create!(
    from_number: from_number,
    text: text,
    channel: channel,
    received_at: Time.now
  )

  # Send auto-reply if needed
  if text.downcase.include?("help")
    client.messages.send_(
      to: from_number,
      text: "Thanks for reaching out! A support agent will contact you shortly."
    )
  end
end

func handleInboundMessage(data map[string]interface{}) {
	from := data["from"].(string)
	text := data["text"].(string)

	// Store the message
	db.Messages.Create(from, text, data["channel"].(string))

	// Send auto-reply if needed
	if strings.Contains(strings.ToLower(text), "help") {
		client.Messages.Send(context.TODO(), zavudev.MessageSendParams{
			To:   zavudev.String(from),
			Text: zavudev.String("Thanks for reaching out! A support agent will contact you shortly."),
		})
	}
}

<?php
function handleInboundMessage(array $data): void {
    $from = $data['from'];
    $text = $data['text'];
    $channel = $data['channel'];

    // Store the message
    Message::create([
        'from_number' => $from,
        'text' => $text,
        'channel' => $channel,
        'received_at' => now(),
    ]);

    // Send auto-reply if needed
    if (str_contains(strtolower($text), 'help')) {
        $client->messages->send([
            'to' => $from,
            'text' => 'Thanks for reaching out! A support agent will contact you shortly.',
        ]);
    }
}

async function handleUnsupportedMessage(data) {
  const { from, messageId } = data;

  // Log unsupported message for analytics
  await db.unsupportedMessages.create({
    messageId,
    from,
    receivedAt: new Date()
  });

  // Optionally notify the customer
  await zavu.messages.send({
    to: from,
    text: "We received your message, but this message type is not supported. Please send a text message instead."
  });
}

async def handle_unsupported_message(data):
    from_number = data["from"]
    message_id = data["messageId"]

    # Log unsupported message for analytics
    await db.unsupported_messages.create(
        message_id=message_id,
        from_number=from_number,
        received_at=datetime.now()
    )

    # Optionally notify the customer
    await zavu.messages.send(
        to=from_number,
        text="We received your message, but this message type is not supported. Please send a text message instead."
    )

def handle_unsupported_message(data)
  from_number = data["from"]
  message_id = data["messageId"]

  # Log unsupported message for analytics
  UnsupportedMessage.create!(
    message_id: message_id,
    from_number: from_number,
    received_at: Time.now
  )

  # Optionally notify the customer
  client.messages.send_(
    to: from_number,
    text: "We received your message, but this message type is not supported. Please send a text message instead."
  )
end

func handleUnsupportedMessage(data map[string]interface{}) {
	from := data["from"].(string)
	messageID := data["messageId"].(string)

	// Log unsupported message for analytics
	db.UnsupportedMessages.Create(messageID, from)

	// Optionally notify the customer
	client.Messages.Send(context.TODO(), zavudev.MessageSendParams{
		To:   zavudev.String(from),
		Text: zavudev.String("We received your message, but this message type is not supported. Please send a text message instead."),
	})
}

<?php
function handleUnsupportedMessage(array $data): void {
    $from = $data['from'];
    $messageId = $data['messageId'];

    // Log unsupported message for analytics
    UnsupportedMessage::create([
        'message_id' => $messageId,
        'from_number' => $from,
        'received_at' => now(),
    ]);

    // Optionally notify the customer
    $client->messages->send([
        'to' => $from,
        'text' => 'We received your message, but this message type is not supported. Please send a text message instead.',
    ]);
}

async function handleReaction(data) {
  const { messageId, reaction } = data;
  const { emoji, from, action } = reaction;

  if (action === "added") {
    // Store the reaction
    await db.reactions.create({
      messageId,
      emoji,
      from,
      createdAt: new Date()
    });

    // Track engagement metrics
    await analytics.track("message_reaction", {
      messageId,
      emoji,
    });
  } else if (action === "removed") {
    // Remove the reaction
    await db.reactions.delete({
      messageId,
      from,
    });
  }
}

async def handle_reaction(data):
    message_id = data["messageId"]
    reaction = data["reaction"]
    emoji = reaction["emoji"]
    from_number = reaction["from"]
    action = reaction["action"]

    if action == "added":
        # Store the reaction
        await db.reactions.create(
            message_id=message_id,
            emoji=emoji,
            from_number=from_number,
            created_at=datetime.now()
        )

        # Track engagement metrics
        await analytics.track("message_reaction", {
            "message_id": message_id,
            "emoji": emoji
        })
    elif action == "removed":
        # Remove the reaction
        await db.reactions.delete(
            message_id=message_id,
            from_number=from_number
        )

def handle_reaction(data)
  message_id = data["messageId"]
  reaction = data["reaction"]
  emoji = reaction["emoji"]
  from_number = reaction["from"]
  action = reaction["action"]

  if action == "added"
    # Store the reaction
    Reaction.create!(
      message_id: message_id,
      emoji: emoji,
      from_number: from_number,
      created_at: Time.now
    )

    # Track engagement metrics
    Analytics.track("message_reaction", {
      message_id: message_id,
      emoji: emoji
    })
  elsif action == "removed"
    # Remove the reaction
    Reaction.where(message_id: message_id, from_number: from_number).destroy_all
  end
end

func handleReaction(data map[string]interface{}) {
	messageID := data["messageId"].(string)
	reaction := data["reaction"].(map[string]interface{})
	emoji := reaction["emoji"].(string)
	from := reaction["from"].(string)
	action := reaction["action"].(string)

	if action == "added" {
		// Store the reaction
		db.Reactions.Create(messageID, emoji, from)

		// Track engagement metrics
		analytics.Track("message_reaction", map[string]string{
			"messageId": messageID,
			"emoji":     emoji,
		})
	} else if action == "removed" {
		// Remove the reaction
		db.Reactions.Delete(messageID, from)
	}
}

<?php
function handleReaction(array $data): void {
    $messageId = $data['messageId'];
    $reaction = $data['reaction'];
    $emoji = $reaction['emoji'];
    $from = $reaction['from'];
    $action = $reaction['action'];

    if ($action === 'added') {
        // Store the reaction
        Reaction::create([
            'message_id' => $messageId,
            'emoji' => $emoji,
            'from_number' => $from,
            'created_at' => now(),
        ]);

        // Track engagement metrics
        Analytics::track('message_reaction', [
            'message_id' => $messageId,
            'emoji' => $emoji,
        ]);
    } elseif ($action === 'removed') {
        // Remove the reaction
        Reaction::where('message_id', $messageId)
            ->where('from_number', $from)
            ->delete();
    }
}

async function handleDeliveryFailure(data) {
  const { messageId, errorCode, errorMessage } = data;

  // Log the failure
  await db.messages.update(messageId, {
    status: "failed",
    errorCode,
    errorMessage,
    failedAt: new Date()
  });

  // Alert your team for critical failures
  if (["30007", "21610"].includes(errorCode)) {
    await alertTeam({
      type: "message_blocked",
      messageId,
      reason: errorMessage
    });
  }
}

async def handle_delivery_failure(data):
    message_id = data["messageId"]
    error_code = data["errorCode"]
    error_message = data["errorMessage"]

    # Log the failure
    await db.messages.update(message_id, {
        "status": "failed",
        "error_code": error_code,
        "error_message": error_message,
        "failed_at": datetime.now()
    })

    # Alert your team for critical failures
    if error_code in ["30007", "21610"]:
        await alert_team({
            "type": "message_blocked",
            "message_id": message_id,
            "reason": error_message
        })

def handle_delivery_failure(data)
  message_id = data["messageId"]
  error_code = data["errorCode"]
  error_message = data["errorMessage"]

  # Log the failure
  Message.find(message_id).update!(
    status: "failed",
    error_code: error_code,
    error_message: error_message,
    failed_at: Time.now
  )

  # Alert your team for critical failures
  if %w[30007 21610].include?(error_code)
    alert_team(
      type: "message_blocked",
      message_id: message_id,
      reason: error_message
    )
  end
end

func handleDeliveryFailure(data map[string]interface{}) {
	messageID := data["messageId"].(string)
	errorCode := data["errorCode"].(string)
	errorMessage := data["errorMessage"].(string)

	// Log the failure
	db.Messages.Update(messageID, map[string]interface{}{
		"status":       "failed",
		"errorCode":    errorCode,
		"errorMessage": errorMessage,
	})

	// Alert your team for critical failures
	if errorCode == "30007" || errorCode == "21610" {
		alertTeam(map[string]string{
			"type":      "message_blocked",
			"messageId": messageID,
			"reason":    errorMessage,
		})
	}
}

<?php
function handleDeliveryFailure(array $data): void {
    $messageId = $data['messageId'];
    $errorCode = $data['errorCode'];
    $errorMessage = $data['errorMessage'];

    // Log the failure
    Message::where('id', $messageId)->update([
        'status' => 'failed',
        'error_code' => $errorCode,
        'error_message' => $errorMessage,
        'failed_at' => now(),
    ]);

    // Alert your team for critical failures
    if (in_array($errorCode, ['30007', '21610'])) {
        alertTeam([
            'type' => 'message_blocked',
            'message_id' => $messageId,
            'reason' => $errorMessage,
        ]);
    }
}

async function handleTemplateStatusChange(data) {
  const { templateId, templateName, currentStatus, rejectionReason } = data;

  // Update template status in your database
  await db.templates.update(templateId, {
    status: currentStatus,
    rejectionReason,
    updatedAt: new Date()
  });

  if (currentStatus === "approved") {
    await notifyTeam({
      message: `Template "${templateName}" has been approved!`,
      type: "success"
    });
  } else if (currentStatus === "rejected") {
    await notifyTeam({
      message: `Template "${templateName}" was rejected: ${rejectionReason}`,
      type: "error"
    });
  }
}

async def handle_template_status_change(data):
    template_id = data["templateId"]
    template_name = data["templateName"]
    current_status = data["currentStatus"]
    rejection_reason = data.get("rejectionReason")

    # Update template status in your database
    await db.templates.update(template_id, {
        "status": current_status,
        "rejection_reason": rejection_reason,
        "updated_at": datetime.now()
    })

    if current_status == "approved":
        await notify_team({
            "message": f'Template "{template_name}" has been approved!',
            "type": "success"
        })
    elif current_status == "rejected":
        await notify_team({
            "message": f'Template "{template_name}" was rejected: {rejection_reason}',
            "type": "error"
        })

def handle_template_status_change(data)
  template_id = data["templateId"]
  template_name = data["templateName"]
  current_status = data["currentStatus"]
  rejection_reason = data["rejectionReason"]

  # Update template status in your database
  Template.find(template_id).update!(
    status: current_status,
    rejection_reason: rejection_reason,
    updated_at: Time.now
  )

  if current_status == "approved"
    notify_team(
      message: "Template \"#{template_name}\" has been approved!",
      type: "success"
    )
  elsif current_status == "rejected"
    notify_team(
      message: "Template \"#{template_name}\" was rejected: #{rejection_reason}",
      type: "error"
    )
  end
end

func handleTemplateStatusChange(data map[string]interface{}) {
	templateID := data["templateId"].(string)
	templateName := data["templateName"].(string)
	currentStatus := data["currentStatus"].(string)
	rejectionReason, _ := data["rejectionReason"].(string)

	// Update template status in your database
	db.Templates.Update(templateID, map[string]interface{}{
		"status":          currentStatus,
		"rejectionReason": rejectionReason,
	})

	if currentStatus == "approved" {
		notifyTeam(map[string]string{
			"message": fmt.Sprintf("Template \"%s\" has been approved!", templateName),
			"type":    "success",
		})
	} else if currentStatus == "rejected" {
		notifyTeam(map[string]string{
			"message": fmt.Sprintf("Template \"%s\" was rejected: %s", templateName, rejectionReason),
			"type":    "error",
		})
	}
}

<?php
function handleTemplateStatusChange(array $data): void {
    $templateId = $data['templateId'];
    $templateName = $data['templateName'];
    $currentStatus = $data['currentStatus'];
    $rejectionReason = $data['rejectionReason'] ?? null;

    // Update template status in your database
    Template::where('id', $templateId)->update([
        'status' => $currentStatus,
        'rejection_reason' => $rejectionReason,
        'updated_at' => now(),
    ]);

    if ($currentStatus === 'approved') {
        notifyTeam([
            'message' => "Template \"{$templateName}\" has been approved!",
            'type' => 'success',
        ]);
    } elseif ($currentStatus === 'rejected') {
        notifyTeam([
            'message' => "Template \"{$templateName}\" was rejected: {$rejectionReason}",
            'type' => 'error',
        ]);
    }
}

async function handleInvitationStatusChanged(data) {
  const { invitationId, clientName, currentStatus, senderId } = data;

  if (currentStatus === "completed") {
    // Client successfully onboarded
    await notifyTeam({
      message: `${clientName} has connected their WhatsApp!`,
      senderId,
    });

    // Create templates for the new client
    await createDefaultTemplates(senderId);
  } else if (currentStatus === "in_progress") {
    // Client started the process
    console.log(`${clientName} is completing WhatsApp setup`);
  }
}

async def handle_invitation_status_changed(data):
    invitation_id = data["invitationId"]
    client_name = data["clientName"]
    current_status = data["currentStatus"]
    sender_id = data.get("senderId")

    if current_status == "completed":
        # Client successfully onboarded
        await notify_team({
            "message": f"{client_name} has connected their WhatsApp!",
            "sender_id": sender_id
        })

        # Create templates for the new client
        await create_default_templates(sender_id)
    elif current_status == "in_progress":
        # Client started the process
        print(f"{client_name} is completing WhatsApp setup")

def handle_invitation_status_changed(data)
  invitation_id = data["invitationId"]
  client_name = data["clientName"]
  current_status = data["currentStatus"]
  sender_id = data["senderId"]

  if current_status == "completed"
    # Client successfully onboarded
    notify_team(
      message: "#{client_name} has connected their WhatsApp!",
      sender_id: sender_id
    )

    # Create templates for the new client
    create_default_templates(sender_id)
  elsif current_status == "in_progress"
    # Client started the process
    puts "#{client_name} is completing WhatsApp setup"
  end
end

func handleInvitationStatusChanged(data map[string]interface{}) {
	clientName := data["clientName"].(string)
	currentStatus := data["currentStatus"].(string)
	senderID, _ := data["senderId"].(string)

	if currentStatus == "completed" {
		// Client successfully onboarded
		notifyTeam(map[string]string{
			"message":  fmt.Sprintf("%s has connected their WhatsApp!", clientName),
			"senderId": senderID,
		})

		// Create templates for the new client
		createDefaultTemplates(senderID)
	} else if currentStatus == "in_progress" {
		// Client started the process
		fmt.Printf("%s is completing WhatsApp setup\n", clientName)
	}
}

<?php
function handleInvitationStatusChanged(array $data): void {
    $clientName = $data['clientName'];
    $currentStatus = $data['currentStatus'];
    $senderId = $data['senderId'] ?? null;

    if ($currentStatus === 'completed') {
        // Client successfully onboarded
        notifyTeam([
            'message' => "{$clientName} has connected their WhatsApp!",
            'sender_id' => $senderId,
        ]);

        // Create templates for the new client
        createDefaultTemplates($senderId);
    } elseif ($currentStatus === 'in_progress') {
        // Client started the process
        echo "{$clientName} is completing WhatsApp setup\n";
    }
}

async function handleBroadcastStatusChanged(data) {
  const { broadcastId, name, status, previousStatus } = data;

  switch (status) {
    case "approved":
      console.log(`Broadcast "${name}" approved — will begin sending`);
      break;
    case "rejected":
      console.log(`Broadcast "${name}" rejected — edit content and retry`);
      await notifyTeam({ message: `Broadcast rejected: ${name}` });
      break;
    case "completed":
      console.log(`Broadcast "${name}" completed!`);
      await generateReport(broadcastId);
      break;
    case "cancelled":
      console.log(`Broadcast "${name}" was cancelled`);
      break;
  }
}

async def handle_broadcast_status_changed(data):
    broadcast_id = data["broadcastId"]
    name = data["name"]
    status = data["status"]

    if status == "approved":
        print(f'Broadcast "{name}" approved — will begin sending')
    elif status == "rejected":
        print(f'Broadcast "{name}" rejected — edit content and retry')
        await notify_team(f"Broadcast rejected: {name}")
    elif status == "completed":
        print(f'Broadcast "{name}" completed!')
        await generate_report(broadcast_id)
    elif status == "cancelled":
        print(f'Broadcast "{name}" was cancelled')