X-Git-Url: http://git.giacomolli.uk/onechat/blobdiff_plain/0b97bb2cc4bc0b8f8fe27cc7aa3f9d1d89ed28c8..1804474c7a03cca8bf780dd870a985e7badb4331:/whatsapp.go?ds=sidebyside

diff --git a/whatsapp.go b/whatsapp.go
index 44b9dfa..929ae5d 100644
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -8,7 +8,6 @@ import (
 	"errors"
 	"fmt"
 	"log"
-	"maps"
 	"net/url"
 	"os"
 	"path/filepath"
@@ -84,21 +83,10 @@ const (
 	// 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"
-
 	// whatsappCatchupLimit is the longest wait for the end of the catch-up
 	// after a connection.
 	whatsappCatchupLimit = time.Minute
 
-	// whatsappGroupsAge is how long whatsapp_find uses the groups that it
-	// read from WhatsApp.
-	whatsappGroupsAge = time.Hour
-
 	// whatsappFindMatches is the most matches of whatsapp_find.
 	whatsappFindMatches = 20
 
@@ -155,7 +143,7 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 		logouts:      make(chan struct{}, 1),
 		wake:         make(chan struct{}, 1),
 		failures:     make(chan error, 1),
-		groupNames:   make(map[string]string),
+		groups:       newWhatsAppGroups(logger),
 	}
 
 	var err error
@@ -238,6 +226,7 @@ type WhatsApp struct {
 	wake         chan struct{}
 	failures     chan error
 	state        *WhatsAppState
+	groups       *WhatsAppGroups
 
 	mutex          sync.Mutex
 	container      *sqlstore.Container
@@ -253,9 +242,6 @@ type WhatsApp struct {
 	noticed        bool
 	timer          *time.Timer
 	closed         bool
-	groupNames     map[string]string
-	groupsAt       time.Time
-	groupsRead     time.Time
 	catchingUp     bool
 	caughtUp       bool
 	catchups       int
@@ -443,6 +429,21 @@ func (w *WhatsApp) isLinked() bool {
 	return w.linked
 }
 
+// link returns a copy of the link of the device: whether it is linked, the
+// device, the client, whether it is connected, and the own IDs.
+func (w *WhatsApp) link() WhatsAppLink {
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+
+	return WhatsAppLink{
+		linked:    w.linked,
+		device:    w.device,
+		client:    w.client,
+		connected: w.connected,
+		own:       slices.Clone(w.own),
+	}
+}
+
 // connect makes the client of the linked device and connects it.
 func (w *WhatsApp) connect(ctx context.Context) {
 	w.mutex.Lock()
@@ -584,7 +585,7 @@ func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop, all bool) error {
 	var turns []Message
 	for _, batch := range w.state.Closed() {
 		if batch.Chat.Group && batch.Chat.Name == "" {
-			batch.Chat.Name = w.groupName(ctx, batch.Chat.ID)
+			batch.Chat.Name = w.groups.name(ctx, w.link(), batch.Chat.ID)
 		}
 
 		message, err := l.Work(whatsappSource, batch.Text(w.clock().Location()), "")
@@ -619,65 +620,6 @@ func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop, all bool) error {
 	return nil
 }
 
-// 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]
-	fresh := time.Since(w.groupsAt) < whatsappGroupsRefresh
-	w.mutex.Unlock()
-
-	if !found && !fresh {
-		w.readGroups(ctx)
-
-		w.mutex.Lock()
-		name, found = w.groupNames[id]
-		w.mutex.Unlock()
-	}
-
-	if !found || name == "" {
-		return whatsappUnknownGroup
-	}
-
-	return name
-}
-
-// readGroups reads the names of the groups of the account from WhatsApp, and
-// tells if it could. They stay in memory only.
-func (w *WhatsApp) readGroups(ctx context.Context) bool {
-	w.mutex.Lock()
-	client := w.client
-	w.mutex.Unlock()
-
-	if client == nil {
-		return false
-	}
-
-	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()
-	if err != nil {
-		return false
-	}
-
-	w.groupsRead = w.groupsAt
-	for _, group := range groups {
-		w.groupNames[group.JID.String()] = group.Name
-	}
-
-	return true
-}
-
 // Find returns the contacts and the groups whose name contains name, with no
 // regard to case and accents, as lines "ID | name | contact" or "ID | name |
 // group", sorted by name. It gives at most whatsappFindMatches lines and the
@@ -690,9 +632,10 @@ func (w *WhatsApp) Find(ctx context.Context, name string) (string, error) {
 	linked := w.linked
 	device := w.device
 	own := slices.Clone(w.own)
-	stale := time.Since(w.groupsRead) >= whatsappGroupsAge
 	w.mutex.Unlock()
 
+	stale := w.groups.stale()
+
 	if !linked {
 		return whatsappNotLinked, nil
 	}
@@ -707,10 +650,8 @@ func (w *WhatsApp) Find(ctx context.Context, name string) (string, error) {
 		return "", fmt.Errorf("read the contacts: %s", w.redact(err.Error()))
 	}
 
-	read := !stale || w.readGroups(ctx)
-	w.mutex.Lock()
-	groups := maps.Clone(w.groupNames)
-	w.mutex.Unlock()
+	read := !stale || w.groups.read(ctx, w.link())
+	groups := w.groups.all()
 
 	if len(contacts) == 0 && len(groups) == 0 {
 		if !read {
@@ -940,20 +881,23 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
 // 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.
 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.Message:
+		return w.receive(event)
 	case *events.GroupInfo:
 		if event.Name != nil {
-			w.groupNames[event.JID.String()] = event.Name.Name
+			w.groups.set(event.JID.String(), event.Name.Name)
 		}
+
+		return true
 	case *events.JoinedGroup:
-		w.groupNames[event.JID.String()] = event.Name
+		w.groups.set(event.JID.String(), event.Name)
+		return true
+	}
+
+	var notice string
+	w.mutex.Lock()
+	switch event := event.(type) {
 	case *events.PairSuccess:
 		w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
 	case *events.Connected:
@@ -1183,7 +1127,7 @@ func (w *WhatsApp) Send(ctx context.Context, id, chat, text string) (string, err
 		record.State = whatsappFailed
 		record.Answer = "The send failed: " + w.redact(err.Error()) + "."
 	} else {
-		name := w.groupName(ctx, jid.String())
+		name := w.groups.name(ctx, w.link(), jid.String())
 		if jid.Server != types.GroupServer {
 			name = whatsappContactName(ctx, device, jid, "")
 		}
@@ -1206,6 +1150,16 @@ type WhatsAppMatch struct {
 	kind string
 }
 
+// WhatsAppLink is a copy of the link of the device at one time, for the parts
+// of WhatsApp that do not own it: the groups, the batches, find, and send.
+type WhatsAppLink struct {
+	linked    bool
+	device    *store.Device
+	client    WhatsAppClient
+	connected bool
+	own       []string
+}
+
 // WhatsAppRequest is a pair or unlink command for Run, with the function that
 // gives its answers to the client that asked. A pairing has the phone number.
 type WhatsAppRequest struct {