invitation process upgrade

client/helpers/invitationAnswerHelper.go

@@ -1,161 +1,110 @@
 package helpers
 
 import (
-	"C"
-	"fmt"
+	"errors"
 	"os"
 	"strings"
 
 	"forge.redroom.link/yves/meowlib"
 	"forge.redroom.link/yves/meowlib/client"
 )
-import (
-	"errors"
-)
-
-// InvitationAnswer
-func InvitationAnswer(cc *meowlib.ContactCard, nickname string, myNickname string, serverUids []string) (*client.Peer, string, error) {
 
+// InvitationStep2Answer creates the invitee's peer from an InvitationInitPayload and returns
+// the new peer (STEP_2, invitee side — in-memory, no server involved).
+func InvitationStep2Answer(payload *meowlib.InvitationInitPayload, nickname string, myNickname string, serverUids []string) (*client.Peer, string, error) {
 	mynick := myNickname
-	// my nickname for that contact
-
 	if myNickname == "" {
 		mynick = client.GetConfig().GetIdentity().Nickname
 	}
-
-	// build my contact card for that friend
-	peer, err := client.GetConfig().GetIdentity().AnswerInvitation(mynick, nickname, serverUids, cc)
+	peer, err := client.GetConfig().GetIdentity().InvitationStep2(mynick, nickname, serverUids, payload)
 	if err != nil {
-		return nil, "InvitationAnswer: AnswerInvitation", err
+		return nil, "InvitationStep2Answer: InvitationStep2", err
 	}
-
-	//peerstr, err := json.Marshal(peer)
-	//fmt.Println("InvitationAnswer: " + string(peerstr))
-	c := client.GetConfig()
-	c.GetIdentity().Save()
-
+	client.GetConfig().GetIdentity().Save()
 	return peer, "", nil
 }
 
-// InvitationAnswerFile
-func InvitationAnswerFile(invitationFile string, nickname string, myNickname string, serverUids []string) (string, error) {
-	format := "qr"
-	var filename string = ""
-	var cc *meowlib.ContactCard
-	c := client.GetConfig()
+// InvitationStep2AnswerFile reads an InvitationInitPayload from a .mwiv file and creates the
+// invitee's peer. It also writes the invitee's ContactCard response to a file (STEP_2_SEND, file variant).
+func InvitationStep2AnswerFile(invitationFile string, nickname string, myNickname string, serverUids []string) (string, error) {
 	if _, err := os.Stat(invitationFile); os.IsNotExist(err) {
-		return "InvitationAnswerFile : os.Stat", err
+		return "InvitationStep2AnswerFile: os.Stat", err
 	}
-	if strings.HasSuffix(invitationFile, ".mwiv") {
-		format = "mwiv"
-		data, err := os.ReadFile(invitationFile)
-		if err != nil {
-			return "InvitationAnswerFile : os.ReadFile", err
-		}
-		cc, err = meowlib.NewContactCardFromCompressed(data)
-		if err != nil {
-			return "InvitationAnswerFile : NewContactCardFromCompressed", err
-		}
+	if !strings.HasSuffix(invitationFile, ".mwiv") {
+		return "InvitationStep2AnswerFile: unsupported format", errors.New("only .mwiv files are supported")
 	}
-	identity := client.GetConfig().GetIdentity()
-	if cc != nil {
-		isAnswer, proposed, received, _ := identity.CheckInvitation(cc)
-		if isAnswer {
-			fmt.Fprintln(os.Stdout, "This is already a response "+proposed+" to your invitation.")
-			fmt.Fprintln(os.Stdout, "You cannot answer again.")
-			fmt.Fprintln(os.Stdout, "You should finalize it by importing "+proposed+" contact card to your meow.")
-			fmt.Fprintln(os.Stdout, "Use : 'meow invitation finalize "+invitationFile+"' to do it.")
-
-		} else {
-			mynick := myNickname
-			// my nickname for that contact
-
-			if myNickname == "" {
-				mynick = client.GetConfig().GetIdentity().Nickname
-			}
-
-			response, err := identity.AnswerInvitation(mynick, nickname, serverUids, cc)
-			if err != nil {
-				return "InvitationAnswerFile : AnswerInvitation", err
-			}
-			fmt.Fprintln(os.Stdout, "Invitation sent by "+received)
-			if format == "qr" {
-				filename = c.StoragePath + string(os.PathSeparator) + mynick + "-" + nickname + ".png"
-				response.GetMyContact().WriteQr(filename)
-			} else {
-				filename = c.StoragePath + string(os.PathSeparator) + mynick + "-" + nickname + ".mwiv"
-				response.GetMyContact().WriteCompressed(filename)
-			}
-			client.GetConfig().GetIdentity().Save()
-		}
-
+	data, err := os.ReadFile(invitationFile)
+	if err != nil {
+		return "InvitationStep2AnswerFile: os.ReadFile", err
 	}
+	payload, err := meowlib.NewInvitationInitPayloadFromCompressed(data)
+	if err != nil {
+		return "InvitationStep2AnswerFile: NewInvitationInitPayloadFromCompressed", err
+	}
+
+	mynick := myNickname
+	if myNickname == "" {
+		mynick = client.GetConfig().GetIdentity().Nickname
+	}
+	c := client.GetConfig()
+	response, err := c.GetIdentity().InvitationStep2(mynick, nickname, serverUids, payload)
+	if err != nil {
+		return "InvitationStep2AnswerFile: InvitationStep2", err
+	}
+
+	filename := c.StoragePath + string(os.PathSeparator) + mynick + "-" + nickname + ".mwiv"
+	if err := response.GetMyContact().WriteCompressed(filename); err != nil {
+		return "InvitationStep2AnswerFile: WriteCompressed", err
+	}
+	c.GetIdentity().Save()
 	return "", nil
 }
 
-// InvitationAnswerMessage
-func InvitationAnswerMessage(invitationId string, invitationServerUid string, timeout int) ([]byte, string, error) {
-
-	// find the peer with that invitation id
-	/*var peer *client.Peer
-	for i := len(client.GetConfig().GetIdentity().Peers) - 1; i >= 0; i-- { //! to allow self invitation : testing only, findinc the received peer before myself
-		// for i := 0; i < len(client.GetConfig().GetIdentity().Peers); i++ {
-		if client.GetConfig().GetIdentity().Peers[i].InvitationId == invitationId {
-			peer = client.GetConfig().GetIdentity().Peers[i]
-			break
-		}
-	}*/
+// InvitationStep2AnswerMessage builds and returns the packed server message that posts the
+// invitee's ContactCard (encrypted with the initiator's temp key) to the invitation server
+// (STEP_2_SEND, through-server variant).
+func InvitationStep2AnswerMessage(invitationId string, invitationServerUid string, timeout int) ([]byte, string, error) {
 	peer := client.GetConfig().GetIdentity().Peers.GetFromInvitationId(invitationId)
-
 	if peer == nil {
-		// declare a custom go error for no peer found
-		return nil, "InvitationAnswerMessage: loop for peer", errors.New("no peer with that invitation id")
+		return nil, "InvitationStep2AnswerMessage: peer not found", errors.New("no peer with that invitation id")
 	}
-	answermsg, err := peer.BuildInvitationAnswerMessage(peer.GetMyContact())
+
+	answermsg, err := peer.BuildInvitationStep2Message(peer.GetMyContact())
 	if err != nil {
-		return nil, "InvitationAnswerMessage: BuildInvitationAnswserMessage", err
+		return nil, "InvitationStep2AnswerMessage: BuildInvitationStep2Message", err
 	}
-	// Server: get the invitation server
+
 	invitationServer, err := client.GetConfig().GetIdentity().MessageServers.LoadServer(invitationServerUid)
 	if err != nil {
-		return nil, "InvitationAnswerMessage: LoadServer", err
+		return nil, "InvitationStep2AnswerMessage: LoadServer", err
 	}
 
-	// this will be the invitation's payload
 	packedMsg, err := peer.ProcessOutboundUserMessage(answermsg)
 	if err != nil {
-		return nil, "InvitationAnswerMessage: ProcessOutboundUserMessage", err
-	}
-	// Creating Server message for transporting the user message
-	toServerMessage, err := invitationServer.BuildToServerMessageInvitationAnswer(packedMsg, peer.MyIdentity.Public, invitationId, timeout)
-	if err != nil {
-		return nil, "InvitationAnswerMessage: BuildToServerMessageInvitationAnswer", err
+		return nil, "InvitationStep2AnswerMessage: ProcessOutboundUserMessage", err
+	}
+
+	toServerMessage, err := invitationServer.BuildToServerMessageInvitationAnswer(packedMsg, peer.MyIdentity.Public, invitationId, timeout)
+	if err != nil {
+		return nil, "InvitationStep2AnswerMessage: BuildToServerMessageInvitationAnswer", err
 	}
 
-	// Server outbound processing
 	bytemsg, err := invitationServer.ProcessOutboundMessage(toServerMessage)
 	if err != nil {
-		return nil, "InvitationAnswerMessage: ProcessOutboundMessage", err
+		return nil, "InvitationStep2AnswerMessage: ProcessOutboundMessage", err
 	}
 	return bytemsg, "", nil
 }
 
-// InvitationAnswerMessageReadResponse
-// Called by the invitation receiver
-// invitationData: the data received from the server
-// invitationServerUid: the uid of the server holding the invitation
-func InvitationAnswerMessageReadResponse(invitationData []byte, invitationServerUid string) (*meowlib.Invitation, string, error) {
-
+// InvitationStep2AnswerMessageReadResponse reads the server acknowledgement of a Step2 answer.
+func InvitationStep2AnswerMessageReadResponse(invitationData []byte, invitationServerUid string) (*meowlib.Invitation, string, error) {
 	server, err := client.GetConfig().GetIdentity().MessageServers.LoadServer(invitationServerUid)
 	if err != nil {
-		return nil, "InvitationAnswerMessageReadResponse: LoadServer", err
+		return nil, "InvitationStep2AnswerMessageReadResponse: LoadServer", err
 	}
-	// Server inbound processing : get the invitation server
 	serverMsg, err := server.ProcessInboundServerResponse(invitationData)
 	if err != nil {
-		return nil, "InvitationAnswerMessageReadResponse: ProcessInboundServerResponse", err
+		return nil, "InvitationStep2AnswerMessageReadResponse: ProcessInboundServerResponse", err
 	}
-
 	return serverMsg.Invitation, "", nil
-
 }