X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/0018014ab36f3de61a4b8a5515009dab803d6c38..f0604a9ebbee5783d5213d6176191535f4ed335b:/whatsapp.go diff --git a/whatsapp.go b/whatsapp.go index 3c519e8..0e71e98 100644 --- a/whatsapp.go +++ b/whatsapp.go @@ -1,22 +1,30 @@ package main import ( + "cmp" "context" "errors" "fmt" "log" + "maps" "net/url" "os" "path/filepath" + "slices" "strings" "sync" "time" + "unicode" "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" + "golang.org/x/text/runes" + "golang.org/x/text/transform" + "golang.org/x/text/unicode/norm" // The session store of the library opens SQLite with this pure Go // driver. @@ -36,7 +44,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 +73,38 @@ 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" + + // 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 + + // whatsappNotLinked is the answer of a WhatsApp tool without a link. + whatsappNotLinked = "WhatsApp is not linked. Tell the user to run /whatsapp pair PHONE in the terminal or in Telegram." + + // whatsappNamesNotReady is the answer of whatsapp_find before the names + // arrive from the phone. + whatsappNamesNotReady = "The names of the contacts and groups have not arrived from the phone yet. They come some minutes after the link. Try again later." ) // WhatsAppClient is the part of the WhatsApp client that the daemon uses. The @@ -75,6 +116,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 @@ -84,13 +126,23 @@ type WhatsAppClient interface { // the client of a device with its event handler. func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *log.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) { w := &WhatsApp{ - dir: filepath.Join(dir, whatsappDirName), - clock: clock, - logger: logger, - newClient: newClient, - noticeDelay: whatsappNoticeDelay, - requests: make(chan WhatsAppRequest, whatsappRequests), - logouts: make(chan struct{}, 1), + dir: filepath.Join(dir, whatsappDirName), + clock: clock, + logger: logger, + newClient: newClient, + noticeDelay: whatsappNoticeDelay, + catchupLimit: whatsappCatchupLimit, + 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()) @@ -113,15 +165,16 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge if w.device.ID != nil { w.linked = true + w.catchingUp = true w.own = whatsappOwnIDs(w.device.ID.User, w.device.LID.User) } 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,18 +185,40 @@ 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. +// +// After each connection, the servers send the messages that came while the +// daemon was away, and then OfflineSyncCompleted. Until then, or until +// catchupLimit passes, the closed batches wait in the state file. At the end of +// the catch-up, Run closes all batches, logs them, and wakes the turn loop +// once, so the whole catch-up gives one turn and not one turn for each chat. +// The batches of the state file at the start wait for the first catch-up in the +// same way. 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 - logger *log.Logger - newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient - noticeDelay time.Duration - requests chan WhatsAppRequest - logouts chan struct{} + dir string + clock func() time.Time + logger *log.Logger + newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient + noticeDelay time.Duration + catchupLimit time.Duration + requests chan WhatsAppRequest + logouts chan struct{} + wake chan struct{} + failures chan error + batches *WhatsAppBatches mutex sync.Mutex container *sqlstore.Container @@ -159,13 +234,23 @@ 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 + catchupTimer *time.Timer } -// 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 +269,29 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) { }() for { + err := w.deliver(ctx, l, false) + 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 +299,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 +354,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 +393,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 +437,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 @@ -340,6 +445,10 @@ func (w *WhatsApp) close() { w.timer.Stop() } + if w.catchupTimer != nil { + w.catchupTimer.Stop() + } + client := w.client w.client = nil w.mutex.Unlock() @@ -349,14 +458,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.deliver(ctx, l, true) + if err != nil { + return err } - err := w.removeSession() + err = w.removeSession() if err != nil { w.logger.Printf("delete the session after the logout: %v", err) } @@ -367,13 +481,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 +498,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.deliver(ctx, l, true) + if err != nil { + return err } var logoutErr error @@ -392,10 +514,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 +527,211 @@ 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, and wakes the loop once with the batches that start 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. During a catch-up it logs +// nothing, and at its end it closes all batches first. With all, it closes and +// logs all batches also during a catch-up. +func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop, all bool) error { + w.mutex.Lock() + catchingUp := w.catchingUp + caughtUp := w.caughtUp + w.caughtUp = false + w.mutex.Unlock() + + var err error + switch { + case all || caughtUp: + err = w.batches.CloseAll() + case catchingUp: + return nil + default: + _, err = w.batches.CloseDue(time.Now()) + } + + if err != nil { + return err + } + + var turns []Message + for _, batch := range w.batches.Closed() { + if batch.Chat.Group && batch.Chat.Name == "" { + batch.Chat.Name = w.groupName(ctx, batch.Chat.ID) + } + + message, err := l.Work(whatsappSource, batch.Text(w.clock().Location()), "") + 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 + } + + if batch.Turn() { + turns = append(turns, message) + } + } + + l.Wake(turns...) + + 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 +// number of the others. The contacts come from the session database, and the +// groups from WhatsApp, read again after whatsappGroupsAge. When the groups +// cannot be read and none are known, the answer says so. Before the names +// arrive from the phone, it says that they are not ready. +func (w *WhatsApp) Find(ctx context.Context, name string) (string, error) { + w.mutex.Lock() + linked := w.linked + device := w.device + own := slices.Clone(w.own) + stale := time.Since(w.groupsRead) >= whatsappGroupsAge + w.mutex.Unlock() + + if !linked { + return whatsappNotLinked, nil + } + + query := whatsappFold(name) + if query == "" { + return "", errors.New("name is empty: give a part of the name of the contact or the group") + } + + contacts, err := device.Contacts.GetAllContacts(ctx) + if err != nil { + 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() + + if len(contacts) == 0 && len(groups) == 0 { + if !read { + return "The names are not known yet, and WhatsApp is disconnected, so the groups cannot be read. Try again later.", nil + } + + return whatsappNamesNotReady, nil + } + + var matches []WhatsAppMatch + for jid, contact := range contacts { + names := []string{contact.FullName, contact.FirstName, contact.BusinessName, contact.PushName} + shown := slices.IndexFunc(names, func(name string) bool { + return name != "" + }) + + if slices.Contains(own, jid.User) || shown < 0 || !slices.ContainsFunc(names, func(name string) bool { + return strings.Contains(whatsappFold(name), query) + }) { + continue + } + + matches = append(matches, WhatsAppMatch{ + id: jid.ToNonAD().String(), + name: names[shown], + kind: "contact", + }) + } + + for id, group := range groups { + if strings.Contains(whatsappFold(group), query) { + matches = append(matches, WhatsAppMatch{ + id: id, + name: group, + kind: "group", + }) + } + } + + return whatsappFindAnswer(name, matches, read || len(groups) > 0), nil } // removeSession ends the connection, closes the session database, and deletes @@ -420,6 +743,7 @@ func (w *WhatsApp) removeSession() error { w.linked = false w.own = nil w.connected = false + w.catchingUp = false if w.timer != nil { w.timer.Stop() } @@ -449,11 +773,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,20 +907,43 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) { w.linked = true } -// handle takes one event of the library and tells if it was handled. 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. +// 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 +// connection starts a catch-up, which ends at OfflineSyncCompleted or after +// catchupLimit. 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. 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: w.connected = true w.connectedAt = w.clock() + w.catchingUp = true + w.catchups++ + catchups := w.catchups + if w.catchupTimer != nil { + w.catchupTimer.Stop() + } + + w.catchupTimer = time.AfterFunc(w.catchupLimit, func() { + w.caughtUpBy(catchups) + }) if w.timer != nil { w.timer.Stop() } @@ -616,6 +963,8 @@ func (w *WhatsApp) handle(event any) bool { } w.connected = false + case *events.OfflineSyncCompleted: + w.endCatchup() case *events.LoggedOut: select { case w.logouts <- struct{}{}: @@ -637,6 +986,159 @@ 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 +} + +// caughtUpBy ends the catch-up of the connection with the number catchups, when +// no later connection started a new one. +func (w *WhatsApp) caughtUpBy(catchups int) { + w.mutex.Lock() + defer w.mutex.Unlock() + + if w.catchups == catchups { + w.endCatchup() + } +} + +// endCatchup ends a running catch-up and wakes Run, which logs all batches. The +// caller holds the mutex. +func (w *WhatsApp) endCatchup() { + if !w.catchingUp { + return + } + + w.catchingUp = false + w.caughtUp = true + if w.catchupTimer != nil { + w.catchupTimer.Stop() + } + + select { + case w.wake <- struct{}{}: + default: + } +} + // disconnectedLong gives the notice of a long disconnection, unless the // disconnection with the number disconnections ended. func (w *WhatsApp) disconnectedLong(disconnections int) { @@ -681,6 +1183,13 @@ func (w *WhatsApp) redact(text string) string { return text } +// WhatsAppMatch is one contact or group of Find. +type WhatsAppMatch struct { + id string + name string + kind 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 { @@ -690,9 +1199,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 +1213,86 @@ 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 + } +} + +// whatsappFold returns text in lower case with no accents and no space at its +// ends, so that names match with no regard to case and accents. +func whatsappFold(text string) string { + folded, _, err := transform.String(transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC), text) + if err != nil { + folded = text + } + + return strings.ToLower(strings.TrimSpace(folded)) +} + +// whatsappFindAnswer returns the answer of Find for name with matches. Without +// groups, the answer says that it has no groups. +func whatsappFindAnswer(name string, matches []WhatsAppMatch, groups bool) string { + slices.SortFunc(matches, func(a, b WhatsAppMatch) int { + return cmp.Or(strings.Compare(whatsappFold(a.name), whatsappFold(b.name)), strings.Compare(a.id, b.id)) + }) + + var lines []string + for _, match := range matches[:min(len(matches), whatsappFindMatches)] { + lines = append(lines, match.id+" | "+match.name+" | "+match.kind) + } + + if len(matches) == 0 { + lines = append(lines, "No contact or group has a name with \""+name+"\".") + } + + if len(matches) > whatsappFindMatches { + lines = append(lines, fmt.Sprintf("%d more: give a longer part of the name.", len(matches)-whatsappFindMatches)) + } + + if !groups { + lines = append(lines, "The groups are not in this answer, because WhatsApp is disconnected.") + } + + return strings.Join(lines, "\n") +} + // whatsappOwnIDs returns the own number and the own LID that are not empty. func whatsappOwnIDs(ids ...string) []string { var own []string @@ -750,9 +1339,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") == ""