simplify send message bg helper

client/helpers/messageHelper.go

@@ -1,9 +1,10 @@
 package helpers
 
 import (
-	"errors"
 	"os"
 	"path/filepath"
+	"strconv"
+	"strings"
 	"time"
 
 	"forge.redroom.link/yves/meowlib"
@@ -27,25 +28,29 @@ func PackMessageForServer(packedMsg *meowlib.PackedUserMessage, srvuid string) (
 }
 
 func CreateStorePackUserMessageForServer(message string, srvuid string, peer_uid string, replyToUid string, filelist []string) ([]byte, string, error) {
-	usermessage, errtxt, err := CreateAndStoreUserMessage(message, peer_uid, replyToUid, filelist)
+	usermessage, _, _, errtxt, err := CreateAndStoreUserMessage(message, peer_uid, replyToUid, filelist)
 	if err != nil {
 		return nil, errtxt, err
 	}
 	return PackMessageForServer(usermessage, srvuid)
 }
 
-func CreateAndStoreUserMessage(message string, peer_uid string, replyToUid string, filelist []string) (*meowlib.PackedUserMessage, string, error) {
+// CreateAndStoreUserMessage creates, signs, and stores an outbound message for
+// peer_uid. It returns the packed (encrypted) form ready for server transport,
+// the peer DB file UUID (dbFile), the SQLite row ID (dbId), an error context
+// string, and any error.
+func CreateAndStoreUserMessage(message string, peer_uid string, replyToUid string, filelist []string) (*meowlib.PackedUserMessage, string, int64, string, error) {
 	peer := client.GetConfig().GetIdentity().Peers.GetFromUid(peer_uid)
 
 	// Creating User message
 	usermessage, err := peer.BuildSimpleUserMessage([]byte(message))
 	if err != nil {
-		return nil, "PrepareServerMessage : BuildSimpleUserMessage", err
+		return nil, "", 0, "PrepareServerMessage : BuildSimpleUserMessage", err
 	}
 	for _, file := range filelist {
 		err = usermessage.AddFile(file, client.GetConfig().Chunksize)
 		if err != nil {
-			return nil, "PrepareServerMessage : AddFile", err
+			return nil, "", 0, "PrepareServerMessage : AddFile", err
 		}
 	}
 	usermessage.Status.Sent = uint64(time.Now().UTC().Unix())
@@ -54,16 +59,19 @@ func CreateAndStoreUserMessage(message string, peer_uid string, replyToUid strin
 	// Store message
 	err = peer.StoreMessage(usermessage, nil)
 	if err != nil {
-		return nil, "messageBuildPostprocess : StoreMessage", err
+		return nil, "", 0, "messageBuildPostprocess : StoreMessage", err
 	}
 
+	dbFile := peer.LastMessage.Dbfile
+	dbId := peer.LastMessage.Dbid
+
 	// Prepare cyphered + packed user message
 	packedMsg, err := peer.ProcessOutboundUserMessage(usermessage)
 	if err != nil {
-		return nil, "messageBuildPostprocess : ProcessOutboundUserMessage", err
+		return nil, "", 0, "messageBuildPostprocess : ProcessOutboundUserMessage", err
 	}
 
-	return packedMsg, "", nil
+	return packedMsg, dbFile, dbId, "", nil
 }
 
 func BuildAckMessage(messageUid string, srvuid string, peer_uid string, received int64, processed int64) ([]byte, string, error) {
@@ -100,26 +108,14 @@ func ReadAckMessageResponse() {
 	//! update the status in message store
 }
 
-// GetPeerLastMessageDbInfo returns the DB location of the most recently stored
-// message for the given peer. Call this immediately after CreateAndStoreUserMessage
-// to get the values needed for SendJob.MessageDbFile and SendJob.MessageDbId.
-func GetPeerLastMessageDbInfo(peer_uid string) (dbFile string, dbId int64, errTxt string, err error) {
-	peer := client.GetConfig().GetIdentity().Peers.GetFromUid(peer_uid)
-	if peer == nil {
-		return "", 0, "GetPeerLastMessageDbInfo: peer not found", errors.New("peer not found")
-	}
-	if peer.LastMessage == nil {
-		return "", 0, "GetPeerLastMessageDbInfo: no message stored yet", errors.New("no message stored yet for this peer")
-	}
-	return peer.LastMessage.Dbfile, peer.LastMessage.Dbid, "", nil
-}
-
 // ProcessSentMessages scans every send queue under storagePath/queues/, updates
 // the message storage entry with server delivery info for each sent job, then
 // removes the job from the queue. Returns the number of messages updated.
 //
-// Each SendJob must have MessageDbFile and MessageDbId set (populated via
-// GetPeerLastMessageDbInfo right after the message is stored).
+// The message DB location is recovered from the job's File basename, which must
+// follow the naming convention produced by CreateUserMessageAndSendJob:
+//
+//	outbox/{dbFile}_{dbId}
 func ProcessSentMessages(storagePath string) int {
 	password, _ := client.GetConfig().GetMemPass()
 	queueDir := filepath.Join(storagePath, "queues")
@@ -152,18 +148,28 @@ func ProcessSentMessages(storagePath string) int {
 				continue
 			}
 
-			if job.MessageDbFile == "" || job.MessageDbId == 0 {
-				logger.Error().Int64("id", job.ID).Str("queue", queue).
-					Msg("ProcessSentMessages: job missing MessageDbFile/MessageDbId — set them via GetPeerLastMessageDbInfo when building the SendJob")
+			// Recover dbFile and dbId from the outbox filename: {dbFile}_{dbId}
+			base := filepath.Base(job.File)
+			sep := strings.LastIndex(base, "_")
+			if sep <= 0 {
+				logger.Error().Int64("id", job.ID).Str("file", job.File).
+					Msg("ProcessSentMessages: cannot parse dbFile/dbId from job filename — use CreateUserMessageAndSendJob to build jobs")
+				continue
+			}
+			dbFile := base[:sep]
+			dbId, parseErr := strconv.ParseInt(base[sep+1:], 10, 64)
+			if parseErr != nil || dbFile == "" || dbId == 0 {
+				logger.Error().Int64("id", job.ID).Str("file", job.File).
+					Msg("ProcessSentMessages: invalid dbFile/dbId in job filename")
 				continue
 			}
 
 			serverUid := job.Servers[*job.SuccessfulServer].GetUid()
 			receiveTime := uint64(job.SentAt.Unix())
 
-			if err := client.SetMessageServerDelivery(job.MessageDbFile, job.MessageDbId, serverUid, receiveTime, password); err != nil {
+			if err := client.SetMessageServerDelivery(dbFile, dbId, serverUid, receiveTime, password); err != nil {
 				logger.Error().Err(err).Str("queue", queue).
-					Str("dbFile", job.MessageDbFile).Int64("dbId", job.MessageDbId).
+					Str("dbFile", dbFile).Int64("dbId", dbId).
 					Msg("ProcessSentMessages: SetMessageServerDelivery")
 				continue
 			}