X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/0018014ab36f3de61a4b8a5515009dab803d6c38..56d959f2d573eef1be5c04d0bf1659fa30d36e7c:/whatsapp.go?ds=inline

diff --git a/whatsapp.go b/whatsapp.go
index 3c519e8..20143a9 100644
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -8,6 +8,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"sync"
 	"time"
@@ -15,6 +16,7 @@ import (
 	"go.mau.fi/whatsmeow"
 	"go.mau.fi/whatsmeow/store"
 	"go.mau.fi/whatsmeow/store/sqlstore"
+	"go.mau.fi/whatsmeow/types"
 	"go.mau.fi/whatsmeow/types/events"
 	waLog "go.mau.fi/whatsmeow/util/log"
 
@@ -36,7 +38,8 @@ const (
 	// as "/whatsapp status".
 	whatsappCommand = "/whatsapp"
 
-	// whatsappUsage is the answer to a WhatsApp command that does not exist.
+	// whatsappUsage is the answer to a WhatsApp command that does not
+	// exist.
 	whatsappUsage = "Use /whatsapp pair PHONE, /whatsapp status, or /whatsapp unlink. PHONE is the number of your WhatsApp account with its country code, such as +15550001111."
 
 	// whatsappPairSteps tells the user what to do with the pairing code,
@@ -64,6 +67,20 @@ const (
 	// whatsappRequests is the number of pair and unlink commands that can
 	// wait for Run.
 	whatsappRequests = 8
+
+	// whatsappSource is the source of the work events of the batches.
+	whatsappSource = "whatsapp"
+
+	// whatsappLookupTime is the longest time of a read of the names in the
+	// session database or of the groups from WhatsApp.
+	whatsappLookupTime = 10 * time.Second
+
+	// whatsappGroupsRefresh is the shortest time between two reads of the
+	// groups from WhatsApp for a group with no name.
+	whatsappGroupsRefresh = time.Minute
+
+	// whatsappUnknownGroup is the name of a group whose name is not known.
+	whatsappUnknownGroup = "A group with no known name"
 )
 
 // WhatsAppClient is the part of the WhatsApp client that the daemon uses. The
@@ -75,6 +92,7 @@ type WhatsAppClient interface {
 	GetQRChannel(ctx context.Context) (<-chan whatsmeow.QRChannelItem, error)
 	PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error)
 	Logout(ctx context.Context) error
+	GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error)
 }
 
 // openWhatsApp opens the WhatsApp session in the data directory dir. Without
@@ -91,6 +109,15 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 		noticeDelay: whatsappNoticeDelay,
 		requests:    make(chan WhatsAppRequest, whatsappRequests),
 		logouts:     make(chan struct{}, 1),
+		wake:        make(chan struct{}, 1),
+		failures:    make(chan error, 1),
+		groupNames:  make(map[string]string),
+	}
+
+	var err error
+	w.batches, err = openWhatsAppBatches(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow)
+	if err != nil {
+		return nil, err
 	}
 
 	info, err := os.Stat(w.sessionPath())
@@ -119,9 +146,9 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 	return w, nil
 }
 
-// WhatsApp is the link of the daemon to the WhatsApp account of the user, as
-// a linked device. The session database of the library in dir holds the keys
-// of the device. Run keeps a linked device connected, and the library connects
+// WhatsApp is the link of the daemon to the WhatsApp account of the user, as a
+// linked device. The session database of the library in dir holds the keys of
+// the device. Run keeps a linked device connected, and the library connects
 // again by itself after a network failure.
 //
 // The commands pair and unlink go to Run as requests, and Run runs one at a
@@ -132,10 +159,21 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 // client, and the state of the connection, which the event handler of the
 // library changes from its own goroutines.
 //
+// The text messages go into batches, one chat at a time, as WhatsAppBatches
+// says. Run logs each closed batch as a work message that starts with
+// [WhatsApp], and a batch that needs the user wakes the turn loop. The event
+// handler acknowledges a message only after the state file holds it, so the
+// servers send again a message that a crash lost. A batch leaves the state file
+// only after its work message is durable in the log. A crash between the two
+// makes the batch repeat once.
+//
 // The library logs nothing, because its log lines hold the ID of the own
 // account, which is the phone number of the user. The own number and the own
 // LID never go to the log of the agent or to the log of the daemon: redact
-// removes them from the errors.
+// removes them from the errors, and a batch shows the messages of the user as
+// You and a mention of the user as @you. The IDs of the other chats go to the
+// log, and those of private chats hold phone numbers, because the agent needs
+// them to send.
 type WhatsApp struct {
 	dir         string
 	clock       func() time.Time
@@ -144,6 +182,9 @@ type WhatsApp struct {
 	noticeDelay time.Duration
 	requests    chan WhatsAppRequest
 	logouts     chan struct{}
+	wake        chan struct{}
+	failures    chan error
+	batches     *WhatsAppBatches
 
 	mutex          sync.Mutex
 	container      *sqlstore.Container
@@ -159,13 +200,18 @@ type WhatsApp struct {
 	noticed        bool
 	timer          *time.Timer
 	closed         bool
+	groupNames     map[string]string
+	groupsAt       time.Time
 }
 
-// Run connects a linked device, runs the pair and unlink commands, and handles
-// a logout from the phone, until ctx ends. Its notes go to the log of l, and
-// notify gets the notices for all clients. A failed first connection is
-// logged, and the library tries again when the failure is one of the network.
-func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) {
+// Run connects a linked device, logs the closed batches in l, runs the pair and
+// unlink commands, and handles a logout from the phone, until ctx ends. Its
+// notes go to the log of l, and notify gets the notices for all clients. A
+// failed first connection is logged, and the library tries again when the
+// failure is one of the network. Run returns the error of a write of the log or
+// of the state file, which stops the daemon, because then messages would be
+// lost.
+func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) error {
 	w.mutex.Lock()
 	w.notify = notify
 	linked := w.linked
@@ -184,11 +230,29 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) {
 	}()
 
 	for {
+		err := w.deliver(ctx, l)
+		if err != nil {
+			return err
+		}
+
+		var due <-chan time.Time
+		wait, open := w.batches.Wait(time.Now())
+		if open {
+			due = time.After(wait)
+		}
+
 		select {
 		case <-ctx.Done():
-			return
+			return nil
+		case err = <-w.failures:
+			return err
+		case <-w.wake:
+		case <-due:
 		case <-w.logouts:
-			w.loggedOut(l)
+			err = w.loggedOut(ctx, l)
+			if err != nil {
+				return err
+			}
 		case request := <-w.requests:
 			cancel()
 			pairing.Wait()
@@ -196,7 +260,10 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) {
 
 			switch {
 			case request.unlink:
-				w.unlink(ctx, l, request.answer)
+				err = w.unlink(ctx, l, request.answer)
+				if err != nil {
+					return err
+				}
 			case w.isLinked():
 				request.answer("WhatsApp is linked already. Run /whatsapp unlink first.")
 			default:
@@ -248,8 +315,8 @@ func (w *WhatsApp) Command(args string, answer func(text string)) {
 }
 
 // Status returns the state of the link: not linked, linked and connected, or
-// linked and disconnected, with the times of the connection. It never holds
-// the phone number.
+// linked and disconnected, with the times of the connection. It never holds the
+// phone number.
 func (w *WhatsApp) Status() string {
 	w.mutex.Lock()
 	defer w.mutex.Unlock()
@@ -287,8 +354,8 @@ func (w *WhatsApp) sessionPath() string {
 	return filepath.Join(w.dir, whatsappSessionFileName)
 }
 
-// openSession opens the session database and its first device. The caller
-// holds the mutex, or no other goroutine uses w yet.
+// openSession opens the session database and its first device. The caller holds
+// the mutex, or no other goroutine uses w yet.
 func (w *WhatsApp) openSession(ctx context.Context) error {
 	address, err := whatsappSessionAddress(w.sessionPath())
 	if err != nil {
@@ -331,8 +398,7 @@ func (w *WhatsApp) connect(ctx context.Context) {
 	}
 }
 
-// close ends the connection and the timer of the notice, and stops all
-// notices.
+// close ends the connection and the timer of the notice, and stops all notices.
 func (w *WhatsApp) close() {
 	w.mutex.Lock()
 	w.closed = true
@@ -349,14 +415,19 @@ func (w *WhatsApp) close() {
 	}
 }
 
-// loggedOut deletes the session after a logout from the phone, notes it in the
-// log of l, and tells all clients one time.
-func (w *WhatsApp) loggedOut(l *TurnLoop) {
+// loggedOut logs the open batches, deletes the session after a logout from the
+// phone, notes it in the log of l, and tells all clients one time.
+func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error {
 	if !w.isLinked() {
-		return
+		return nil
 	}
 
-	err := w.removeSession()
+	err := w.deliverAll(ctx, l)
+	if err != nil {
+		return err
+	}
+
+	err = w.removeSession()
 	if err != nil {
 		w.logger.Printf("delete the session after the logout: %v", err)
 	}
@@ -367,13 +438,16 @@ func (w *WhatsApp) loggedOut(l *TurnLoop) {
 	}
 
 	w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.")
+
+	return nil
 }
 
-// unlink logs out the linked device and deletes the session. When the logout
-// call fails, as it does while WhatsApp is disconnected, the session is
-// deleted all the same, and answer tells the user to remove the device in the
-// phone.
-func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text string)) {
+// unlink logs the open batches, logs out the linked device, and deletes the
+// session. When the logout call fails, as it does while WhatsApp is
+// disconnected, the session is deleted all the same, and answer tells the user
+// to remove the device in the phone. Its error is one of the log or the state
+// file.
+func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text string)) error {
 	w.mutex.Lock()
 	linked := w.linked
 	client := w.client
@@ -381,7 +455,12 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
 
 	if !linked {
 		answer("WhatsApp is not linked.")
-		return
+		return nil
+	}
+
+	err := w.deliverAll(ctx, l)
+	if err != nil {
+		return err
 	}
 
 	var logoutErr error
@@ -392,10 +471,10 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
 		logoutErr = client.Logout(ctx)
 	}
 
-	err := w.removeSession()
+	err = w.removeSession()
 	if err != nil {
 		answer("The unlink failed: " + w.redact(err.Error()))
-		return
+		return nil
 	}
 
 	err = l.note("WhatsApp is unlinked.")
@@ -405,10 +484,105 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
 
 	if client == nil || logoutErr != nil {
 		answer("WhatsApp is unlinked here, but the phone did not get the logout. In WhatsApp on your phone, open Linked devices and remove the device.")
-		return
+		return nil
 	}
 
 	answer("WhatsApp is unlinked.")
+
+	return nil
+}
+
+// deliver logs the closed batches in l in order, each as a work message of
+// whatsappSource that wakes the loop when the batch starts a turn. A batch
+// leaves the state file after its message is durable in the log. A group with
+// no name gets its name from WhatsApp first.
+func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop) error {
+	_, err := w.batches.CloseDue(time.Now())
+	if err != nil {
+		return err
+	}
+
+	for _, batch := range w.batches.Closed() {
+		if batch.Chat.Group && batch.Chat.Name == "" {
+			batch.Chat.Name = w.groupName(ctx, batch.Chat.ID)
+		}
+
+		_, err = l.Work(whatsappSource, batch.Text(w.clock().Location()), "", batch.Turn())
+		if err != nil {
+			return fmt.Errorf("log a WhatsApp batch: %w", err)
+		}
+
+		// A stop of the daemon during the flush is no failure: the
+		// batch stays in the state file and repeats once at the next
+		// start.
+		err = l.Flush(ctx)
+		if ctx.Err() != nil {
+			return nil
+		}
+
+		if err != nil {
+			return fmt.Errorf("log a WhatsApp batch: %w", err)
+		}
+
+		err = w.batches.Remove(batch.Number)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// deliverAll closes every open batch and logs all of them.
+func (w *WhatsApp) deliverAll(ctx context.Context, l *TurnLoop) error {
+	err := w.batches.CloseAll()
+	if err != nil {
+		return err
+	}
+
+	return w.deliver(ctx, l)
+}
+
+// groupName returns the name of the group id, or whatsappUnknownGroup. A group
+// that is not in the names of the groups reads the groups from WhatsApp again,
+// at most once in whatsappGroupsRefresh.
+func (w *WhatsApp) groupName(ctx context.Context, id string) string {
+	w.mutex.Lock()
+	name, found := w.groupNames[id]
+	client := w.client
+	fresh := time.Since(w.groupsAt) < whatsappGroupsRefresh
+	w.mutex.Unlock()
+
+	if found {
+		return name
+	}
+
+	if client == nil || fresh {
+		return whatsappUnknownGroup
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, whatsappLookupTime)
+	defer cancel()
+
+	groups, err := client.GetJoinedGroups(ctx)
+	if err != nil {
+		w.logger.Printf("read the groups: %s", w.redact(err.Error()))
+	}
+
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+
+	w.groupsAt = time.Now()
+	for _, group := range groups {
+		w.groupNames[group.JID.String()] = group.Name
+	}
+
+	name, found = w.groupNames[id]
+	if !found || name == "" {
+		return whatsappUnknownGroup
+	}
+
+	return name
 }
 
 // removeSession ends the connection, closes the session database, and deletes
@@ -449,11 +623,11 @@ func (w *WhatsApp) removeSession() error {
 	return err
 }
 
-// pair links a new device to the account of phone with a pairing code. It
-// gives the steps and the code to answer, and then the end of the pairing:
-// the linked number, an expired code, or a failure. A pairing that a new one
-// ends gives no answer. A link notes "WhatsApp is linked." in the log of l,
-// with no number. The client of a pairing that does not link is disconnected.
+// pair links a new device to the account of phone with a pairing code. It gives
+// the steps and the code to answer, and then the end of the pairing: the linked
+// number, an expired code, or a failure. A pairing that a new one ends gives no
+// answer. A link notes "WhatsApp is linked." in the log of l, with no number.
+// The client of a pairing that does not link is disconnected.
 func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer func(text string)) {
 	device, err := w.newDevice(ctx)
 	if err != nil {
@@ -583,15 +757,27 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
 	w.linked = true
 }
 
-// handle takes one event of the library and tells if it was handled. A
+// handle takes one event of the library and tells if it was handled. A message
+// goes to receive. The names of the groups follow the events of the groups. A
 // disconnection keeps the time of its start while the library tries again.
 // After noticeDelay of a disconnection, all clients get one notice, and they
-// get one more when the connection comes back. A disconnection that the
-// library does not try again gives a notice at once.
+// get one more when the connection comes back. A disconnection that the library
+// does not try again gives a notice at once.
 func (w *WhatsApp) handle(event any) bool {
+	message, isMessage := event.(*events.Message)
+	if isMessage {
+		return w.receive(message)
+	}
+
 	var notice string
 	w.mutex.Lock()
 	switch event := event.(type) {
+	case *events.GroupInfo:
+		if event.Name != nil {
+			w.groupNames[event.JID.String()] = event.Name.Name
+		}
+	case *events.JoinedGroup:
+		w.groupNames[event.JID.String()] = event.Name
 	case *events.PairSuccess:
 		w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
 	case *events.Connected:
@@ -637,6 +823,129 @@ func (w *WhatsApp) handle(event any) bool {
 	return true
 }
 
+// receive puts the text of event into its batch and wakes Run. It returns false
+// when the state file cannot hold the message, so that the library does not
+// acknowledge it, and Run stops the daemon. A message that is not text, or that
+// the batches do not take, is handled with nothing to do.
+func (w *WhatsApp) receive(event *events.Message) bool {
+	ctx, cancel := context.WithTimeout(context.Background(), whatsappLookupTime)
+	defer cancel()
+
+	chat, message, found := w.message(ctx, event)
+	if !found {
+		return true
+	}
+
+	_, err := w.batches.Add(chat, message, time.Now())
+	if err != nil {
+		select {
+		case w.failures <- err:
+		default:
+		}
+
+		return false
+	}
+
+	select {
+	case w.wake <- struct{}{}:
+	default:
+	}
+
+	return true
+}
+
+// message returns the chat and the batch message of event, or false when the
+// batches do not take it. They take the text of a private chat or a group, from
+// another person or from the user. They do not take media, reactions, edits,
+// deletions, view-once and disappearing messages, old history, status
+// broadcasts, channels, and the chat of the user with itself.
+//
+// A mention of the user becomes @you, another mention @NAME when the name is
+// known, and the own number and LID become OWN, so that they never go to the
+// log.
+func (w *WhatsApp) message(ctx context.Context, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
+	w.mutex.Lock()
+	device := w.device
+	own := slices.Clone(w.own)
+	w.mutex.Unlock()
+
+	info := event.Info
+	chatJID := info.Chat.ToNonAD()
+	switch {
+	case device == nil:
+	case event.IsEdit, info.Edit != "", event.IsEphemeral, event.IsViewOnce, event.SourceWebMsg != nil:
+	case chatJID.Server != types.DefaultUserServer && chatJID.Server != types.HiddenUserServer && chatJID.Server != types.GroupServer:
+	case slices.Contains(own, chatJID.User):
+	default:
+		return w.text(ctx, device, own, event)
+	}
+
+	return WhatsAppChat{}, WhatsAppMessage{}, false
+}
+
+// text returns the chat and the batch message of event, a message that the
+// batches take when it has text.
+func (w *WhatsApp) text(ctx context.Context, device *store.Device, own []string, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
+	info := event.Info
+	text := event.Message.GetConversation()
+	extended := event.Message.GetExtendedTextMessage()
+	if text == "" {
+		text = extended.GetText()
+	}
+
+	if strings.TrimSpace(text) == "" {
+		return WhatsAppChat{}, WhatsAppMessage{}, false
+	}
+
+	contextInfo := extended.GetContextInfo()
+	message := WhatsAppMessage{
+		ID:   info.ID,
+		Time: info.Timestamp,
+		Mine: info.IsFromMe,
+	}
+
+	if !message.Mine {
+		message.Sender = whatsappContactName(ctx, device, info.Sender, info.PushName)
+	}
+
+	for _, mentioned := range contextInfo.GetMentionedJID() {
+		jid, err := types.ParseJID(mentioned)
+		switch {
+		case err != nil:
+		case slices.Contains(own, jid.User):
+			message.Mention = true
+			text = strings.ReplaceAll(text, "@"+jid.User, "@you")
+		default:
+			text = strings.ReplaceAll(text, "@"+jid.User, "@"+whatsappContactName(ctx, device, jid, ""))
+		}
+	}
+
+	participant, err := types.ParseJID(contextInfo.GetParticipant())
+	message.Reply = err == nil && slices.Contains(own, participant.User)
+
+	for _, id := range own {
+		text = strings.ReplaceAll(text, id, "OWN")
+	}
+
+	message.Text = text
+	chatJID := info.Chat.ToNonAD()
+	chat := WhatsAppChat{
+		ID:    chatJID.String(),
+		Group: chatJID.Server == types.GroupServer,
+	}
+
+	if !chat.Group {
+		push := info.PushName
+		if message.Mine {
+			push = ""
+		}
+
+		chat.Name = whatsappContactName(ctx, device, chatJID, push)
+	}
+
+	return chat, message, true
+}
+
 // disconnectedLong gives the notice of a long disconnection, unless the
 // disconnection with the number disconnections ended.
 func (w *WhatsApp) disconnectedLong(disconnections int) {
@@ -690,9 +999,9 @@ type WhatsAppRequest struct {
 }
 
 // whatsappNewClient returns the client of the library for device, with handle
-// as its event handler. The client tries again after a failed first
-// connection, acknowledges a message only after handle returns true, and
-// downloads no old history. The phone shows the device with the name OneChat.
+// as its event handler. The client tries again after a failed first connection,
+// acknowledges a message only after handle returns true, and downloads no old
+// history. The phone shows the device with the name OneChat.
 func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsAppClient {
 	store.SetOSInfo("OneChat", [3]uint32{0, 1, 0})
 	client := whatsmeow.NewClient(device, waLog.Noop)
@@ -704,6 +1013,48 @@ func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsA
 	return client
 }
 
+// whatsappContactName returns the name of the person jid: the full name, the
+// first name, the business name, or the push name of the contact in the session
+// of device, then push, the push name of a message, then the phone number. A
+// LID gets its phone number from the LID map of the session.
+func whatsappContactName(ctx context.Context, device *store.Device, jid types.JID, push string) string {
+	jid = jid.ToNonAD()
+	candidates := []types.JID{jid}
+	phone := types.EmptyJID
+	switch jid.Server {
+	case types.DefaultUserServer:
+		phone = jid
+	case types.HiddenUserServer:
+		mapped, err := device.LIDs.GetPNForLID(ctx, jid)
+		if err == nil && !mapped.IsEmpty() {
+			phone = mapped
+			candidates = append(candidates, mapped)
+		}
+	}
+
+	for _, candidate := range candidates {
+		contact, err := device.Contacts.GetContact(ctx, candidate)
+		if err != nil || !contact.Found {
+			continue
+		}
+
+		for _, name := range []string{contact.FullName, contact.FirstName, contact.BusinessName, contact.PushName} {
+			if name != "" {
+				return name
+			}
+		}
+	}
+
+	switch {
+	case push != "":
+		return push
+	case !phone.IsEmpty():
+		return "+" + phone.User
+	default:
+		return jid.User
+	}
+}
+
 // whatsappOwnIDs returns the own number and the own LID that are not empty.
 func whatsappOwnIDs(ids ...string) []string {
 	var own []string
@@ -750,9 +1101,9 @@ func whatsappCommandArgs(line string) (string, bool) {
 	return strings.TrimSpace(args), true
 }
 
-// whatsappPhone returns the digits of phone, a number with its country code
-// and an optional + and dashes, and tells if it has the form of a number: 7 to
-// 15 digits, with no 0 first.
+// whatsappPhone returns the digits of phone, a number with its country code and
+// an optional + and dashes, and tells if it has the form of a number: 7 to 15
+// digits, with no 0 first.
 func whatsappPhone(phone string) (string, bool) {
 	phone = strings.ReplaceAll(strings.TrimPrefix(phone, "+"), "-", "")
 	valid := len(phone) >= 7 && len(phone) <= 15 && phone[0] != '0' && strings.Trim(phone, "0123456789") == ""