GOWA - WhatsApp REST API with support for UI, Multi Account, Webhooks, and MCP, and Chatwoot. Built with Golang for efficient memory use.
Go botgogolanggolang-whatsappgolang-whatsapp-apirestrest-apiwhatsappwhatsapp-apiwhatsapp-api-gowhatsapp-multi-devicewhatsapp-web-multi-device
package usecase
import (
"context"
"fmt"
"os"
"path/filepath"
"strings"
"time"
"unicode"
"unicode/utf8"
"github.com/aldinokemal/go-whatsapp-web-multidevice/config"
domainChatStorage "github.com/aldinokemal/go-whatsapp-web-multidevice/domains/chatstorage"
domainMessage "github.com/aldinokemal/go-whatsapp-web-multidevice/domains/message"
"github.com/aldinokemal/go-whatsapp-web-multidevice/infrastructure/whatsapp"
pkgError "github.com/aldinokemal/go-whatsapp-web-multidevice/pkg/error"
"github.com/aldinokemal/go-whatsapp-web-multidevice/pkg/utils"
"github.com/aldinokemal/go-whatsapp-web-multidevice/validations"
"github.com/sirupsen/logrus"
"go.mau.fi/whatsmeow"
"go.mau.fi/whatsmeow/appstate"
"go.mau.fi/whatsmeow/proto/waCommon"
"go.mau.fi/whatsmeow/proto/waE2E"
"go.mau.fi/whatsmeow/proto/waSyncAction"
"go.mau.fi/whatsmeow/types"
"go.mau.fi/whatsmeow/types/events"
"google.golang.org/protobuf/proto"
)
type markReadFunc func(context.Context, *whatsmeow.Client, []types.MessageID, time.Time, types.JID, types.JID, ...types.ReceiptType) error
type serviceMessage struct {
chatStorageRepo domainChatStorage.IChatStorageRepository
validateJIDFn func(client *whatsmeow.Client, jid string) (types.JID, error)
markReadFn markReadFunc
sendMessageFn func(ctx context.Context, client *whatsmeow.Client, recipient types.JID, message *waE2E.Message) (whatsmeow.SendResponse, error)
sendAppStateFn func(ctx context.Context, client *whatsmeow.Client, patch appstate.PatchInfo) error
}
func NewMessageService(chatStorageRepo domainChatStorage.IChatStorageRepository) domainMessage.IMessageUsecase {
return &serviceMessage{
chatStorageRepo: chatStorageRepo,
}
}
func (service serviceMessage) validateJID(client *whatsmeow.Client, jid string) (types.JID, error) {
if service.validateJIDFn != nil {
return service.validateJIDFn(client, jid)
}
return utils.ValidateJidWithLogin(client, jid)
}
func (service serviceMessage) sendMessage(ctx context.Context, client *whatsmeow.Client, recipient types.JID, message *waE2E.Message) (whatsmeow.SendResponse, error) {
if service.sendMessageFn != nil {
return service.sendMessageFn(ctx, client, recipient, message)
}
return client.SendMessage(ctx, recipient, message)
}
func (service serviceMessage) markRead(ctx context.Context, client *whatsmeow.Client, ids []types.MessageID, timestamp time.Time, chat, sender types.JID, receiptTypeExtra ...types.ReceiptType) error {
if service.markReadFn != nil {
return service.markReadFn(ctx, client, ids, timestamp, chat, sender, receiptTypeExtra...)
}
return client.MarkRead(ctx, ids, timestamp, chat, sender, receiptTypeExtra...)
}
func (service serviceMessage) sendAppState(ctx context.Context, client *whatsmeow.Client, patch appstate.PatchInfo) error {
if service.sendAppStateFn != nil {
return service.sendAppStateFn(ctx, client, patch)
}
return client.SendAppState(ctx, patch)
}
func (service serviceMessage) deleteStoredMessage(ctx context.Context, client *whatsmeow.Client, messageID, chatJID string) error {
deviceID := deviceIDFromContext(ctx)
if deviceID == "" && client != nil && client.Store != nil && client.Store.ID != nil {
deviceID = client.Store.ID.ToNonAD().String()
}
if deviceID == "" {
return fmt.Errorf("WhatsApp action succeeded, but local message %s could not be deleted without a device ID", messageID)
}
if service.chatStorageRepo == nil {
return fmt.Errorf("WhatsApp action succeeded, but local message %s could not be deleted without chat storage", messageID)
}
if err := service.chatStorageRepo.DeleteMessageByDevice(deviceID, messageID, chatJID); err != nil {
return fmt.Errorf("WhatsApp action succeeded, but failed to delete local message %s: %w", messageID, err)
}
return nil
}
// storedMessageForAction loads the calling device's own copy of a message in
// one chat. Each device stores its own row for a message, and the rows differ:
// the sender's copy is "from me", a recipient's is not, and only a device that
// received the message holds its media keys. A lookup by ID alone can return
// another device's row, so it must never back a user-facing action.
func (service serviceMessage) storedMessageForAction(ctx context.Context, chatJID types.JID, messageID string) (*domainChatStorage.Message, error) {
if service.chatStorageRepo == nil {
return nil, nil
}
deviceID := storageDeviceID(ctx)
if deviceID == "" {
return nil, fmt.Errorf("device identification required")
}
return service.chatStorageRepo.GetMessageByIDChatAndDevice(deviceID, chatJID.ToNonAD().String(), messageID)
}
func isGroupReadSenderServer(server string) bool {
switch server {
case types.DefaultUserServer, types.HiddenUserServer, types.LegacyUserServer, types.MessengerServer:
return true
default:
return false
}
}
func normalizeGroupReadSender(ctx context.Context, client *whatsmeow.Client, rawSender string, messageID string) (types.JID, error) {
if rawSender == "" {
return types.JID{}, fmt.Errorf("sender is missing for group message %s", messageID)
}
senderJID, err := utils.ParseJID(rawSender)
if err != nil {
return types.JID{}, fmt.Errorf("failed to parse sender for message %s: %w", messageID, err)
}
senderJID = senderJID.ToNonAD()
if senderJID.Server == types.HiddenUserServer {
senderJID = utils.ResolveLIDToPhone(ctx, senderJID, client).ToNonAD()
}
if senderJID.User == "" || !isGroupReadSenderServer(senderJID.Server) {
return types.JID{}, fmt.Errorf("invalid sender JID %s for group message %s", senderJID.String(), messageID)
}
return senderJID, nil
}
func (service serviceMessage) MarkAsRead(ctx context.Context, request domainMessage.MarkAsReadRequest) (response domainMessage.GenericResponse, err error) {
if err = validations.ValidateMarkAsRead(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
chatJID, err := service.validateJID(client, request.Phone)
if err != nil {
return response, err
}
senderJID := client.Store.ID.ToNonAD()
if chatJID.Server == types.GroupServer {
if service.chatStorageRepo == nil {
return response, fmt.Errorf("cannot mark message %s as read without chat storage", request.MessageID)
}
message, lookupErr := service.chatStorageRepo.GetMessageByIDChatAndDevice(
deviceIDFromContext(ctx),
chatJID.ToNonAD().String(),
request.MessageID,
)
if lookupErr != nil {
return response, fmt.Errorf("failed to resolve message %s: %w", request.MessageID, lookupErr)
}
if message == nil {
return response, fmt.Errorf(
"message with ID %s not found for current device and chat %s",
request.MessageID,
chatJID.ToNonAD().String(),
)
}
if !message.IsFromMe {
senderJID, err = normalizeGroupReadSender(ctx, client, message.Sender, request.MessageID)
if err != nil {
return response, err
}
}
}
ids := []types.MessageID{request.MessageID}
if err = service.markRead(ctx, client, ids, time.Now(), chatJID, senderJID); err != nil {
return response, err
}
logrus.Info(map[string]any{
"phone": request.Phone,
"message_id": request.MessageID,
"chat": chatJID.String(),
"sender": senderJID.String(),
})
response.MessageID = request.MessageID
response.Status = fmt.Sprintf("Mark as read success %s", request.MessageID)
return response, nil
}
func (service serviceMessage) MarkAsPlayed(ctx context.Context, request domainMessage.MarkAsPlayedRequest) (response domainMessage.GenericResponse, err error) {
if err = validations.ValidateMarkAsRead(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
chatJID, err := service.validateJID(client, request.Phone)
if err != nil {
return response, err
}
if service.chatStorageRepo == nil {
return response, fmt.Errorf("cannot mark message %s as played without chat storage", request.MessageID)
}
message, err := service.chatStorageRepo.GetMessageByIDAndDevice(deviceIDFromContext(ctx), request.MessageID)
if err != nil {
return response, fmt.Errorf("failed to resolve message %s: %w", request.MessageID, err)
}
if message == nil {
return response, fmt.Errorf("message with ID %s not found for current device", request.MessageID)
}
storedChatJID, err := utils.ParseJID(message.ChatJID)
if err != nil {
return response, fmt.Errorf("failed to parse chat for message %s: %w", request.MessageID, err)
}
if storedChatJID.ToNonAD().String() != chatJID.ToNonAD().String() {
return response, pkgError.ValidationError(fmt.Sprintf("message %s does not belong to chat %s", request.MessageID, chatJID.ToNonAD().String()))
}
if message.MediaType != "audio" && message.MediaType != "ptt" {
return response, pkgError.ValidationError(fmt.Sprintf("message %s is not an audio message", request.MessageID))
}
if message.IsFromMe {
return response, pkgError.ValidationError(fmt.Sprintf("message %s is not an incoming message", request.MessageID))
}
senderJID, err := utils.ParseJID(message.Sender)
if err != nil {
return response, fmt.Errorf("failed to parse sender for message %s: %w", request.MessageID, err)
}
if chatJID.Server == types.GroupServer && senderJID.User == "" {
return response, fmt.Errorf("sender is missing for group message %s", request.MessageID)
}
if err = service.markRead(
ctx,
client,
[]types.MessageID{request.MessageID},
time.Now(),
chatJID,
senderJID,
types.ReceiptTypePlayed,
); err != nil {
return response, err
}
logrus.Info(map[string]any{
"phone": request.Phone,
"message_id": request.MessageID,
"chat": chatJID.String(),
"sender": senderJID.String(),
"receipt_type": types.ReceiptTypePlayed,
})
response.MessageID = request.MessageID
response.Status = fmt.Sprintf("Mark as played success %s", request.MessageID)
return response, nil
}
func (service serviceMessage) ReactMessage(ctx context.Context, request domainMessage.ReactionRequest) (response domainMessage.GenericResponse, err error) {
if err = validations.ValidateReactMessage(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
dataWaRecipient, err := service.validateJID(client, request.Phone)
if err != nil {
return response, err
}
// Determine the sender of the original message for BuildReaction.
// BuildReaction uses BuildMessageKey internally, which correctly sets the
// Participant field for group chats — required by the WhatsApp protocol.
// An empty JID means "message was from me".
senderJID := types.EmptyJID
// IsFromMe is relative to the receiving device, so another device's copy
// of the same message cannot determine the reaction's sender.
message, err := service.chatStorageRepo.GetMessageByIDChatAndDevice(
deviceIDFromContext(ctx),
dataWaRecipient.ToNonAD().String(),
request.MessageID,
)
if err != nil {
logrus.Warnf("Failed to lookup message %s for reaction: %v, using heuristic", request.MessageID, err)
if len(request.MessageID) > 22 {
if dataWaRecipient.Server == types.GroupServer {
logrus.Warnf("Cannot determine original sender for group reaction to %s — reaction may not be delivered", request.MessageID)
}
}
} else if message != nil {
if !message.IsFromMe && message.Sender != "" {
parsed, parseErr := utils.ParseJID(message.Sender)
if parseErr == nil {
senderJID = parsed
} else {
logrus.Warnf("Failed to parse sender JID '%s' for reaction: %v", message.Sender, parseErr)
}
}
} else {
logrus.Debugf("Message %s not found in database, assuming sent by me", request.MessageID)
}
// BuildReaction correctly constructs the MessageKey with Participant field
// for group chats, which is required for the reaction to be delivered.
msg := client.BuildReaction(dataWaRecipient, senderJID, request.MessageID, request.Emoji)
ts, err := service.sendMessage(ctx, client, dataWaRecipient, msg)
if err != nil {
return response, err
}
response.MessageID = ts.ID
response.Status = fmt.Sprintf("Reaction sent to %s (server timestamp: %s)", request.Phone, ts.Timestamp)
return response, nil
}
func (service serviceMessage) RevokeMessage(ctx context.Context, request domainMessage.RevokeRequest) (response domainMessage.GenericResponse, err error) {
if err = validations.ValidateRevokeMessage(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
dataWaRecipient, err := service.validateJID(client, request.Phone)
if err != nil {
return response, err
}
// Resolve the original sender so group admins can revoke other members'
// messages. BuildRevoke treats types.EmptyJID as "message was from me";
// any other JID is admin-revoke and requires the bot to be group admin.
// IsFromMe belongs to a device's copy of the message, so resolve it
// within the current device and chat before choosing self- or admin-revoke.
senderJID := types.EmptyJID
message, lookupErr := service.chatStorageRepo.GetMessageByIDChatAndDevice(
deviceIDFromContext(ctx),
dataWaRecipient.ToNonAD().String(),
request.MessageID,
)
if lookupErr != nil {
logrus.Warnf("Failed to lookup message %s for revoke: %v, assuming self-revoke", request.MessageID, lookupErr)
} else if message != nil && !message.IsFromMe && message.Sender != "" {
parsed, parseErr := utils.ParseJID(message.Sender)
if parseErr != nil {
logrus.Warnf("Failed to parse sender JID '%s' for revoke: %v", message.Sender, parseErr)
} else {
// Stored senders can still be @lid; whatsmeow's Revoke needs
// the phone-number form or it rejects the request at the wire.
senderJID = whatsapp.NormalizeJIDFromLID(ctx, parsed, client)
}
}
ts, err := service.sendMessage(ctx, client, dataWaRecipient, client.BuildRevoke(dataWaRecipient, senderJID, request.MessageID))
if err != nil {
return response, err
}
if err := service.deleteStoredMessage(ctx, client, request.MessageID, dataWaRecipient.ToNonAD().String()); err != nil {
return response, err
}
response.MessageID = ts.ID
response.Status = fmt.Sprintf("Revoke success %s (server timestamp: %s)", request.Phone, ts.Timestamp)
return response, nil
}
func (service serviceMessage) DeleteMessage(ctx context.Context, request domainMessage.DeleteRequest) (err error) {
if err = validations.ValidateDeleteMessage(ctx, request); err != nil {
return err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return pkgError.ErrWaCLI
}
dataWaRecipient, err := service.validateJID(client, request.Phone)
if err != nil {
return err
}
isFromMe := "1"
if len(request.MessageID) > 22 {
isFromMe = "0"
}
patchInfo := appstate.PatchInfo{
Timestamp: time.Now(),
Type: appstate.WAPatchRegularHigh,
Mutations: []appstate.MutationInfo{{
Index: []string{appstate.IndexDeleteMessageForMe, dataWaRecipient.String(), request.MessageID, isFromMe, client.Store.ID.String()},
Value: &waSyncAction.SyncActionValue{
DeleteMessageForMeAction: &waSyncAction.DeleteMessageForMeAction{
DeleteMedia: proto.Bool(true),
MessageTimestamp: proto.Int64(time.Now().UnixMilli()),
},
},
}},
}
if err = service.sendAppState(ctx, client, patchInfo); err != nil {
return err
}
return service.deleteStoredMessage(ctx, client, request.MessageID, dataWaRecipient.ToNonAD().String())
}
// updateStoredMessage mirrors an edit sent through the API into local chat
// storage, the same way deleteStoredMessage does for a revoke or delete.
//
// An edit that ARRIVES from another device is already applied: CreateMessage
// spots the MESSAGE_EDIT protocol message and calls storeEditedMessage. An edit
// we send ourselves is never echoed back to us, so nothing applied it, and the
// stored copy keeps the text as first sent — indefinitely.
//
// That matters beyond the chat viewer, because mergeReplyContext builds a
// reply's quoted context from the stored copy. Quoting a message that was edited
// therefore sends the recipient the PRE-EDIT text, so the quote can show wording
// the message no longer contains.
//
// The edit is replayed in the ProtocolMessage shape CreateMessage already
// recognises, so it runs through the existing, tested edit path (content update
// plus a message_edits history row) rather than a second implementation that
// could drift from it.
//
// This is an adapter for local storage, not a claim of equivalence with a
// dispatched event. whatsmeow's ParseWebMessage unwraps MESSAGE_EDIT before a
// history-synced edit is handled (Info.ID becomes the target id and Message
// becomes the edited content); only the live receive path leaves the
// ProtocolMessage intact.
func (service serviceMessage) updateStoredMessage(
ctx context.Context,
client *whatsmeow.Client,
messageID string,
recipient types.JID,
newContent string,
editEventID string,
editedAt time.Time,
) error {
if service.chatStorageRepo == nil {
return fmt.Errorf("WhatsApp action succeeded, but local message %s could not be updated without chat storage", messageID)
}
senderJID := types.EmptyJID
if client != nil && client.Store != nil && client.Store.ID != nil {
senderJID = *client.Store.ID
}
evt := &events.Message{
Info: types.MessageInfo{
MessageSource: types.MessageSource{
Chat: recipient,
Sender: senderJID,
IsFromMe: true,
},
ID: editEventID,
Timestamp: editedAt,
},
Message: &waE2E.Message{
ProtocolMessage: &waE2E.ProtocolMessage{
Type: waE2E.ProtocolMessage_MESSAGE_EDIT.Enum(),
Key: &waCommon.MessageKey{
ID: proto.String(messageID),
RemoteJID: proto.String(recipient.String()),
FromMe: proto.Bool(true),
},
EditedMessage: &waE2E.Message{Conversation: proto.String(newContent)},
},
},
}
if err := service.chatStorageRepo.CreateMessage(ctx, evt); err != nil {
return fmt.Errorf("WhatsApp action succeeded, but failed to update local message %s: %w", messageID, err)
}
return nil
}
func (service serviceMessage) UpdateMessage(ctx context.Context, request domainMessage.UpdateMessageRequest) (response domainMessage.GenericResponse, err error) {
if err = validations.ValidateUpdateMessage(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
dataWaRecipient, err := service.validateJID(client, request.Phone)
if err != nil {
return response, err
}
text := request.Message
msg := &waE2E.Message{Conversation: proto.String(text)}
if link := strings.TrimSpace(request.Link); link != "" {
if !containsLinkToken(text, link) {
text = buildLinkMessageText(text, link)
}
msg, err = buildLinkPreviewMessage(ctx, client, dataWaRecipient, text, link)
if err != nil {
return response, err
}
}
ts, err := service.sendMessage(ctx, client, dataWaRecipient, client.BuildEdit(dataWaRecipient, request.MessageID, msg))
if err != nil {
return response, err
}
if err := service.updateStoredMessage(ctx, client, request.MessageID, dataWaRecipient.ToNonAD(), text, ts.ID, ts.Timestamp); err != nil {
return response, err
}
response.MessageID = ts.ID
response.Status = fmt.Sprintf("Update message success %s (server timestamp: %s)", request.Phone, ts.Timestamp)
return response, nil
}
// containsLinkToken reports whether link already appears in text as a complete
// URL. The match must start at the beginning of text, after whitespace, or after
// an opening bracket or quote that does not continue another URL token, and must
// end at the end of text, at whitespace, or at trailing punctuation followed by
// the end of text or whitespace. Prose and markdown such as
// "Visit (https://example.com)." or "[label](https://example.com)" count as
// present; https://example.com.evil and https://evil.test/(https://example.com)
// do not. This accepts prose such as "Visit (https://example.com)." while a
// longer URL that merely starts with link (https://example.com.evil) does not
// count as present.
func containsLinkToken(text, link string) bool {
if link == "" {
return false
}
for offset := 0; ; {
idx := strings.Index(text[offset:], link)
if idx < 0 {
return false
}
start := offset + idx
end := start + len(link)
if linkStartsAtBoundary(text, start) && linkEndsAtBoundary(text, end) {
return true
}
offset = start + 1
}
}
func linkStartsAtBoundary(text string, start int) bool {
prefix := text[:start]
if prefix == "" {
return true
}
r, _ := utf8.DecodeLastRuneInString(prefix)
if unicode.IsSpace(r) {
return true
}
before := strings.TrimRight(prefix, "([{<\"'“‘")
if before == prefix {
// Directly attached to other text (e.g. "?u=" in a query string).
return false
}
// Wrapped in an opening bracket or quote: accept prose and markdown such as
// "See(link)" or "[label](link)", but not a wrapper that continues another
// URL token such as "https://evil.test/(link)".
fields := strings.Fields(before)
if len(fields) == 0 || unicode.IsSpace(lastRune(before)) {
return true
}
return !strings.Contains(fields[len(fields)-1], "://")
}
func lastRune(s string) rune {
r, _ := utf8.DecodeLastRuneInString(s)
return r
}
func linkEndsAtBoundary(text string, end int) bool {
rest := strings.TrimLeft(text[end:], ".,;:!?)]}>\"'”’")
if rest == "" {
return true
}
r, _ := utf8.DecodeRuneInString(rest)
return unicode.IsSpace(r)
}
// StarMessage implements message.IMessageService.
func (service serviceMessage) StarMessage(ctx context.Context, request domainMessage.StarRequest) (err error) {
if err = validations.ValidateStarMessage(ctx, request); err != nil {
return err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return pkgError.ErrWaCLI
}
dataWaRecipient, err := utils.ValidateJidWithLogin(client, request.Phone)
if err != nil {
return err
}
isFromMe := true
if len(request.MessageID) > 22 {
isFromMe = false
}
patchInfo := appstate.BuildStar(dataWaRecipient.ToNonAD(), *client.Store.ID, request.MessageID, isFromMe, request.IsStarred)
if err = client.SendAppState(ctx, patchInfo); err != nil {
return err
}
return nil
}
// DownloadMedia implements message.IMessageService.
func (service serviceMessage) DownloadMedia(ctx context.Context, request domainMessage.DownloadMediaRequest) (response domainMessage.DownloadMediaResponse, err error) {
if err = validations.ValidateDownloadMedia(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
dataWaRecipient, err := service.validateJID(client, request.Phone)
if err != nil {
return response, err
}
// Query the message from chat storage. The row holds the media keys, so
// it must be this device's own copy in the requested chat: a message that
// only another device received is "not found" here.
if service.chatStorageRepo == nil {
return response, fmt.Errorf("cannot download media for message %s without chat storage", request.MessageID)
}
message, err := service.storedMessageForAction(ctx, dataWaRecipient, request.MessageID)
if err != nil {
return response, fmt.Errorf("message not found: %v", err)
}
if message == nil {
return response, fmt.Errorf("message with ID %s not found in chat %s for current device", request.MessageID, dataWaRecipient.String())
}
directPath := utils.ResolveMediaDirectPath(message.DirectPath, message.URL)
// Check if message has media
if message.MediaType == "" || directPath == "" {
return response, fmt.Errorf("message %s does not contain downloadable media", request.MessageID)
}
// Create directory structure for organized storage
chatDir := filepath.Join(config.PathMedia, utils.ExtractPhoneNumber(message.ChatJID))
dateDir := filepath.Join(chatDir, message.Timestamp.Format("2006-01-02"))
err = os.MkdirAll(dateDir, 0755)
if err != nil {
return response, fmt.Errorf("failed to create directory: %v", err)
}
downloadableMsg, err := utils.BuildDownloadableMessage(
message.MediaType,
message.URL,
directPath,
message.Filename,
message.MediaKey,
message.FileSHA256,
message.FileEncSHA256,
message.FileLength,
)
if err != nil {
return response, fmt.Errorf("unsupported media type: %s", message.MediaType)
}
// Download the media using existing utils.ExtractMedia function
extractedMedia, err := utils.ExtractMedia(ctx, client, dateDir, downloadableMsg)
if err != nil {
return response, fmt.Errorf("failed to download media: %v", err)
}
// Get file size
fileInfo, err := os.Stat(extractedMedia.MediaPath)
if err != nil {
logrus.Warnf("Could not get file size for %s: %v", extractedMedia.MediaPath, err)
}
// Build response
response.MessageID = request.MessageID
response.Status = fmt.Sprintf("Media downloaded successfully to %s", extractedMedia.MediaPath)
response.MediaType = message.MediaType
response.Filename = filepath.Base(extractedMedia.MediaPath)
response.FilePath = extractedMedia.MediaPath
if fileInfo != nil {
response.FileSize = fileInfo.Size()
}
logrus.Info(map[string]any{
"message_id": request.MessageID,
"phone": request.Phone,
"chat": dataWaRecipient.String(),
"media_type": response.MediaType,
"file_path": response.FilePath,
"file_size": response.FileSize,
})
return response, nil
}