iamatulsingh
2893 lines
73 KiB
Go
2893 lines
73 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"log/slog"
|
|
"math"
|
|
"math/rand"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"path/filepath"
|
|
"reflect"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
"whatsapp-bridge/auth"
|
|
"whatsapp-bridge/config"
|
|
bridgelogger "whatsapp-bridge/logger"
|
|
"whatsapp-bridge/wastate"
|
|
|
|
"go.mau.fi/whatsmeow/proto/waCompanionReg"
|
|
"go.mau.fi/whatsmeow/socket"
|
|
|
|
_ "github.com/lib/pq"
|
|
_ "github.com/mattn/go-sqlite3"
|
|
"github.com/mdp/qrterminal"
|
|
qrcode "github.com/skip2/go-qrcode"
|
|
|
|
"bytes"
|
|
|
|
"go.mau.fi/whatsmeow"
|
|
"go.mau.fi/whatsmeow/proto/waE2E"
|
|
"go.mau.fi/whatsmeow/store"
|
|
"go.mau.fi/whatsmeow/store/sqlstore"
|
|
"go.mau.fi/whatsmeow/types"
|
|
"go.mau.fi/whatsmeow/types/events"
|
|
waLog "go.mau.fi/whatsmeow/util/log"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
type MessageInteraction struct {
|
|
Timestamp time.Time `json:"timestamp"`
|
|
Sender string `json:"sender"`
|
|
Content string `json:"content"`
|
|
IsFromMe bool `json:"is_from_me"`
|
|
ChatJID string `json:"chat_jid"`
|
|
ID string `json:"id"`
|
|
ChatName string `json:"chat_name,omitempty"`
|
|
MediaType string `json:"media_type,omitempty"`
|
|
}
|
|
|
|
type Chat struct {
|
|
JID string `json:"jid"`
|
|
Name string `json:"name,omitempty"`
|
|
LastMessageTime time.Time `json:"last_message_time,omitempty"`
|
|
LastMessage string `json:"last_message,omitempty"`
|
|
LastSender string `json:"last_sender,omitempty"`
|
|
LastIsFromMe bool `json:"last_is_from_me,omitempty"`
|
|
}
|
|
|
|
func (c *Chat) IsGroup() bool {
|
|
return strings.HasSuffix(c.JID, "@g.us")
|
|
}
|
|
|
|
type Contact struct {
|
|
PhoneNumber string `json:"phone_number"`
|
|
Name string `json:"name,omitempty"`
|
|
JID string `json:"jid"`
|
|
}
|
|
|
|
type MessageContext struct {
|
|
Message MessageInteraction `json:"message"`
|
|
Before []MessageInteraction `json:"before"`
|
|
After []MessageInteraction `json:"after"`
|
|
}
|
|
|
|
type ListMessagesParams struct {
|
|
After, Before string
|
|
SenderPhoneNumber *string
|
|
ChatJid *string
|
|
Query *string
|
|
Limit, Page int
|
|
IncludeContext bool
|
|
ContextBefore int
|
|
ContextAfter int
|
|
}
|
|
|
|
type Message struct {
|
|
Time time.Time
|
|
Sender string
|
|
Content string
|
|
IsFromMe bool
|
|
MediaType string
|
|
Filename string
|
|
}
|
|
|
|
type MessageStore struct {
|
|
db *sql.DB
|
|
}
|
|
|
|
var isPostgres = false
|
|
|
|
func openDatabase(dbName string) (*sql.DB, error) {
|
|
if val, ok := os.LookupEnv("IS_POSTGRES"); ok && strings.ToLower(val) == "true" {
|
|
cfg, err := config.LoadConfig()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("missing environment variable")
|
|
}
|
|
isPostgres = cfg.DB.IsPostgres
|
|
|
|
connStr := fmt.Sprintf("postgresql://%s:%s@%s:%s/%s?sslmode=disable",
|
|
cfg.DB.User, cfg.DB.Pass, cfg.DB.Host, cfg.DB.Port, dbName)
|
|
log.Println("Connecting to postgres")
|
|
return sql.Open("postgres", connStr)
|
|
}
|
|
|
|
// Fallback to SQLite
|
|
log.Println("Connecting to sqlite3")
|
|
return sql.Open("sqlite3", "file:store/messages.db?_foreign_keys=on")
|
|
}
|
|
|
|
// validateMediaPath sanitize media path
|
|
func validateMediaPath(mediaPath string) (string, error) {
|
|
if mediaPath == "" {
|
|
return "", fmt.Errorf("empty media path")
|
|
}
|
|
|
|
// Allowed media directory
|
|
baseDir := "./media"
|
|
|
|
absBaseDir, err := filepath.Abs(baseDir)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Reject absolute paths
|
|
if filepath.IsAbs(mediaPath) {
|
|
return "", fmt.Errorf("absolute paths are not allowed")
|
|
}
|
|
|
|
// Clean traversal sequences
|
|
cleanPath := filepath.Clean(mediaPath)
|
|
|
|
fullPath := filepath.Join(absBaseDir, cleanPath)
|
|
|
|
absPath, err := filepath.Abs(fullPath)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Ensure resolved path stays inside media directory
|
|
if !strings.HasPrefix(absPath, absBaseDir+string(os.PathSeparator)) &&
|
|
absPath != absBaseDir {
|
|
return "", fmt.Errorf("path traversal detected")
|
|
}
|
|
|
|
return absPath, nil
|
|
}
|
|
|
|
// NewMessageStore Initialize message store
|
|
func NewMessageStore() (*MessageStore, error) {
|
|
if err := os.MkdirAll("store", 0755); err != nil {
|
|
return nil, fmt.Errorf("failed to create store directory: %v", err)
|
|
}
|
|
|
|
db, err := openDatabase("whatsapp")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to open message database: %v", err)
|
|
}
|
|
|
|
val, ok := os.LookupEnv("IS_POSTGRES")
|
|
|
|
var blobType string
|
|
if ok && strings.ToLower(val) == "true" {
|
|
blobType = "BYTEA"
|
|
} else {
|
|
blobType = "BLOB"
|
|
}
|
|
|
|
_, err = db.Exec(fmt.Sprintf(`
|
|
CREATE TABLE IF NOT EXISTS chats (
|
|
jid TEXT PRIMARY KEY,
|
|
name TEXT,
|
|
last_message_time TIMESTAMP
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS messages (
|
|
id TEXT,
|
|
chat_jid TEXT,
|
|
sender TEXT,
|
|
content TEXT,
|
|
timestamp TIMESTAMP,
|
|
is_from_me BOOLEAN,
|
|
media_type TEXT,
|
|
filename TEXT,
|
|
url TEXT,
|
|
media_key %s,
|
|
file_sha256 %s,
|
|
file_enc_sha256 %s,
|
|
file_length INTEGER,
|
|
PRIMARY KEY (id, chat_jid),
|
|
FOREIGN KEY (chat_jid) REFERENCES chats(jid)
|
|
);
|
|
`, blobType, blobType, blobType))
|
|
if err != nil {
|
|
db.Close()
|
|
return nil, fmt.Errorf("failed to create tables: %v", err)
|
|
}
|
|
|
|
return &MessageStore{db: db}, nil
|
|
}
|
|
|
|
// Close the database connection
|
|
func (store *MessageStore) Close() error {
|
|
return store.db.Close()
|
|
}
|
|
|
|
// normalizeUserJID converts a LID JID (xxxx@lid) into a phone-number JID (xxxx@s.whatsapp.net)
|
|
// using the whatsmeow LID mapping store. Non-LID JIDs are returned unchanged.
|
|
func normalizeUserJID(client *whatsmeow.Client, jid types.JID) types.JID {
|
|
if client == nil || client.Store == nil || client.Store.LIDs == nil {
|
|
return jid
|
|
}
|
|
|
|
// Only normalize hidden-user server (@lid)
|
|
if jid.Server != types.HiddenUserServer {
|
|
return jid
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
|
|
pn, err := client.Store.LIDs.GetPNForLID(ctx, jid)
|
|
if err != nil || pn.IsEmpty() {
|
|
return jid
|
|
}
|
|
|
|
return pn
|
|
}
|
|
|
|
// migrateLIDChatsToPhoneJIDs merges chats stored under @lid
|
|
// into their corresponding @s.whatsapp.net chats.
|
|
//
|
|
// This is idempotent and safe to run on every startup.
|
|
//
|
|
// Migration order:
|
|
//
|
|
// 1. Create/upsert PN chat
|
|
// 2. Move messages to PN chat
|
|
// 3. Delete leftover duplicate messages
|
|
// 4. Delete old LID chat
|
|
func migrateLIDChatsToPhoneJIDs(
|
|
client *whatsmeow.Client,
|
|
store *MessageStore,
|
|
logger waLog.Logger,
|
|
isPostgresDB bool,
|
|
) {
|
|
if client == nil || store == nil || store.db == nil {
|
|
return
|
|
}
|
|
|
|
db := store.db
|
|
|
|
var query string
|
|
arg := "%@" + types.HiddenUserServer
|
|
|
|
if isPostgresDB {
|
|
query = `
|
|
SELECT jid, name, last_message_time
|
|
FROM chats
|
|
WHERE jid LIKE $1
|
|
`
|
|
} else {
|
|
query = `
|
|
SELECT jid, name, last_message_time
|
|
FROM chats
|
|
WHERE jid LIKE ?
|
|
`
|
|
}
|
|
|
|
rows, err := db.Query(query, arg)
|
|
if err != nil {
|
|
logger.Errorf("LID migration: failed listing chats: %v", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
type lidChat struct {
|
|
JID string
|
|
Name string
|
|
LastMessageTime time.Time
|
|
}
|
|
|
|
var chats []lidChat
|
|
|
|
for rows.Next() {
|
|
var c lidChat
|
|
|
|
if err := rows.Scan(&c.JID, &c.Name, &c.LastMessageTime); err != nil {
|
|
logger.Warnf("LID migration: scan failed: %v", err)
|
|
continue
|
|
}
|
|
|
|
chats = append(chats, c)
|
|
}
|
|
|
|
if len(chats) == 0 {
|
|
return
|
|
}
|
|
|
|
logger.Infof("LID migration: found %d @lid chats", len(chats))
|
|
|
|
merged := 0
|
|
skipped := 0
|
|
|
|
for _, c := range chats {
|
|
|
|
tx, err := db.Begin()
|
|
if err != nil {
|
|
logger.Warnf("LID migration: tx begin failed for %s: %v", c.JID, err)
|
|
skipped++
|
|
continue
|
|
}
|
|
|
|
commit := false
|
|
defer func() {
|
|
if !commit {
|
|
_ = tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
lidJID, parseErr := types.ParseJID(c.JID)
|
|
if parseErr != nil {
|
|
logger.Warnf("LID migration: invalid jid %s: %v", c.JID, parseErr)
|
|
_ = tx.Rollback()
|
|
skipped++
|
|
continue
|
|
}
|
|
|
|
pnJID := normalizeUserJID(client, lidJID)
|
|
|
|
if pnJID.Server != types.DefaultUserServer {
|
|
_ = tx.Rollback()
|
|
skipped++
|
|
continue
|
|
}
|
|
|
|
pnStr := pnJID.String()
|
|
|
|
var upsertQuery string
|
|
|
|
if isPostgresDB {
|
|
upsertQuery = `
|
|
INSERT INTO chats (jid, name, last_message_time)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (jid)
|
|
DO UPDATE SET
|
|
name = COALESCE(NULLIF(chats.name, ''), EXCLUDED.name),
|
|
last_message_time = GREATEST(
|
|
chats.last_message_time,
|
|
EXCLUDED.last_message_time
|
|
)
|
|
`
|
|
} else {
|
|
upsertQuery = `
|
|
INSERT INTO chats (jid, name, last_message_time)
|
|
VALUES (?, ?, ?)
|
|
ON CONFLICT(jid)
|
|
DO UPDATE SET
|
|
name = COALESCE(NULLIF(chats.name, ''), excluded.name),
|
|
last_message_time = MAX(
|
|
chats.last_message_time,
|
|
excluded.last_message_time
|
|
)
|
|
`
|
|
}
|
|
|
|
if _, err = tx.Exec(upsertQuery, pnStr, c.Name, c.LastMessageTime); err != nil {
|
|
logger.Warnf("LID migration: upsert failed %s -> %s: %v", c.JID, pnStr, err)
|
|
_ = tx.Rollback()
|
|
skipped++
|
|
continue
|
|
}
|
|
|
|
var moveMessagesQuery string
|
|
|
|
if isPostgresDB {
|
|
moveMessagesQuery = `
|
|
UPDATE messages
|
|
SET chat_jid = $1
|
|
WHERE chat_jid = $2
|
|
`
|
|
} else {
|
|
moveMessagesQuery = `
|
|
UPDATE messages
|
|
SET chat_jid = ?
|
|
WHERE chat_jid = ?
|
|
`
|
|
}
|
|
|
|
if _, err = tx.Exec(moveMessagesQuery, pnStr, c.JID); err != nil {
|
|
logger.Warnf("LID migration: move messages failed %s -> %s: %v", c.JID, pnStr, err)
|
|
_ = tx.Rollback()
|
|
skipped++
|
|
continue
|
|
}
|
|
|
|
var deleteChatQuery string
|
|
|
|
if isPostgresDB {
|
|
deleteChatQuery = `DELETE FROM chats WHERE jid = $1`
|
|
} else {
|
|
deleteChatQuery = `DELETE FROM chats WHERE jid = ?`
|
|
}
|
|
|
|
if _, err = tx.Exec(deleteChatQuery, c.JID); err != nil {
|
|
logger.Warnf("LID migration: delete old chat failed %s: %v", c.JID, err)
|
|
_ = tx.Rollback()
|
|
skipped++
|
|
continue
|
|
}
|
|
|
|
if err = tx.Commit(); err != nil {
|
|
logger.Warnf("LID migration: commit failed %s: %v", c.JID, err)
|
|
_ = tx.Rollback()
|
|
skipped++
|
|
continue
|
|
}
|
|
|
|
commit = true
|
|
|
|
logger.Infof("LID migration: merged %s -> %s", c.JID, pnStr)
|
|
merged++
|
|
}
|
|
|
|
logger.Infof(
|
|
"LID migration complete: %d merged, %d skipped",
|
|
merged,
|
|
skipped,
|
|
)
|
|
}
|
|
|
|
// StoreChat Store a chat in the database
|
|
func (store *MessageStore) StoreChat(jid, name string, lastMessageTime time.Time) error {
|
|
if isPostgres {
|
|
_, err := store.db.Exec(
|
|
`INSERT INTO chats (jid, name, last_message_time)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (jid) DO UPDATE SET
|
|
name = EXCLUDED.name,
|
|
last_message_time = EXCLUDED.last_message_time`,
|
|
jid, name, lastMessageTime,
|
|
)
|
|
return err
|
|
}
|
|
_, err := store.db.Exec(
|
|
"INSERT OR REPLACE INTO chats (jid, name, last_message_time) VALUES (?, ?, ?)",
|
|
jid, name, lastMessageTime,
|
|
)
|
|
return err
|
|
}
|
|
|
|
// StoreMessage Store a message in the database
|
|
func (store *MessageStore) StoreMessage(id, chatJID, sender, content string, timestamp time.Time, isFromMe bool,
|
|
mediaType, filename, url string, mediaKey, fileSHA256, fileEncSHA256 []byte, fileLength uint64) error {
|
|
if content == "" && mediaType == "" {
|
|
return nil
|
|
}
|
|
|
|
if !isPostgres {
|
|
_, err := store.db.Exec(
|
|
`INSERT OR REPLACE INTO messages
|
|
(id, chat_jid, sender, content, timestamp, is_from_me, media_type, filename, url, media_key, file_sha256, file_enc_sha256, file_length)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
id, chatJID, sender, content, timestamp, isFromMe, mediaType, filename, url, mediaKey, fileSHA256, fileEncSHA256, fileLength,
|
|
)
|
|
return err
|
|
}
|
|
_, err := store.db.Exec(
|
|
`INSERT INTO messages
|
|
(id, chat_jid, sender, content, timestamp, is_from_me, media_type, filename, url, media_key, file_sha256, file_enc_sha256, file_length)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
|
|
ON CONFLICT(id, chat_jid) DO UPDATE SET
|
|
chat_jid = EXCLUDED.chat_jid,
|
|
sender = EXCLUDED.sender,
|
|
content = EXCLUDED.content,
|
|
timestamp = EXCLUDED.timestamp,
|
|
is_from_me = EXCLUDED.is_from_me,
|
|
media_type = EXCLUDED.media_type,
|
|
filename = EXCLUDED.filename,
|
|
url = EXCLUDED.url,
|
|
media_key = EXCLUDED.media_key,
|
|
file_sha256 = EXCLUDED.file_sha256,
|
|
file_enc_sha256 = EXCLUDED.file_enc_sha256,
|
|
file_length = EXCLUDED.file_length`,
|
|
id, chatJID, sender, content, timestamp, isFromMe, mediaType, filename, url, mediaKey, fileSHA256, fileEncSHA256, fileLength,
|
|
)
|
|
|
|
return err
|
|
}
|
|
|
|
// GetMessages Get messages from a chat
|
|
func (store *MessageStore) GetMessages(chatJID string, limit int) ([]Message, error) {
|
|
var rows *sql.Rows
|
|
var err error
|
|
|
|
if isPostgres {
|
|
rows, err = store.db.Query(
|
|
`SELECT sender, content, timestamp, is_from_me, media_type, filename
|
|
FROM messages
|
|
WHERE chat_jid = $1
|
|
ORDER BY timestamp DESC
|
|
LIMIT $2`,
|
|
chatJID, limit,
|
|
)
|
|
} else {
|
|
rows, err = store.db.Query(
|
|
"SELECT sender, content, timestamp, is_from_me, media_type, filename FROM messages WHERE chat_jid = ? ORDER BY timestamp DESC LIMIT ?",
|
|
chatJID, limit,
|
|
)
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var messages []Message
|
|
for rows.Next() {
|
|
var msg Message
|
|
var timestamp time.Time
|
|
err := rows.Scan(&msg.Sender, &msg.Content, ×tamp, &msg.IsFromMe, &msg.MediaType, &msg.Filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
msg.Time = timestamp
|
|
messages = append(messages, msg)
|
|
}
|
|
|
|
return messages, nil
|
|
}
|
|
|
|
// GetChats Get all chats
|
|
func (store *MessageStore) GetChats() (map[string]time.Time, error) {
|
|
rows, err := store.db.Query("SELECT jid, last_message_time FROM chats ORDER BY last_message_time DESC")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
chats := make(map[string]time.Time)
|
|
for rows.Next() {
|
|
var jid string
|
|
var lastMessageTime time.Time
|
|
err := rows.Scan(&jid, &lastMessageTime)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
chats[jid] = lastMessageTime
|
|
}
|
|
|
|
return chats, nil
|
|
}
|
|
|
|
// Extract text content from a message
|
|
func extractTextContent(msg *waE2E.Message) string {
|
|
if msg == nil {
|
|
return ""
|
|
}
|
|
|
|
// Try to get text content
|
|
if text := msg.GetConversation(); text != "" {
|
|
return text
|
|
} else if extendedText := msg.GetExtendedTextMessage(); extendedText != nil {
|
|
return extendedText.GetText()
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
// SendMessageResponse represents the response for the send message API
|
|
type SendMessageResponse struct {
|
|
Success bool `json:"success"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
// SendMessageRequest represents the request body for the send message API
|
|
type SendMessageRequest struct {
|
|
Recipient string `json:"recipient"`
|
|
Message string `json:"message"`
|
|
MediaPath string `json:"media_path,omitempty"`
|
|
}
|
|
|
|
var clientVersionRegex = regexp.MustCompile(`"client_revision":(\d+),`)
|
|
|
|
func CustomGetLatestVersion(ctx context.Context, httpClient *http.Client) (*store.WAVersionContainer, error) {
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, socket.Origin, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to prepare request: %w", err)
|
|
}
|
|
req.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36")
|
|
req.Header.Set("Sec-Fetch-Dest", "document")
|
|
req.Header.Set("Sec-Fetch-Mode", "navigate")
|
|
req.Header.Set("Sec-Fetch-Site", "none")
|
|
req.Header.Set("Sec-Fetch-User", "?1")
|
|
req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7")
|
|
req.Header.Set("Accept-Language", "en-US,en;q=0.9")
|
|
if httpClient == nil {
|
|
httpClient = http.DefaultClient
|
|
}
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to send request: %w", err)
|
|
}
|
|
data, err := io.ReadAll(resp.Body)
|
|
_ = resp.Body.Close()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response: %w", err)
|
|
} else if resp.StatusCode != 200 {
|
|
return nil, fmt.Errorf("unexpected response with status %d: %s", resp.StatusCode, data)
|
|
} else if match := clientVersionRegex.FindSubmatch(data); len(match) == 0 {
|
|
return nil, fmt.Errorf("version number not found")
|
|
} else if parsedVer, err := strconv.ParseInt(string(match[1]), 10, 64); err != nil {
|
|
return nil, fmt.Errorf("failed to parse version number: %w", err)
|
|
} else {
|
|
return &store.WAVersionContainer{2, 3000, uint32(parsedVer)}, nil
|
|
}
|
|
}
|
|
|
|
// Function to send a WhatsApp message
|
|
func sendWhatsAppMessage(client *whatsmeow.Client, recipient string, message string, mediaPath string) (bool, string) {
|
|
if !client.IsConnected() {
|
|
return false, "Not connected to WhatsApp"
|
|
}
|
|
|
|
var recipientJID types.JID
|
|
var err error
|
|
|
|
isJID := strings.Contains(recipient, "@")
|
|
|
|
if isJID {
|
|
recipientJID, err = types.ParseJID(recipient)
|
|
if err != nil {
|
|
return false, fmt.Sprintf("Error parsing JID: %v", err)
|
|
}
|
|
} else {
|
|
recipientJID = types.JID{
|
|
User: recipient,
|
|
Server: "s.whatsapp.net", // For personal chats
|
|
}
|
|
}
|
|
|
|
msg := &waE2E.Message{}
|
|
|
|
if mediaPath != "" {
|
|
validatedPath, err := validateMediaPath(mediaPath)
|
|
if err != nil {
|
|
return false, fmt.Sprintf("Invalid media path: %v", err)
|
|
}
|
|
mediaData, err := os.ReadFile(validatedPath)
|
|
if err != nil {
|
|
return false, fmt.Sprintf("Error reading media file: %v", err)
|
|
}
|
|
|
|
fileExt := strings.ToLower(mediaPath[strings.LastIndex(mediaPath, ".")+1:])
|
|
var mediaType whatsmeow.MediaType
|
|
var mimeType string
|
|
|
|
switch fileExt {
|
|
case "jpg", "jpeg":
|
|
mediaType = whatsmeow.MediaImage
|
|
mimeType = "image/jpeg"
|
|
case "png":
|
|
mediaType = whatsmeow.MediaImage
|
|
mimeType = "image/png"
|
|
case "gif":
|
|
mediaType = whatsmeow.MediaImage
|
|
mimeType = "image/gif"
|
|
case "webp":
|
|
mediaType = whatsmeow.MediaImage
|
|
mimeType = "image/webp"
|
|
|
|
case "ogg":
|
|
mediaType = whatsmeow.MediaAudio
|
|
mimeType = "audio/ogg; codecs=opus"
|
|
|
|
case "mp4":
|
|
mediaType = whatsmeow.MediaVideo
|
|
mimeType = "video/mp4"
|
|
case "avi":
|
|
mediaType = whatsmeow.MediaVideo
|
|
mimeType = "video/avi"
|
|
case "mov":
|
|
mediaType = whatsmeow.MediaVideo
|
|
mimeType = "video/quicktime"
|
|
|
|
default:
|
|
mediaType = whatsmeow.MediaDocument
|
|
mimeType = "application/octet-stream"
|
|
}
|
|
|
|
resp, err := client.Upload(context.Background(), mediaData, mediaType)
|
|
if err != nil {
|
|
return false, fmt.Sprintf("Error uploading media: %v", err)
|
|
}
|
|
|
|
slog.Info("media uploaded", "response", resp)
|
|
|
|
switch mediaType {
|
|
case whatsmeow.MediaImage:
|
|
msg.ImageMessage = &waE2E.ImageMessage{
|
|
Caption: proto.String(message),
|
|
Mimetype: proto.String(mimeType),
|
|
URL: &resp.URL,
|
|
DirectPath: &resp.DirectPath,
|
|
MediaKey: resp.MediaKey,
|
|
FileEncSHA256: resp.FileEncSHA256,
|
|
FileSHA256: resp.FileSHA256,
|
|
FileLength: &resp.FileLength,
|
|
}
|
|
case whatsmeow.MediaAudio:
|
|
var seconds uint32 = 30
|
|
var waveform []byte = nil
|
|
|
|
if strings.Contains(mimeType, "ogg") {
|
|
analyzedSeconds, analyzedWaveform, err := analyzeOggOpus(mediaData)
|
|
if err == nil {
|
|
seconds = analyzedSeconds
|
|
waveform = analyzedWaveform
|
|
} else {
|
|
return false, fmt.Sprintf("Failed to analyze Ogg Opus file: %v", err)
|
|
}
|
|
} else {
|
|
slog.Warn("not an Ogg Opus file", "mime_type", mimeType)
|
|
}
|
|
|
|
msg.AudioMessage = &waE2E.AudioMessage{
|
|
Mimetype: proto.String(mimeType),
|
|
URL: &resp.URL,
|
|
DirectPath: &resp.DirectPath,
|
|
MediaKey: resp.MediaKey,
|
|
FileEncSHA256: resp.FileEncSHA256,
|
|
FileSHA256: resp.FileSHA256,
|
|
FileLength: &resp.FileLength,
|
|
Seconds: proto.Uint32(seconds),
|
|
PTT: proto.Bool(true),
|
|
Waveform: waveform,
|
|
}
|
|
case whatsmeow.MediaVideo:
|
|
msg.VideoMessage = &waE2E.VideoMessage{
|
|
Caption: proto.String(message),
|
|
Mimetype: proto.String(mimeType),
|
|
URL: &resp.URL,
|
|
DirectPath: &resp.DirectPath,
|
|
MediaKey: resp.MediaKey,
|
|
FileEncSHA256: resp.FileEncSHA256,
|
|
FileSHA256: resp.FileSHA256,
|
|
FileLength: &resp.FileLength,
|
|
}
|
|
case whatsmeow.MediaDocument:
|
|
msg.DocumentMessage = &waE2E.DocumentMessage{
|
|
Title: proto.String(mediaPath[strings.LastIndex(mediaPath, "/")+1:]),
|
|
Caption: proto.String(message),
|
|
Mimetype: proto.String(mimeType),
|
|
URL: &resp.URL,
|
|
DirectPath: &resp.DirectPath,
|
|
MediaKey: resp.MediaKey,
|
|
FileEncSHA256: resp.FileEncSHA256,
|
|
FileSHA256: resp.FileSHA256,
|
|
FileLength: &resp.FileLength,
|
|
}
|
|
}
|
|
} else {
|
|
msg.Conversation = proto.String(message)
|
|
}
|
|
|
|
_, err = client.SendMessage(context.Background(), recipientJID, msg)
|
|
|
|
if err != nil {
|
|
return false, fmt.Sprintf("Error sending message: %v", err)
|
|
}
|
|
|
|
return true, fmt.Sprintf("Message sent to %s", recipient)
|
|
}
|
|
|
|
// Extract media info from a message
|
|
func extractMediaInfo(msg *waE2E.Message) (mediaType string, filename string, url string, mediaKey []byte, fileSHA256 []byte, fileEncSHA256 []byte, fileLength uint64) {
|
|
if msg == nil {
|
|
return "", "", "", nil, nil, nil, 0
|
|
}
|
|
|
|
if img := msg.GetImageMessage(); img != nil {
|
|
return "image", "image_" + time.Now().Format("20060102_150405") + ".jpg",
|
|
img.GetURL(), img.GetMediaKey(), img.GetFileSHA256(), img.GetFileEncSHA256(), img.GetFileLength()
|
|
}
|
|
|
|
if vid := msg.GetVideoMessage(); vid != nil {
|
|
return "video", "video_" + time.Now().Format("20060102_150405") + ".mp4",
|
|
vid.GetURL(), vid.GetMediaKey(), vid.GetFileSHA256(), vid.GetFileEncSHA256(), vid.GetFileLength()
|
|
}
|
|
|
|
if aud := msg.GetAudioMessage(); aud != nil {
|
|
return "audio", "audio_" + time.Now().Format("20060102_150405") + ".ogg",
|
|
aud.GetURL(), aud.GetMediaKey(), aud.GetFileSHA256(), aud.GetFileEncSHA256(), aud.GetFileLength()
|
|
}
|
|
|
|
if doc := msg.GetDocumentMessage(); doc != nil {
|
|
filename := doc.GetFileName()
|
|
if filename == "" {
|
|
filename = "document_" + time.Now().Format("20060102_150405")
|
|
}
|
|
return "document", filename,
|
|
doc.GetURL(), doc.GetMediaKey(), doc.GetFileSHA256(), doc.GetFileEncSHA256(), doc.GetFileLength()
|
|
}
|
|
|
|
return "", "", "", nil, nil, nil, 0
|
|
}
|
|
|
|
// Handle regular incoming messages with media support
|
|
func handleMessage(client *whatsmeow.Client, messageStore *MessageStore, msg *events.Message, logger waLog.Logger) {
|
|
go func() {
|
|
cfg, err := config.LoadConfig()
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
log.Println("Recovered in webhook goroutine:", r)
|
|
}
|
|
}()
|
|
if cfg.WebhookUrl == "" {
|
|
return
|
|
}
|
|
|
|
content := extractTextContent(msg.Message)
|
|
if content == "" {
|
|
return
|
|
}
|
|
|
|
payload := map[string]interface{}{
|
|
"chat_jid": msg.Info.Chat.String(),
|
|
"sender": msg.Info.Sender.User,
|
|
"content": extractTextContent(msg.Message),
|
|
"is_from_me": msg.Info.IsFromMe,
|
|
"timestamp": msg.Info.Timestamp.String(),
|
|
"push_name": msg.Info.PushName,
|
|
"is_group": strings.Contains(msg.Info.Chat.String(), "@g.us"),
|
|
"message_id": msg.Info.ID,
|
|
}
|
|
|
|
jsonData, err := json.Marshal(payload)
|
|
if err != nil {
|
|
log.Println("Webhook marshal error:", err)
|
|
return
|
|
}
|
|
|
|
resp, err := http.Post(
|
|
cfg.WebhookUrl,
|
|
"application/json",
|
|
bytes.NewBuffer(jsonData),
|
|
)
|
|
|
|
if err != nil {
|
|
log.Println("Webhook POST error:", err)
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
}()
|
|
chatJID := normalizeUserJID(client, msg.Info.Chat).String()
|
|
sender := normalizeUserJID(client, msg.Info.Sender).User
|
|
|
|
name := GetChatName(client, messageStore, msg.Info.Chat, chatJID, nil, sender, logger)
|
|
|
|
err := messageStore.StoreChat(chatJID, name, msg.Info.Timestamp)
|
|
if err != nil {
|
|
logger.Warnf("Failed to store chat: %v", err)
|
|
}
|
|
|
|
content := extractTextContent(msg.Message)
|
|
|
|
mediaType, filename, url, mediaKey, fileSHA256, fileEncSHA256, fileLength := extractMediaInfo(msg.Message)
|
|
|
|
if content == "" && mediaType == "" {
|
|
return
|
|
}
|
|
|
|
err = messageStore.StoreMessage(
|
|
msg.Info.ID,
|
|
chatJID,
|
|
sender,
|
|
content,
|
|
msg.Info.Timestamp,
|
|
msg.Info.IsFromMe,
|
|
mediaType,
|
|
filename,
|
|
url,
|
|
mediaKey,
|
|
fileSHA256,
|
|
fileEncSHA256,
|
|
fileLength,
|
|
)
|
|
|
|
if err != nil {
|
|
logger.Warnf("Failed to store message: %v", err)
|
|
} else {
|
|
timestamp := msg.Info.Timestamp.Format("2006-01-02 15:04:05")
|
|
direction := "←"
|
|
if msg.Info.IsFromMe {
|
|
direction = "→"
|
|
}
|
|
|
|
if mediaType != "" {
|
|
slog.Info("message", "ts", timestamp, "direction", direction, "sender", sender, "media_type", mediaType, "filename", filename, "content", content)
|
|
} else if content != "" {
|
|
slog.Info("message", "ts", timestamp, "direction", direction, "sender", sender, "content", content)
|
|
}
|
|
}
|
|
}
|
|
|
|
// DownloadMediaRequest represents the request body for the download media API
|
|
type DownloadMediaRequest struct {
|
|
MessageID string `json:"message_id"`
|
|
ChatJID string `json:"chat_jid"`
|
|
}
|
|
|
|
// DownloadMediaResponse represents the response for the download media API
|
|
type DownloadMediaResponse struct {
|
|
Success bool `json:"success"`
|
|
Message string `json:"message"`
|
|
Filename string `json:"filename,omitempty"`
|
|
Path string `json:"path,omitempty"`
|
|
}
|
|
|
|
// StoreMediaInfo Store additional media info in the database
|
|
func (store *MessageStore) StoreMediaInfo(id, chatJID, url string, mediaKey, fileSHA256, fileEncSHA256 []byte, fileLength uint64) error {
|
|
if isPostgres {
|
|
_, err := store.db.Exec(
|
|
`UPDATE messages
|
|
SET url = $1,
|
|
media_key = $2,
|
|
file_sha256 = $3,
|
|
file_enc_sha256 = $4,
|
|
file_length = $5
|
|
WHERE id = $6 AND chat_jid = $7`,
|
|
url, mediaKey, fileSHA256, fileEncSHA256, fileLength, id, chatJID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
_, err := store.db.Exec(
|
|
"UPDATE messages SET url = ?, media_key = ?, file_sha256 = ?, file_enc_sha256 = ?, file_length = ? WHERE id = ? AND chat_jid = ?",
|
|
url, mediaKey, fileSHA256, fileEncSHA256, fileLength, id, chatJID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
// GetMediaInfo Get media info from the database
|
|
func (store *MessageStore) GetMediaInfo(id, chatJID string) (string, string, string, []byte, []byte, []byte, uint64, error) {
|
|
var mediaType, filename, url string
|
|
var mediaKey, fileSHA256, fileEncSHA256 []byte
|
|
var fileLength uint64
|
|
var err error
|
|
|
|
if isPostgres {
|
|
err = store.db.QueryRow(
|
|
`SELECT media_type, filename, url, media_key, file_sha256, file_enc_sha256, file_length
|
|
FROM messages
|
|
WHERE id = $1 AND chat_jid = $2`,
|
|
id, chatJID,
|
|
).Scan(&mediaType, &filename, &url, &mediaKey, &fileSHA256, &fileEncSHA256, &fileLength)
|
|
} else {
|
|
err = store.db.QueryRow(
|
|
"SELECT media_type, filename, url, media_key, file_sha256, file_enc_sha256, file_length FROM messages WHERE id = ? AND chat_jid = ?",
|
|
id, chatJID,
|
|
).Scan(&mediaType, &filename, &url, &mediaKey, &fileSHA256, &fileEncSHA256, &fileLength)
|
|
}
|
|
|
|
return mediaType, filename, url, mediaKey, fileSHA256, fileEncSHA256, fileLength, err
|
|
}
|
|
|
|
// MediaDownloader implements the whatsmeow.DownloadableMessage interface
|
|
type MediaDownloader struct {
|
|
URL string
|
|
DirectPath string
|
|
MediaKey []byte
|
|
FileLength uint64
|
|
FileSHA256 []byte
|
|
FileEncSHA256 []byte
|
|
MediaType whatsmeow.MediaType
|
|
}
|
|
|
|
// GetDirectPath implements the DownloadableMessage interface
|
|
func (d *MediaDownloader) GetDirectPath() string {
|
|
return d.DirectPath
|
|
}
|
|
|
|
// GetURL implements the DownloadableMessage interface
|
|
func (d *MediaDownloader) GetURL() string {
|
|
return d.URL
|
|
}
|
|
|
|
// GetMediaKey implements the DownloadableMessage interface
|
|
func (d *MediaDownloader) GetMediaKey() []byte {
|
|
return d.MediaKey
|
|
}
|
|
|
|
// GetFileLength implements the DownloadableMessage interface
|
|
func (d *MediaDownloader) GetFileLength() uint64 {
|
|
return d.FileLength
|
|
}
|
|
|
|
// GetFileSHA256 implements the DownloadableMessage interface
|
|
func (d *MediaDownloader) GetFileSHA256() []byte {
|
|
return d.FileSHA256
|
|
}
|
|
|
|
// GetFileEncSHA256 implements the DownloadableMessage interface
|
|
func (d *MediaDownloader) GetFileEncSHA256() []byte {
|
|
return d.FileEncSHA256
|
|
}
|
|
|
|
// GetMediaType implements the DownloadableMessage interface
|
|
func (d *MediaDownloader) GetMediaType() whatsmeow.MediaType {
|
|
return d.MediaType
|
|
}
|
|
|
|
// Function to download media from a message
|
|
func downloadMedia(client *whatsmeow.Client, messageStore *MessageStore, messageID, chatJID string) (bool, string, string, string, error) {
|
|
var mediaType, filename, url string
|
|
var mediaKey, fileSHA256, fileEncSHA256 []byte
|
|
var fileLength uint64
|
|
var err error
|
|
|
|
chatDir := fmt.Sprintf("store/%s", strings.ReplaceAll(chatJID, ":", "_"))
|
|
localPath := ""
|
|
|
|
mediaType, filename, url, mediaKey, fileSHA256, fileEncSHA256, fileLength, err = messageStore.GetMediaInfo(messageID, chatJID)
|
|
|
|
if err != nil {
|
|
if isPostgres {
|
|
err = messageStore.db.QueryRow(
|
|
`SELECT media_type, filename FROM messages WHERE id = $1 AND chat_jid = $2`,
|
|
messageID, chatJID,
|
|
).Scan(&mediaType, &filename)
|
|
} else {
|
|
err = messageStore.db.QueryRow(
|
|
"SELECT media_type, filename FROM messages WHERE id = ? AND chat_jid = ?",
|
|
messageID, chatJID,
|
|
).Scan(&mediaType, &filename)
|
|
}
|
|
|
|
if err != nil {
|
|
return false, "", "", "", fmt.Errorf("failed to find message: %v", err)
|
|
}
|
|
}
|
|
|
|
if mediaType == "" {
|
|
return false, "", "", "", fmt.Errorf("not a media message")
|
|
}
|
|
|
|
if err := os.MkdirAll(chatDir, 0755); err != nil {
|
|
return false, "", "", "", fmt.Errorf("failed to create chat directory: %v", err)
|
|
}
|
|
|
|
localPath = fmt.Sprintf("%s/%s", chatDir, filename)
|
|
|
|
absPath, err := filepath.Abs(localPath)
|
|
if err != nil {
|
|
return false, "", "", "", fmt.Errorf("failed to get absolute path: %v", err)
|
|
}
|
|
|
|
if _, err := os.Stat(localPath); err == nil {
|
|
return true, mediaType, filename, absPath, nil
|
|
}
|
|
|
|
if url == "" || len(mediaKey) == 0 || len(fileSHA256) == 0 || len(fileEncSHA256) == 0 || fileLength == 0 {
|
|
return false, "", "", "", fmt.Errorf("incomplete media information for download")
|
|
}
|
|
|
|
slog.Info("attempting to download media", "message_id", messageID, "chat_jid", chatJID)
|
|
|
|
directPath := extractDirectPathFromURL(url)
|
|
|
|
var waMediaType whatsmeow.MediaType
|
|
switch mediaType {
|
|
case "image":
|
|
waMediaType = whatsmeow.MediaImage
|
|
case "video":
|
|
waMediaType = whatsmeow.MediaVideo
|
|
case "audio":
|
|
waMediaType = whatsmeow.MediaAudio
|
|
case "document":
|
|
waMediaType = whatsmeow.MediaDocument
|
|
default:
|
|
return false, "", "", "", fmt.Errorf("unsupported media type: %s", mediaType)
|
|
}
|
|
|
|
downloader := &MediaDownloader{
|
|
URL: url,
|
|
DirectPath: directPath,
|
|
MediaKey: mediaKey,
|
|
FileLength: fileLength,
|
|
FileSHA256: fileSHA256,
|
|
FileEncSHA256: fileEncSHA256,
|
|
MediaType: waMediaType,
|
|
}
|
|
|
|
mediaData, err := client.Download(context.Background(), downloader)
|
|
if err != nil {
|
|
return false, "", "", "", fmt.Errorf("failed to download media: %v", err)
|
|
}
|
|
|
|
if err := os.WriteFile(localPath, mediaData, 0644); err != nil {
|
|
return false, "", "", "", fmt.Errorf("failed to save media file: %v", err)
|
|
}
|
|
|
|
slog.Info("successfully downloaded media", "media_type", mediaType, "path", absPath, "bytes", len(mediaData))
|
|
return true, mediaType, filename, absPath, nil
|
|
}
|
|
|
|
func extractDirectPathFromURL(url string) string {
|
|
// The direct path is typically in the URL, we need to extract it
|
|
// Example URL: https://mmg.whatsapp.net/v/t62.7118-24/13812002_698058036224062_3424455886509161511_n.enc?ccb=11-4&oh=...
|
|
|
|
parts := strings.SplitN(url, ".net/", 2)
|
|
if len(parts) < 2 {
|
|
return url // Return original URL if parsing fails
|
|
}
|
|
|
|
pathPart := parts[1]
|
|
|
|
pathPart = strings.SplitN(pathPart, "?", 2)[0]
|
|
|
|
return "/" + pathPart
|
|
}
|
|
|
|
// Start a REST API server to expose the WhatsApp client functionality
|
|
func startRESTServer(client *whatsmeow.Client, messageStore *MessageStore, cfg *config.Config, state *wastate.State) {
|
|
apiMux := http.NewServeMux()
|
|
|
|
// Send message
|
|
apiMux.HandleFunc("/send", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
var req SendMessageRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "Invalid request format", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if req.Recipient == "" {
|
|
http.Error(w, "Recipient is required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if req.Message == "" && req.MediaPath == "" {
|
|
http.Error(w, "Message or media path is required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
slog.Info("received request to send message", "message", req.Message, "media_path", req.MediaPath)
|
|
|
|
success, message := sendWhatsAppMessage(client, req.Recipient, req.Message, req.MediaPath)
|
|
slog.Info("message sent", "success", success, "message", message)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
if !success {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(SendMessageResponse{
|
|
Success: success,
|
|
Message: message,
|
|
})
|
|
})
|
|
|
|
// Handler for downloading media
|
|
apiMux.HandleFunc("/download", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
var req DownloadMediaRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "Invalid request format", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if req.MessageID == "" || req.ChatJID == "" {
|
|
http.Error(w, "Message ID and Chat JID are required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
success, mediaType, filename, path, err := downloadMedia(client, messageStore, req.MessageID, req.ChatJID)
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
if !success || err != nil {
|
|
errMsg := "Unknown error"
|
|
if err != nil {
|
|
errMsg = err.Error()
|
|
}
|
|
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
json.NewEncoder(w).Encode(DownloadMediaResponse{
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to download media: %s", errMsg),
|
|
})
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(DownloadMediaResponse{
|
|
Success: true,
|
|
Message: fmt.Sprintf("Successfully downloaded %s media", mediaType),
|
|
Filename: filename,
|
|
Path: path,
|
|
})
|
|
})
|
|
|
|
// List recent chats
|
|
apiMux.HandleFunc("/chats", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
q := r.URL.Query().Get("q")
|
|
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
|
|
page, _ := strconv.Atoi(r.URL.Query().Get("page"))
|
|
sortBy := r.URL.Query().Get("sort")
|
|
|
|
if limit < 1 {
|
|
limit = 30
|
|
}
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
|
|
var queryPtr *string
|
|
if q != "" {
|
|
queryPtr = &q
|
|
}
|
|
|
|
chats, err := messageStore.ListChats(queryPtr, limit, page, true, sortBy)
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
respondJSON(w, http.StatusOK, map[string]interface{}{
|
|
"chats": chats,
|
|
"count": len(chats),
|
|
})
|
|
})
|
|
|
|
// Get single chat
|
|
apiMux.HandleFunc("/chats/", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
jid := strings.TrimPrefix(r.URL.Path, "/chats/")
|
|
if jid == "" {
|
|
http.Error(w, "Missing chat JID", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
chat, err := messageStore.GetChat(jid, true)
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
if chat == nil {
|
|
http.Error(w, "Chat not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
respondJSON(w, http.StatusOK, map[string]interface{}{
|
|
"chat": chat,
|
|
})
|
|
})
|
|
|
|
// List messages (very flexible)
|
|
apiMux.HandleFunc("/messages", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
params := ListMessagesParams{
|
|
Limit: 50,
|
|
Page: 0,
|
|
IncludeContext: false,
|
|
ContextBefore: 5,
|
|
ContextAfter: 5,
|
|
}
|
|
|
|
q := r.URL.Query()
|
|
if after := q.Get("after"); after != "" {
|
|
params.After = after
|
|
}
|
|
if before := q.Get("before"); before != "" {
|
|
params.Before = before
|
|
}
|
|
if chat := q.Get("chat"); chat != "" {
|
|
params.ChatJid = &chat
|
|
}
|
|
if sender := q.Get("sender"); sender != "" {
|
|
params.SenderPhoneNumber = &sender
|
|
}
|
|
if search := q.Get("search"); search != "" {
|
|
params.Query = &search
|
|
}
|
|
if lim := q.Get("limit"); lim != "" {
|
|
if v, err := strconv.Atoi(lim); err == nil && v > 0 {
|
|
params.Limit = v
|
|
}
|
|
}
|
|
if pg := q.Get("page"); pg != "" {
|
|
if v, err := strconv.Atoi(pg); err == nil && v >= 0 {
|
|
params.Page = v
|
|
}
|
|
}
|
|
if ctx := q.Get("context"); ctx == "true" {
|
|
params.IncludeContext = true
|
|
}
|
|
|
|
result, err := messageStore.ListMessages(params)
|
|
if err != nil {
|
|
respondError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
respondJSON(w, http.StatusOK, map[string]interface{}{
|
|
"result": result,
|
|
})
|
|
})
|
|
|
|
// Get message + context
|
|
apiMux.HandleFunc("/messages/context/", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
messageID := strings.TrimPrefix(r.URL.Path, "/messages/context/")
|
|
if messageID == "" {
|
|
http.Error(w, "Missing message ID", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
before, _ := strconv.Atoi(r.URL.Query().Get("before"))
|
|
after, _ := strconv.Atoi(r.URL.Query().Get("after"))
|
|
if before == 0 {
|
|
before = 6
|
|
}
|
|
if after == 0 {
|
|
after = 6
|
|
}
|
|
|
|
ctx, err := messageStore.GetMessageContext(messageID, before, after)
|
|
if err != nil {
|
|
respondError(w, http.StatusNotFound, err.Error())
|
|
return
|
|
}
|
|
|
|
respondJSON(w, http.StatusOK, ctx)
|
|
})
|
|
|
|
// Search contacts
|
|
apiMux.HandleFunc("/contacts/search", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
query := r.URL.Query().Get("q")
|
|
if query == "" {
|
|
http.Error(w, "Missing search query (?q=...)", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
contacts, err := messageStore.SearchContacts(query)
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
respondJSON(w, http.StatusOK, map[string]interface{}{
|
|
"contacts": contacts,
|
|
})
|
|
})
|
|
|
|
// GET /api/direct-contacts/:phone/chat
|
|
// Find the 1:1 (direct) chat for a given phone number
|
|
apiMux.HandleFunc("/direct-contacts/", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
path := strings.TrimPrefix(r.URL.Path, "/direct-contacts/")
|
|
parts := strings.Split(path, "/")
|
|
if len(parts) < 2 || parts[1] != "chat" {
|
|
http.Error(w, "Invalid path. Use /api/direct-contacts/{phone}/chat", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
phone := parts[0]
|
|
if phone == "" {
|
|
http.Error(w, "Phone number is required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
chat, err := messageStore.GetDirectChatByContact(phone)
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
if chat == nil {
|
|
respondJSON(w, http.StatusNotFound, map[string]string{
|
|
"error": "No direct chat found for this phone number",
|
|
})
|
|
return
|
|
}
|
|
|
|
respondJSON(w, http.StatusOK, map[string]interface{}{
|
|
"chat": chat,
|
|
})
|
|
})
|
|
|
|
// GET /api/contacts/:jid/chats
|
|
// List all chats where this contact (by JID) appears as sender or in group
|
|
apiMux.HandleFunc("/contacts/", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
path := strings.TrimPrefix(r.URL.Path, "/contacts/")
|
|
parts := strings.Split(path, "/")
|
|
if len(parts) < 2 || parts[1] != "chats" {
|
|
// Skip if not this endpoint (previous handler already took /chat)
|
|
return
|
|
}
|
|
|
|
jid := parts[0]
|
|
if jid == "" {
|
|
http.Error(w, "JID is required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
|
|
page, _ := strconv.Atoi(r.URL.Query().Get("page"))
|
|
if limit <= 0 {
|
|
limit = 20
|
|
}
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
|
|
chats, err := messageStore.GetContactChats(jid, limit, page)
|
|
if err != nil {
|
|
respondError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
respondJSON(w, http.StatusOK, map[string]interface{}{
|
|
"chats": chats,
|
|
"count": len(chats),
|
|
})
|
|
})
|
|
|
|
apiMux.HandleFunc("/auth/status", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
respondJSON(w, http.StatusOK, map[string]any{
|
|
"connected": state.Connected(),
|
|
"logged_in": state.LoggedIn(),
|
|
"pairing_required": state.PairingRequired(),
|
|
"wa_version": state.WAVersion(),
|
|
})
|
|
})
|
|
|
|
apiMux.HandleFunc("/auth/pairing-qr", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
png := state.PairingQRPNG()
|
|
if png == nil {
|
|
http.Error(w, "no pairing QR available; client is logged in or has not started pairing yet", http.StatusGone)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "image/png")
|
|
w.Header().Set("Cache-Control", "no-store")
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write(png)
|
|
})
|
|
|
|
// Authentication
|
|
protected := auth.JwtAuthMiddleware(cfg, apiMux)
|
|
http.Handle("/api/", http.StripPrefix("/api", protected))
|
|
http.Handle("/auth/login", auth.LoginHandler(cfg))
|
|
|
|
serverAddr := fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)
|
|
slog.Info("starting REST API server", "addr", serverAddr)
|
|
|
|
go func() {
|
|
if err := http.ListenAndServe(serverAddr, nil); err != nil {
|
|
slog.Error("rest api server error", "err", err)
|
|
}
|
|
}()
|
|
}
|
|
|
|
func respondJSON(w http.ResponseWriter, status int, data interface{}) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(status)
|
|
json.NewEncoder(w).Encode(data)
|
|
}
|
|
|
|
func respondError(w http.ResponseWriter, status int, msg string) {
|
|
respondJSON(w, status, map[string]string{
|
|
"error": msg,
|
|
})
|
|
}
|
|
|
|
// GetChatName determines the appropriate name for a chat based on JID and other info
|
|
func GetChatName(client *whatsmeow.Client, messageStore *MessageStore, jid types.JID, chatJID string, conversation interface{}, sender string, logger waLog.Logger) string {
|
|
var existingName string
|
|
err := messageStore.db.QueryRow("SELECT name FROM chats WHERE jid = ?", chatJID).Scan(&existingName)
|
|
if err == nil && existingName != "" {
|
|
logger.Infof("Using existing chat name for %s: %s", chatJID, existingName)
|
|
return existingName
|
|
}
|
|
|
|
var name string
|
|
|
|
if jid.Server == "g.us" {
|
|
logger.Infof("Getting name for group: %s", chatJID)
|
|
|
|
if conversation != nil {
|
|
var displayName, convName *string
|
|
v := reflect.ValueOf(conversation)
|
|
if v.Kind() == reflect.Ptr && !v.IsNil() {
|
|
v = v.Elem()
|
|
|
|
if displayNameField := v.FieldByName("DisplayName"); displayNameField.IsValid() && displayNameField.Kind() == reflect.Ptr && !displayNameField.IsNil() {
|
|
dn := displayNameField.Elem().String()
|
|
displayName = &dn
|
|
}
|
|
|
|
if nameField := v.FieldByName("Name"); nameField.IsValid() && nameField.Kind() == reflect.Ptr && !nameField.IsNil() {
|
|
n := nameField.Elem().String()
|
|
convName = &n
|
|
}
|
|
}
|
|
|
|
if displayName != nil && *displayName != "" {
|
|
name = *displayName
|
|
} else if convName != nil && *convName != "" {
|
|
name = *convName
|
|
}
|
|
}
|
|
|
|
if name == "" {
|
|
groupInfo, err := client.GetGroupInfo(context.Background(), jid)
|
|
if err == nil && groupInfo.Name != "" {
|
|
name = groupInfo.Name
|
|
} else {
|
|
name = fmt.Sprintf("Group %s", jid.User)
|
|
}
|
|
}
|
|
|
|
logger.Infof("Using group name: %s", name)
|
|
} else {
|
|
logger.Infof("Getting name for contact: %s", chatJID)
|
|
|
|
contact, err := client.Store.Contacts.GetContact(context.Background(), jid)
|
|
if err == nil {
|
|
switch {
|
|
case contact.FullName != "":
|
|
name = contact.FullName
|
|
case contact.PushName != "":
|
|
name = contact.PushName
|
|
case contact.FirstName != "":
|
|
name = contact.FirstName
|
|
}
|
|
}
|
|
|
|
if name == "" && sender != "" {
|
|
name = sender
|
|
}
|
|
|
|
if name == "" {
|
|
name = jid.User
|
|
}
|
|
|
|
logger.Infof("Using contact name: %s", name)
|
|
}
|
|
|
|
return name
|
|
}
|
|
|
|
// Handle history sync events
|
|
func handleHistorySync(client *whatsmeow.Client, messageStore *MessageStore, historySync *events.HistorySync, logger waLog.Logger) {
|
|
slog.Info("received history sync event", "conversations", len(historySync.Data.Conversations))
|
|
|
|
syncedCount := 0
|
|
for _, conversation := range historySync.Data.Conversations {
|
|
if conversation.ID == nil {
|
|
continue
|
|
}
|
|
|
|
chatJID := *conversation.ID
|
|
|
|
jid, err := types.ParseJID(chatJID)
|
|
if err != nil {
|
|
logger.Warnf("Failed to parse JID %s: %v", chatJID, err)
|
|
continue
|
|
}
|
|
jid = normalizeUserJID(client, jid)
|
|
chatJID = jid.String()
|
|
|
|
name := GetChatName(client, messageStore, jid, chatJID, conversation, "", logger)
|
|
|
|
messages := conversation.Messages
|
|
if len(messages) > 0 {
|
|
latestMsg := messages[0]
|
|
if latestMsg == nil || latestMsg.Message == nil {
|
|
continue
|
|
}
|
|
|
|
timestamp := time.Time{}
|
|
if ts := latestMsg.Message.GetMessageTimestamp(); ts != 0 {
|
|
timestamp = time.Unix(int64(ts), 0)
|
|
} else {
|
|
continue
|
|
}
|
|
|
|
messageStore.StoreChat(chatJID, name, timestamp)
|
|
|
|
for _, msg := range messages {
|
|
if msg == nil || msg.Message == nil {
|
|
continue
|
|
}
|
|
|
|
var content string
|
|
if msg.Message.Message != nil {
|
|
if conv := msg.Message.Message.GetConversation(); conv != "" {
|
|
content = conv
|
|
} else if ext := msg.Message.Message.GetExtendedTextMessage(); ext != nil {
|
|
content = ext.GetText()
|
|
}
|
|
}
|
|
|
|
var mediaType, filename, url string
|
|
var mediaKey, fileSHA256, fileEncSHA256 []byte
|
|
var fileLength uint64
|
|
|
|
if msg.Message.Message != nil {
|
|
mediaType, filename, url, mediaKey, fileSHA256, fileEncSHA256, fileLength = extractMediaInfo(msg.Message.Message)
|
|
}
|
|
|
|
logger.Infof("Message content: %v, Media Type: %v", content, mediaType)
|
|
|
|
if content == "" && mediaType == "" {
|
|
continue
|
|
}
|
|
|
|
var sender string
|
|
isFromMe := false
|
|
if msg.Message.Key != nil {
|
|
if msg.Message.Key.FromMe != nil {
|
|
isFromMe = *msg.Message.Key.FromMe
|
|
}
|
|
if !isFromMe && msg.Message.Key.Participant != nil && *msg.Message.Key.Participant != "" {
|
|
if pJid, err := types.ParseJID(*msg.Message.Key.Participant); err == nil {
|
|
sender = normalizeUserJID(client, pJid).User
|
|
} else {
|
|
sender = *msg.Message.Key.Participant
|
|
}
|
|
} else if isFromMe {
|
|
sender = client.Store.ID.User
|
|
} else {
|
|
sender = jid.User
|
|
}
|
|
} else {
|
|
sender = jid.User
|
|
}
|
|
|
|
msgID := ""
|
|
if msg.Message.Key != nil && msg.Message.Key.ID != nil {
|
|
msgID = *msg.Message.Key.ID
|
|
}
|
|
|
|
timestamp := time.Time{}
|
|
if ts := msg.Message.GetMessageTimestamp(); ts != 0 {
|
|
timestamp = time.Unix(int64(ts), 0)
|
|
} else {
|
|
continue
|
|
}
|
|
|
|
err = messageStore.StoreMessage(
|
|
msgID,
|
|
chatJID,
|
|
sender,
|
|
content,
|
|
timestamp,
|
|
isFromMe,
|
|
mediaType,
|
|
filename,
|
|
url,
|
|
mediaKey,
|
|
fileSHA256,
|
|
fileEncSHA256,
|
|
fileLength,
|
|
)
|
|
if err != nil {
|
|
logger.Warnf("Failed to store history message: %v", err)
|
|
} else {
|
|
syncedCount++
|
|
if mediaType != "" {
|
|
logger.Infof("Stored message: [%s] %s -> %s: [%s: %s] %s",
|
|
timestamp.Format("2006-01-02 15:04:05"), sender, chatJID, mediaType, filename, content)
|
|
} else {
|
|
logger.Infof("Stored message: [%s] %s -> %s: %s",
|
|
timestamp.Format("2006-01-02 15:04:05"), sender, chatJID, content)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
slog.Info("history sync complete", "stored_messages", syncedCount)
|
|
}
|
|
|
|
// Request history sync from the server
|
|
func requestHistorySync(client *whatsmeow.Client) {
|
|
if client == nil {
|
|
slog.Error("client is not initialized, cannot request history sync")
|
|
return
|
|
}
|
|
|
|
if !client.IsConnected() {
|
|
slog.Warn("client is not connected to whatsapp")
|
|
return
|
|
}
|
|
|
|
if client.Store.ID == nil {
|
|
slog.Warn("client is not logged in, please scan the qr code")
|
|
return
|
|
}
|
|
|
|
historyMsg := client.BuildHistorySyncRequest(nil, 100)
|
|
if historyMsg == nil {
|
|
slog.Error("failed to build history sync request")
|
|
return
|
|
}
|
|
|
|
_, err := client.SendMessage(context.Background(), types.JID{
|
|
Server: "s.whatsapp.net",
|
|
User: "status",
|
|
}, historyMsg)
|
|
|
|
if err != nil {
|
|
slog.Error("failed to request history sync", "err", err)
|
|
} else {
|
|
slog.Info("history sync requested, waiting for server response")
|
|
}
|
|
}
|
|
|
|
// analyzeOggOpus tries to extract duration and generate a simple waveform from an Ogg Opus file
|
|
func analyzeOggOpus(data []byte) (duration uint32, waveform []byte, err error) {
|
|
// Try to detect if this is a valid Ogg file by checking for the "OggS" signature
|
|
// at the beginning of the file
|
|
if len(data) < 4 || string(data[0:4]) != "OggS" {
|
|
return 0, nil, fmt.Errorf("not a valid Ogg file (missing OggS signature)")
|
|
}
|
|
|
|
// Parse Ogg pages to find the last page with a valid granule position
|
|
var lastGranule uint64
|
|
var sampleRate uint32 = 48000 // Default Opus sample rate
|
|
var preSkip uint16 = 0
|
|
var foundOpusHead bool
|
|
|
|
for i := 0; i < len(data); {
|
|
if i+27 >= len(data) {
|
|
break
|
|
}
|
|
|
|
if string(data[i:i+4]) != "OggS" {
|
|
i++
|
|
continue
|
|
}
|
|
|
|
granulePos := binary.LittleEndian.Uint64(data[i+6 : i+14])
|
|
pageSeqNum := binary.LittleEndian.Uint32(data[i+18 : i+22])
|
|
numSegments := int(data[i+26])
|
|
|
|
if i+27+numSegments >= len(data) {
|
|
break
|
|
}
|
|
segmentTable := data[i+27 : i+27+numSegments]
|
|
|
|
pageSize := 27 + numSegments
|
|
for _, segLen := range segmentTable {
|
|
pageSize += int(segLen)
|
|
}
|
|
|
|
if !foundOpusHead && pageSeqNum <= 1 {
|
|
pageData := data[i : i+pageSize]
|
|
headPos := bytes.Index(pageData, []byte("OpusHead"))
|
|
if headPos >= 0 && headPos+12 < len(pageData) {
|
|
headPos += 8
|
|
if headPos+12 <= len(pageData) {
|
|
preSkip = binary.LittleEndian.Uint16(pageData[headPos+10 : headPos+12])
|
|
sampleRate = binary.LittleEndian.Uint32(pageData[headPos+12 : headPos+16])
|
|
foundOpusHead = true
|
|
slog.Info("found OpusHead", "sample_rate", sampleRate, "pre_skip", preSkip)
|
|
}
|
|
}
|
|
}
|
|
|
|
if granulePos != 0 {
|
|
lastGranule = granulePos
|
|
}
|
|
|
|
i += pageSize
|
|
}
|
|
|
|
if !foundOpusHead {
|
|
slog.Warn("opushead not found, using default values")
|
|
}
|
|
|
|
if lastGranule > 0 {
|
|
durationSeconds := float64(lastGranule-uint64(preSkip)) / float64(sampleRate)
|
|
duration = uint32(math.Ceil(durationSeconds))
|
|
slog.Info("calculated Opus duration from granule", "duration_seconds", durationSeconds, "last_granule", lastGranule)
|
|
} else {
|
|
slog.Warn("no valid granule position found, using estimation")
|
|
durationEstimate := float64(len(data)) / 2000.0
|
|
duration = uint32(durationEstimate)
|
|
}
|
|
|
|
if duration < 1 {
|
|
duration = 1
|
|
} else if duration > 300 {
|
|
duration = 300
|
|
}
|
|
|
|
waveform = placeholderWaveform(duration)
|
|
|
|
slog.Info("ogg opus analysis complete", "size_bytes", len(data), "duration_sec", duration, "waveform_bytes", len(waveform))
|
|
|
|
return duration, waveform, nil
|
|
}
|
|
|
|
func placeholderWaveform(duration uint32) []byte {
|
|
const waveformLength = 64
|
|
waveform := make([]byte, waveformLength)
|
|
|
|
source := rand.NewSource(int64(duration))
|
|
rng := rand.New(source)
|
|
|
|
baseAmplitude := 35.0
|
|
frequencyFactor := float64(min(int(duration), 120)) / 30.0
|
|
|
|
for i := range waveform {
|
|
pos := float64(i) / float64(waveformLength)
|
|
|
|
val := baseAmplitude * math.Sin(pos*math.Pi*frequencyFactor*8)
|
|
val += (baseAmplitude / 2) * math.Sin(pos*math.Pi*frequencyFactor*16)
|
|
|
|
val += (rng.Float64() - 0.5) * 15
|
|
|
|
fadeInOut := math.Sin(pos * math.Pi)
|
|
val = val * (0.7 + 0.3*fadeInOut)
|
|
|
|
val = val + 50
|
|
|
|
if val < 0 {
|
|
val = 0
|
|
} else if val > 100 {
|
|
val = 100
|
|
}
|
|
|
|
waveform[i] = byte(val)
|
|
}
|
|
|
|
return waveform
|
|
}
|
|
|
|
func (store *MessageStore) GetSenderName(senderJID string) string {
|
|
var name string
|
|
var err error
|
|
|
|
if isPostgres {
|
|
err = store.db.QueryRow(
|
|
"SELECT name FROM chats WHERE jid = $1 LIMIT 1",
|
|
senderJID,
|
|
).Scan(&name)
|
|
|
|
if err == nil && name != "" {
|
|
return name
|
|
}
|
|
|
|
phonePart := senderJID
|
|
if idx := strings.Index(senderJID, "@"); idx > 0 {
|
|
phonePart = senderJID[:idx]
|
|
}
|
|
|
|
err = store.db.QueryRow(
|
|
"SELECT name FROM chats WHERE jid LIKE $1 LIMIT 1",
|
|
"%"+phonePart+"%",
|
|
).Scan(&name)
|
|
|
|
if err == nil && name != "" {
|
|
return name
|
|
}
|
|
|
|
return senderJID
|
|
}
|
|
|
|
err = store.db.QueryRow(
|
|
"SELECT name FROM chats WHERE jid = ? LIMIT 1",
|
|
senderJID,
|
|
).Scan(&name)
|
|
|
|
if err == nil && name != "" {
|
|
return name
|
|
}
|
|
|
|
phonePart := senderJID
|
|
if idx := strings.Index(senderJID, "@"); idx > 0 {
|
|
phonePart = senderJID[:idx]
|
|
}
|
|
|
|
err = store.db.QueryRow(
|
|
"SELECT name FROM chats WHERE jid LIKE ? LIMIT 1",
|
|
"%"+phonePart+"%",
|
|
).Scan(&name)
|
|
|
|
if err == nil && name != "" {
|
|
return name
|
|
}
|
|
|
|
return senderJID
|
|
}
|
|
|
|
func (store *MessageStore) FormatMessage(msg MessageInteraction, showChatInfo bool) string {
|
|
var sb strings.Builder
|
|
|
|
ts := msg.Timestamp.Format("2006-01-02 15:04:05")
|
|
|
|
if showChatInfo && msg.ChatName != "" {
|
|
sb.WriteString(fmt.Sprintf("[%s] Chat: %s ", ts, msg.ChatName))
|
|
} else {
|
|
sb.WriteString(fmt.Sprintf("[%s] ", ts))
|
|
}
|
|
|
|
prefix := ""
|
|
if msg.MediaType != "" {
|
|
prefix = fmt.Sprintf("[%s - Message ID: %s - Chat JID: %s] ", msg.MediaType, msg.ID, msg.ChatJID)
|
|
}
|
|
|
|
senderName := "Me"
|
|
if !msg.IsFromMe {
|
|
senderName = store.GetSenderName(msg.Sender)
|
|
}
|
|
|
|
sb.WriteString(fmt.Sprintf("From: %s: %s%s\n", senderName, prefix, msg.Content))
|
|
return sb.String()
|
|
}
|
|
|
|
func (store *MessageStore) FormatMessagesList(messages []MessageInteraction, showChatInfo bool) string {
|
|
if len(messages) == 0 {
|
|
return "No messages to display.\n"
|
|
}
|
|
var sb strings.Builder
|
|
for _, m := range messages {
|
|
sb.WriteString(store.FormatMessage(m, showChatInfo))
|
|
}
|
|
return sb.String()
|
|
}
|
|
|
|
func (store *MessageStore) ListMessages(s ListMessagesParams) (string, error) {
|
|
var args []any
|
|
var where []string
|
|
|
|
placeholder := func(n int) string {
|
|
if isPostgres {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
|
|
q := `
|
|
SELECT
|
|
m.timestamp, m.sender, c.name, m.content, m.is_from_me,
|
|
c.jid, m.id, m.media_type
|
|
FROM messages m
|
|
JOIN chats c ON m.chat_jid = c.jid
|
|
`
|
|
|
|
if s.After != "" {
|
|
t, err := time.Parse(time.RFC3339, s.After)
|
|
if err != nil {
|
|
return "", fmt.Errorf("invalid after format: %w", err)
|
|
}
|
|
where = append(where, "m.timestamp > "+placeholder(len(args)+1))
|
|
args = append(args, t)
|
|
}
|
|
|
|
if s.Before != "" {
|
|
t, err := time.Parse(time.RFC3339, s.Before)
|
|
if err != nil {
|
|
return "", fmt.Errorf("invalid before format: %w", err)
|
|
}
|
|
where = append(where, "m.timestamp < "+placeholder(len(args)+1))
|
|
args = append(args, t)
|
|
}
|
|
|
|
if s.SenderPhoneNumber != nil && *s.SenderPhoneNumber != "" {
|
|
where = append(where, "m.sender = "+placeholder(len(args)+1))
|
|
args = append(args, *s.SenderPhoneNumber)
|
|
}
|
|
|
|
if s.ChatJid != nil && *s.ChatJid != "" {
|
|
where = append(where, "m.chat_jid = "+placeholder(len(args)+1))
|
|
args = append(args, *s.ChatJid)
|
|
}
|
|
|
|
if s.Query != nil && *s.Query != "" {
|
|
where = append(where, "LOWER(m.content) LIKE LOWER("+placeholder(len(args)+1)+")")
|
|
args = append(args, "%"+*s.Query+"%")
|
|
}
|
|
|
|
if len(where) > 0 {
|
|
q += " WHERE " + strings.Join(where, " AND ")
|
|
}
|
|
|
|
q += " ORDER BY m.timestamp DESC"
|
|
q += " LIMIT " + placeholder(len(args)+1)
|
|
args = append(args, s.Limit)
|
|
|
|
q += " OFFSET " + placeholder(len(args)+1)
|
|
args = append(args, s.Page*s.Limit)
|
|
|
|
rows, err := store.db.Query(q, args...)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var msgs []MessageInteraction
|
|
for rows.Next() {
|
|
var (
|
|
ts time.Time
|
|
sender string
|
|
chatName sql.NullString
|
|
content string
|
|
isFromMe bool
|
|
cJid string
|
|
id string
|
|
mediaType sql.NullString
|
|
)
|
|
|
|
if err := rows.Scan(&ts, &sender, &chatName, &content, &isFromMe, &cJid, &id, &mediaType); err != nil {
|
|
log.Printf("scan error: %v", err)
|
|
continue
|
|
}
|
|
|
|
m := MessageInteraction{
|
|
Timestamp: ts,
|
|
Sender: sender,
|
|
Content: content,
|
|
IsFromMe: isFromMe,
|
|
ChatJID: cJid,
|
|
ID: id,
|
|
}
|
|
|
|
if chatName.Valid {
|
|
m.ChatName = chatName.String
|
|
}
|
|
if mediaType.Valid {
|
|
m.MediaType = mediaType.String
|
|
}
|
|
|
|
msgs = append(msgs, m)
|
|
}
|
|
|
|
if s.IncludeContext && len(msgs) > 0 {
|
|
var all []MessageInteraction
|
|
for _, m := range msgs {
|
|
ctx, err := store.GetMessageContext(m.ID, s.ContextBefore, s.ContextAfter)
|
|
if err != nil {
|
|
log.Printf("context error for %s: %v", m.ID, err)
|
|
continue
|
|
}
|
|
all = append(all, ctx.Before...)
|
|
all = append(all, ctx.Message)
|
|
all = append(all, ctx.After...)
|
|
}
|
|
return store.FormatMessagesList(all, true), nil
|
|
}
|
|
|
|
return store.FormatMessagesList(msgs, true), nil
|
|
}
|
|
|
|
func (store *MessageStore) GetMessageContext(messageID string, before, after int) (MessageContext, error) {
|
|
placeholder := func(n int) string {
|
|
if isPostgres {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
|
|
// --- Fetch the target message ---
|
|
q := `
|
|
SELECT m.timestamp, m.sender, c.name, m.content, m.is_from_me,
|
|
c.jid, m.id, m.media_type, m.chat_jid
|
|
FROM messages m
|
|
JOIN chats c ON m.chat_jid = c.jid
|
|
WHERE m.id = ` + placeholder(1)
|
|
|
|
var (
|
|
ts time.Time
|
|
sender string
|
|
chatName sql.NullString
|
|
content string
|
|
isFromMe bool
|
|
chatJid string
|
|
id string
|
|
media sql.NullString
|
|
chatJid2 string
|
|
)
|
|
|
|
row := store.db.QueryRow(q, messageID)
|
|
if err := row.Scan(&ts, &sender, &chatName, &content, &isFromMe, &chatJid, &id, &media, &chatJid2); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
return MessageContext{}, fmt.Errorf("message not found: %s", messageID)
|
|
}
|
|
return MessageContext{}, err
|
|
}
|
|
|
|
target := MessageInteraction{
|
|
Timestamp: ts,
|
|
Sender: sender,
|
|
Content: content,
|
|
IsFromMe: isFromMe,
|
|
ChatJID: chatJid,
|
|
ID: id,
|
|
}
|
|
if chatName.Valid {
|
|
target.ChatName = chatName.String
|
|
}
|
|
if media.Valid {
|
|
target.MediaType = media.String
|
|
}
|
|
|
|
qBefore := `
|
|
SELECT m.timestamp, m.sender, c.name, m.content, m.is_from_me,
|
|
c.jid, m.id, m.media_type
|
|
FROM messages m
|
|
JOIN chats c ON m.chat_jid = c.jid
|
|
WHERE m.chat_jid = ` + placeholder(1) + `
|
|
AND m.timestamp < ` + placeholder(2) + `
|
|
ORDER BY m.timestamp DESC
|
|
LIMIT ` + placeholder(3)
|
|
|
|
bRows, err := store.db.Query(qBefore, chatJid2, ts, before)
|
|
if err != nil {
|
|
return MessageContext{}, err
|
|
}
|
|
defer bRows.Close()
|
|
|
|
var beforeMsgs []MessageInteraction
|
|
for bRows.Next() {
|
|
var (
|
|
bts time.Time
|
|
bsender sql.NullString
|
|
bname sql.NullString
|
|
bcontent string
|
|
bif bool
|
|
bjid string
|
|
bid string
|
|
bmedia sql.NullString
|
|
)
|
|
|
|
if err := bRows.Scan(&bts, &bsender, &bname, &bcontent, &bif, &bjid, &bid, &bmedia); err != nil {
|
|
continue
|
|
}
|
|
|
|
m := MessageInteraction{
|
|
Timestamp: bts,
|
|
Sender: bsender.String,
|
|
Content: bcontent,
|
|
IsFromMe: bif,
|
|
ChatJID: bjid,
|
|
ID: bid,
|
|
}
|
|
if bname.Valid {
|
|
m.ChatName = bname.String
|
|
}
|
|
if bmedia.Valid {
|
|
m.MediaType = bmedia.String
|
|
}
|
|
beforeMsgs = append(beforeMsgs, m)
|
|
}
|
|
|
|
qAfter := `
|
|
SELECT m.timestamp, m.sender, c.name, m.content, m.is_from_me,
|
|
c.jid, m.id, m.media_type
|
|
FROM messages m
|
|
JOIN chats c ON m.chat_jid = c.jid
|
|
WHERE m.chat_jid = ` + placeholder(1) + `
|
|
AND m.timestamp > ` + placeholder(2) + `
|
|
ORDER BY m.timestamp ASC
|
|
LIMIT ` + placeholder(3)
|
|
|
|
aRows, err := store.db.Query(qAfter, chatJid2, ts, after)
|
|
if err != nil {
|
|
return MessageContext{}, err
|
|
}
|
|
defer aRows.Close()
|
|
|
|
var afterMsgs []MessageInteraction
|
|
for aRows.Next() {
|
|
var (
|
|
ats time.Time
|
|
asender sql.NullString
|
|
aname sql.NullString
|
|
acontent string
|
|
aif bool
|
|
ajid string
|
|
aid string
|
|
amedia sql.NullString
|
|
)
|
|
|
|
if err := aRows.Scan(&ats, &asender, &aname, &acontent, &aif, &ajid, &aid, &amedia); err != nil {
|
|
continue
|
|
}
|
|
|
|
m := MessageInteraction{
|
|
Timestamp: ats,
|
|
Sender: asender.String,
|
|
Content: acontent,
|
|
IsFromMe: aif,
|
|
ChatJID: ajid,
|
|
ID: aid,
|
|
}
|
|
if aname.Valid {
|
|
m.ChatName = aname.String
|
|
}
|
|
if amedia.Valid {
|
|
m.MediaType = amedia.String
|
|
}
|
|
afterMsgs = append(afterMsgs, m)
|
|
}
|
|
|
|
return MessageContext{
|
|
Message: target,
|
|
Before: beforeMsgs,
|
|
After: afterMsgs,
|
|
}, nil
|
|
}
|
|
|
|
func (store *MessageStore) ListChats(
|
|
query *string,
|
|
limit, page int,
|
|
includeLastMessage bool,
|
|
sortBy string,
|
|
) ([]Chat, error) {
|
|
|
|
placeholder := func(n int) string {
|
|
if isPostgres {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
|
|
q := `
|
|
SELECT
|
|
c.jid, c.name, c.last_message_time,
|
|
m.content AS last_message,
|
|
m.sender AS last_sender,
|
|
m.is_from_me AS last_is_from_me
|
|
FROM chats c
|
|
`
|
|
|
|
if includeLastMessage {
|
|
q += `
|
|
LEFT JOIN messages m
|
|
ON c.jid = m.chat_jid
|
|
AND c.last_message_time = m.timestamp
|
|
`
|
|
}
|
|
|
|
var args []any
|
|
var where []string
|
|
|
|
if query != nil && *query != "" {
|
|
if isPostgres {
|
|
where = append(where, "(LOWER(c.name) LIKE LOWER("+placeholder(len(args)+1)+") OR c.jid LIKE "+placeholder(len(args)+2)+")")
|
|
} else {
|
|
where = append(where, "(LOWER(c.name) LIKE LOWER(?) OR c.jid LIKE ?)")
|
|
}
|
|
args = append(args, "%"+*query+"%", "%"+*query+"%")
|
|
}
|
|
|
|
if len(where) > 0 {
|
|
q += " WHERE " + strings.Join(where, " AND ")
|
|
}
|
|
|
|
order := "c.last_message_time DESC"
|
|
if sortBy == "name" {
|
|
order = "c.name ASC"
|
|
}
|
|
q += " ORDER BY " + order
|
|
|
|
q += " LIMIT " + placeholder(len(args)+1) + "::int"
|
|
args = append(args, limit)
|
|
|
|
q += " OFFSET " + placeholder(len(args)+1) + "::int"
|
|
args = append(args, page*limit)
|
|
|
|
rows, err := store.db.Query(q, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var chats []Chat
|
|
for rows.Next() {
|
|
var (
|
|
jid string
|
|
name sql.NullString
|
|
lastMsgTime sql.NullTime
|
|
lastMsg sql.NullString
|
|
lastSender sql.NullString
|
|
lastFromMe sql.NullBool
|
|
)
|
|
|
|
if err := rows.Scan(&jid, &name, &lastMsgTime, &lastMsg, &lastSender, &lastFromMe); err != nil {
|
|
log.Printf("list_chats scan error: %v", err)
|
|
continue
|
|
}
|
|
|
|
c := Chat{JID: jid}
|
|
|
|
if name.Valid {
|
|
c.Name = name.String
|
|
}
|
|
if lastMsgTime.Valid {
|
|
c.LastMessageTime = lastMsgTime.Time
|
|
}
|
|
if lastMsg.Valid {
|
|
c.LastMessage = lastMsg.String
|
|
}
|
|
if lastSender.Valid {
|
|
c.LastSender = lastSender.String
|
|
}
|
|
if lastFromMe.Valid {
|
|
c.LastIsFromMe = lastFromMe.Bool
|
|
}
|
|
|
|
chats = append(chats, c)
|
|
}
|
|
|
|
return chats, nil
|
|
}
|
|
|
|
func (store *MessageStore) SearchContacts(query string) ([]Contact, error) {
|
|
placeholder := func(n int) string {
|
|
if isPostgres {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
|
|
q := `
|
|
SELECT DISTINCT their_jid, first_name
|
|
FROM whatsmeow_contacts
|
|
WHERE (LOWER(first_name) LIKE LOWER(` + placeholder(1) + `)
|
|
OR LOWER(their_jid) LIKE LOWER(` + placeholder(2) + `))
|
|
AND their_jid NOT LIKE '%@g.us'
|
|
ORDER BY first_name, their_jid
|
|
LIMIT 50
|
|
`
|
|
|
|
args := []any{"%" + query + "%", "%" + query + "%"}
|
|
|
|
rows, err := store.db.Query(q, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var contacts []Contact
|
|
|
|
for rows.Next() {
|
|
var jid, name sql.NullString
|
|
|
|
if err := rows.Scan(&jid, &name); err != nil {
|
|
continue
|
|
}
|
|
if !jid.Valid {
|
|
continue
|
|
}
|
|
|
|
phone := strings.Split(jid.String, "@")[0]
|
|
|
|
c := Contact{
|
|
PhoneNumber: phone,
|
|
JID: jid.String,
|
|
}
|
|
if name.Valid {
|
|
c.Name = name.String
|
|
}
|
|
|
|
contacts = append(contacts, c)
|
|
}
|
|
|
|
return contacts, nil
|
|
}
|
|
|
|
func (store *MessageStore) GetContactChats(jid string, limit, page int) ([]Chat, error) {
|
|
placeholder := func(n int) string {
|
|
if isPostgres {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
|
|
q := `
|
|
SELECT DISTINCT
|
|
c.jid, c.name, c.last_message_time,
|
|
m.content AS last_message,
|
|
m.sender AS last_sender,
|
|
m.is_from_me AS last_is_from_me
|
|
FROM chats c
|
|
JOIN messages m ON c.jid = m.chat_jid
|
|
WHERE m.sender = ` + placeholder(1) + `
|
|
OR c.jid = ` + placeholder(2) + `
|
|
ORDER BY c.last_message_time DESC
|
|
LIMIT ` + placeholder(3) + `
|
|
OFFSET ` + placeholder(4)
|
|
|
|
args := []any{jid, jid, limit, page * limit}
|
|
|
|
rows, err := store.db.Query(q, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var chats []Chat
|
|
|
|
for rows.Next() {
|
|
var (
|
|
cjid string
|
|
name sql.NullString
|
|
lmt sql.NullTime
|
|
lmsg sql.NullString
|
|
lsender sql.NullString
|
|
lfromme sql.NullBool
|
|
)
|
|
|
|
if err := rows.Scan(&cjid, &name, &lmt, &lmsg, &lsender, &lfromme); err != nil {
|
|
continue
|
|
}
|
|
|
|
c := Chat{JID: cjid}
|
|
|
|
if name.Valid {
|
|
c.Name = name.String
|
|
}
|
|
if lmt.Valid {
|
|
c.LastMessageTime = lmt.Time
|
|
}
|
|
if lmsg.Valid {
|
|
c.LastMessage = lmsg.String
|
|
}
|
|
if lsender.Valid {
|
|
c.LastSender = lsender.String
|
|
}
|
|
if lfromme.Valid {
|
|
c.LastIsFromMe = lfromme.Bool
|
|
}
|
|
|
|
chats = append(chats, c)
|
|
}
|
|
|
|
return chats, nil
|
|
}
|
|
|
|
func (store *MessageStore) GetLastInteraction(jid string) (string, error) {
|
|
placeholder := func(n int) string {
|
|
if isPostgres {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
|
|
q := `
|
|
SELECT
|
|
m.timestamp, m.sender, c.name, m.content, m.is_from_me,
|
|
c.jid, m.id, m.media_type
|
|
FROM messages m
|
|
JOIN chats c ON m.chat_jid = c.jid
|
|
WHERE m.sender = ` + placeholder(1) + `
|
|
OR c.jid = ` + placeholder(2) + `
|
|
ORDER BY m.timestamp DESC
|
|
LIMIT 1
|
|
`
|
|
|
|
row := store.db.QueryRow(q, jid, jid)
|
|
|
|
var (
|
|
ts time.Time
|
|
sender string
|
|
chatName sql.NullString
|
|
content string
|
|
isFromMe bool
|
|
chatJid string
|
|
id string
|
|
mediaType sql.NullString
|
|
)
|
|
|
|
if err := row.Scan(&ts, &sender, &chatName, &content, &isFromMe, &chatJid, &id, &mediaType); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
return "", nil
|
|
}
|
|
return "", err
|
|
}
|
|
|
|
msg := MessageInteraction{
|
|
Timestamp: ts,
|
|
Sender: sender,
|
|
Content: content,
|
|
IsFromMe: isFromMe,
|
|
ChatJID: chatJid,
|
|
ID: id,
|
|
}
|
|
|
|
if chatName.Valid {
|
|
msg.ChatName = chatName.String
|
|
}
|
|
if mediaType.Valid {
|
|
msg.MediaType = mediaType.String
|
|
}
|
|
|
|
return store.FormatMessage(msg, true), nil
|
|
}
|
|
|
|
func (store *MessageStore) GetChat(chatJID string, includeLastMessage bool) (*Chat, error) {
|
|
placeholder := func(n int) string {
|
|
if isPostgres {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
|
|
q := `
|
|
SELECT
|
|
c.jid, c.name, c.last_message_time,
|
|
m.content AS last_message,
|
|
m.sender AS last_sender,
|
|
m.is_from_me AS last_is_from_me
|
|
FROM chats c
|
|
`
|
|
|
|
if includeLastMessage {
|
|
q += `
|
|
LEFT JOIN messages m
|
|
ON c.jid = m.chat_jid
|
|
AND c.last_message_time = m.timestamp
|
|
`
|
|
}
|
|
|
|
q += " WHERE c.jid = " + placeholder(1)
|
|
|
|
row := store.db.QueryRow(q, chatJID)
|
|
|
|
var (
|
|
jid string
|
|
name sql.NullString
|
|
lmt sql.NullTime
|
|
lmsg sql.NullString
|
|
lsender sql.NullString
|
|
lfromme sql.NullBool
|
|
)
|
|
|
|
if err := row.Scan(&jid, &name, &lmt, &lmsg, &lsender, &lfromme); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
c := Chat{JID: jid}
|
|
|
|
if name.Valid {
|
|
c.Name = name.String
|
|
}
|
|
if lmt.Valid {
|
|
c.LastMessageTime = lmt.Time
|
|
}
|
|
if lmsg.Valid {
|
|
c.LastMessage = lmsg.String
|
|
}
|
|
if lsender.Valid {
|
|
c.LastSender = lsender.String
|
|
}
|
|
if lfromme.Valid {
|
|
c.LastIsFromMe = lfromme.Bool
|
|
}
|
|
|
|
return &c, nil
|
|
}
|
|
|
|
func (store *MessageStore) GetDirectChatByContact(phone string) (*Chat, error) {
|
|
placeholder := func(n int) string {
|
|
if isPostgres {
|
|
return fmt.Sprintf("$%d", n)
|
|
}
|
|
return "?"
|
|
}
|
|
|
|
q := `
|
|
SELECT
|
|
c.jid, c.name, c.last_message_time,
|
|
m.content AS last_message,
|
|
m.sender AS last_sender,
|
|
m.is_from_me AS last_is_from_me
|
|
FROM chats c
|
|
LEFT JOIN messages m
|
|
ON c.jid = m.chat_jid
|
|
AND c.last_message_time = m.timestamp
|
|
WHERE c.jid LIKE ` + placeholder(1) + `
|
|
AND c.jid NOT LIKE '%@g.us'
|
|
LIMIT 1
|
|
`
|
|
|
|
arg := "%" + phone + "%"
|
|
|
|
row := store.db.QueryRow(q, arg)
|
|
|
|
var (
|
|
jid string
|
|
name sql.NullString
|
|
lmt sql.NullTime
|
|
lmsg sql.NullString
|
|
lsender sql.NullString
|
|
lfromme sql.NullBool
|
|
)
|
|
|
|
if err := row.Scan(&jid, &name, &lmt, &lmsg, &lsender, &lfromme); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Chat{
|
|
JID: jid,
|
|
Name: name.String,
|
|
LastMessageTime: lmt.Time,
|
|
LastMessage: lmsg.String,
|
|
LastSender: lsender.String,
|
|
LastIsFromMe: lfromme.Bool,
|
|
}, nil
|
|
}
|
|
|
|
func main() {
|
|
logger := waLog.Stdout("Client", "INFO", true)
|
|
logger.Infof("Starting WhatsApp client...")
|
|
|
|
dbLog := waLog.Stdout("Database", "INFO", true)
|
|
|
|
if err := os.MkdirAll("store", 0755); err != nil {
|
|
logger.Errorf("Failed to create store directory: %v", err)
|
|
return
|
|
}
|
|
|
|
slog.SetDefault(bridgelogger.New(os.Getenv("LOG_LEVEL")))
|
|
|
|
cfg, err := config.LoadConfig()
|
|
if err != nil {
|
|
logger.Errorf("Failed to load config: %v", err)
|
|
return
|
|
}
|
|
|
|
dialect := "sqlite3"
|
|
connStr := "file:store/whatsapp.db?_foreign_keys=on"
|
|
|
|
if cfg.DB.IsPostgres {
|
|
dialect = "postgres"
|
|
connStr = fmt.Sprintf("postgresql://%s:%s@%s:%s/%s?sslmode=disable", cfg.DB.User,
|
|
cfg.DB.Pass, cfg.DB.Host, cfg.DB.Port, "whatsapp")
|
|
}
|
|
|
|
container, err := sqlstore.New(context.Background(), dialect, connStr, dbLog)
|
|
if err != nil {
|
|
logger.Errorf("Failed to connect to database: %v", err)
|
|
return
|
|
}
|
|
|
|
deviceStore, err := container.GetFirstDevice(context.Background())
|
|
if err != nil {
|
|
if err == sql.ErrNoRows {
|
|
deviceStore = container.NewDevice()
|
|
logger.Infof("Created new device")
|
|
} else {
|
|
logger.Errorf("Failed to get device: %v", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
state := wastate.New()
|
|
|
|
version, err := CustomGetLatestVersion(context.Background(), nil)
|
|
if err != nil {
|
|
logger.Errorf("Failed to retrieve current WhatsApp Web client Version")
|
|
} else {
|
|
store.SetWAVersion(*version)
|
|
state.SetWAVersion(fmt.Sprintf("%d.%d.%d", version[0], version[1], version[2]))
|
|
logger.Infof("WhatsApp Web Client Version: %d.%d.%d\n", version[0], version[1], version[2])
|
|
}
|
|
client := whatsmeow.NewClient(deviceStore, logger)
|
|
if client == nil {
|
|
logger.Errorf("Failed to create WhatsApp client")
|
|
return
|
|
}
|
|
|
|
store.SetOSInfo("Linux", store.GetWAVersion())
|
|
store.DeviceProps.PlatformType = waCompanionReg.DeviceProps_CHROME.Enum()
|
|
|
|
messageStore, err := NewMessageStore()
|
|
if err != nil {
|
|
logger.Errorf("Failed to initialize message store: %v", err)
|
|
return
|
|
}
|
|
defer messageStore.Close()
|
|
|
|
state.SetLoggedIn(client.Store.ID != nil) // existing session means already logged in
|
|
|
|
const maxOutdatedRetries = 3
|
|
var outdatedRetries int
|
|
var outdatedRetriesMu sync.Mutex
|
|
|
|
client.AddEventHandler(func(evt interface{}) {
|
|
switch v := evt.(type) {
|
|
case *events.Message:
|
|
handleMessage(client, messageStore, v, logger)
|
|
|
|
case *events.HistorySync:
|
|
handleHistorySync(client, messageStore, v, logger)
|
|
|
|
case *events.Connected:
|
|
logger.Infof("Connected to WhatsApp")
|
|
state.SetConnected(true)
|
|
state.SetLoggedIn(true)
|
|
state.ClearPairingQR()
|
|
outdatedRetriesMu.Lock()
|
|
outdatedRetries = 0
|
|
outdatedRetriesMu.Unlock()
|
|
|
|
case *events.Disconnected:
|
|
logger.Warnf("Disconnected from WhatsApp")
|
|
state.SetConnected(false)
|
|
|
|
case *events.LoggedOut:
|
|
logger.Warnf("Device logged out, please scan QR code to log in again")
|
|
state.SetLoggedIn(false)
|
|
state.SetConnected(false)
|
|
|
|
case *events.ClientOutdated:
|
|
outdatedRetriesMu.Lock()
|
|
outdatedRetries++
|
|
n := outdatedRetries
|
|
outdatedRetriesMu.Unlock()
|
|
state.SetConnected(false)
|
|
if n > maxOutdatedRetries {
|
|
slog.Error("client outdated: exceeded retry budget; whatsmeow library likely needs a real upgrade",
|
|
"retries", n, "max", maxOutdatedRetries)
|
|
return
|
|
}
|
|
slog.Warn("client outdated (405); refreshing wa version and reconnecting",
|
|
"attempt", n, "max", maxOutdatedRetries)
|
|
go func() {
|
|
time.Sleep(5 * time.Second)
|
|
newVersion, err := CustomGetLatestVersion(context.Background(), nil)
|
|
if err != nil {
|
|
slog.Error("failed to refresh wa version", "err", err)
|
|
return
|
|
}
|
|
store.SetWAVersion(*newVersion)
|
|
state.SetWAVersion(fmt.Sprintf("%d.%d.%d", newVersion[0], newVersion[1], newVersion[2]))
|
|
slog.Info("applied refreshed wa version, attempting reconnect", "version", state.WAVersion())
|
|
if err := client.Connect(); err != nil {
|
|
slog.Error("reconnect after wa version refresh failed", "err", err)
|
|
}
|
|
}()
|
|
}
|
|
})
|
|
|
|
migrateLIDChatsToPhoneJIDs(client, messageStore, logger, cfg.DB.IsPostgres)
|
|
|
|
// REST server comes up first so /api/auth/status and /api/auth/pairing-qr
|
|
// are reachable during pairing. WhatsApp connect runs concurrently below.
|
|
startRESTServer(client, messageStore, cfg, state)
|
|
|
|
// Periodically refresh the WhatsApp Web client version so reconnects
|
|
// after transient drops use a current version string. Only the next
|
|
// connection picks up the refreshed value; the active session is unaffected.
|
|
go func() {
|
|
t := time.NewTicker(6 * time.Hour)
|
|
defer t.Stop()
|
|
for range t.C {
|
|
v, err := CustomGetLatestVersion(context.Background(), nil)
|
|
if err != nil {
|
|
slog.Warn("periodic wa version refresh failed", "err", err)
|
|
continue
|
|
}
|
|
store.SetWAVersion(*v)
|
|
next := fmt.Sprintf("%d.%d.%d", v[0], v[1], v[2])
|
|
if next != state.WAVersion() {
|
|
slog.Info("wa version updated by periodic refresh", "from", state.WAVersion(), "to", next)
|
|
state.SetWAVersion(next)
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Pair / connect to WhatsApp in a goroutine so main can block on signals.
|
|
go func() {
|
|
if client.Store.ID == nil {
|
|
qrChan, _ := client.GetQRChannel(context.Background())
|
|
if err := client.Connect(); err != nil {
|
|
logger.Errorf("Failed to connect: %v", err)
|
|
return
|
|
}
|
|
for evt := range qrChan {
|
|
switch evt.Event {
|
|
case "code":
|
|
fmt.Println("\nScan this QR code with your WhatsApp app:")
|
|
qrterminal.GenerateHalfBlock(evt.Code, qrterminal.L, os.Stdout)
|
|
if png, err := qrcode.Encode(evt.Code, qrcode.Medium, 256); err == nil {
|
|
state.SetPairingQRPNG(png)
|
|
} else {
|
|
slog.Warn("failed to encode pairing qr as png", "err", err)
|
|
}
|
|
case "success":
|
|
fmt.Println("\nSuccessfully connected and authenticated!")
|
|
return
|
|
case "timeout":
|
|
logger.Errorf("Pairing QR timeout")
|
|
return
|
|
}
|
|
}
|
|
} else {
|
|
if err := client.Connect(); err != nil {
|
|
logger.Errorf("Failed to connect: %v", err)
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
exitChan := make(chan os.Signal, 1)
|
|
signal.Notify(exitChan, syscall.SIGINT, syscall.SIGTERM)
|
|
|
|
fmt.Println("REST server is running. Press Ctrl+C to disconnect and exit.")
|
|
|
|
<-exitChan
|
|
|
|
fmt.Println("Disconnecting...")
|
|
client.Disconnect()
|
|
}
|