"net/url"
"os"
"path/filepath"
+ "slices"
"strings"
"sync"
"time"
"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"
// 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,
// 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
)
// WhatsAppClient is the part of the WhatsApp client that the daemon uses. The
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
// 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())
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
// 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
noticed bool
timer *time.Timer
closed bool
+ groupNames map[string]string
+ groupsAt 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
}()
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()
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:
}
// 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()
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 {
}
}
-// 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
w.timer.Stop()
}
+ if w.catchupTimer != nil {
+ w.catchupTimer.Stop()
+ }
+
client := w.client
w.client = nil
w.mutex.Unlock()
}
}
-// 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.deliver(ctx, l, true)
+ if err != nil {
+ return err
+ }
+
+ err = w.removeSession()
if err != nil {
w.logger.Printf("delete the session after the logout: %v", err)
}
}
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
if !linked {
answer("WhatsApp is not linked.")
- return
+ return nil
+ }
+
+ err := w.deliver(ctx, l, true)
+ if err != nil {
+ return err
}
var logoutErr error
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.")
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]
+ 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
w.linked = false
w.own = nil
w.connected = false
+ w.catchingUp = false
if w.timer != nil {
w.timer.Stop()
}
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 {
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()
}
}
w.connected = false
+ case *events.OfflineSyncCompleted:
+ w.endCatchup()
case *events.LoggedOut:
select {
case w.logouts <- struct{}{}:
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) {
}
// 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)
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
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") == ""
projects / onechat / blobdiff