wdevs/whatshooked
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Whatsapp Business support

Browse Source
This commit is contained in:
Warky
2025-12-29 06:23:16 +02:00
parent 09a12560d3
commit ae169f81e4
14 changed files with 2269 additions and 800 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
internal/config/config.go
View File

@@ -28,10 +28,22 @@ type ServerConfig struct {
// WhatsAppConfig holds configuration for a WhatsApp account
type WhatsAppConfig struct {
ID string `json:"id"`
PhoneNumber string `json:"phone_number"`
SessionPath string `json:"session_path"`
ShowQR bool `json:"show_qr,omitempty"`
ID string `json:"id"`
Type string `json:"type"` // "whatsmeow" or "business-api"
PhoneNumber string `json:"phone_number"`
SessionPath string `json:"session_path,omitempty"`
ShowQR bool `json:"show_qr,omitempty"`
BusinessAPI *BusinessAPIConfig `json:"business_api,omitempty"`
}
// BusinessAPIConfig holds configuration for WhatsApp Business API
type BusinessAPIConfig struct {
PhoneNumberID string `json:"phone_number_id"`
AccessToken string `json:"access_token"`
BusinessAccountID string `json:"business_account_id,omitempty"`
APIVersion string `json:"api_version,omitempty"` // Default: v21.0
WebhookPath string `json:"webhook_path,omitempty"`
VerifyToken string `json:"verify_token,omitempty"`
}
// Hook represents a registered webhook
@@ -114,6 +126,19 @@ func Load(path string) (*Config, error) {
cfg.Database.SQLitePath = "./data/events.db"
}
// Default WhatsApp account type to whatsmeow for backwards compatibility
for i := range cfg.WhatsApp {
if cfg.WhatsApp[i].Type == "" {
cfg.WhatsApp[i].Type = "whatsmeow"
}
// Set default API version for Business API
if cfg.WhatsApp[i].Type == "business-api" && cfg.WhatsApp[i].BusinessAPI != nil {
if cfg.WhatsApp[i].BusinessAPI.APIVersion == "" {
cfg.WhatsApp[i].BusinessAPI.APIVersion = "v21.0"
}
}
}
return &cfg, nil
}

354
internal/whatsapp/businessapi/client.go Normal file
View File

@@ -0,0 +1,354 @@
package businessapi
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
"sync"
"time"
"git.warky.dev/wdevs/whatshooked/internal/config"
"git.warky.dev/wdevs/whatshooked/internal/events"
"git.warky.dev/wdevs/whatshooked/internal/logging"
"go.mau.fi/whatsmeow/types"
)
// Client represents a WhatsApp Business API client
type Client struct {
id string
phoneNumber string
config config.BusinessAPIConfig
httpClient *http.Client
eventBus *events.EventBus
mediaConfig config.MediaConfig
connected bool
mu sync.RWMutex
}
// NewClient creates a new Business API client
func NewClient(cfg config.WhatsAppConfig, eventBus *events.EventBus, mediaConfig config.MediaConfig) (*Client, error) {
if cfg.Type != "business-api" {
return nil, fmt.Errorf("invalid client type for business-api: %s", cfg.Type)
}
if cfg.BusinessAPI == nil {
return nil, fmt.Errorf("business_api configuration is required for business-api type")
}
// Validate required fields
if cfg.BusinessAPI.PhoneNumberID == "" {
return nil, fmt.Errorf("phone_number_id is required")
}
if cfg.BusinessAPI.AccessToken == "" {
return nil, fmt.Errorf("access_token is required")
}
// Set default API version
if cfg.BusinessAPI.APIVersion == "" {
cfg.BusinessAPI.APIVersion = "v21.0"
}
return &Client{
id: cfg.ID,
phoneNumber: cfg.PhoneNumber,
config: *cfg.BusinessAPI,
httpClient: &http.Client{
Timeout: 30 * time.Second,
},
eventBus: eventBus,
mediaConfig: mediaConfig,
connected: false,
}, nil
}
// Connect validates the Business API credentials
func (c *Client) Connect(ctx context.Context) error {
// Validate credentials by making a test request to get phone number details
url := fmt.Sprintf("https://graph.facebook.com/%s/%s",
c.config.APIVersion,
c.config.PhoneNumberID)
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
if err != nil {
return fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Authorization", "Bearer "+c.config.AccessToken)
resp, err := c.httpClient.Do(req)
if err != nil {
c.eventBus.Publish(events.WhatsAppPairFailedEvent(ctx, c.id, err))
return fmt.Errorf("failed to validate credentials: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
body, _ := io.ReadAll(resp.Body)
err := fmt.Errorf("API returned status %d: %s", resp.StatusCode, string(body))
c.eventBus.Publish(events.WhatsAppPairFailedEvent(ctx, c.id, err))
return err
}
c.mu.Lock()
c.connected = true
c.mu.Unlock()
logging.Info("Business API client connected", "account_id", c.id, "phone", c.phoneNumber)
c.eventBus.Publish(events.WhatsAppConnectedEvent(ctx, c.id, c.phoneNumber))
return nil
}
// Disconnect closes the Business API client
func (c *Client) Disconnect() error {
c.mu.Lock()
c.connected = false
c.mu.Unlock()
logging.Info("Business API client disconnected", "account_id", c.id)
return nil
}
// IsConnected returns whether the client is connected
func (c *Client) IsConnected() bool {
c.mu.RLock()
defer c.mu.RUnlock()
return c.connected
}
// GetID returns the client ID
func (c *Client) GetID() string {
return c.id
}
// GetPhoneNumber returns the phone number
func (c *Client) GetPhoneNumber() string {
return c.phoneNumber
}
// GetType returns the client type
func (c *Client) GetType() string {
return "business-api"
}
// SendTextMessage sends a text message via Business API
func (c *Client) SendTextMessage(ctx context.Context, jid types.JID, text string) (string, error) {
if ctx == nil {
ctx = context.Background()
}
// Convert JID to phone number
phoneNumber := jidToPhoneNumber(jid)
// Create request
reqBody := SendMessageRequest{
MessagingProduct: "whatsapp",
To: phoneNumber,
Type: "text",
Text: &TextObject{
Body: text,
},
}
messageID, err := c.sendMessage(ctx, reqBody)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, phoneNumber, text, err))
return "", err
}
logging.Debug("Message sent via Business API", "account_id", c.id, "to", phoneNumber)
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, messageID, phoneNumber, text))
return messageID, nil
}
// SendImage sends an image message via Business API
func (c *Client) SendImage(ctx context.Context, jid types.JID, imageData []byte, mimeType string, caption string) (string, error) {
if ctx == nil {
ctx = context.Background()
}
phoneNumber := jidToPhoneNumber(jid)
// Upload media first
mediaID, err := c.uploadMedia(ctx, imageData, mimeType)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, phoneNumber, caption, err))
return "", fmt.Errorf("failed to upload image: %w", err)
}
// Send message with media ID
reqBody := SendMessageRequest{
MessagingProduct: "whatsapp",
To: phoneNumber,
Type: "image",
Image: &MediaObject{
ID: mediaID,
Caption: caption,
},
}
messageID, err := c.sendMessage(ctx, reqBody)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, phoneNumber, caption, err))
return "", err
}
logging.Debug("Image sent via Business API", "account_id", c.id, "to", phoneNumber)
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, messageID, phoneNumber, caption))
return messageID, nil
}
// SendVideo sends a video message via Business API
func (c *Client) SendVideo(ctx context.Context, jid types.JID, videoData []byte, mimeType string, caption string) (string, error) {
if ctx == nil {
ctx = context.Background()
}
phoneNumber := jidToPhoneNumber(jid)
// Upload media first
mediaID, err := c.uploadMedia(ctx, videoData, mimeType)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, phoneNumber, caption, err))
return "", fmt.Errorf("failed to upload video: %w", err)
}
// Send message with media ID
reqBody := SendMessageRequest{
MessagingProduct: "whatsapp",
To: phoneNumber,
Type: "video",
Video: &MediaObject{
ID: mediaID,
Caption: caption,
},
}
messageID, err := c.sendMessage(ctx, reqBody)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, phoneNumber, caption, err))
return "", err
}
logging.Debug("Video sent via Business API", "account_id", c.id, "to", phoneNumber)
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, messageID, phoneNumber, caption))
return messageID, nil
}
// SendDocument sends a document message via Business API
func (c *Client) SendDocument(ctx context.Context, jid types.JID, documentData []byte, mimeType string, filename string, caption string) (string, error) {
if ctx == nil {
ctx = context.Background()
}
phoneNumber := jidToPhoneNumber(jid)
// Upload media first
mediaID, err := c.uploadMedia(ctx, documentData, mimeType)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, phoneNumber, caption, err))
return "", fmt.Errorf("failed to upload document: %w", err)
}
// Send message with media ID
reqBody := SendMessageRequest{
MessagingProduct: "whatsapp",
To: phoneNumber,
Type: "document",
Document: &DocumentObject{
ID: mediaID,
Caption: caption,
Filename: filename,
},
}
messageID, err := c.sendMessage(ctx, reqBody)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, phoneNumber, caption, err))
return "", err
}
logging.Debug("Document sent via Business API", "account_id", c.id, "to", phoneNumber, "filename", filename)
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, messageID, phoneNumber, caption))
return messageID, nil
}
// sendMessage sends a message request to the Business API
func (c *Client) sendMessage(ctx context.Context, reqBody SendMessageRequest) (string, error) {
url := fmt.Sprintf("https://graph.facebook.com/%s/%s/messages",
c.config.APIVersion,
c.config.PhoneNumberID)
jsonData, err := json.Marshal(reqBody)
if err != nil {
return "", fmt.Errorf("failed to marshal request: %w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
if err != nil {
return "", fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Authorization", "Bearer "+c.config.AccessToken)
req.Header.Set("Content-Type", "application/json")
resp, err := c.httpClient.Do(req)
if err != nil {
return "", fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
var errResp ErrorResponse
if err := json.Unmarshal(body, &errResp); err == nil {
return "", fmt.Errorf("API error: %s (code: %d)", errResp.Error.Message, errResp.Error.Code)
}
return "", fmt.Errorf("API returned status %d: %s", resp.StatusCode, string(body))
}
var sendResp SendMessageResponse
if err := json.Unmarshal(body, &sendResp); err != nil {
return "", fmt.Errorf("failed to parse response: %w", err)
}
if len(sendResp.Messages) == 0 {
return "", fmt.Errorf("no message ID in response")
}
return sendResp.Messages[0].ID, nil
}
// jidToPhoneNumber converts a WhatsApp JID to E.164 phone number format
func jidToPhoneNumber(jid types.JID) string {
// JID format is like "27123456789@s.whatsapp.net"
// Extract the phone number part before @
phone := jid.User
// Ensure it starts with + for E.164
if !strings.HasPrefix(phone, "+") {
phone = "+" + phone
}
return phone
}
// phoneNumberToJID converts an E.164 phone number to WhatsApp JID
func phoneNumberToJID(phoneNumber string) types.JID {
// Remove + if present
phone := strings.TrimPrefix(phoneNumber, "+")
// Create JID
return types.JID{
User: phone,
Server: types.DefaultUserServer, // "s.whatsapp.net"
}
}

288
internal/whatsapp/businessapi/events.go Normal file
View File

@@ -0,0 +1,288 @@
package businessapi
import (
"context"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"strconv"
"time"
"git.warky.dev/wdevs/whatshooked/internal/events"
"git.warky.dev/wdevs/whatshooked/internal/logging"
)
// HandleWebhook processes incoming webhook events from WhatsApp Business API
func (c *Client) HandleWebhook(r *http.Request) error {
body, err := io.ReadAll(r.Body)
if err != nil {
return fmt.Errorf("failed to read request body: %w", err)
}
var payload WebhookPayload
if err := json.Unmarshal(body, &payload); err != nil {
return fmt.Errorf("failed to parse webhook payload: %w", err)
}
// Process each entry
for _, entry := range payload.Entry {
for _, change := range entry.Changes {
c.processChange(change)
}
}
return nil
}
// processChange processes a webhook change
func (c *Client) processChange(change WebhookChange) {
ctx := context.Background()
// Process messages
for _, msg := range change.Value.Messages {
c.processMessage(ctx, msg, change.Value.Contacts)
}
// Process statuses
for _, status := range change.Value.Statuses {
c.processStatus(ctx, status)
}
}
// processMessage processes an incoming message
func (c *Client) processMessage(ctx context.Context, msg WebhookMessage, contacts []WebhookContact) {
// Get sender name from contacts
senderName := ""
for _, contact := range contacts {
if contact.WaID == msg.From {
senderName = contact.Profile.Name
break
}
}
// Parse timestamp
timestamp := c.parseTimestamp(msg.Timestamp)
var text string
var messageType string
var mimeType string
var filename string
var mediaBase64 string
var mediaURL string
// Process based on message type
switch msg.Type {
case "text":
if msg.Text != nil {
text = msg.Text.Body
}
messageType = "text"
case "image":
if msg.Image != nil {
messageType = "image"
mimeType = msg.Image.MimeType
text = msg.Image.Caption
// Download and process media
data, _, err := c.downloadMedia(ctx, msg.Image.ID)
if err != nil {
logging.Error("Failed to download image", "account_id", c.id, "media_id", msg.Image.ID, "error", err)
} else {
filename, mediaURL = c.processMediaData(msg.ID, data, mimeType, &mediaBase64)
}
}
case "video":
if msg.Video != nil {
messageType = "video"
mimeType = msg.Video.MimeType
text = msg.Video.Caption
// Download and process media
data, _, err := c.downloadMedia(ctx, msg.Video.ID)
if err != nil {
logging.Error("Failed to download video", "account_id", c.id, "media_id", msg.Video.ID, "error", err)
} else {
filename, mediaURL = c.processMediaData(msg.ID, data, mimeType, &mediaBase64)
}
}
case "document":
if msg.Document != nil {
messageType = "document"
mimeType = msg.Document.MimeType
text = msg.Document.Caption
filename = msg.Document.Filename
// Download and process media
data, _, err := c.downloadMedia(ctx, msg.Document.ID)
if err != nil {
logging.Error("Failed to download document", "account_id", c.id, "media_id", msg.Document.ID, "error", err)
} else {
filename, mediaURL = c.processMediaData(msg.ID, data, mimeType, &mediaBase64)
}
}
default:
logging.Warn("Unsupported message type", "account_id", c.id, "type", msg.Type)
return
}
// Publish message received event
c.eventBus.Publish(events.MessageReceivedEvent(
ctx,
c.id,
msg.ID,
msg.From,
msg.From, // For Business API, chat is same as sender for individual messages
text,
timestamp,
false, // Business API doesn't indicate groups in this webhook
"",
senderName,
messageType,
mimeType,
filename,
mediaBase64,
mediaURL,
))
logging.Debug("Message received via Business API", "account_id", c.id, "from", msg.From, "type", messageType)
}
// processStatus processes a message status update
func (c *Client) processStatus(ctx context.Context, status WebhookStatus) {
timestamp := c.parseTimestamp(status.Timestamp)
switch status.Status {
case "sent":
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, status.ID, status.RecipientID, ""))
logging.Debug("Message sent status", "account_id", c.id, "message_id", status.ID)
case "delivered":
c.eventBus.Publish(events.MessageDeliveredEvent(ctx, c.id, status.ID, status.RecipientID, timestamp))
logging.Debug("Message delivered", "account_id", c.id, "message_id", status.ID)
case "read":
c.eventBus.Publish(events.MessageReadEvent(ctx, c.id, status.ID, status.RecipientID, timestamp))
logging.Debug("Message read", "account_id", c.id, "message_id", status.ID)
case "failed":
errMsg := "unknown error"
if len(status.Errors) > 0 {
errMsg = fmt.Sprintf("%s (code: %d)", status.Errors[0].Title, status.Errors[0].Code)
}
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, status.RecipientID, "", fmt.Errorf("%s", errMsg)))
logging.Error("Message failed", "account_id", c.id, "message_id", status.ID, "error", errMsg)
default:
logging.Debug("Unknown status type", "account_id", c.id, "status", status.Status)
}
}
// parseTimestamp parses a Unix timestamp string to time.Time
func (c *Client) parseTimestamp(ts string) time.Time {
unix, err := strconv.ParseInt(ts, 10, 64)
if err != nil {
logging.Warn("Failed to parse timestamp", "timestamp", ts, "error", err)
return time.Now()
}
return time.Unix(unix, 0)
}
// processMediaData processes media based on the configured mode
func (c *Client) processMediaData(messageID string, data []byte, mimeType string, mediaBase64 *string) (string, string) {
mode := c.mediaConfig.Mode
var filename string
var mediaURL string
// Generate filename
ext := getExtensionFromMimeType(mimeType)
hash := sha256.Sum256(data)
hashStr := hex.EncodeToString(hash[:8])
filename = fmt.Sprintf("%s_%s%s", messageID, hashStr, ext)
// Handle base64 mode
if mode == "base64" || mode == "both" {
*mediaBase64 = base64.StdEncoding.EncodeToString(data)
}
// Handle link mode
if mode == "link" || mode == "both" {
// Save file to disk
filePath, err := c.saveMediaFile(messageID, data, mimeType)
if err != nil {
logging.Error("Failed to save media file", "account_id", c.id, "message_id", messageID, "error", err)
} else {
filename = filepath.Base(filePath)
mediaURL = c.generateMediaURL(messageID, filename)
}
}
return filename, mediaURL
}
// saveMediaFile saves media data to disk
func (c *Client) saveMediaFile(messageID string, data []byte, mimeType string) (string, error) {
mediaDir := filepath.Join(c.mediaConfig.DataPath, c.id)
if err := os.MkdirAll(mediaDir, 0755); err != nil {
return "", fmt.Errorf("failed to create media directory: %w", err)
}
hash := sha256.Sum256(data)
hashStr := hex.EncodeToString(hash[:8])
ext := getExtensionFromMimeType(mimeType)
filename := fmt.Sprintf("%s_%s%s", messageID, hashStr, ext)
filePath := filepath.Join(mediaDir, filename)
if err := os.WriteFile(filePath, data, 0644); err != nil {
return "", fmt.Errorf("failed to write media file: %w", err)
}
return filePath, nil
}
// generateMediaURL generates a URL for accessing stored media
func (c *Client) generateMediaURL(messageID, filename string) string {
baseURL := c.mediaConfig.BaseURL
if baseURL == "" {
baseURL = "http://localhost:8080"
}
return fmt.Sprintf("%s/api/media/%s/%s", baseURL, c.id, filename)
}
// getExtensionFromMimeType returns the file extension for a given MIME type
func getExtensionFromMimeType(mimeType string) string {
extensions := map[string]string{
"image/jpeg": ".jpg",
"image/png": ".png",
"image/gif": ".gif",
"image/webp": ".webp",
"video/mp4": ".mp4",
"video/mpeg": ".mpeg",
"video/webm": ".webm",
"video/3gpp": ".3gp",
"application/pdf": ".pdf",
"application/msword": ".doc",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
"application/vnd.ms-excel": ".xls",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
"text/plain": ".txt",
"application/json": ".json",
"audio/mpeg": ".mp3",
"audio/ogg": ".ogg",
}
if ext, ok := extensions[mimeType]; ok {
return ext
}
return ""
}

138
internal/whatsapp/businessapi/media.go Normal file
View File

@@ -0,0 +1,138 @@
package businessapi
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"mime/multipart"
"net/http"
)
// uploadMedia uploads media to the Business API and returns the media ID
func (c *Client) uploadMedia(ctx context.Context, data []byte, mimeType string) (string, error) {
url := fmt.Sprintf("https://graph.facebook.com/%s/%s/media",
c.config.APIVersion,
c.config.PhoneNumberID)
// Create multipart form data
var requestBody bytes.Buffer
writer := multipart.NewWriter(&requestBody)
// Add the file
part, err := writer.CreateFormFile("file", "media")
if err != nil {
return "", fmt.Errorf("failed to create form file: %w", err)
}
if _, err := part.Write(data); err != nil {
return "", fmt.Errorf("failed to write file data: %w", err)
}
// Add messaging_product field
if err := writer.WriteField("messaging_product", "whatsapp"); err != nil {
return "", fmt.Errorf("failed to write messaging_product field: %w", err)
}
// Add type field (mime type)
if err := writer.WriteField("type", mimeType); err != nil {
return "", fmt.Errorf("failed to write type field: %w", err)
}
if err := writer.Close(); err != nil {
return "", fmt.Errorf("failed to close multipart writer: %w", err)
}
// Create request
req, err := http.NewRequestWithContext(ctx, "POST", url, &requestBody)
if err != nil {
return "", fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Authorization", "Bearer "+c.config.AccessToken)
req.Header.Set("Content-Type", writer.FormDataContentType())
// Send request
resp, err := c.httpClient.Do(req)
if err != nil {
return "", fmt.Errorf("failed to upload media: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("failed to read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
var errResp ErrorResponse
if err := json.Unmarshal(body, &errResp); err == nil {
return "", fmt.Errorf("upload error: %s (code: %d)", errResp.Error.Message, errResp.Error.Code)
}
return "", fmt.Errorf("upload failed with status %d: %s", resp.StatusCode, string(body))
}
var uploadResp MediaUploadResponse
if err := json.Unmarshal(body, &uploadResp); err != nil {
return "", fmt.Errorf("failed to parse upload response: %w", err)
}
return uploadResp.ID, nil
}
// downloadMedia downloads media from the Business API using the media ID
func (c *Client) downloadMedia(ctx context.Context, mediaID string) ([]byte, string, error) {
// Step 1: Get the media URL
url := fmt.Sprintf("https://graph.facebook.com/%s/%s",
c.config.APIVersion,
mediaID)
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
if err != nil {
return nil, "", fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Authorization", "Bearer "+c.config.AccessToken)
resp, err := c.httpClient.Do(req)
if err != nil {
return nil, "", fmt.Errorf("failed to get media URL: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
body, _ := io.ReadAll(resp.Body)
return nil, "", fmt.Errorf("failed to get media URL, status %d: %s", resp.StatusCode, string(body))
}
var mediaResp MediaURLResponse
if err := json.NewDecoder(resp.Body).Decode(&mediaResp); err != nil {
return nil, "", fmt.Errorf("failed to parse media URL response: %w", err)
}
// Step 2: Download from the CDN URL
downloadReq, err := http.NewRequestWithContext(ctx, "GET", mediaResp.URL, nil)
if err != nil {
return nil, "", fmt.Errorf("failed to create download request: %w", err)
}
downloadReq.Header.Set("Authorization", "Bearer "+c.config.AccessToken)
downloadResp, err := c.httpClient.Do(downloadReq)
if err != nil {
return nil, "", fmt.Errorf("failed to download media: %w", err)
}
defer downloadResp.Body.Close()
if downloadResp.StatusCode != http.StatusOK {
return nil, "", fmt.Errorf("failed to download media, status %d", downloadResp.StatusCode)
}
data, err := io.ReadAll(downloadResp.Body)
if err != nil {
return nil, "", fmt.Errorf("failed to read media data: %w", err)
}
return data, mediaResp.MimeType, nil
}

193
internal/whatsapp/businessapi/types.go Normal file
View File

@@ -0,0 +1,193 @@
package businessapi
// SendMessageRequest represents a request to send a text message via Business API
type SendMessageRequest struct {
MessagingProduct string `json:"messaging_product"` // Always "whatsapp"
RecipientType string `json:"recipient_type,omitempty"` // "individual"
To string `json:"to"` // Phone number in E.164 format
Type string `json:"type"` // "text", "image", "video", "document"
Text *TextObject `json:"text,omitempty"`
Image *MediaObject `json:"image,omitempty"`
Video *MediaObject `json:"video,omitempty"`
Document *DocumentObject `json:"document,omitempty"`
}
// TextObject represents a text message
type TextObject struct {
Body string `json:"body"`
}
// MediaObject represents media (image/video) message
type MediaObject struct {
ID string `json:"id,omitempty"` // Media ID (from upload)
Link string `json:"link,omitempty"` // Or direct URL
Caption string `json:"caption,omitempty"`
}
// DocumentObject represents a document message
type DocumentObject struct {
ID string `json:"id,omitempty"` // Media ID (from upload)
Link string `json:"link,omitempty"` // Or direct URL
Caption string `json:"caption,omitempty"`
Filename string `json:"filename,omitempty"`
}
// SendMessageResponse represents the response from sending a message
type SendMessageResponse struct {
MessagingProduct string `json:"messaging_product"`
Contacts []struct {
Input string `json:"input"`
WaID string `json:"wa_id"`
} `json:"contacts"`
Messages []struct {
ID string `json:"id"`
} `json:"messages"`
}
// MediaUploadResponse represents the response from uploading media
type MediaUploadResponse struct {
ID string `json:"id"` // Media ID to use in messages
}
// MediaURLResponse represents the response when getting media URL
type MediaURLResponse struct {
URL string `json:"url"` // CDN URL to download media
MimeType string `json:"mime_type"`
SHA256 string `json:"sha256"`
FileSize int64 `json:"file_size"`
ID string `json:"id"`
MessagingProduct string `json:"messaging_product"`
}
// ErrorResponse represents an error from the Business API
type ErrorResponse struct {
Error struct {
Message string `json:"message"`
Type string `json:"type"`
Code int `json:"code"`
ErrorSubcode int `json:"error_subcode,omitempty"`
FBTraceID string `json:"fbtrace_id,omitempty"`
} `json:"error"`
}
// WebhookPayload represents the incoming webhook from WhatsApp Business API
type WebhookPayload struct {
Object string `json:"object"` // "whatsapp_business_account"
Entry []WebhookEntry `json:"entry"`
}
// WebhookEntry represents an entry in the webhook
type WebhookEntry struct {
ID string `json:"id"` // WhatsApp Business Account ID
Changes []WebhookChange `json:"changes"`
}
// WebhookChange represents a change notification
type WebhookChange struct {
Value WebhookValue `json:"value"`
Field string `json:"field"` // "messages"
}
// WebhookValue contains the actual webhook data
type WebhookValue struct {
MessagingProduct string `json:"messaging_product"`
Metadata WebhookMetadata `json:"metadata"`
Contacts []WebhookContact `json:"contacts,omitempty"`
Messages []WebhookMessage `json:"messages,omitempty"`
Statuses []WebhookStatus `json:"statuses,omitempty"`
}
// WebhookMetadata contains metadata about the phone number
type WebhookMetadata struct {
DisplayPhoneNumber string `json:"display_phone_number"`
PhoneNumberID string `json:"phone_number_id"`
}
// WebhookContact represents a contact in the webhook
type WebhookContact struct {
Profile WebhookProfile `json:"profile"`
WaID string `json:"wa_id"`
}
// WebhookProfile contains profile information
type WebhookProfile struct {
Name string `json:"name"`
}
// WebhookMessage represents a message in the webhook
type WebhookMessage struct {
From string `json:"from"` // Sender phone number
ID string `json:"id"` // Message ID
Timestamp string `json:"timestamp"` // Unix timestamp as string
Type string `json:"type"` // "text", "image", "video", "document", etc.
Text *WebhookText `json:"text,omitempty"`
Image *WebhookMediaMessage `json:"image,omitempty"`
Video *WebhookMediaMessage `json:"video,omitempty"`
Document *WebhookDocumentMessage `json:"document,omitempty"`
Context *WebhookContext `json:"context,omitempty"` // Reply context
}
// WebhookText represents a text message
type WebhookText struct {
Body string `json:"body"`
}
// WebhookMediaMessage represents a media message (image/video)
type WebhookMediaMessage struct {
ID string `json:"id"` // Media ID
MimeType string `json:"mime_type"`
SHA256 string `json:"sha256"`
Caption string `json:"caption,omitempty"`
}
// WebhookDocumentMessage represents a document message
type WebhookDocumentMessage struct {
ID string `json:"id"` // Media ID
MimeType string `json:"mime_type"`
SHA256 string `json:"sha256"`
Filename string `json:"filename,omitempty"`
Caption string `json:"caption,omitempty"`
}
// WebhookContext represents reply context
type WebhookContext struct {
From string `json:"from"`
ID string `json:"id"` // Message ID being replied to
MessageID string `json:"message_id,omitempty"`
}
// WebhookStatus represents a message status update
type WebhookStatus struct {
ID string `json:"id"` // Message ID
Status string `json:"status"` // "sent", "delivered", "read", "failed"
Timestamp string `json:"timestamp"` // Unix timestamp as string
RecipientID string `json:"recipient_id"`
Conversation *WebhookConversation `json:"conversation,omitempty"`
Pricing *WebhookPricing `json:"pricing,omitempty"`
Errors []WebhookError `json:"errors,omitempty"`
}
// WebhookConversation contains conversation details
type WebhookConversation struct {
ID string `json:"id"`
ExpirationTimestamp string `json:"expiration_timestamp,omitempty"`
Origin WebhookOrigin `json:"origin"`
}
// WebhookOrigin contains conversation origin
type WebhookOrigin struct {
Type string `json:"type"`
}
// WebhookPricing contains pricing information
type WebhookPricing struct {
Billable bool `json:"billable"`
PricingModel string `json:"pricing_model"`
Category string `json:"category"`
}
// WebhookError represents an error in status update
type WebhookError struct {
Code int `json:"code"`
Title string `json:"title"`
}

767
internal/whatsapp/client.go
View File

@@ -1,767 +0,0 @@
package whatsapp
import (
"context"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"fmt"
"os"
"path/filepath"
"sync"
"time"
"git.warky.dev/wdevs/whatshooked/internal/config"
"git.warky.dev/wdevs/whatshooked/internal/events"
"git.warky.dev/wdevs/whatshooked/internal/logging"
qrterminal "github.com/mdp/qrterminal/v3"
"go.mau.fi/whatsmeow"
"go.mau.fi/whatsmeow/proto/waE2E"
"go.mau.fi/whatsmeow/store/sqlstore"
"go.mau.fi/whatsmeow/types"
waEvents "go.mau.fi/whatsmeow/types/events"
waLog "go.mau.fi/whatsmeow/util/log"
"google.golang.org/protobuf/proto"
_ "github.com/mattn/go-sqlite3"
)
// Manager manages multiple WhatsApp client connections
type Manager struct {
clients map[string]*Client
mu sync.RWMutex
eventBus *events.EventBus
mediaConfig config.MediaConfig
config *config.Config
configPath string
onConfigUpdate func(*config.Config) error
}
// Client represents a single WhatsApp connection
type Client struct {
ID string
PhoneNumber string
Client *whatsmeow.Client
Container *sqlstore.Container
keepAliveCancel context.CancelFunc
}
// NewManager creates a new WhatsApp manager
func NewManager(eventBus *events.EventBus, mediaConfig config.MediaConfig, cfg *config.Config, configPath string, onConfigUpdate func(*config.Config) error) *Manager {
return &Manager{
clients: make(map[string]*Client),
eventBus: eventBus,
mediaConfig: mediaConfig,
config: cfg,
configPath: configPath,
onConfigUpdate: onConfigUpdate,
}
}
// Connect establishes a connection to a WhatsApp account
func (m *Manager) Connect(ctx context.Context, cfg config.WhatsAppConfig) error {
m.mu.Lock()
defer m.mu.Unlock()
if _, exists := m.clients[cfg.ID]; exists {
return fmt.Errorf("client %s already connected", cfg.ID)
}
// Ensure session directory exists
if err := os.MkdirAll(cfg.SessionPath, 0700); err != nil {
return fmt.Errorf("failed to create session directory: %w", err)
}
// Create database container for session storage
dbPath := filepath.Join(cfg.SessionPath, "session.db")
dbLog := waLog.Stdout("Database", "ERROR", true)
container, err := sqlstore.New(ctx, "sqlite3", "file:"+dbPath+"?_foreign_keys=on", dbLog)
if err != nil {
return fmt.Errorf("failed to create database container: %w", err)
}
// Get device store
deviceStore, err := container.GetFirstDevice(ctx)
if err != nil {
return fmt.Errorf("failed to get device: %w", err)
}
// Set custom client information
//if deviceStore.ID == nil {
// Only set for new devices
deviceStore.Platform = "WhatsHooked"
deviceStore.BusinessName = "git.warky.dev/wdevs/whatshooked"
//}
// Create client
clientLog := waLog.Stdout("Client", "ERROR", true)
client := whatsmeow.NewClient(deviceStore, clientLog)
// Register event handler
client.AddEventHandler(func(evt interface{}) {
m.handleEvent(cfg.ID, evt)
})
// Connect
if client.Store.ID == nil {
// New device, need to pair
qrChan, _ := client.GetQRChannel(ctx)
if err := client.Connect(); err != nil {
m.eventBus.Publish(events.WhatsAppPairFailedEvent(ctx, cfg.ID, err))
return fmt.Errorf("failed to connect: %w", err)
}
// Wait for QR code
for evt := range qrChan {
switch evt.Event {
case "code":
logging.Info("QR code received for pairing", "account_id", cfg.ID)
// Always display QR code in terminal
fmt.Println("\n========================================")
fmt.Printf("WhatsApp QR Code for account: %s\n", cfg.ID)
fmt.Printf("Phone: %s\n", cfg.PhoneNumber)
fmt.Println("========================================")
fmt.Println("Scan this QR code with WhatsApp on your phone:")
qrterminal.GenerateHalfBlock(evt.Code, qrterminal.L, os.Stdout)
fmt.Println("========================================")
// Publish QR code event
m.eventBus.Publish(events.WhatsAppQRCodeEvent(ctx, cfg.ID, evt.Code))
case "success":
logging.Info("Pairing successful", "account_id", cfg.ID, "phone", cfg.PhoneNumber)
m.eventBus.Publish(events.WhatsAppPairSuccessEvent(ctx, cfg.ID))
case "timeout":
logging.Warn("QR code timeout", "account_id", cfg.ID)
m.eventBus.Publish(events.WhatsAppQRTimeoutEvent(ctx, cfg.ID))
case "error":
logging.Error("QR code error", "account_id", cfg.ID, "error", evt.Error)
m.eventBus.Publish(events.WhatsAppQRErrorEvent(ctx, cfg.ID, fmt.Errorf("%v", evt.Error)))
default:
logging.Info("Pairing event", "account_id", cfg.ID, "event", evt.Event)
m.eventBus.Publish(events.WhatsAppPairEventGeneric(ctx, cfg.ID, evt.Event, map[string]any{
"code": evt.Code,
}))
}
}
} else {
// Already paired, just connect
if err := client.Connect(); err != nil {
return fmt.Errorf("failed to connect: %w", err)
}
}
if deviceStore.PushName == "" {
deviceStore.PushName = fmt.Sprintf("WhatsHooked %s", cfg.PhoneNumber)
if err := deviceStore.Save(ctx); err != nil {
logging.Error("failed to save device store %s", cfg.ID)
}
}
waClient := &Client{
ID: cfg.ID,
PhoneNumber: cfg.PhoneNumber,
Client: client,
Container: container,
}
m.clients[cfg.ID] = waClient
if client.IsConnected() {
err := client.SendPresence(ctx, types.PresenceAvailable)
if err != nil {
logging.Warn("Failed to send presence", "account_id", cfg.ID, "error", err)
} else {
logging.Debug("Sent presence update", "account_id", cfg.ID)
}
}
// Start keep-alive routine
m.startKeepAlive(waClient)
logging.Info("WhatsApp client connected", "account_id", cfg.ID, "phone", cfg.PhoneNumber)
return nil
}
// Disconnect disconnects a WhatsApp client
func (m *Manager) Disconnect(id string) error {
m.mu.Lock()
defer m.mu.Unlock()
client, exists := m.clients[id]
if !exists {
return fmt.Errorf("client %s not found", id)
}
// Stop keep-alive
if client.keepAliveCancel != nil {
client.keepAliveCancel()
}
client.Client.Disconnect()
delete(m.clients, id)
logging.Info("WhatsApp client disconnected", "account_id", id)
return nil
}
// DisconnectAll disconnects all WhatsApp clients
func (m *Manager) DisconnectAll() {
m.mu.Lock()
defer m.mu.Unlock()
for id, client := range m.clients {
// Stop keep-alive
if client.keepAliveCancel != nil {
client.keepAliveCancel()
}
client.Client.Disconnect()
logging.Info("WhatsApp client disconnected", "account_id", id)
}
m.clients = make(map[string]*Client)
}
// SendTextMessage sends a text message from a specific account
func (m *Manager) SendTextMessage(ctx context.Context, accountID string, jid types.JID, text string) error {
if ctx == nil {
ctx = context.Background()
}
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
err := fmt.Errorf("client %s not found", accountID)
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), text, err))
return err
}
msg := &waE2E.Message{
Conversation: proto.String(text),
}
resp, err := client.Client.SendMessage(ctx, jid, msg)
if err != nil {
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), text, err))
return fmt.Errorf("failed to send message: %w", err)
}
logging.Debug("Message sent", "account_id", accountID, "to", jid.String())
m.eventBus.Publish(events.MessageSentEvent(ctx, accountID, resp.ID, jid.String(), text))
return nil
}
// SendImage sends an image message from a specific account
func (m *Manager) SendImage(ctx context.Context, accountID string, jid types.JID, imageData []byte, mimeType string, caption string) error {
if ctx == nil {
ctx = context.Background()
}
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
err := fmt.Errorf("client %s not found", accountID)
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return err
}
// Upload the image
uploaded, err := client.Client.Upload(ctx, imageData, whatsmeow.MediaImage)
if err != nil {
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return fmt.Errorf("failed to upload image: %w", err)
}
// Create image message
msg := &waE2E.Message{
ImageMessage: &waE2E.ImageMessage{
URL: proto.String(uploaded.URL),
DirectPath: proto.String(uploaded.DirectPath),
MediaKey: uploaded.MediaKey,
Mimetype: proto.String(mimeType),
FileEncSHA256: uploaded.FileEncSHA256,
FileSHA256: uploaded.FileSHA256,
FileLength: proto.Uint64(uint64(len(imageData))),
},
}
// Add caption if provided
if caption != "" {
msg.ImageMessage.Caption = proto.String(caption)
}
// Send the message
resp, err := client.Client.SendMessage(ctx, jid, msg)
if err != nil {
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return fmt.Errorf("failed to send image: %w", err)
}
logging.Debug("Image sent", "account_id", accountID, "to", jid.String())
m.eventBus.Publish(events.MessageSentEvent(ctx, accountID, resp.ID, jid.String(), caption))
return nil
}
// SendVideo sends a video message from a specific account
func (m *Manager) SendVideo(ctx context.Context, accountID string, jid types.JID, videoData []byte, mimeType string, caption string) error {
if ctx == nil {
ctx = context.Background()
}
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
err := fmt.Errorf("client %s not found", accountID)
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return err
}
// Upload the video
uploaded, err := client.Client.Upload(ctx, videoData, whatsmeow.MediaVideo)
if err != nil {
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return fmt.Errorf("failed to upload video: %w", err)
}
// Create video message
msg := &waE2E.Message{
VideoMessage: &waE2E.VideoMessage{
URL: proto.String(uploaded.URL),
DirectPath: proto.String(uploaded.DirectPath),
MediaKey: uploaded.MediaKey,
Mimetype: proto.String(mimeType),
FileEncSHA256: uploaded.FileEncSHA256,
FileSHA256: uploaded.FileSHA256,
FileLength: proto.Uint64(uint64(len(videoData))),
},
}
// Add caption if provided
if caption != "" {
msg.VideoMessage.Caption = proto.String(caption)
}
// Send the message
resp, err := client.Client.SendMessage(ctx, jid, msg)
if err != nil {
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return fmt.Errorf("failed to send video: %w", err)
}
logging.Debug("Video sent", "account_id", accountID, "to", jid.String())
m.eventBus.Publish(events.MessageSentEvent(ctx, accountID, resp.ID, jid.String(), caption))
return nil
}
// SendDocument sends a document message from a specific account
func (m *Manager) SendDocument(ctx context.Context, accountID string, jid types.JID, documentData []byte, mimeType string, filename string, caption string) error {
if ctx == nil {
ctx = context.Background()
}
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
err := fmt.Errorf("client %s not found", accountID)
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return err
}
// Upload the document
uploaded, err := client.Client.Upload(ctx, documentData, whatsmeow.MediaDocument)
if err != nil {
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return fmt.Errorf("failed to upload document: %w", err)
}
// Create document message
msg := &waE2E.Message{
DocumentMessage: &waE2E.DocumentMessage{
URL: proto.String(uploaded.URL),
DirectPath: proto.String(uploaded.DirectPath),
MediaKey: uploaded.MediaKey,
Mimetype: proto.String(mimeType),
FileEncSHA256: uploaded.FileEncSHA256,
FileSHA256: uploaded.FileSHA256,
FileLength: proto.Uint64(uint64(len(documentData))),
FileName: proto.String(filename),
},
}
// Add caption if provided
if caption != "" {
msg.DocumentMessage.Caption = proto.String(caption)
}
// Send the message
resp, err := client.Client.SendMessage(ctx, jid, msg)
if err != nil {
m.eventBus.Publish(events.MessageFailedEvent(ctx, accountID, jid.String(), caption, err))
return fmt.Errorf("failed to send document: %w", err)
}
logging.Debug("Document sent", "account_id", accountID, "to", jid.String(), "filename", filename)
m.eventBus.Publish(events.MessageSentEvent(ctx, accountID, resp.ID, jid.String(), caption))
return nil
}
// GetClient returns a client by ID
func (m *Manager) GetClient(id string) (*Client, bool) {
m.mu.RLock()
defer m.mu.RUnlock()
client, exists := m.clients[id]
return client, exists
}
// handleEvent processes WhatsApp events
func (m *Manager) handleEvent(accountID string, evt interface{}) {
ctx := context.Background()
switch v := evt.(type) {
case *waEvents.Message:
logging.Debug("Message received", "account_id", accountID, "from", v.Info.Sender.String())
// Get the client for downloading media
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
logging.Error("Client not found for message event", "account_id", accountID)
return
}
// Extract message content based on type
var text string
var messageType string = "text"
var mimeType string
var filename string
var mediaBase64 string
var mediaURL string
// Handle text messages
if v.Message.Conversation != nil {
text = *v.Message.Conversation
messageType = "text"
} else if v.Message.ExtendedTextMessage != nil && v.Message.ExtendedTextMessage.Text != nil {
text = *v.Message.ExtendedTextMessage.Text
messageType = "text"
}
// Handle image messages
if v.Message.ImageMessage != nil {
img := v.Message.ImageMessage
messageType = "image"
mimeType = img.GetMimetype()
// Use filename from caption or default
if img.Caption != nil {
text = *img.Caption
}
// Download image
data, err := client.Client.Download(ctx, img)
if err != nil {
logging.Error("Failed to download image", "account_id", accountID, "error", err)
} else {
filename, mediaURL = m.processMediaData(accountID, v.Info.ID, data, mimeType, &mediaBase64)
}
}
// Handle video messages
if v.Message.VideoMessage != nil {
vid := v.Message.VideoMessage
messageType = "video"
mimeType = vid.GetMimetype()
// Use filename from caption or default
if vid.Caption != nil {
text = *vid.Caption
}
// Download video
data, err := client.Client.Download(ctx, vid)
if err != nil {
logging.Error("Failed to download video", "account_id", accountID, "error", err)
} else {
filename, mediaURL = m.processMediaData(accountID, v.Info.ID, data, mimeType, &mediaBase64)
}
}
// Handle document messages
if v.Message.DocumentMessage != nil {
doc := v.Message.DocumentMessage
messageType = "document"
mimeType = doc.GetMimetype()
// Use provided filename or generate one
if doc.FileName != nil {
filename = *doc.FileName
}
// Use caption as text if provided
if doc.Caption != nil {
text = *doc.Caption
}
// Download document
data, err := client.Client.Download(ctx, doc)
if err != nil {
logging.Error("Failed to download document", "account_id", accountID, "error", err)
} else {
filename, mediaURL = m.processMediaData(accountID, v.Info.ID, data, mimeType, &mediaBase64)
}
}
// Publish message received event
m.eventBus.Publish(events.MessageReceivedEvent(
ctx,
accountID,
v.Info.ID,
v.Info.Sender.String(),
v.Info.Chat.String(),
text,
v.Info.Timestamp,
v.Info.IsGroup,
"", // group name - TODO: extract from message
"", // sender name - TODO: extract from message
messageType,
mimeType,
filename,
mediaBase64,
mediaURL,
))
case *waEvents.Connected:
logging.Info("WhatsApp connected", "account_id", accountID)
// Get phone number and client for account
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
phoneNumber := ""
if exists {
// Get the actual phone number from WhatsApp
if client.Client.Store.ID != nil {
actualPhone := client.Client.Store.ID.User
phoneNumber = "+" + actualPhone
// Update phone number in client and config if it's different
if client.PhoneNumber != phoneNumber {
client.PhoneNumber = phoneNumber
logging.Info("Updated phone number from WhatsApp", "account_id", accountID, "phone", phoneNumber)
// Update config
m.updateConfigPhoneNumber(accountID, phoneNumber)
}
} else if client.PhoneNumber != "" {
phoneNumber = client.PhoneNumber
}
}
m.eventBus.Publish(events.WhatsAppConnectedEvent(ctx, accountID, phoneNumber))
case *waEvents.Disconnected:
logging.Warn("WhatsApp disconnected", "account_id", accountID)
m.eventBus.Publish(events.WhatsAppDisconnectedEvent(ctx, accountID, "connection lost"))
case *waEvents.Receipt:
// Handle delivery and read receipts
if v.Type == types.ReceiptTypeDelivered {
for _, messageID := range v.MessageIDs {
logging.Debug("Message delivered", "account_id", accountID, "message_id", messageID, "from", v.Sender.String())
m.eventBus.Publish(events.MessageDeliveredEvent(ctx, accountID, messageID, v.Sender.String(), v.Timestamp))
}
} else if v.Type == types.ReceiptTypeRead {
for _, messageID := range v.MessageIDs {
logging.Debug("Message read", "account_id", accountID, "message_id", messageID, "from", v.Sender.String())
m.eventBus.Publish(events.MessageReadEvent(ctx, accountID, messageID, v.Sender.String(), v.Timestamp))
}
}
}
}
// startKeepAlive starts a goroutine that sends presence updates to keep the connection alive
func (m *Manager) startKeepAlive(client *Client) {
ctx, cancel := context.WithCancel(context.Background())
client.keepAliveCancel = cancel
go func() {
ticker := time.NewTicker(60 * time.Second) // Send presence every 60 seconds
defer ticker.Stop()
for {
select {
case <-ctx.Done():
logging.Debug("Keep-alive stopped", "account_id", client.ID)
return
case <-ticker.C:
// Send presence as "available"
if client.Client.IsConnected() {
err := client.Client.SendPresence(ctx, types.PresenceAvailable)
if err != nil {
logging.Warn("Failed to send presence", "account_id", client.ID, "error", err)
} else {
logging.Debug("Sent presence update", "account_id", client.ID)
}
}
}
}
}()
logging.Info("Keep-alive started", "account_id", client.ID)
}
// updateConfigPhoneNumber updates the phone number for an account in the config and saves it
func (m *Manager) updateConfigPhoneNumber(accountID, phoneNumber string) {
if m.config == nil || m.onConfigUpdate == nil {
return
}
// Find and update the account in the config
for i := range m.config.WhatsApp {
if m.config.WhatsApp[i].ID == accountID {
m.config.WhatsApp[i].PhoneNumber = phoneNumber
// Save the updated config
if err := m.onConfigUpdate(m.config); err != nil {
logging.Error("Failed to save updated config", "account_id", accountID, "error", err)
} else {
logging.Info("Config updated with phone number", "account_id", accountID, "phone", phoneNumber)
}
break
}
}
}
// processMediaData processes media based on the configured mode
// Returns filename and mediaURL, and optionally sets mediaBase64
func (m *Manager) processMediaData(accountID, messageID string, data []byte, mimeType string, mediaBase64 *string) (string, string) {
mode := m.mediaConfig.Mode
var filename string
var mediaURL string
// Generate filename
ext := getExtensionFromMimeType(mimeType)
hash := sha256.Sum256(data)
hashStr := hex.EncodeToString(hash[:8])
filename = fmt.Sprintf("%s_%s%s", messageID, hashStr, ext)
// Handle base64 mode
if mode == "base64" || mode == "both" {
*mediaBase64 = base64.StdEncoding.EncodeToString(data)
}
// Handle link mode
if mode == "link" || mode == "both" {
// Save file to disk
filePath, err := m.saveMediaFile(accountID, messageID, data, mimeType)
if err != nil {
logging.Error("Failed to save media file", "account_id", accountID, "message_id", messageID, "error", err)
} else {
// Extract just the filename from the full path
filename = filepath.Base(filePath)
mediaURL = m.generateMediaURL(accountID, messageID, filename)
}
}
return filename, mediaURL
}
// saveMediaFile saves media data to disk and returns the file path
func (m *Manager) saveMediaFile(accountID, messageID string, data []byte, mimeType string) (string, error) {
// Create account-specific media directory
mediaDir := filepath.Join(m.mediaConfig.DataPath, accountID)
if err := os.MkdirAll(mediaDir, 0755); err != nil {
return "", fmt.Errorf("failed to create media directory: %w", err)
}
// Generate unique filename using message ID and hash
hash := sha256.Sum256(data)
hashStr := hex.EncodeToString(hash[:8]) // Use first 8 bytes of hash
ext := getExtensionFromMimeType(mimeType)
filename := fmt.Sprintf("%s_%s%s", messageID, hashStr, ext)
// Full path to file
filePath := filepath.Join(mediaDir, filename)
// Write file
if err := os.WriteFile(filePath, data, 0644); err != nil {
return "", fmt.Errorf("failed to write media file: %w", err)
}
return filePath, nil
}
// generateMediaURL generates a URL for accessing stored media
func (m *Manager) generateMediaURL(accountID, messageID, filename string) string {
baseURL := m.mediaConfig.BaseURL
if baseURL == "" {
baseURL = "http://localhost:8080" // default
}
return fmt.Sprintf("%s/api/media/%s/%s", baseURL, accountID, filename)
}
// getExtensionFromMimeType returns the file extension for a given MIME type
func getExtensionFromMimeType(mimeType string) string {
extensions := map[string]string{
// Images
"image/jpeg": ".jpg",
"image/jpg": ".jpg",
"image/png": ".png",
"image/gif": ".gif",
"image/webp": ".webp",
"image/bmp": ".bmp",
"image/svg+xml": ".svg",
// Videos
"video/mp4": ".mp4",
"video/mpeg": ".mpeg",
"video/quicktime": ".mov",
"video/x-msvideo": ".avi",
"video/webm": ".webm",
"video/3gpp": ".3gp",
// Documents
"application/pdf": ".pdf",
"application/msword": ".doc",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
"application/vnd.ms-excel": ".xls",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
"application/vnd.ms-powerpoint": ".ppt",
"application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
"text/plain": ".txt",
"text/html": ".html",
"application/zip": ".zip",
"application/x-rar-compressed": ".rar",
"application/x-7z-compressed": ".7z",
"application/json": ".json",
"application/xml": ".xml",
// Audio
"audio/mpeg": ".mp3",
"audio/ogg": ".ogg",
"audio/wav": ".wav",
"audio/aac": ".aac",
"audio/x-m4a": ".m4a",
}
if ext, ok := extensions[mimeType]; ok {
return ext
}
return "" // No extension if mime type is unknown
}

34
internal/whatsapp/interface.go Normal file
View File

@@ -0,0 +1,34 @@
package whatsapp
import (
"context"
"go.mau.fi/whatsmeow/types"
)
// ClientType identifies the type of WhatsApp client
type ClientType string
const (
ClientTypeWhatsmeow ClientType = "whatsmeow"
ClientTypeBusinessAPI ClientType = "business-api"
)
// Client represents any WhatsApp client implementation (whatsmeow or Business API)
type Client interface {
// Connection Management
Connect(ctx context.Context) error
Disconnect() error
IsConnected() bool
// Account Information
GetID() string
GetPhoneNumber() string
GetType() string
// Message Sending
SendTextMessage(ctx context.Context, jid types.JID, text string) (messageID string, err error)
SendImage(ctx context.Context, jid types.JID, imageData []byte, mimeType string, caption string) (messageID string, err error)
SendVideo(ctx context.Context, jid types.JID, videoData []byte, mimeType string, caption string) (messageID string, err error)
SendDocument(ctx context.Context, jid types.JID, documentData []byte, mimeType string, filename string, caption string) (messageID string, err error)
}

171
internal/whatsapp/manager.go Normal file
View File

@@ -0,0 +1,171 @@
package whatsapp
import (
"context"
"fmt"
"sync"
"git.warky.dev/wdevs/whatshooked/internal/config"
"git.warky.dev/wdevs/whatshooked/internal/events"
"git.warky.dev/wdevs/whatshooked/internal/logging"
"git.warky.dev/wdevs/whatshooked/internal/whatsapp/businessapi"
"git.warky.dev/wdevs/whatshooked/internal/whatsapp/whatsmeow"
"go.mau.fi/whatsmeow/types"
)
// Manager manages multiple WhatsApp client connections
type Manager struct {
clients map[string]Client
mu sync.RWMutex
eventBus *events.EventBus
mediaConfig config.MediaConfig
config *config.Config
configPath string
onConfigUpdate func(*config.Config) error
}
// NewManager creates a new WhatsApp manager
func NewManager(eventBus *events.EventBus, mediaConfig config.MediaConfig, cfg *config.Config, configPath string, onConfigUpdate func(*config.Config) error) *Manager {
return &Manager{
clients: make(map[string]Client),
eventBus: eventBus,
mediaConfig: mediaConfig,
config: cfg,
configPath: configPath,
onConfigUpdate: onConfigUpdate,
}
}
// Connect establishes a connection to a WhatsApp account using the appropriate client type
func (m *Manager) Connect(ctx context.Context, cfg config.WhatsAppConfig) error {
m.mu.Lock()
defer m.mu.Unlock()
if _, exists := m.clients[cfg.ID]; exists {
return fmt.Errorf("client %s already connected", cfg.ID)
}
var client Client
var err error
// Factory pattern based on type
switch cfg.Type {
case "business-api":
client, err = businessapi.NewClient(cfg, m.eventBus, m.mediaConfig)
case "whatsmeow", "":
client, err = whatsmeow.NewClient(cfg, m.eventBus, m.mediaConfig)
default:
return fmt.Errorf("unknown client type: %s", cfg.Type)
}
if err != nil {
return fmt.Errorf("failed to create client: %w", err)
}
if err := client.Connect(ctx); err != nil {
return fmt.Errorf("failed to connect: %w", err)
}
m.clients[cfg.ID] = client
logging.Info("Client connected", "account_id", cfg.ID, "type", client.GetType())
return nil
}
// Disconnect disconnects a WhatsApp client
func (m *Manager) Disconnect(id string) error {
m.mu.Lock()
defer m.mu.Unlock()
client, exists := m.clients[id]
if !exists {
return fmt.Errorf("client %s not found", id)
}
if err := client.Disconnect(); err != nil {
return fmt.Errorf("failed to disconnect: %w", err)
}
delete(m.clients, id)
logging.Info("Client disconnected", "account_id", id)
return nil
}
// DisconnectAll disconnects all WhatsApp clients
func (m *Manager) DisconnectAll() {
m.mu.Lock()
defer m.mu.Unlock()
for id, client := range m.clients {
if err := client.Disconnect(); err != nil {
logging.Error("Failed to disconnect client", "account_id", id, "error", err)
} else {
logging.Info("Client disconnected", "account_id", id)
}
}
m.clients = make(map[string]Client)
}
// SendTextMessage sends a text message from a specific account
func (m *Manager) SendTextMessage(ctx context.Context, accountID string, jid types.JID, text string) error {
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
return fmt.Errorf("client %s not found", accountID)
}
_, err := client.SendTextMessage(ctx, jid, text)
return err
}
// SendImage sends an image message from a specific account
func (m *Manager) SendImage(ctx context.Context, accountID string, jid types.JID, imageData []byte, mimeType string, caption string) error {
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
return fmt.Errorf("client %s not found", accountID)
}
_, err := client.SendImage(ctx, jid, imageData, mimeType, caption)
return err
}
// SendVideo sends a video message from a specific account
func (m *Manager) SendVideo(ctx context.Context, accountID string, jid types.JID, videoData []byte, mimeType string, caption string) error {
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
return fmt.Errorf("client %s not found", accountID)
}
_, err := client.SendVideo(ctx, jid, videoData, mimeType, caption)
return err
}
// SendDocument sends a document message from a specific account
func (m *Manager) SendDocument(ctx context.Context, accountID string, jid types.JID, documentData []byte, mimeType string, filename string, caption string) error {
m.mu.RLock()
client, exists := m.clients[accountID]
m.mu.RUnlock()
if !exists {
return fmt.Errorf("client %s not found", accountID)
}
_, err := client.SendDocument(ctx, jid, documentData, mimeType, filename, caption)
return err
}
// GetClient returns a client by ID
func (m *Manager) GetClient(id string) (Client, bool) {
m.mu.RLock()
defer m.mu.RUnlock()
client, exists := m.clients[id]
return client, exists
}

678
internal/whatsapp/whatsmeow/client.go Normal file
View File

@@ -0,0 +1,678 @@
package whatsmeow
import (
"context"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"fmt"
"os"
"path/filepath"
"time"
"git.warky.dev/wdevs/whatshooked/internal/config"
"git.warky.dev/wdevs/whatshooked/internal/events"
"git.warky.dev/wdevs/whatshooked/internal/logging"
qrterminal "github.com/mdp/qrterminal/v3"
"go.mau.fi/whatsmeow"
"go.mau.fi/whatsmeow/proto/waE2E"
"go.mau.fi/whatsmeow/store/sqlstore"
"go.mau.fi/whatsmeow/types"
waEvents "go.mau.fi/whatsmeow/types/events"
waLog "go.mau.fi/whatsmeow/util/log"
"google.golang.org/protobuf/proto"
_ "github.com/mattn/go-sqlite3"
)
// Client represents a WhatsApp connection using whatsmeow
type Client struct {
id string
phoneNumber string
sessionPath string
client *whatsmeow.Client
container *sqlstore.Container
eventBus *events.EventBus
mediaConfig config.MediaConfig
showQR bool
keepAliveCancel context.CancelFunc
}
// NewClient creates a new whatsmeow client
func NewClient(cfg config.WhatsAppConfig, eventBus *events.EventBus, mediaConfig config.MediaConfig) (*Client, error) {
if cfg.Type != "whatsmeow" && cfg.Type != "" {
return nil, fmt.Errorf("invalid client type for whatsmeow: %s", cfg.Type)
}
sessionPath := cfg.SessionPath
if sessionPath == "" {
sessionPath = fmt.Sprintf("./sessions/%s", cfg.ID)
}
return &Client{
id: cfg.ID,
phoneNumber: cfg.PhoneNumber,
sessionPath: sessionPath,
eventBus: eventBus,
mediaConfig: mediaConfig,
showQR: cfg.ShowQR,
}, nil
}
// Connect establishes a connection to WhatsApp
func (c *Client) Connect(ctx context.Context) error {
// Ensure session directory exists
if err := os.MkdirAll(c.sessionPath, 0700); err != nil {
return fmt.Errorf("failed to create session directory: %w", err)
}
// Create database container for session storage
dbPath := filepath.Join(c.sessionPath, "session.db")
dbLog := waLog.Stdout("Database", "ERROR", true)
container, err := sqlstore.New(ctx, "sqlite3", "file:"+dbPath+"?_foreign_keys=on", dbLog)
if err != nil {
return fmt.Errorf("failed to create database container: %w", err)
}
c.container = container
// Get device store
deviceStore, err := container.GetFirstDevice(ctx)
if err != nil {
return fmt.Errorf("failed to get device: %w", err)
}
// Set custom client information
deviceStore.Platform = "WhatsHooked"
deviceStore.BusinessName = "git.warky.dev/wdevs/whatshooked"
// Create client
clientLog := waLog.Stdout("Client", "ERROR", true)
client := whatsmeow.NewClient(deviceStore, clientLog)
c.client = client
// Register event handler
client.AddEventHandler(func(evt interface{}) {
c.handleEvent(evt)
})
// Connect
if client.Store.ID == nil {
// New device, need to pair
qrChan, _ := client.GetQRChannel(ctx)
if err := client.Connect(); err != nil {
c.eventBus.Publish(events.WhatsAppPairFailedEvent(ctx, c.id, err))
return fmt.Errorf("failed to connect: %w", err)
}
// Wait for QR code
for evt := range qrChan {
switch evt.Event {
case "code":
logging.Info("QR code received for pairing", "account_id", c.id)
// Display QR code in terminal
fmt.Println("\n========================================")
fmt.Printf("WhatsApp QR Code for account: %s\n", c.id)
fmt.Printf("Phone: %s\n", c.phoneNumber)
fmt.Println("========================================")
fmt.Println("Scan this QR code with WhatsApp on your phone:")
qrterminal.GenerateHalfBlock(evt.Code, qrterminal.L, os.Stdout)
fmt.Println("========================================")
// Publish QR code event
c.eventBus.Publish(events.WhatsAppQRCodeEvent(ctx, c.id, evt.Code))
case "success":
logging.Info("Pairing successful", "account_id", c.id, "phone", c.phoneNumber)
c.eventBus.Publish(events.WhatsAppPairSuccessEvent(ctx, c.id))
case "timeout":
logging.Warn("QR code timeout", "account_id", c.id)
c.eventBus.Publish(events.WhatsAppQRTimeoutEvent(ctx, c.id))
case "error":
logging.Error("QR code error", "account_id", c.id, "error", evt.Error)
c.eventBus.Publish(events.WhatsAppQRErrorEvent(ctx, c.id, fmt.Errorf("%v", evt.Error)))
default:
logging.Info("Pairing event", "account_id", c.id, "event", evt.Event)
c.eventBus.Publish(events.WhatsAppPairEventGeneric(ctx, c.id, evt.Event, map[string]any{
"code": evt.Code,
}))
}
}
} else {
// Already paired, just connect
if err := client.Connect(); err != nil {
return fmt.Errorf("failed to connect: %w", err)
}
}
if deviceStore.PushName == "" {
deviceStore.PushName = fmt.Sprintf("WhatsHooked %s", c.phoneNumber)
if err := deviceStore.Save(ctx); err != nil {
logging.Error("failed to save device store", "account_id", c.id)
}
}
if client.IsConnected() {
err := client.SendPresence(ctx, types.PresenceAvailable)
if err != nil {
logging.Warn("Failed to send presence", "account_id", c.id, "error", err)
} else {
logging.Debug("Sent presence update", "account_id", c.id)
}
}
// Start keep-alive routine
c.startKeepAlive()
logging.Info("WhatsApp client connected", "account_id", c.id, "phone", c.phoneNumber)
return nil
}
// Disconnect closes the WhatsApp connection
func (c *Client) Disconnect() error {
// Stop keep-alive
if c.keepAliveCancel != nil {
c.keepAliveCancel()
}
if c.client != nil {
c.client.Disconnect()
}
logging.Info("WhatsApp client disconnected", "account_id", c.id)
return nil
}
// IsConnected returns whether the client is connected
func (c *Client) IsConnected() bool {
if c.client == nil {
return false
}
return c.client.IsConnected()
}
// GetID returns the client ID
func (c *Client) GetID() string {
return c.id
}
// GetPhoneNumber returns the phone number
func (c *Client) GetPhoneNumber() string {
return c.phoneNumber
}
// GetType returns the client type
func (c *Client) GetType() string {
return "whatsmeow"
}
// SendTextMessage sends a text message
func (c *Client) SendTextMessage(ctx context.Context, jid types.JID, text string) (string, error) {
if ctx == nil {
ctx = context.Background()
}
if c.client == nil {
err := fmt.Errorf("client not initialized")
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), text, err))
return "", err
}
msg := &waE2E.Message{
Conversation: proto.String(text),
}
resp, err := c.client.SendMessage(ctx, jid, msg)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), text, err))
return "", fmt.Errorf("failed to send message: %w", err)
}
logging.Debug("Message sent", "account_id", c.id, "to", jid.String())
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, resp.ID, jid.String(), text))
return resp.ID, nil
}
// SendImage sends an image message
func (c *Client) SendImage(ctx context.Context, jid types.JID, imageData []byte, mimeType string, caption string) (string, error) {
if ctx == nil {
ctx = context.Background()
}
if c.client == nil {
err := fmt.Errorf("client not initialized")
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", err
}
// Upload the image
uploaded, err := c.client.Upload(ctx, imageData, whatsmeow.MediaImage)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", fmt.Errorf("failed to upload image: %w", err)
}
// Create image message
msg := &waE2E.Message{
ImageMessage: &waE2E.ImageMessage{
URL: proto.String(uploaded.URL),
DirectPath: proto.String(uploaded.DirectPath),
MediaKey: uploaded.MediaKey,
Mimetype: proto.String(mimeType),
FileEncSHA256: uploaded.FileEncSHA256,
FileSHA256: uploaded.FileSHA256,
FileLength: proto.Uint64(uint64(len(imageData))),
},
}
// Add caption if provided
if caption != "" {
msg.ImageMessage.Caption = proto.String(caption)
}
// Send the message
resp, err := c.client.SendMessage(ctx, jid, msg)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", fmt.Errorf("failed to send image: %w", err)
}
logging.Debug("Image sent", "account_id", c.id, "to", jid.String())
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, resp.ID, jid.String(), caption))
return resp.ID, nil
}
// SendVideo sends a video message
func (c *Client) SendVideo(ctx context.Context, jid types.JID, videoData []byte, mimeType string, caption string) (string, error) {
if ctx == nil {
ctx = context.Background()
}
if c.client == nil {
err := fmt.Errorf("client not initialized")
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", err
}
// Upload the video
uploaded, err := c.client.Upload(ctx, videoData, whatsmeow.MediaVideo)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", fmt.Errorf("failed to upload video: %w", err)
}
// Create video message
msg := &waE2E.Message{
VideoMessage: &waE2E.VideoMessage{
URL: proto.String(uploaded.URL),
DirectPath: proto.String(uploaded.DirectPath),
MediaKey: uploaded.MediaKey,
Mimetype: proto.String(mimeType),
FileEncSHA256: uploaded.FileEncSHA256,
FileSHA256: uploaded.FileSHA256,
FileLength: proto.Uint64(uint64(len(videoData))),
},
}
// Add caption if provided
if caption != "" {
msg.VideoMessage.Caption = proto.String(caption)
}
// Send the message
resp, err := c.client.SendMessage(ctx, jid, msg)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", fmt.Errorf("failed to send video: %w", err)
}
logging.Debug("Video sent", "account_id", c.id, "to", jid.String())
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, resp.ID, jid.String(), caption))
return resp.ID, nil
}
// SendDocument sends a document message
func (c *Client) SendDocument(ctx context.Context, jid types.JID, documentData []byte, mimeType string, filename string, caption string) (string, error) {
if ctx == nil {
ctx = context.Background()
}
if c.client == nil {
err := fmt.Errorf("client not initialized")
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", err
}
// Upload the document
uploaded, err := c.client.Upload(ctx, documentData, whatsmeow.MediaDocument)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", fmt.Errorf("failed to upload document: %w", err)
}
// Create document message
msg := &waE2E.Message{
DocumentMessage: &waE2E.DocumentMessage{
URL: proto.String(uploaded.URL),
DirectPath: proto.String(uploaded.DirectPath),
MediaKey: uploaded.MediaKey,
Mimetype: proto.String(mimeType),
FileEncSHA256: uploaded.FileEncSHA256,
FileSHA256: uploaded.FileSHA256,
FileLength: proto.Uint64(uint64(len(documentData))),
FileName: proto.String(filename),
},
}
// Add caption if provided
if caption != "" {
msg.DocumentMessage.Caption = proto.String(caption)
}
// Send the message
resp, err := c.client.SendMessage(ctx, jid, msg)
if err != nil {
c.eventBus.Publish(events.MessageFailedEvent(ctx, c.id, jid.String(), caption, err))
return "", fmt.Errorf("failed to send document: %w", err)
}
logging.Debug("Document sent", "account_id", c.id, "to", jid.String(), "filename", filename)
c.eventBus.Publish(events.MessageSentEvent(ctx, c.id, resp.ID, jid.String(), caption))
return resp.ID, nil
}
// handleEvent processes WhatsApp events
func (c *Client) handleEvent(evt interface{}) {
ctx := context.Background()
switch v := evt.(type) {
case *waEvents.Message:
logging.Debug("Message received", "account_id", c.id, "from", v.Info.Sender.String())
// Extract message content based on type
var text string
var messageType string = "text"
var mimeType string
var filename string
var mediaBase64 string
var mediaURL string
// Handle text messages
if v.Message.Conversation != nil {
text = *v.Message.Conversation
messageType = "text"
} else if v.Message.ExtendedTextMessage != nil && v.Message.ExtendedTextMessage.Text != nil {
text = *v.Message.ExtendedTextMessage.Text
messageType = "text"
}
// Handle image messages
if v.Message.ImageMessage != nil {
img := v.Message.ImageMessage
messageType = "image"
mimeType = img.GetMimetype()
if img.Caption != nil {
text = *img.Caption
}
// Download image
data, err := c.client.Download(ctx, img)
if err != nil {
logging.Error("Failed to download image", "account_id", c.id, "error", err)
} else {
filename, mediaURL = c.processMediaData(v.Info.ID, data, mimeType, &mediaBase64)
}
}
// Handle video messages
if v.Message.VideoMessage != nil {
vid := v.Message.VideoMessage
messageType = "video"
mimeType = vid.GetMimetype()
if vid.Caption != nil {
text = *vid.Caption
}
// Download video
data, err := c.client.Download(ctx, vid)
if err != nil {
logging.Error("Failed to download video", "account_id", c.id, "error", err)
} else {
filename, mediaURL = c.processMediaData(v.Info.ID, data, mimeType, &mediaBase64)
}
}
// Handle document messages
if v.Message.DocumentMessage != nil {
doc := v.Message.DocumentMessage
messageType = "document"
mimeType = doc.GetMimetype()
if doc.FileName != nil {
filename = *doc.FileName
}
if doc.Caption != nil {
text = *doc.Caption
}
// Download document
data, err := c.client.Download(ctx, doc)
if err != nil {
logging.Error("Failed to download document", "account_id", c.id, "error", err)
} else {
filename, mediaURL = c.processMediaData(v.Info.ID, data, mimeType, &mediaBase64)
}
}
// Publish message received event
c.eventBus.Publish(events.MessageReceivedEvent(
ctx,
c.id,
v.Info.ID,
v.Info.Sender.String(),
v.Info.Chat.String(),
text,
v.Info.Timestamp,
v.Info.IsGroup,
"", // group name - TODO: extract from message
"", // sender name - TODO: extract from message
messageType,
mimeType,
filename,
mediaBase64,
mediaURL,
))
case *waEvents.Connected:
logging.Info("WhatsApp connected", "account_id", c.id)
// Get the actual phone number from WhatsApp
phoneNumber := ""
if c.client.Store.ID != nil {
actualPhone := c.client.Store.ID.User
phoneNumber = "+" + actualPhone
// Update phone number in client if it's different
if c.phoneNumber != phoneNumber {
c.phoneNumber = phoneNumber
logging.Info("Updated phone number from WhatsApp", "account_id", c.id, "phone", phoneNumber)
}
} else if c.phoneNumber != "" {
phoneNumber = c.phoneNumber
}
c.eventBus.Publish(events.WhatsAppConnectedEvent(ctx, c.id, phoneNumber))
case *waEvents.Disconnected:
logging.Warn("WhatsApp disconnected", "account_id", c.id)
c.eventBus.Publish(events.WhatsAppDisconnectedEvent(ctx, c.id, "connection lost"))
case *waEvents.Receipt:
// Handle delivery and read receipts
if v.Type == types.ReceiptTypeDelivered {
for _, messageID := range v.MessageIDs {
logging.Debug("Message delivered", "account_id", c.id, "message_id", messageID, "from", v.Sender.String())
c.eventBus.Publish(events.MessageDeliveredEvent(ctx, c.id, messageID, v.Sender.String(), v.Timestamp))
}
} else if v.Type == types.ReceiptTypeRead {
for _, messageID := range v.MessageIDs {
logging.Debug("Message read", "account_id", c.id, "message_id", messageID, "from", v.Sender.String())
c.eventBus.Publish(events.MessageReadEvent(ctx, c.id, messageID, v.Sender.String(), v.Timestamp))
}
}
}
}
// startKeepAlive starts a goroutine that sends presence updates to keep the connection alive
func (c *Client) startKeepAlive() {
ctx, cancel := context.WithCancel(context.Background())
c.keepAliveCancel = cancel
go func() {
ticker := time.NewTicker(60 * time.Second)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
logging.Debug("Keep-alive stopped", "account_id", c.id)
return
case <-ticker.C:
if c.client != nil && c.client.IsConnected() {
err := c.client.SendPresence(ctx, types.PresenceAvailable)
if err != nil {
logging.Warn("Failed to send presence", "account_id", c.id, "error", err)
} else {
logging.Debug("Sent presence update", "account_id", c.id)
}
}
}
}
}()
logging.Info("Keep-alive started", "account_id", c.id)
}
// processMediaData processes media based on the configured mode
func (c *Client) processMediaData(messageID string, data []byte, mimeType string, mediaBase64 *string) (string, string) {
mode := c.mediaConfig.Mode
var filename string
var mediaURL string
// Generate filename
ext := getExtensionFromMimeType(mimeType)
hash := sha256.Sum256(data)
hashStr := hex.EncodeToString(hash[:8])
filename = fmt.Sprintf("%s_%s%s", messageID, hashStr, ext)
// Handle base64 mode
if mode == "base64" || mode == "both" {
*mediaBase64 = base64.StdEncoding.EncodeToString(data)
}
// Handle link mode
if mode == "link" || mode == "both" {
// Save file to disk
filePath, err := c.saveMediaFile(messageID, data, mimeType)
if err != nil {
logging.Error("Failed to save media file", "account_id", c.id, "message_id", messageID, "error", err)
} else {
// Extract just the filename from the full path
filename = filepath.Base(filePath)
mediaURL = c.generateMediaURL(messageID, filename)
}
}
return filename, mediaURL
}
// saveMediaFile saves media data to disk and returns the file path
func (c *Client) saveMediaFile(messageID string, data []byte, mimeType string) (string, error) {
// Create account-specific media directory
mediaDir := filepath.Join(c.mediaConfig.DataPath, c.id)
if err := os.MkdirAll(mediaDir, 0755); err != nil {
return "", fmt.Errorf("failed to create media directory: %w", err)
}
// Generate unique filename using message ID and hash
hash := sha256.Sum256(data)
hashStr := hex.EncodeToString(hash[:8])
ext := getExtensionFromMimeType(mimeType)
filename := fmt.Sprintf("%s_%s%s", messageID, hashStr, ext)
// Full path to file
filePath := filepath.Join(mediaDir, filename)
// Write file
if err := os.WriteFile(filePath, data, 0644); err != nil {
return "", fmt.Errorf("failed to write media file: %w", err)
}
return filePath, nil
}
// generateMediaURL generates a URL for accessing stored media
func (c *Client) generateMediaURL(messageID, filename string) string {
baseURL := c.mediaConfig.BaseURL
if baseURL == "" {
baseURL = "http://localhost:8080"
}
return fmt.Sprintf("%s/api/media/%s/%s", baseURL, c.id, filename)
}
// getExtensionFromMimeType returns the file extension for a given MIME type
func getExtensionFromMimeType(mimeType string) string {
extensions := map[string]string{
// Images
"image/jpeg": ".jpg",
"image/jpg": ".jpg",
"image/png": ".png",
"image/gif": ".gif",
"image/webp": ".webp",
"image/bmp": ".bmp",
"image/svg+xml": ".svg",
// Videos
"video/mp4": ".mp4",
"video/mpeg": ".mpeg",
"video/quicktime": ".mov",
"video/x-msvideo": ".avi",
"video/webm": ".webm",
"video/3gpp": ".3gp",
// Documents
"application/pdf": ".pdf",
"application/msword": ".doc",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
"application/vnd.ms-excel": ".xls",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
"application/vnd.ms-powerpoint": ".ppt",
"application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
"text/plain": ".txt",
"text/html": ".html",
"application/zip": ".zip",
"application/x-rar-compressed": ".rar",
"application/x-7z-compressed": ".7z",
"application/json": ".json",
"application/xml": ".xml",
// Audio
"audio/mpeg": ".mp3",
"audio/ogg": ".ogg",
"audio/wav": ".wav",
"audio/aac": ".aac",
"audio/x-m4a": ".m4a",
}
if ext, ok := extensions[mimeType]; ok {
return ext
}
return ""
}