initial commit
This commit is contained in:
767
internal/whatsapp/client.go
Normal file
767
internal/whatsapp/client.go
Normal file
@@ -0,0 +1,767 @@
|
||||
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
|
||||
}
|
||||
Reference in New Issue
Block a user