feat: add on-demand media download API and auto-download UI (#398)

- Add DownloadMedia API endpoint (GET /message/:id/download)
- Implement media download with organized storage by chat/date
- Support all media types: image, video, audio, document, sticker
- Add auto-download functionality to ChatMessages UI component
- Display actual media content instead of "Media Available" labels
- Include loading states, error handling, and retry functionality
- Implement concurrency control for batch downloads (max 3 concurrent)

Author: aldinokemal

src/domains/message/interfaces.go

@@ -16,6 +16,7 @@ type IMessageActions interface {
 type IMessageManagement interface {
 	DeleteMessage(ctx context.Context, request DeleteRequest) (err error)
 	StarMessage(ctx context.Context, request StarRequest) (err error)
+	DownloadMedia(ctx context.Context, request DownloadMediaRequest) (response DownloadMediaResponse, err error)
 }
 
 // IMessageUsecase combines all message interfaces

src/domains/message/message.go

@@ -37,3 +37,17 @@ type StarRequest struct {
 	Phone     string `json:"phone" form:"phone"`
 	IsStarred bool   `json:"is_starred"`
 }
+
+type DownloadMediaRequest struct {
+	MessageID string `json:"message_id" uri:"message_id"`
+	Phone     string `json:"phone" form:"phone"`
+}
+
+type DownloadMediaResponse struct {
+	MessageID string `json:"message_id"`
+	Status    string `json:"status"`
+	MediaType string `json:"media_type"`
+	Filename  string `json:"filename"`
+	FilePath  string `json:"file_path"`
+	FileSize  int64  `json:"file_size"`
+}

src/pkg/utils/environment.go

@@ -17,19 +17,19 @@ func IsLocal() bool {
 }
 
 func Env[T any](key string, defValue ...T) T {
-        if env := viper.Get(key); env != nil {
-                // Ensure type safety for retrieved environment variables
-                if value, ok := env.(T); ok {
-                        return value
-                }
-        }
+	if env := viper.Get(key); env != nil {
+		// Ensure type safety for retrieved environment variables
+		if value, ok := env.(T); ok {
+			return value
+		}
+	}
 
-        if len(defValue) > 0 {
-                return defValue[0]
-        }
+	if len(defValue) > 0 {
+		return defValue[0]
+	}
 
-        var zero T
-        return zero
+	var zero T
+	return zero
 }
 
 // MustHaveEnv ensure the ENV is exists, otherwise will crashing the app

src/ui/rest/message.go

@@ -21,6 +21,7 @@ func InitRestMessage(app fiber.Router, service domainMessage.IMessageUsecase) Me
 	app.Post("/message/:message_id/read", rest.MarkAsRead)
 	app.Post("/message/:message_id/star", rest.StarMessage)
 	app.Post("/message/:message_id/unstar", rest.UnstarMessage)
+	app.Get("/message/:message_id/download", rest.DownloadMedia)
 	return rest
 }
 
@@ -157,3 +158,21 @@ func (controller *Message) UnstarMessage(c *fiber.Ctx) error {
 		Results: nil,
 	})
 }
+
+func (controller *Message) DownloadMedia(c *fiber.Ctx) error {
+	var request domainMessage.DownloadMediaRequest
+
+	request.MessageID = c.Params("message_id")
+	request.Phone = c.Query("phone")
+	utils.SanitizePhone(&request.Phone)
+
+	response, err := controller.Service.DownloadMedia(c.UserContext(), request)
+	utils.PanicIfNeeded(err)
+
+	return c.JSON(utils.ResponseData{
+		Status:  200,
+		Code:    "SUCCESS",
+		Message: response.Status,
+		Results: response,
+	})
+}

src/usecase/message.go

@@ -3,14 +3,18 @@ package usecase
 import (
 	"context"
 	"fmt"
+	"os"
+	"path/filepath"
 	"time"
 
+	"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"
 	"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"
@@ -182,3 +186,126 @@ func (service serviceMessage) StarMessage(ctx context.Context, request domainMes
 	}
 	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
+	}
+
+	dataWaRecipient, err := utils.ValidateJidWithLogin(whatsapp.GetClient(), request.Phone)
+	if err != nil {
+		return response, err
+	}
+
+	// Query the message from chat storage
+	message, err := service.chatStorageRepo.GetMessageByID(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", request.MessageID)
+	}
+
+	// Check if message has media
+	if message.MediaType == "" || message.URL == "" {
+		return response, fmt.Errorf("message %s does not contain downloadable media", request.MessageID)
+	}
+
+	// Verify the message is from the specified chat
+	if message.ChatJID != dataWaRecipient.String() {
+		return response, fmt.Errorf("message %s does not belong to chat %s", request.MessageID, dataWaRecipient.String())
+	}
+
+	// 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)
+	}
+
+	// Create a downloadable message interface based on media type
+	var downloadableMsg interface{}
+
+	switch message.MediaType {
+	case "image":
+		downloadableMsg = &waE2E.ImageMessage{
+			URL:           proto.String(message.URL),
+			MediaKey:      message.MediaKey,
+			FileSHA256:    message.FileSHA256,
+			FileEncSHA256: message.FileEncSHA256,
+			FileLength:    proto.Uint64(message.FileLength),
+		}
+	case "video":
+		downloadableMsg = &waE2E.VideoMessage{
+			URL:           proto.String(message.URL),
+			MediaKey:      message.MediaKey,
+			FileSHA256:    message.FileSHA256,
+			FileEncSHA256: message.FileEncSHA256,
+			FileLength:    proto.Uint64(message.FileLength),
+		}
+	case "audio":
+		downloadableMsg = &waE2E.AudioMessage{
+			URL:           proto.String(message.URL),
+			MediaKey:      message.MediaKey,
+			FileSHA256:    message.FileSHA256,
+			FileEncSHA256: message.FileEncSHA256,
+			FileLength:    proto.Uint64(message.FileLength),
+		}
+	case "document":
+		downloadableMsg = &waE2E.DocumentMessage{
+			URL:           proto.String(message.URL),
+			MediaKey:      message.MediaKey,
+			FileSHA256:    message.FileSHA256,
+			FileEncSHA256: message.FileEncSHA256,
+			FileLength:    proto.Uint64(message.FileLength),
+			FileName:      proto.String(message.Filename),
+		}
+	case "sticker":
+		downloadableMsg = &waE2E.StickerMessage{
+			URL:           proto.String(message.URL),
+			MediaKey:      message.MediaKey,
+			FileSHA256:    message.FileSHA256,
+			FileEncSHA256: message.FileEncSHA256,
+			FileLength:    proto.Uint64(message.FileLength),
+		}
+	default:
+		return response, fmt.Errorf("unsupported media type: %s", message.MediaType)
+	}
+
+	// Download the media using existing utils.ExtractMedia function
+	extractedMedia, err := utils.ExtractMedia(ctx, whatsapp.GetClient(), dateDir, downloadableMsg.(whatsmeow.DownloadableMessage))
+	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
+}

src/validations/message_validation.go

@@ -89,3 +89,16 @@ func ValidateStarMessage(ctx context.Context, request domainMessage.StarRequest)
 
 	return nil
 }
+
+func ValidateDownloadMedia(ctx context.Context, request domainMessage.DownloadMediaRequest) error {
+	err := validation.ValidateStructWithContext(ctx, &request,
+		validation.Field(&request.Phone, validation.Required),
+		validation.Field(&request.MessageID, validation.Required),
+	)
+
+	if err != nil {
+		return pkgError.ValidationError(err.Error())
+	}
+
+	return nil
+}