meowlib/client/helpers/messageHelper.go

package helpers

import (
	"forge.redroom.link/yves/meowlib"
	"forge.redroom.link/yves/meowlib/client"
)

func messageBuildPostprocess(msg *meowlib.UserMessage, srvuid string, peer *client.Peer) ([]byte, string, error) {
	// Get the message server
	srv, err := client.GetConfig().GetIdentity().MessageServers.LoadServer(srvuid)
	if err != nil {
		return nil, "messageBuildPostprocess : LoadServer", err
	}
	// Prepare cyphered + packed user message
	packedMsg, err := peer.ProcessOutboundUserMessage(msg)
	if err != nil {
		return nil, "messageBuildPostprocess : ProcessOutboundUserMessage", err
	}
	// Creating Server message for transporting the user message
	toServerMessage := srv.BuildToServerMessageFromUserMessage(packedMsg)
	data, err := srv.ProcessOutboundMessage(toServerMessage)
	if err != nil {
		return nil, "messageBuildPostprocess : ProcessOutboundMessage", err
	}
	// Store message
	err = peer.StoreMessage(msg, nil)
	if err != nil {
		return nil, "messageBuildPostprocess : StoreMessage", err
	}
	return data, "", nil
}

func PrepareUserMessage(message string, srvuid string, peer_idx int, replyToUid string, filelist []string) ([]byte, string, error) {

	peer := client.GetConfig().GetIdentity().Peers[peer_idx]

	// Creating User message
	usermessage, err := peer.BuildSimpleUserMessage([]byte(message))
	if err != nil {
		return nil, "PrepareServerMessage : BuildSimpleUserMessage", err
	}
	for _, file := range filelist {
		err = usermessage.AddFile(file, client.GetConfig().Chunksize)
		if err != nil {
			return nil, "PrepareServerMessage : AddFile", err
		}
	}
	usermessage.Status.AnswerToUuid = replyToUid

	return messageBuildPostprocess(usermessage, srvuid, peer)

}

func BuildAckMessage(messageUid string, srvuid string, peer_idx int, received int64, processed int64) ([]byte, string, error) {

	peer := client.GetConfig().GetIdentity().Peers[peer_idx]
	srv, err := client.GetConfig().GetIdentity().MessageServers.LoadServer(srvuid)
	if err != nil {
		return nil, "PrepareServerMessage : LoadServer", err
	}
	// Creating User message
	usermessage, err := peer.BuildSimpleUserMessage(nil)
	if err != nil {
		return nil, "PrepareServerMessage : BuildSimpleUserMessage", err
	}
	usermessage.Status.Uuid = messageUid
	usermessage.Status.Received = uint64(received)
	usermessage.Status.Processed = uint64(processed)
	// Prepare cyphered + packed user message
	packedMsg, err := peer.ProcessOutboundUserMessage(usermessage)
	if err != nil {
		return nil, "PrepareServerMessage : ProcessOutboundUserMessage", err
	}
	// Creating Server message for transporting the user message
	toServerMessage := srv.BuildToServerMessageFromUserMessage(packedMsg)
	data, err := srv.ProcessOutboundMessage(toServerMessage)
	if err != nil {
		return nil, "PrepareServerMessage : ProcessOutboundMessage", err
	}

	return data, "", nil
}

func ReadAckMessageResponse() {
	//! update the status in message store
}